SENTINEL/i — Personal Auto & Property Insurance Core

SENTINEL/i is a personal-lines (auto + property) insurance core system: party/producer masters, policy administration across the full lifecycle (issue → endorse → renew → cancel), risk/coverage items with rating-driven underwriting, installment billing and oldest-due-first cash application, a claims workflow (FNOL → adjudication → payment), agent commissions, and a balanced GL posting feed cross-checked debits=credits. It is a classic AS/400-native application: column-exact DDS physical/logical/display/printer files, RPG (fixed-form C-spec and /free), one ILE COBOL program, CL build and night-batch drivers, DB2 for i (one RUNSQLSTM table + embedded SQL), 5250 WORKSTN screens (plain and SFL/SFLCTL subfile), PRTF spool, and journaling. Business rules live in the RPG/COBOL programs themselves; there is no SQL-PL layer. This manual is the reference for the operator who runs the screens and the night batch, and for the developer maintaining the application. It is grounded entirely in the committed source (insurance2-app/src/sources.mjs, src/seed.mjs, PLAN.md, and the test/sentinel_*.mjs drivers). Everything runs in library SENTINEL.

A. Overview & Architecture ↑ top

A.1 What it does

SENTINEL/i administers one coherent line of business — personal auto and property insurance — end to end:

• Masters & underwriting — party/insured (PARTYMS) and producer (PRODMS) masters, a create/change/inquire maintenance path (PARTYMNT), and a callable underwriting subprogram (UWCHK) that applies an age-band rating factor from RATETB and hard-declines on excessive prior claims.
• Policy lifecycle — issue (POLBIND, which CALLs UWCHK to rate), mid-term endorsement (POLENDT), renewal (POLRENEW), and cancellation (POLCANCL). Each writes an immutable, journaled POLLOG transaction row (LOGTYPE I / E / R / C) — the core-system audit trail.
• Risk/coverage — N coverage items per policy (RISKMS, keyed POLICYNO+RISKCD), each with a limit, deductible and premium.
• Billing & cash — idempotent quarterly installment generation (BILLRUN), oldest-due-first partial-pay-aware cash application (CASHAPP), and an aged-receivables PRTF report (AGERUN).
• Claims — the signature workflow FNOL (CLMOPEN) → adjudication (CLMADJ, approve/cap the reserve against the covering coverage limit) → payment (CLMPAYP, limit-checked, with a balanced GL pair).
• Commissions & GL — commission per bound issuance (COMMRUN) and a consolidated, self-balancing GL posting feed (GLRUN) that COMMITs only when debits=credits.
• Reporting — the aged-receivables spool plus an ILE COBOL portfolio summary (POLSUM2) that cross-checks inforce premium against the GL written-premium feed.

A.2 Classic-RPG architecture: programs own the logic

Unlike a SQL-PL-centric design, SENTINEL/i keeps its business rules in the RPG and COBOL programs themselves. There is no stored-procedure layer: rating math is in UWCHK, the payment waterfall/aging/pro-rata math is in the RPG programs, and DB2 for i appears only as (1) one RUNSQLSTM-created table, GLPOST2, the GL posting feed, and (2) embedded EXEC SQL INSERT/SELECT/COMMIT/ROLLBACK in the three GL-touching programs (COMMRUN, CLMPAYP, GLRUN) and the COBOL cross-check (POLSUM2). All other I/O is native record-level access (CHAIN / READ / WRITE / UPDATE) over DDS files.

The system is deliberately built as a broad platform-stress workload: it exercises DDS PFs/LFs, keyed and arrival I/O, fixed-form and free-form RPG, program-to-program CALL (POLBIND→UWCHK), an ILE COBOL + DB2 bridge, CL build and night-batch drivers, three DSPF screens (plain + subfile + menu), a PRTF spool, journaling with a receiver roll, and commitment-controlled posting with a balanced control total. All objects live in one library, SENTINEL.

A.3 Component & flow

  SETUP / ISSUANCE          ONLINE (5250)            NIGHT BATCH (SNNIGHT, SBMJOB)
  ----------------          -------------            -----------------------------
  SNSETUP  (build+jrnl)     MAINMENU (menu)          STRCMTCTL LCKLVL(*CHG)
  REFLD    (seed rates,       opt 1 -> POLVIEW         BILLRUN   (installments)
            parties, prod)      (POLSCRN, plain)       CASHAPP   (apply receipts)
  POLBIND  --CALL--> UWCHK    opt 2 -> CLMVIEW         COMMRUN   (commission + GL)
    (issue, journal 'I')        (CLMSCRN, SFL/SFLCTL)  CLMPAYP   (claim pay + GL)
  POLENDT/POLRENEW/POLCANCL                            GLRUN     (premium GL, balance
    (endorse/renew/cancel,   \                    /              gate: COMMIT/ROLLBACK)
     journal E/R/C)           \                  /     ENDCMTCTL
  CLMOPEN -> CLMADJ            v                v
    (FNOL, adjudicate)   POLICYMS / RISKMS / CLAIMMS / INSTMS ...   SNJRN (journals POLLOG)
                                |
  REPORTING                     +--> POLLOG  (journaled txn/audit log: I/E/R/C)
  AGERUN  (PRTF spool)          +--> GLPOST2 (DB2 GL feed: batch 10 prem, 20 claim, 30 comm)
  POLSUM2 (COBOL+SQL x-check)

A single business event — say, issuing a policy — flows: REFLD seeds and closes the rate/party/producer reference data → POLBIND CALLs UWCHK for the rated premium → writes the POLICYMS header, its RISKMS coverage rows, and a journaled POLLOG ‘I’ row → the SNJRN journal captures the POLLOG write. Downstream, the night SNNIGHT chain bills, applies cash, commissions, pays claims and posts a balanced GL under commitment control.

A.4 Object inventory

The catalogue is 11 PFs + 4 LFs + 1 DB2 table, 3 DSPF + 1 PRTF, 19 RPG/COBOL programs, 2 CL programs, and 1 journal/receiver pair. Sections D and F expand each.

B. Online Transactions & Screens ↑ top

B.1 The command/entry line

SENTINEL/i has no CICS transaction identifiers and no transid switch. On IBM i, each program is reached by name from a 5250 command-entry line (or a JOBQ/scheduler for the batch jobs). The operator equivalent of “type a transid and Enter” is “type a CALL command and Enter”. Before invoking anything, the job's library list must include SENTINEL — the tested jobs run with LIBL = QSYS QGPL SENTINEL QTEMP and CURLIB = SENTINEL.

B.2 The menu & the two inquiry screens

Three DSPF programs are interactive. MAINMENU (format MENUFMT over MAINMNU) is the entry point: it prompts for a 1-char option and routes via a classic, indicator-conditioned dynamic CALL — option 1 CALLs POLVIEW, option 2 CALLs CLMVIEW. Any other value redisplays with Invalid option. F3 exits.

POLVIEW — policy inquiry (POLSCRN, plain WORKSTN)

A non-subfile screen: key a policy number, Enter, and it CHAINs POLICYMS and displays the header (insured party, line of business, status, annual premium, balance) plus up to four risk/coverage lines read from the RISKLV logical (the program loads at most 4 fixed slots, DRISK1–DRISK4). A not-found key shows Policy not found:. The loop re-displays until F3.

CLMVIEW — claim inquiry (CLMSCRN, SFL/SFLCTL subfile)

The one subfile screen. Key a claim number, Enter: it CHAINs CLAIMMS for the header (policy, loss date, cause, status, total reserved/paid), then loads a subfile (DDS record CLMSFL under control record CLMCTL, SFLPAG(0010), SFLSIZ(0020)) from the CLMLINLV logical — one row per claim line (reserve R, adjudication A, payment P) with its date, type and amount. The screen uses the standard indicator set *IN31=SFLDSP, *IN32=SFLDSPCTL, *IN33=SFLCLR, *IN34=SFLEND(*MORE).

Actions & keys (all three screens)

• Enter — on MAINMENU, select/route; on POLVIEW/CLMVIEW, look up the keyed policy/claim and (re)display.
• F3 (Exit) — CA03(03) on every format; sets *IN03 and the program's dow *in03 = *off loop ends, returning to the caller (MAINMENU, or the command line).
• Keyed access is case-sensitive (EBCDIC alphanumeric key, no translation): auto0001 does not match AUTO0001 (confirmed in PLAN.md §6).

B.3 Controls & audit workflow (no four-eyes maker–checker)

Honest statement: SENTINEL/i does not model a true four-eyes maker–checker / separate-authorization workflow. There is no “one user enters, a second approves” gate: a policy issued by POLBIND is inforce immediately; a claim adjudicated by CLMADJ moves O→A in one program; a payment posted by CLMPAYP is applied at once. Even the two 5250 screens (POLVIEW, CLMVIEW) are inquiry-only — they read and display, they do not update. All state change happens in the batch/driver programs. The control model the application does have:

• Immutable journaled audit log (POLLOG). Every policy event writes a POLLOG row (LOGTYPE I issue / E endorse / R renew / C cancel) carrying the amount or delta. POLLOG is journaled to SNJRN with IMAGES(*BOTH) (see F.3), so even a direct UPDATE captures before/after images. A full lifecycle leaves the history I,I,E,R,R,C (verified by sentinel_lifecycle.mjs).
• Claim line trail (CLMLINE). Every reserve/adjudication/payment is a separate immutable CLMLINE row (R/A/P), aggregated per claim through the CLMLINLV logical — a complete, reconstructable claim history.
• Business-rule gating. UWCHK hard-declines when prior claims > 3; CLMADJ caps a reserve at the covering RISKMS coverage limit; CLMPAYP rejects a payment that would exceed RLIMIT − TOTPAY (remaining limit); BILLRUN is idempotent (a dup-key CHAIN skips already-billed policies).
• Balanced GL control total. The night posting runs under STRCMTCTL LCKLVL(*CHG); GLRUN EXEC SQL COMMITs the GL unit-of-work only when SUM(DR)=SUM(CR), else ROLLBACK. POLSUM2 independently cross-checks inforce premium against the GL written-premium feed.

In sum, the control posture is immutable journaled audit + business-rule/limit gating + a balanced GL control total, rather than a segregation-of-duties approval workflow.

C. Batch Jobs & the Periodic Cycle ↑ top

SENTINEL/i's batch work centres on one night chain, SNNIGHT, submitted as a single SBMJOB onto a job queue and run under commitment control. Around it sit the on-demand lifecycle drivers (issue/endorse/renew/cancel) and the two reporting programs. Because the programs carry hard-coded work data (see B.1), a run is a bare CALL/SBMJOB with no run-date parameter.

-- install once: build all objects + arm journaling on POLLOG
CRTCLPGM PGM(SENTINEL/SNSETUP) SRCFILE(SENTINEL/QCLSRC) SRCMBR(SNSETUP)
CALL PGM(SENTINEL/SNSETUP)

-- seed reference/master data, then issue the day's policies
CALL PGM(SENTINEL/REFLD)
CALL PGM(SENTINEL/POLBIND)

-- submit the night chain onto a job queue (runs BILLRUN..GLRUN under STRCMTCTL)
CRTJOBQ JOBQ(SENTINEL/NITEQ) TEXT('SENTINEL night batch queue')
SBMJOB CMD(CALL SENTINEL/SNNIGHT) JOB(SNNITE) JOBQ(SENTINEL/NITEQ) HOLD(*NO)

C.1 Full batch / driver program set

C.2 The SNNIGHT night chain

SNNIGHT is a CL program that runs the five posting programs in one commitment boundary:

SNNIGHT (CL):
  STRCMTCTL LCKLVL(*CHG)
  MONMSG    MSGID(SFF0000)
  CALL PGM(SENTINEL/BILLRUN)    generate installments
  CALL PGM(SENTINEL/CASHAPP)    apply receipts, reduce POLBAL
  CALL PGM(SENTINEL/COMMRUN)    commission + GL batch 30
  CALL PGM(SENTINEL/CLMPAYP)    claim payment + GL batch 20
  CALL PGM(SENTINEL/GLRUN)      premium GL batch 10 + balance gate
  ENDCMTCTL

The three GL-touching programs' EXEC SQL INSERTs are staged inside the commit boundary; GLRUN makes the final decision — COMMIT if the whole feed balances, ROLLBACK otherwise. In the reference day the feed balances at DR = CR = 6102.00 (premium 2820.00 + claim 3000.00 + commission 282.00, each posted as a balanced pair), and the premium batch (10) credit total persists at exactly 2820.00 post-COMMIT.

Expected DSPLY highlights across the chain:
  BILLRUN GENERATED=2 SKIPPED=0
  CASHAPP FULL=1 PART=1 NONE=0
  COMMRUN ROWS=2 TOTAL=282.00
  CLMPAYP PAID 3000.00
  GLRUN IN BALANCE DR=6102.00 CR=6102.00

C.3 Ordering & dependencies

• REFLD before POLBIND. UWCHK's CHAIN on RATETB only sees rows written by a program that has closed the file. REFLD seeds and ends (closing RATETB) so POLBIND→UWCHK rates against real bands; seeding inline in POLBIND would leave the CHAIN unsatisfied (factor defaults to 1.000). See F.4 and PLAN.md §6.
• POLBIND before the night chain. BILLRUN bills only inforce policies, COMMRUN/GLRUN post only against POLLOG 'I' rows, so policies must be issued first.
• Within SNNIGHT the order is fixed: BILLRUN → CASHAPP (needs installments) → COMMRUN → CLMPAYP → GLRUN last (it is the balance gate that COMMITs/ROLLBACKs the whole unit-of-work).
• Claims path order: CLMOPEN → CLMADJ → CLMPAYP — the payment posts against an approved, limit-checked claim.

D. Data Files (data dictionary) ↑ top

All files are in library SENTINEL, defined by column-exact DDS in sources.mjs. Dates are stored as signed zoned 8S 0 in YYYYMMDD form; money is packed 9P 2 (or wider for GL); rating factors are packed 5P 3. UNIQUE-keyed PFs are the masters; three PFs (POLLOG, RCPTMS, CLMLINE) are effectively arrival logs keyed by a generated sequence.

Status-code legend: POLSTAT I=inforce C=cancelled X=expired; LOGTYPE I=issue E=endorse R=renew C=cancel; ISTAT O=open D=part-paid P=paid; CLSTAT O=open A=adjudicated/approved C=closed D=denied; LINETYP R=reserve A=adjudication P=payment; DRCR D=debit C=credit.

PARTYMS — Party/insured master (UNIQUE, K PARTNO)

PRODMS — Producer/agency master (UNIQUE, K PRODNO)

POLICYMS — Policy header (UNIQUE, K POLICYNO)

POLLOG — Policy transaction/audit log (UNIQUE, K LOGID; journaled)

RISKMS — Coverage/risk items (UNIQUE, K POLICYNO+RISKCD)

RATETB — Underwriting rating factors (UNIQUE, K BANDCD)

INSTMS — Billing installments (UNIQUE, K POLICYNO+INSTNO)

RCPTMS — Cash receipts (arrival, UNIQUE K RCPTNO)

CLAIMMS — Claim header (UNIQUE, K CLAIMNO)

CLMLINE — Claim lines (arrival, UNIQUE K LINEID)

COMMMS — Commission lines (K COMMR; keyed to avoid dup-write)

GLPOST2 — GL posting feed (DB2 table, RUNSQLSTM)

Logical files (4)

Relationships

• POLICYMS.PARTNO → PARTYMS.PARTNO; POLICYMS.PRODNO → PRODMS.PRODNO (referenced by CHAIN, not a declared DB2 FK).
• POLICYMS.ANNPREM is derived at issue from RATETB via UWCHK (age band × base premium).
• RISKMS / INSTMS / POLLOG / CLAIMMS → POLICYMS.POLICYNO (per-policy detail).
• CLMLINE → CLAIMMS.CLAIMNO; COMMMS → POLICYMS + PRODMS + POLLOG.LOGID.
• GLPOST2 is a standalone DB2 feed keyed by BATCHNO/SRCPGM; POLLOG is journaled to SNJRN.

E. Operations Runbook ↑ top

E.1 Day-in-the-life

1. One-time install: CRTLIB SENTINEL, seed the source members, compile the two CL programs, then CALL SENTINEL/SNSETUP — this creates all PF/LF/DSPF/PRTF objects, the GLPOST2 DB2 table (RUNSQLSTM), compiles every RPG/COBOL program, and arms journaling on POLLOG (CRTJRNRCV SNJRNR / CRTJRN SNJRN / STRJRNPF POLLOG IMAGES(*BOTH)).
2. Seed & issue: CALL SENTINEL/REFLD (rates/parties/producer, runs to completion), then CALL SENTINEL/POLBIND to issue the day's policies (rates via UWCHK, journals 'I').
3. Intraday lifecycle / claims as they arrive: endorse (POLENDT), party maintenance (PARTYMNT), open+adjudicate a claim (CLMOPEN → CLMADJ), and record cash receipts into RCPTMS.
4. Night batch: create the queue (CRTJOBQ SENTINEL/NITEQ) and SBMJOB CMD(CALL SENTINEL/SNNIGHT) JOBQ(SENTINEL/NITEQ). Wait for the job to reach OUTQ.
5. Inquiries: handle policy/claim look-ups through CALL SENTINEL/MAINMENU (option 1 → POLVIEW, option 2 → CLMVIEW). These are read-only.

Pre-checks: confirm the job's library list includes SENTINEL; confirm REFLD ran and closed before POLBIND (otherwise premiums come out at the default 1.000 factor).

Post-checks after the night chain:

• BILLRUN GENERATED=2 SKIPPED=0 on a first run (or SKIPPED=2 on an idempotent rerun); INSTMS holds 8 rows.
• CASHAPP FULL=1 PART=1 NONE=0; the applied installments flipped ISTAT and POLBAL dropped by the applied cash.
• COMMRUN ROWS=2 TOTAL=282.00; GLRUN IN BALANCE (never OUT OF BALANCE).
• The SNNITE job reached OUTQ cleanly.

E.2 Period close & reporting (reconciling figures)

1. Run the aged-receivables report: CALL SENTINEL/AGERUN, then read the POLREGP2 spooled file. It shows a SENTINEL/i -- Aged Receivables banner, one detail line per installment with a PAID/PARTIAL/OPEN bucket, and a total line.
2. Run the COBOL cross-check: CALL SENTINEL/POLSUM2. It totals inforce annual premium from POLICYMS and compares to SUM(GLAMT) of the written-premium GL credits (BATCHNO=10, DRCR='C'), printing IN BALANCE or OUT OF BALANCE.

Reconciling figures (the same ones the focused test suites assert against):

• Premium. AUTO0001 = 1200.00 base × STD 1.000 = 1200.00; PROP0001 = 1800.00 base × SNR 0.900 = 1620.00. Inforce premium at issue = 2820.00. GL written-premium (batch 10 credit) = 2820.00.
• Installments. 4 per policy; AUTO0001's four sum to exactly 1200.00 (the remainder from ANNPREM DIV 4 lands on installment 4).
• Cash. A 300.00 receipt fully pays AUTO0001 inst 1 (ISTAT P); a 200.00 receipt partially pays PROP0001 inst 1 (ISTAT D). POLBAL: AUTO0001 900.00, PROP0001 1420.00.
• Commission. AG01 @10%: 120.00 (of 1200) + 162.00 (of 1620) = 282.00.
• Claim. Reserve 5000.00 (within the PD limit, approved not capped); payment 3000.00; TOTPAY 3000.00.
• GL balance. Whole feed SUM(DR) = SUM(CR) = 6102.00 (2820 premium + 3000 claim + 282 commission, each a balanced pair).

E.3 Failure & re-run rules

F. Developer Reference ↑ top

The complete program surface, from sources.mjs. All objects are in library SENTINEL; source members live in QDDSSRC, QRPGLESRC, QCBLLESRC, QCLSRC, QSQLSRC.

F.1 Programs (19 RPG/COBOL + 2 CL)

UWCHK (RPGLE) — PI: pDob(8:0), pClaims(3:0), pBasePrem(9:2) in; pOutPrem(9:2), pOutStat(1) out

Callable rating subprogram. Hard-declines when pClaims > 3 (pOutStat 'D', premium 0). Otherwise derives an age band from (today − pDob)/10000 (<25 YNG, ≥65 SNR, else STD), CHAINs RATETB for the factor, and returns pBasePrem × RFACTOR with pOutStat 'A'. Uses nested if/else (not free-form elseif) — see F.4.

REFLD (RPGLE)

Reference/master seed loader (RATETB bands, two parties, one producer). Runs to completion so the rows are visible to UWCHK's CHAIN. Opens RATETB/PARTYMS/PRODMS output-add.

POLBIND (RPGLE)

Issues AUTO0001 (std) and PROP0001 (senior): callp uwsub(...) to rate, writes the POLICYMS header, RISKMS coverage rows, and a journaled 'I' POLLOG row per policy.

POLENDT (RPGLE)

Endorsement: full-key CHAIN/UPDATE on RISKMS (raise PD limit +25000, +150 delta) and POLICYMS (re-rate header), writes a journaled 'E' POLLOG row carrying the delta only.

POLRENEW (RPGLE)

Renewal sweep: sequential READ over POLICYMS; for inforce policies with EXPDT ≤ 20270101 rolls EFFDT/EXPDT +1yr (+10000 packed add), applies a 5% load, writes a journaled 'R' row. Its EXPDT-past-cutoff test makes a same-window rerun renew 0.

POLCANCL (RPGLE)

Cancellation: computes a pro-rata unearned credit (ANNPREM × 0.500 for a half-term remaining), sets POLBAL to the earned half, flips POLSTAT 'C', writes a journaled 'C' POLLOG row with the negative unearned credit.

PARTYMNT (RPGLE) — PI: pAct(1), pPartno(6), pPnam(25)

Master maintenance over PARTYMS via a SELECT on the action code: 'A' add (if not found), 'C' change name (if found), 'I' inquire (CHAIN + DSPLY), else BADACT.

BILLRUN (RPGLE, fixed-form + /free)

One pass over inforce POLICYMS; per policy a dup-check CHAIN(E) on INSTMS (skip if installment 1 exists), else generate 4 installments (ANNPREM DIV 4, remainder via MVR on installment 4). Idempotent.

CASHAPP (RPGLE, fixed-form + /free)

Arrival pass over RCPTMS; per receipt a bounded full-key chain (policyno:instno) retry 1..4 for the oldest open/partial installment; full pay → ISTAT 'P', partial → ISTAT 'D'; then decrements POLICYMS.POLBAL by the applied amount.

AGERUN (RPGLE)

Forward READ over the AGEDLV (by DUEDT) logical; buckets each installment PAID/PARTIAL/OPEN and writes the POLREGP2 PRTF (header, detail, total) to spool. Uses nested if/else for the bucket (see F.4).

CLMOPEN (RPGLE)

FNOL: writes the CLAIMMS header (CLM00001 on AUTO0001, reserve 5000.00, CLSTAT 'O', covering RISKCD 'PD') and the initial 'R' reserve CLMLINE.

CLMADJ (RPGLE)

Adjudication: CHAINs CLAIMMS, then the covering RISKMS line (full composite key POLICYNO+RISKCD) for RLIMIT; caps the reserve at the limit if over, flips CLSTAT 'O'→'A', writes an 'A' memo line.

CLMPAYP (SQLRPGLE)

Claim payment: remaining limit = RLIMIT − TOTPAY; if the 3000.00 payment fits, writes a 'P' CLMLINE, bumps CLAIMMS.TOTPAY, and posts a balanced GL pair (batch 20: 4100-CLMEXP DR / 1000-CASH CR) via embedded SQL.

COMMRUN (SQLRPGLE)

Per POLLOG 'I' row: CHAIN POLICYMS then PRODMS, commission = LOGAMT × COMMPCT/100, write COMMMS + a balanced GL pair (batch 30: 5200-COMMEXP DR / 2100-COMMPAY CR).

GLRUN (SQLRPGLE)

Per POLLOG 'I' row: premium GL pair (batch 10: 1200-PREMREC DR / 4000-WRTNPRM CR). Then SELECTs SUM(DR)/SUM(CR) over the whole feed and COMMITs if equal, else ROLLBACK — the balance gate for the commit unit-of-work.

POLVIEW / CLMVIEW / MAINMENU (RPGLE, WORKSTN)

The three interactive programs (B.2). POLVIEW: plain EXFMT over POLSCRN, header + up to 4 RISKLV lines. CLMVIEW: SFL/SFLCTL over CLMSCRN, header + CLMLINLV subfile load. MAINMENU: menu + indicator-conditioned dynamic CALL 'POLVIEW'/'CLMVIEW'.

POLSUM2 (CBLLE, ILE COBOL + EXEC SQL)

Indexed sequential READ over POLICYMS (COMP-3 FD matching the packed layout byte-for-byte), totals inforce ANNPREM, then EXEC SQL SELECT SUM(GLAMT) ... WHERE BATCHNO=10 AND DRCR='C' and prints IN/OUT OF BALANCE.

SNSETUP (CLP)

Install driver: DLTF/CRTPF/CRTLF/CRTDSPF/CRTPRTF, RUNSQLSTM GLPOST2, CRTBNDRPG/CRTBNDCBL every program, and CRTJRNRCV/CRTJRN/STRJRNPF POLLOG IMAGES(*BOTH).

SNNIGHT (CLP)

Night chain under STRCMTCTL LCKLVL(*CHG): BILLRUN → CASHAPP → COMMRUN → CLMPAYP → GLRUN → ENDCMTCTL.

F.2 The rating & GL model

Rating. Premium = base × age-band factor (RATETB): YNG (<25) 1.250, STD 1.000, SNR (≥65) 0.900. Endorsement adds a flat delta; renewal applies a 5% load; cancellation credits a pro-rata unearned fraction. A prior-claim count > 3 hard-declines.

GL feed. Three balanced DR/CR batches, all cross-checked SUM(DR)=SUM(CR):

F.3 Journaling

POLLOG is journaled to SNJRN (receiver SNJRNR) with IMAGES(*BOTH), armed in SNSETUP. Effects verified by sentinel_journal.mjs: WRITE puts appear as PT record-put images; a native UPDATE captures a UB before-image and a UP after-image (UB seq < UP seq); DSPJRN JRN(SENTINEL/SNJRN) FILE(SENTINEL/POLLOG) renders those lines; and a receiver roll (CRTJRNRCV SNJRNR2 + CHGJRN) detaches SNJRNR (*ONLINE), attaches SNJRNR2 (*ATTACHED), and a traversal spans both receivers with seq still increasing.

F.4 Embedded-SQL & platform-quirk adaptations

The three SQLRPGLE programs and the COBOL program use these embedded-SQL idioms; the app also carries several documented adaptations to the emulator (from PLAN.md §6 — the app is adapted AS-IS, the engine is never modified):

• EXEC SQL INSERT — the GL DR/CR pairs, e.g. insert into SENTINEL.GLPOST2 (...) values(10,'1200-PREMREC','D',:wamt,'GLRUN');
• EXEC SQL SELECT ... INTO — the balance sums (SUM(CASE WHEN DRCR='D' ...)) into host variables; POLSUM2's SELECT SUM(GLAMT) INTO :G-PRM.
• COMMIT / ROLLBACK — GLRUN commits the whole GL unit-of-work only when it balances, under the SNNIGHT STRCMTCTL LCKLVL(*CHG) boundary.
• Record-visibility across a called subprogram. Rows WRITTEN to an output-opened file are not visible to a CALLED subprogram reading the same file in the same job until the writer closes it — so reference data is seeded by REFLD (which ends, closing RATETB) before POLBIND→UWCHK, rather than inline.
• Nested if/else, never free-form elseif. Free-form if/elseif/else/endif mis-scopes the trailing END-IF on this emulator (pulling loop-body statements into the wrong branch); UWCHK and AGERUN use nested if/else everywhere a multi-way branch is needed.
• Composite-key CHAIN spelling. A free-form CHAIN cannot reference a fixed-form named KLIST, so composite keys in /free use the parenthesised form chain (policyno:instno) instr; (BILLRUN/CASHAPP); fixed-form KLIST + fixed-form CHAIN is used where appropriate.
• DDL table not an objfs *FILE. GLPOST2 is verified by SELECT COUNT(*), not objExists (D, above).

G. Glossary ↑ top

Adjudication

The middle claim step (CLMADJ): approve the reserve against the covering coverage limit (cap it if over-limit), move CLSTAT O→A, write an 'A' memo line.

Age band / rating factor

A date-of-birth band (YNG/STD/SNR in RATETB) whose factor multiplies the base premium at underwriting (UWCHK).

Arrival file

A PF read/written in arrival (physical) sequence rather than by key — here RCPTMS, POLLOG and CLMLINE (each keyed by a generated sequence number).

Commitment control

STRCMTCTL/ENDCMTCTL bracket a unit-of-work; SQL INSERTs stage until COMMIT (or discard on ROLLBACK). SNNIGHT wraps the whole GL posting chain; GLRUN decides.

Endorsement

A mid-term policy change (POLENDT): raise a coverage limit and re-rate the header by a delta; journaled 'E'.

FNOL — First Notice of Loss

Opening a claim (CLMOPEN): the CLAIMMS header + an initial 'R' reserve line.

GL feed (GLPOST2)

The DB2 table of balanced debit/credit posting rows (batches 10 premium, 20 claim, 30 commission), cross-checked SUM(DR)=SUM(CR).

Idempotent

Safe to run again with the same result. BILLRUN (dup-key skip) and POLRENEW (EXPDT-past-cutoff guard) are idempotent.

Inforce

An active policy (POLSTAT='I'); the set BILLRUN bills and POLSUM2 totals.

Journaling / DSPJRN

Recording each POLLOG change to SNJRN with before/after images (IMAGES(*BOTH)); DSPJRN renders the entries (PT/UB/UP).

Line of business (LOB)

The coverage family on a policy: A auto, P property.

POLLOG

The immutable, journaled policy transaction/audit log — one row per lifecycle event (I/E/R/C) with its amount or delta.

Pro-rata unearned premium

On cancellation (POLCANCL), the fraction of premium for the unexpired term, refunded as a negative 'C' POLLOG credit; the earned half stays as POLBAL.

Reserve

The estimated claim liability set at FNOL (TOTRSV / 'R' line), reviewed/capped at adjudication.

SBMJOB / *JOBQ

Submit a program to run as a batch job on a job queue — here SBMJOB CMD(CALL SENTINEL/SNNIGHT) JOBQ(SENTINEL/NITEQ).

Subfile (SFL/SFLCTL)

A 5250 construct listing many rows on one screen; CLMVIEW's claim-line list (CLMSFL under CLMCTL).

UWCHK

The callable underwriting subprogram: age-band rating + prior-claim decline; the program-to-program CALL proof point.

Waterfall / oldest-due-first

CASHAPP applies each receipt to the oldest open/partial installment first (bounded 1..4 key retry), partial-pay aware.