SCHOLARIS/i — K-12 School Business Office

SCHOLARIS/i is a K-12 school business-office application: a family/payer master and student master, grade-level tuition schedules, per-year fee items and financial-aid awards, a family accounts-receivable (AR) ledger, installment payment plans and cash receipts, prepaid lunch/POS accounts that are never allowed to go negative, and a balanced general-ledger (GL) feed. The book flows one way — enrollment → tuition and fees net of aid → the family ledger → cash / payment plans / lunch accounts → the GL — and every money movement is journaled to a durable audit trail. The application is deliberately minimal and hand-derivable: every posted figure is stated as exact arithmetic in the tests. This manual is the reference for the operator who runs the online screens and the three job cycles, and for the developer maintaining the application. It is grounded entirely in the committed source (school-app/src/sources.mjs, src/seed.mjs, the test/sc_*.mjs drivers, and school-app/FINDINGS.md). Everything runs in library SCHOLARIS.

A. Overview & Architecture ↑ top

A.1 What it does

SCHOLARIS/i runs a school's business office across three cycles:

• Term assessment (SCTERM). For every active enrollment in the school year, charge one term's tuition (one-third of the grade's annual figure) plus every active fee item linked to the student's grade, credit any active financial-aid award (capped at the gross charge), and post each component as a separate family-ledger line — raising the family's AR balance by exactly the net charge.
• Daily lunch & cash (SCDAILY). Apply pending lunch/POS transactions against each student's prepaid balance — a charge that would overdraw the account is declined, never applied (the never-negative invariant) — then apply cash receipts against family-ledger charges, lowering the family balance by exactly what is applied.
• Monthly close (SCMONTH). Post one payment-plan installment per active plan, age the AR ledger and assess a flat late fee per overdue family, sweep lunch accounts for low balances, then post a balanced GL distribution and a trial balance.

A.2 One-way posting model: the family balance is the spine

SCHOLARIS/i has a single financial invariant that ties the whole application together: the family's running AR balance (SCFAM.FBAL) moves only two ways — up when a charge is posted (term assessment, a plan installment, a late fee) and down when cash is applied. It is never edited directly. Every posting program that raises or lowers FBAL also writes the matching ledger line (SCLEDG) and a durable history row (SCHIST), so the book stays reconstructable and the COBOL trial balance SCGLRPT can prove, at any time, that the sum of every open ledger item's LOPEN reconciles to the sum of every family's FBAL (its BALDIFF is zero).

Two design choices keep the arithmetic honest and hand-derivable. First, tuition is charged as an exact one-third of the annual figure per term (the seeded annual tuitions — K5 6000.00, grade 03 7200.00, grade 08 8400.00 — divide cleanly into 2000.00 / 2400.00 / 2800.00, so three terms sum back to the annual figure with no rounding drift). Second, a financial-aid award is posted as a negative ledger line, so the ledger lines for a student sum directly to the net charge and the family balance rises by exactly that net.

A.3 Component & flow

  ONLINE (5250)          TERM              DAILY               MONTHLY
  -------------          ----              -----               -------
  SCMENU                 SCTERM            SCDAILY             SCMONTH
    1 -> SCSTUIQ           SCASSESS          SCLPOS  (lunch)     SCINST   (plan installments)
    2 -> SCLEDIQ            (assess)          SCCASH  (cash)      SCLATE   (aging + late fees)
                          SCGLRPT                                SCLWARN  (lunch low-bal sweep)
                           (trial bal)                           SCGLDST  (GL distribution)
                                                                 SCGLRPT  (trial balance)
       \                        |                    |                    /
        \                       v                    v                   /
         +----------------> SCFAM.FBAL  (family AR balance: up on charge, down on cash) <-+
                                 |
                                 v
         SCLEDG (open-item ledger) --+-- SCHIST (durable audit trail, disjoint key ranges)
         SCLUNCH / SCLTXN (lunch)    +-- SCGLDIST (SQL GL, balanced DR/CR pairs)
         SCPLAN (payment plans)      +-- SCRCPT (cash receipts)

A single event — say, one term charge — flows: SCASSESS reads the active enrollment → looks up the grade tuition schedule and the grade's fee links → caps any aid at the gross → writes the tuition, fee and aid ledger lines into SCLEDG → raises SCFAM.FBAL by the net → writes the SCHIST history rows the monthly GL post later sums.

A.4 Object inventory

The catalogue is 13 PFs + 2 LFs, 1 SQL table + 1 index, 3 DSPFs and 1 PRTF, driven by 11 RPGLE programs + 1 SQLRPGLE + 1 COBOL program, wired together by 4 CL programs. Sections D and F expand each.

B. Online Transactions & Screens ↑ top

B.1 The command/entry line

SCHOLARIS/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 through the menu SCMENU for the two inquiries, or a JOBQ/scheduler for the batch cycles). Before invoking anything, the job's library list must include SCHOLARIS — the tested jobs run with LIBL = QSYS QGPL SCHOLARIS QTEMP and CURLIB = SCHOLARIS.

The batch cycles take no CALL parameters. Unlike a control-row-driven design, each SCHOLARIS/i batch program carries its processing dates as literals in the source (the term run posts for period 20260901 / due 20260915; the plan run dates 20261001; the aging run dates 20261025; the GL batch is 202610), so a scheduled submission is a bare CALL. Only SCMENU, SCSTUIQ and SCLEDIQ are interactive; the batch programs run to completion and DSPLY a one-line result per step.

B.2 The menu & inquiry screens

Three interactive programs share the shipped DSPFs. The menu (SCMENU over SCMENUD) simply routes: option 1 CALLs SCSTUIQ, option 2 CALLs SCLEDIQ, any other non-blank option sets 'Invalid option.' and re-displays the menu; F3 ends it. Both inquiries return to the menu on F3.

Student / family inquiry (SCSTUIQ / SCSTUD) — a plain screen

Key a student number and press Enter. SCSTUIQ CHAINs SCSTU for the master, then SCFAM for the billing family (showing the derived family AR balance), then SCLUNCH for that student's prepaid lunch balance. A miss clears the detail and reports 'Student not found.'; a student with no lunch account leaves the lunch field blank rather than showing a stale value.

Family ledger inquiry (SCLEDIQ / SCLEDD) — the subfile screen

Key a family number and press Enter. SCLEDIQ CHAINs SCFAM for the header (family name + derived balance), then walks SCLEDG on the family key and loads one subfile row per open ledger item in sequence order. The subfile is SFLPAG(5) per page over SFLSIZ(20) with Roll paging (ROLLUP/ROLLDOWN), so a longer ledger pages.

Subfile columns (LSFL record)

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

Honest statement: SCHOLARIS/i does not model a true four-eyes maker–checker / separate-authorization workflow. There is no “one clerk posts, a second approves” gate: the term assessment, cash application, plan installments, late fees and lunch POS all post immediately when their cycle runs. The manual documents the control model the application does have:

• Durable audit trail (SCHIST). Every posting program contributes a history row for each money movement: tuition/fee/aid charges (SCASSESS), cash applied (SCCASH), plan installments (SCINST), late fees (SCLATE) and lunch POS charges (SCLPOS). This is the after-the-fact accountability trail.
• Idempotency guard (CHAIN(EN)). Every history key is derived from a stable business key in a range disjoint per program (see F.3). Before posting, the program CHAINs SCHIST on that key; if the row already exists it skips. So a re-run of any cycle for the same period posts nothing twice.
• The never-negative lunch invariant. SCLPOS refuses a charge that would overdraw a prepaid lunch balance — it stamps the transaction 'D' (declined) and leaves the balance untouched, rather than letting LBAL go negative.
• Aid capped at the gross charge. SCASSESS caps a financial-aid award at the term's gross charge, so a family is never credited past zero for a single term.
• Trial-balance reconciliation. The COBOL SCGLRPT proves ΣLOPEN = ΣFBAL (BALDIFF zero) at the end of every cycle chain, and SCGLDST posts only balanced DR/CR pairs into the SQL GL.

In sum, the control posture is durable audit + idempotency guards + hard invariants (never-negative lunch, aid cap) + trial-balance reconciliation, all enforced in the posting programs and the data, rather than a segregation-of-duties approval workflow.

C. Batch Jobs & the Periodic Cycle ↑ top

SCHOLARIS/i runs as three periodic cycles rather than one monolithic nightly job: a term cycle (tuition + fee assessment), a daily cycle (lunch POS + cash application), and a monthly cycle (plan installments + aging + late fees + lunch sweep + GL close). Each cycle is a CL driver that ADDLIBLE SCHOLARIS, CALLs its programs in a fixed order, and sends a completion banner. The batch programs take no CALL parameters — their processing dates are literals in the source — so a scheduled/JOBQ submission is a bare CALL.

-- first-time setup (once): build/compile objects, seed reference data
CALL PGM(SCHOLARIS/SCSETUP)
CALL PGM(SCHOLARIS/SCREFLD)

-- then submit a (parameterless) cycle
SBMJOB CMD(CALL PGM(SCHOLARIS/SCTERM)) JOB(SCTERM)

C.1 Full batch program set

C.2 Term / daily / monthly detail

Term — SCTERM (SCASSESS → SCGLRPT)

SCASSESS walks SCENR; for each enrollment it skips a withdrawn enrollment (ESTAT≠'A') or a wrong-year row, confirms the student is still active, then for the active enrollment: (1) charges one term's tuition = grade schedule TUITION / 3 as a 'T' ledger line; (2) writes one 'F' ledger line per active fee item linked to the grade for the year; (3) credits any active aid award, capped at the gross charge, as a negative 'A' line; then (4) raises SCFAM.FBAL by the net (gross − aid). It writes the SCHIST rows the GL post later sums. SCGLRPT then proves the trial balance.

Expected DSPLY (3 active enrollments, S00004 withdrawn):
  SCASSESS ASSESSED=3 SKIP=1

Worked arithmetic (from the test oracle):
  S00001 K5   2000.00 tuition + 150 REG + 75 ACT  = 2225.00 gross
              - 500.00 aid                         = 1725.00 net
  S00002 03   2400.00 + 150 + 75                   = 2625.00 net (no aid)
  F00001 balance = 1725.00 + 2625.00              = 4350.00
  S00003 08   2800.00 + 150 + 75 + 50 (LAB)        = 3075.00 net
  F00002 balance                                   = 3075.00
  F00003 balance (S00004 enrollment withdrawn)     =    0.00
  school-wide: gross 7925.00 - aid 500.00          = 7425.00

Daily — SCDAILY (SCLPOS → SCCASH)

SCLPOS applies each pending ('E') lunch transaction in TSEQ order against the student's SCLUNCH balance: a reload ('R') always applies and raises the balance; a charge ('C') applies only if TAMT ≤ LBAL, otherwise it is declined (TSTAT='D', balance unchanged). Because reloads and charges apply in sequence, a reload posted before a charge tops the balance up first. SCCASH then applies each unapplied receipt (RCSTAT='U') against the ledger charge it names: it takes only what is owed (any excess stays unapplied), never touches a negative-open aid credit, lowers SCFAM.FBAL by exactly what it applied, and stamps the receipt 'A' (fully applied) or 'P' (part-applied).

Expected DSPLY:
  SCLPOS APPLIED=3 DECLINED=1 SKIP=0
  SCCASH APPLIED=2 SKIP=0

Lunch worked example:
  S00001  20.00 - 4.50 charge         = 15.50  (applied)
  S00002   3.00 + 20.00 reload        = 23.00, then - 4.50 = 18.50  (TSEQ order)
  S00003  10.00 - 15.00 charge        = DECLINED, stays 10.00  (never-negative)

Cash worked example (against the term ledger):
  RC000001 2000.00 vs S00001 K5 tuition 2000.00 open -> full: open 0.00, P
           F00001 4350.00 -> 2350.00
  RC000002 1000.00 vs F00002 tuition 2800.00 open   -> part: open 1800.00, O
           F00002 3075.00 -> 2075.00; receipt itself fully applied (A)

Monthly — SCMONTH (SCINST → SCLATE → SCLWARN → SCGLDST → SCGLRPT)

SCINST posts one installment per active plan with installments remaining (PLPAID < PLCNT): a new 'T' ledger charge of PLINST, raising FBAL, advancing PLPAID and flipping the plan to 'C' when the last one posts — a plan smooths when money falls due, it does not discount the total. SCLATE runs two passes on a 30/360 date convention: pass 1 ages every open positive charge into bucket 0/1/2/3 by days overdue; pass 2 assesses one flat 25.00 late fee per active family that has any open charge past the 30-day grace (a negative aid-credit line is never aged and never triggers a fee). SCLWARN reports (read-only) any active lunch account at/below its own LWARN line. SCGLDST sums the SCHIST history by type and posts balanced GL pairs for the movement since the last close. SCGLRPT proves the trial balance.

Expected DSPLY:
  SCINST POSTED=1 SKIP=0
  SCLATE B0=0 B1=1 B2=11 B3=0 FEES=2
  SCLWARN LOW=1 OK=3
  SCGLDST BATCH=202610 ROWS=n

GL balanced pairs (worked, from the test oracle):
  DR 1400-FAR  7975.00   (charges: tuition 7200 + fees 725 + late 50)
  CR 4100-TUIT 7200.00 / CR 4200-FEE 725.00 / CR 4300-LATE 50.00
  DR 5100-AID   500.00 / CR 1400-FAR 500.00   (the aid pair, its own balanced leg)
  => SUM(DR) = SUM(CR) to the cent

C.3 Ordering & dependencies

• TERM before DAILY and MONTHLY. The daily cash-apply and the monthly aging/late-fee/GL steps all operate on the family ledger the term assessment creates. Assess first; there is nothing to apply cash against, age, or post to the GL until SCASSESS has run.
• Within DAILY: lunch POS (SCLPOS) then cash application (SCCASH) — the two halves are independent (lunch accounts vs the family ledger) but the driver fixes the order.
• Within MONTHLY: installments (SCINST) → aging + late fees (SCLATE) → lunch sweep (SCLWARN) → GL distribution (SCGLDST) → trial balance (SCGLRPT). Installments post before aging so the fresh installment charge is itself aged; the GL post runs after all charges (including late fees) exist so it sums the full period.
• Idempotency, not ordering, guards re-runs. Every posting program's CHAIN(EN) history guard means a re-run in the same period is safe (see E.3 and F.3).

D. Data Files (data dictionary) ↑ top

All files are in library SCHOLARIS, grounded in the DDS/SQL source in src/sources.mjs. Dates are stored as signed numeric in YYYYMMDD form; money is packed decimal. Field types are given as they appear in DDS (P packed, S zoned, A character).

SCFAM — Family / payer master (K FAMNO)

SCSTU — Student master (K STUNO)  /  SCSTULF (LF, K FAMNO)

SCSTULF is a non-unique logical over SCSTU keyed by FAMNO, so a family's whole roster can be walked without scanning the student file.

SCGRADE — Grade-level tuition schedule (K GRADE, SCHYR)

Seeded 2026 schedule: K5 6000.00, grade 03 7200.00, grade 08 8400.00.

SCENR — Enrollment (K STUNO, SCHYR)

SCFEE — Fee-item master (K FEECD, SCHYR)  /  SCGFEE — grade-fee links (K GRADE, FEECD)

SCGFEE maps (GRADE, FEECD, SCHYR): which fee items apply to which grade. Seeded links: REG + ACT for every grade, LAB for grade 08 only.

SCAID — Financial-aid award (K STUNO, SCHYR)

SCLEDG — Family AR open-item ledger (K FAMNO, LSEQ)  /  SCLEDLF (LF, K LDUE, FAMNO)

SCLEDLF is a logical over SCLEDG keyed by due date, so the aging run can walk oldest-due-first — the access path an ageing report wants and the family-keyed PF cannot give.

SCPLAN — Payment plan (K FAMNO)

SCRCPT — Cash receipts (K RCPTNO)

SCLUNCH — Prepaid lunch/POS account (K STUNO)  /  SCLTXN — lunch transactions (K STUNO, TSEQ)

SCHIST — Durable audit trail (K HSEQ)

SCGLDIST — GL distribution (SQL, PK GLSEQ)  /  index SCGLDACC

Index SCGLDACC is on (ACCT, DRCR) — the access path the incremental GL post uses to sum what has already been debited per account.

Relationships

• SCSTU.FAMNO → SCFAM.FAMNO (student's billing family); SCSTULF keys the same rows by FAMNO.
• SCENR.(STUNO,SCHYR) is the fact that ties a student to a GRADE → SCGRADE tuition schedule for billing.
• SCGFEE maps GRADE → the SCFEE items charged; SCAID.(STUNO,SCHYR) supplies the aid credit.
• SCLEDG.FAMNO → SCFAM.FAMNO; SCLEDLF keys the same ledger by LDUE for aging.
• SCRCPT.(FAMNO,RCLSEQ) → the SCLEDG charge it applies against.
• SCLTXN.STUNO → SCLUNCH.STUNO (POS against the prepaid account).
• SCHIST is the aggregate audit trail every posting program writes; SCGLDIST is the aggregate GL feed.

E. Operations Runbook ↑ top

E.1 Term-in-the-life

1. Once, at first setup: CALL SCHOLARIS/SCSETUP (build/compile every object), then CALL SCHOLARIS/SCREFLD (seed reference data). Confirm the banner SCREFLD FAM=3 STU=4 GRADE=3 ENR=4 FEE=3 GFEE=7 AID=1.
2. At the start of a term: submit the assessment cycle SBMJOB CMD(CALL PGM(SCHOLARIS/SCTERM)).
3. Post-check the term run (see below).
4. Each business day: load the day's lunch POS transactions and cash receipts as pending rows, then submit SCDAILY. Check the SCLPOS/SCCASH lines.
5. Handle interactive lookups through CALL SCHOLARIS/SCMENU (option 1 student inquiry, option 2 family ledger) as questions arrive.

Pre-checks: confirm the job's library list includes SCHOLARIS; confirm reference data is seeded (a fresh library needs SCREFLD before SCTERM can assess anything).

Post-checks after the term cycle:

• SCASSESS ASSESSED= equals the active enrollments and SKIP= the withdrawn/other-year ones.
• Each family's FBAL equals the sum of its ledger lines (aid credits netting off) — the term test asserts F00001=4350.00, F00002=3075.00, F00003=0.00.
• Every fresh ledger line has LOPEN = LAMT (nothing paid yet).
• The COBOL trial balance line reads SCGLRPT BALDIFF 0.00.

E.2 Month-end close

1. Confirm the term assessment has run and the month's daily cycles (lunch + cash) are all applied.
2. Load any payment-plan rows (SCPLAN) that should post an installment this month.
3. Submit SCMONTH. Confirm the completion banner and the four DSPLY lines (SCINST/SCLATE/SCLWARN/SCGLDST).
4. Reconcile the GL distribution:

SELECT ACCT, DRCR, SUM(AMT) FROM SCHOLARIS.SCGLDIST GROUP BY ACCT, DRCR;
SELECT SUM(CASE WHEN DRCR='D' THEN AMT ELSE -AMT END) AS NET FROM SCHOLARIS.SCGLDIST;

Reconciling figures (the same ones the monthly volume simulation checks against a hand-derived oracle):

• GL balances — SUM(DR) = SUM(CR) to the cent (the NET above is 0.00).
• Revenue by account — 4100-TUIT = tuition history total (7200.00), 4200-FEE = 725.00, 4300-LATE = 25.00×(late fees) = 50.00.
• Aid pair — 5100-AID debited 500.00 with a matching 1400-FAR credit — the aid reduces the receivable rather than floating unbalanced.
• Family receivable — 1400-FAR DR (charges) 7975.00, CR (aid) 500.00 — both legs of the one control account.
• Trial balance — SCGLRPT BALDIFF 0.00: ΣLOPEN = ΣFBAL.

Ad-hoc statement: the AR ageing / billing report writes through the SCAGEP printer file (header AGEHDR, one AGEDTL per aged line, an AGETOT footer with item count and total outstanding).

E.3 Failure & re-run rules

Each program DSPLYs a one-line result. A healthy chain also ends with the completion banner its CL driver sends. Because every posting program guards on a stable history key, most cycles are safe to re-run.

F. Developer Reference ↑ top

The full program surface, from src/sources.mjs. Programs are fixed-form RPG IV with embedded /free blocks (built by the C()/D() column-exact helpers), one SQLRPGLE, and one ILE COBOL. All objects are in library SCHOLARIS.

F.1 Batch programs

SCREFLD — reference-data loader

Writes the seeded families, students, grade schedules, enrollments, fee items, grade-fee links and one aid award, then DSPLYs the count banner. Mirrors the sibling apps' RLREFLD/PYREFLD loaders.

SCASSESS — term tuition + fee assessment

Reads SCENR; per active in-year enrollment: CHAINs SCSTU (family + still-active check), CHAINs SCGRADE for TUITION/3, walks the grade's SCGFEE links CHAINing each active SCFEE, caps SCAID at the gross, writes the T/F/A ledger lines and history rows, and raises SCFAM.FBAL by the net. The next LSEQ is found by a SETLL/READE partial-key walk keeping the highest seq seen.

SCCASH — cash-receipt application

Reads SCRCPT; for each unapplied receipt CHAINs the named SCLEDG charge (KLIST FAMNO+LSEQ), takes min(RCAMT, LOPEN) of a POSITIVE open charge (never an aid credit), lowers SCFAM.FBAL, writes a negative-amount 'P' history row, and stamps the receipt A/P.

SCLPOS — lunch POS run

Reads SCLTXN in key (TSEQ) order; a reload always applies, a charge applies only if it fits the balance else it is declined; re-CHAINs the transaction row after each SCLUNCH update (the update moved the file cursor) to stamp A/D. DSPLYs applied/declined/skip counts.

SCINST — plan installment posting

Reads SCPLAN; for an active plan with PLPAID < PLCNT posts one PLINST as a 'T' ledger charge, raises FBAL, advances PLPAID and flips PSTAT to 'C' on the last one.

SCLATE — AR aging + late fees

Pass 1 sequentially ages every open positive charge (30/360 serial, bucket 0/1/2/3, updating LAGE). Pass 2 walks SCFAM, and per family re-walks its own ledger rows to decide if any open charge is past the 30-day grace, assessing at most one flat 25.00 late fee (its own ledger line + history row + FBAL bump). Aid credits are never aged and never trigger a fee.

SCLWARN — lunch low-balance sweep

Read-only over SCLUNCH: counts active accounts at/below their own LWARN line vs OK, DSPLYs the tally. Never mutates a balance.

SCGLDST — GL distribution (SQLRPGLE)

Accumulates SCHIST by type (T/F/A/L), reads what has already been debited to 1400-FAR and 5100-AID via EXEC SQL SELECT, and posts only the movement since the last close as balanced pairs (the glrow subroutine INSERTs and counts only sqlcod=0 rows). The financial-aid pair is posted separately so DR total = CR total.

SCGLRPT — COBOL trial balance

Sequentially sums every SCLEDG.LOPEN and every SCFAM.FBAL, then DISPLAYs LEDGOPEN, FAMBAL, BALDIFF (should be 0.00), ITEMS and FAMS. Proves the AR sub-ledger reconciles to the family master.

F.2 Interactive programs

SCMENU (over SCMENUD)

EXFMTs the menu in a loop; option 1 CALLs SCSTUIQ, 2 CALLs SCLEDIQ, any other non-blank sets 'Invalid option.'; *IN03 (F3) ends.

SCSTUIQ (over SCSTUD)

Plain screen. EXFMT/CHAIN SCSTU → SCFAM → SCLUNCH, editing FBAL/LBAL with %editc(:'K'). Clears detail and reports the outcome message; a miss says 'Student not found.', a family-less student 'Student found -- no family on file.'

SCLEDIQ (over SCLEDD, subfile)

SFL/SFLCTL subfile. Clears the subfile with *IN31 (SFLCLR) after the EXFMT returns the new key, CHAINs SCFAM for the header, then SETLL/READE SCLEDG on the family key writing one LSFL row per open item. The message is decided AFTER the load from RRN: 'Family found.' if rows loaded, else 'No ledger for this family.'

F.3 The idempotency-key scheme (SCHIST disjoint ranges)

There is no control table and no transaction sequence generator. Instead, every posting program derives its SCHIST.HSEQ from a stable business key in a range disjoint per program, CHAINs SCHIST on it before posting (CHAIN(EN)), and skips if the row already exists. A re-run regenerates the same key and is refused — this is the app's idempotency guard.

Because the ranges are disjoint, the five programs never collide, and each is idempotent in exactly the sense its business needs: SCASSESS/SCCASH/SCLPOS/SCLATE are period-stable (a re-run posts nothing), while SCINST's key advances with the installment number so a genuinely new month posts the next installment — and refuses a second post of the same number.

F.4 Engine notes & a subfile quirk

Two implementation details are documented in the source and matter operationally:

• Same-named cross-file field capture (SCASSESS). SCGFEE and SCFEE both carry a field named SCHYR, which share one storage slot across externally-described files. The fee-item loop therefore captures SCHYR/FEECD into work fields (WGFYR/WGFFEE) immediately after the SCGFEER READE, before the SCFEER CHAIN reloads the shared slot. (An app-level fix, per FINDINGS.md.)
• Cursor movement on update (SCLPOS/SCLATE). An UPDATE to a second file moves the record cursor, so these programs re-CHAIN the transaction/family row after each dependent update before stamping or reading it. This is a deliberate accommodation, not a bug.

G. Glossary ↑ top

AR (accounts receivable)

What families owe the school. The running total per family is SCFAM.FBAL, backed by the open-item ledger SCLEDG.

Ageing bucket

How overdue an open charge is, by days past its due date: 0 current, 1 =1-30, 2 =31-60, 3 =61+ (SCLEDG.LAGE, stamped by SCLATE on a 30/360 convention).

Enrollment

The fact (SCENR) tying a student to a grade for a school year — the thing the term assessment bills. A withdrawn enrollment (ESTAT='W') is skipped even if the student master is active.

Family balance (FBAL)

The spine of the application: a family's running AR balance, moved up only by a charge and down only by cash. Never edited directly.

Financial-aid credit

A scholarship/award (SCAID) posted as a NEGATIVE ledger line, capped at the gross charge, so the family's net charge is gross minus aid.

Gross vs net charge

Gross = one term's tuition + the grade's fees; net = gross minus any aid credit. The family balance rises by the net.

Idempotent

Safe to run again with the same result. Here enforced by a CHAIN(EN) guard on a stable, business-key-derived SCHIST.HSEQ (see F.3). Term/daily/late/GL cycles are idempotent within a period; plan installments advance across months by design.

Lunch / POS account

A student's prepaid meal balance (SCLUNCH). A charge that would overdraw it is declined — the never-negative invariant.

Never-negative invariant

The rule that a prepaid lunch balance is never allowed below zero: SCLPOS declines an overdrawing charge rather than applying it.

Open item / LOPEN

A ledger charge's outstanding amount, reduced as cash is applied; SCGLRPT proves ΣLOPEN = ΣFBAL.

Payment plan

An installment arrangement (SCPLAN) that smooths WHEN a family's charges fall due; SCINST posts one installment per month as a ledger charge. It does not discount the total owed.

SBMJOB

Submit Job — the IBM i command that queues a program as a batch job (e.g. SBMJOB CMD(CALL PGM(SCHOLARIS/SCTERM))).

Subfile

A 5250 display construct listing many rows on one screen (DDS SFL/SFLCTL). SCLEDIQ's family ledger list is a subfile.

Trial balance (SCGLRPT)

The COBOL reconciliation proving the AR sub-ledger ties to the family master; its BALDIFF is the single “does the book balance” number.