GRANARY/i — Grain Elevator Co-op

GRANARY/i runs the operations of a grain elevator cooperative: producer members drive loaded trucks onto the scale, each load is weighed and sampled into a scale ticket, the ticket is graded (net weight, then moisture/dockage shrink deducted to net bushels), priced against the grower's contract, and posted — creating grain inventory in a storage bin and a settlement liability the co-op owes the member. A separate settlement run pays those liabilities through the member AR/AP ledger; at fiscal year-end a patronage dividend is allocated off each member's volume of business and the general ledger closes. The logic is hand-written RPG/COBOL/CL/DDS plus a little embedded SQL, driven as three CL job cycles. This manual is the reference for the operator who runs the online screens and the periodic cycles, and for the developer maintaining the application. It is grounded entirely in the committed source (grain-app/src/sources.mjs, src/seed.mjs, and the test/gr_build.mjs / gr_daily.mjs / gr_settle.mjs / gr_annual.mjs drivers). Everything runs in library GRANARY.

A. Overview & Architecture ↑ top

A.1 What it does

GRANARY/i covers the full life of a load of grain through a country elevator:

• Weigh-in & grade — a truck is weighed loaded (gross) and empty (tare) giving net pounds; a sample gives moisture, test weight and dockage. Grading converts net pounds to raw bushels at the commodity's legal bushel weight, then deducts shrink bushels for moisture and dockage over the commodity's discount-free thresholds, yielding net bushels.
• Price & post — a graded ticket is priced against the member's contract (cash at the contract price; a deferred contract not yet priced is held). Pricing posts the net bushels into the storage bin's grain inventory, writes a settlement liability (net bushels × price) the co-op owes the grower, credits the member AR/AP ledger, and advances the contract fill.
• Settle — a settlement run pays every unpaid settlement, posting a debit to the member AR/AP ledger and moving cash, so a fully-paid member's running balance nets to zero.
• Patronage — at fiscal year-end each member's settled-bushel volume earns a flat per-bushel patronage dividend, which accrues to the member's paid-in equity and the ledger.
• GL close — the annual close sums the AR ledger by type and posts balanced debit/credit pairs into the SQL GL feed; every batch balances to zero.

A.2 The grain-flow architecture: files, RPG/COBOL programs, three CL cycles

Unlike a SQL-PL application, GRANARY/i keeps its business rules in hand-written RPG (and one ILE COBOL reconciliation report) operating over keyed DB2 for i physical and logical files, with a small amount of embedded SQL only where a set-based total or the GL feed makes it natural (GRGLPST). The structure has three layers:

• Data layer. Nine physical files and five logical (alternate-key) files hold members, commodities, bins, grain inventory, contracts, scale tickets, settlements, the AR/AP ledger and patronage accruals, plus one SQL-defined GL feed table. The logical files provide the by-commodity, by-member and by-status access paths the batch programs walk.
• Program layer. Each business step is one program: GRGRADE grades, GRPRICE prices and posts, GRSETLR pays, GRPATRN allocates patronage, GRGLPST posts the GL, with report programs (GRTKTPR, GRARBAL, GRRECON) and interactive inquiries (GRMENU, GRBININQ, GRTKTIQ) alongside.
• Cycle layer. Three CL programs chain the batch steps into the co-op's rhythm: GRDAILY (grade → price → report), GRSETLC (settle → balance → reconcile), GRYEAR (patronage → GL → reconcile). A fourth CL, GRSETUP, creates every object and compiles every program.

The benefit for operations: each step is a small, re-runnable program guarded by a status flag on the record it processes, and each cycle is a single CALL that runs its steps in the fixed correct order. Every money movement lands in the durable AR/AP ledger, so a member balance and the co-op's whole position are always reconstructable.

A.3 Component & flow

  ONLINE                    DAILY (GRDAILY)          SETTLE (GRSETLC)       ANNUAL (GRYEAR)
  ------                    ---------------          ----------------       ---------------
  GRMENU (5250)             GRGRADE  grade tickets   GRSETLR pay settls     GRPATRN patronage
    1 -> GRBININQ             O -> G  (shrink)         N   -> Y (paid)         settled bu x rate
    2 -> GRTKTIQ (subfile)  GRPRICE  price + post    GRARBAL member bals    GRGLPST GL feed
                              G -> P  inventory in    GRRECON conservation   GRRECON conservation
                                      settlement out
                            GRTKTPR  status report

  SCALE TICKET (GRTKT)  O weighed-in -> G graded -> P priced/posted
       |                                    |
       |  grade: net lb / bushel wt         |  price: net bu x contract price
       v                                    v
   net bushels ------ inventory ----> GRSTK (bin grain on hand)
                 \                    GRSETL (one settlement per priced ticket)
                  +---- liability --> GRAR  (member AR/AP ledger: S credit, Y debit, P credit)
                                      GRCTR.CTFILL advanced        GRMEMB.MEQTY grown by patronage
                                      GRPATR (year-end accrual)    GRGLFEED (balanced DR/CR)

A single load flows: a scale ticket is written OPEN → GRGRADE computes shrink and net bushels, flipping it to GRADED → GRPRICE prices it against the contract, posting bushels into GRSTK, a row into GRSETL, a credit into GRAR, advancing GRCTR.CTFILL, and flipping the ticket to PRICED. The settle and annual cycles then draw the liability down and close the books — all money, never grain, so grain conservation holds throughout.

A.4 Object inventory

The full catalogue is 9 PFs + 5 LFs + 1 SQL table, 3 DSPFs + 1 PRTF, 11 RPG programs, 1 COBOL program and 4 CL programs. Sections D and F expand each.

B. Online Transactions & Screens ↑ top

B.1 The command/entry line

GRANARY/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 cycles). 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 GRANARY — the tested jobs run with LIBL = QSYS QGPL GRANARY QTEMP and CURLIB = GRANARY.

The batch cycles and programs take no CALL parameters — each processes whatever records are in the right status, so a scheduled submission is a bare CALL. Only GRMENU, GRBININQ and GRTKTIQ are interactive; the batch programs run to completion and DSPLY a one-line result per step (e.g. GRGRADE GRADED= 3 SKIP= 0).

B.2 The menu & inquiry screens

GRMENU / GRMENUD — main menu

GRMENU presents the two-option menu and dispatches by calling the chosen inquiry program. Option 1 calls GRBININQ; option 2 calls GRTKTIQ; any other non-blank option shows Invalid option. F3 exits.

GRBININQ / GRBIND — bin / grain-inventory inquiry (plain screen)

The operator keys an elevator and bin; the program CHAINs the bin master (GRBIN) and walks the bin's grain-inventory rows (GRSTK) to show what it holds and the fill percent against capacity. A bin that exists but has no inventory shows Bin found -- no inventory yet.; an unknown bin shows Bin not found.

GRTKTIQ / GRTKTD — scale-ticket inquiry (subfile)

GRTKTIQ presents a subfile (DDS record TSFL under control record TCTL, SFLPAG(5) per page, SFLSIZ(20)) of scale tickets, filtered by the status the operator keys in Status filter: O open, G graded, P priced, or * for all. Each pass clears and reloads the subfile from the by-status/date logical file (GRTKTLF), so the filter takes effect immediately, and shows the count and total net bushels matched.

• Enter — apply the filter, clear and reload the subfile.
• Roll Up / Roll Down — page the subfile (DDS ROLLUP(25)/ROLLDOWN(26), SFLEND(*MORE)).
• F3 (Exit) — leave the program (DDS CA03).

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

Honest statement: GRANARY/i does not model a true four-eyes maker–checker / separate-authorization workflow. There is no "one clerk grades, a second approves" or "one user prices, a second releases the payment" step in the code: the daily chain grades and prices in one run, and the settlement run pays every unpaid settlement without a separate release. The manual documents the control model the application does have:

• Status gating on every record. A ticket moves O → G → P and each program only acts on its own inbound status: GRGRADE touches only TSTAT='O', GRPRICE only 'G', and both flip the flag as they go, so a step can never double-process a record. Settlements gate on SPDFLG (N→Y); patronage gates on the GRPATR (FYEAR, MEMBNO) key.
• The durable AR/AP ledger (GRAR). Every money event — a settlement liability booked (LTYPE='S', positive), a payment made ('Y', negative), a patronage accrual ('P', positive) — posts one signed, sequence-keyed row. A member's balance is the running sum of their rows, and the whole ledger is the reconstructable audit trail of what the co-op owes and has paid.
• Business gating on state. A deferred contract still carrying CTSTAT='D' (not yet priced by the grower) is refused by GRPRICE: no inventory, no settlement, no ledger row — the ticket stays graded until the contract is priced. Only active members (MSTAT='A') accrue patronage.
• Idempotency guards (stable keys). Every posting program derives a stable key from the record it processes (settlement key from the ticket number; ledger keys from the ticket number or member/year) and refuses re-entry with a CHAIN(EN) "already exists" test, so a re-run of any cycle posts nothing new. This is the integrity backbone in place of a segregation-of-duties gate.
• Grain conservation as a control. GRRECON (ILE COBOL) independently sums bushels ticketed in (net bushels on priced tickets) against bushels stored (GRSTK on hand) every settle and annual cycle; the two must match. Settlement and the annual close move money and equity, never grain, so the invariant is a continuous cross-check.

In sum, the control posture is per-record status gating + a durable signed ledger + stable-key idempotency + a grain-conservation cross-check, all enforced in the programs and files, rather than a segregation-of-duties approval workflow.

C. Batch Jobs & the Periodic Cycle ↑ top

GRANARY/i's processing runs as three CL job cycles rather than one monolithic job, matching a country elevator's rhythm: a daily grade-price-inventory chain as trucks come off the scale (GRDAILY), a settlement run that pays members (GRSETLC), and an annual patronage allocation + GL close (GRYEAR). Every batch program takes no CALL parameters — each simply processes whatever records are in the right status — so a scheduled submission is a bare CALL (or SBMJOB). There is no control table: the fiscal year and patronage rate that the annual programs need are compiled constants (GRPATRN uses wfy = 2025, wrate = 0.1500; GRGLPST uses wbatch = 202512), so the co-op re-hosts a new year by rebuilding those two programs.

-- run a cycle directly, or submit it to a job queue
CALL PGM(GRANARY/GRDAILY)
SBMJOB CMD(CALL PGM(GRANARY/GRSETLC)) JOB(GRSETLC)
SBMJOB CMD(CALL PGM(GRANARY/GRYEAR))  JOB(GRYEAR)

C.1 Full batch program set

The three cycle drivers (GRDAILY, GRSETLC, GRYEAR) each ADDLIBLE GRANARY then chain their steps with plain CALL PGM(...) and end with a SNDPGMMSG completion banner. GRSETUP is the one-time object-build CL (delete + CRTPF/CRTLF/CRTDSPF/CRTPRTF/RUNSQLSTM + CRTBNDRPG/CRTBNDCBL for every member).

C.2 Daily / settle / annual detail

Daily — GRDAILY (GRGRADE → GRPRICE → GRTKTPR)

GRGRADE walks GRTKT and grades every TSTAT='O' ticket: TBU = TNET / CBASETW (net pounds ÷ the commodity's legal bushel weight), then subtracts shrink bushels for moisture over CBASEM and dockage over CDOCKPT (TSHKBU = TBU × (moist-pts × CSHMOIS + dock-pts × CSHDOCK)), giving TNETBU; it flips the ticket to 'G'. GRPRICE then prices every 'G' ticket against its contract: a cash contract prices at CTPRICE; a deferred contract still carrying CTSTAT='D' is skipped (counted as DEFERRED, left graded). A priced ticket posts TNETBU into the bin's GRSTK row, writes one GRSETL settlement (SNETAMT = TNETBU × SPRICE) and one GRAR credit (LTYPE='S'), advances CTFILL, and flips the ticket to 'P'. GRTKTPR prints the resulting status counts.

Expected DSPLY (the tested 3-ticket day: two cash, one deferred-unpriced):
  GRGRADE GRADED=3 SKIP=0
  GRPRICE PRICED=2 DEFERRED=1 SKIP=0    T0000003's deferred contract is unpriced
  GRTKTPR OPEN=0 GRADED=1 PRICED=2 NETBU=1945.00   962.00 + 983.00

Settle — GRSETLC (GRSETLR → GRARBAL → GRRECON)

GRSETLR walks GRSETL and pays every SPDFLG='N' settlement: it posts a negative ('Y', debit) GRAR row for SNETAMT and flips SPDFLG to 'Y'. Because the settlement credit and the payment debit are equal and opposite, a fully-paid member's running ledger balance nets to exactly zero. GRARBAL then reports each member's balance by control-break over GRARLF, and GRRECON cross-checks grain conservation.

Expected DSPLY (paying the two tested settlements):
  GRSETLR PAID=2 TOTAL=15387.75 SKIP=0   4329.00 + 11058.75
  GRARBAL MEMB=M00001 BALANCE=0.00       credit + payment net to zero
  GRARBAL MEMB=M00003 BALANCE=0.00
  GRARBAL MEMBERS=2 GRANDTOTAL=0.00
  GRRECON TICKETED     1945.00           settlement moved money, not grain
  GRRECON STORED       1945.00

Annual — GRYEAR (GRPATRN → GRGLPST → GRRECON)

GRPATRN reads every member, sums that member's settled bushels for fiscal year 2025 (walking the member-keyed settlement path, filtering on %int(sdt/10000)=wfy), and allocates PALLOC = PBU × 0.1500. It writes a GRPATR accrual, a GRAR credit ('P'), and grows MEQTY by the same amount. Only active (MSTAT='A') members with settled bushels accrue. GRGLPST then totals the whole AR ledger by type and posts balanced DR/CR pairs (see F.5), and GRRECON re-checks conservation.

Expected DSPLY (the tested year: M00001 962 bu, M00003 983 bu settled):
  GRPATRN ALLOCATED=2 SKIP=2   M00002 (unpriced) & M00004 (no tickets) skip
       M00001: 962.00 x 0.1500 = 144.30 -> equity 12500.00 -> 12644.30
       M00003: 983.00 x 0.1500 = 147.45 -> equity  3200.00 ->  3347.45
  GRGLPST BATCH=202512 ROWS=6
  GRRECON TICKETED     1945.00   patronage/GL moved money and equity, not grain
  GRRECON STORED       1945.00

C.3 Ordering & dependencies

• Within the daily cycle grade must precede price: GRPRICE only acts on TSTAT='G' tickets, which only GRGRADE produces, and it reads TNETBU that grading computes. The report runs last so its counts reflect the day.
• Daily before settle. A settlement row only exists once GRPRICE has written it; GRSETLR has nothing to pay until the day's pricing has run.
• Settle before annual. Patronage is off settled bushels for the year, and the GL close totals the ledger's settlement/payment/patronage rows. Run the year's dailies and settlements, then the annual close last so the snapshot reflects fully-settled activity.
• Every cycle is safely re-runnable. Each posting program derives a stable key from the record it processes and guards on it (plus the status flag), so a repeated CALL of any cycle posts nothing new — inventory, settlements, payments, patronage and GL rows do not double (F.3).

D. Data Files (data dictionary) ↑ top

All files are in library GRANARY, grounded in the DDS in src/sources.mjs. Dates are packed/signed numerics in YYYYMMDD form (4S 0 crop year is YYYY); money and quantities are packed decimal (P); prices and shrink rates carry 4 decimal places so fractional cents and fractional-percent shrink factors are exact. Nine physical files, five logical (alternate-key) files and one SQL table.

GRMEMB — Member (producer) master (PK MEMBNO)

GRCOMM — Commodity master (PK COMM)

Seeded set: CORN 15.00%/56.00lb/2.00%/.0140/.0100; SOYB 13.00%/60.00lb/1.00%/.0120/.0100; WHET 13.50%/60.00lb/1.00%/.0130/.0100.

GRBIN — Storage bin master (PK ELEV+BIN)

GRSTK — Grain inventory (PK ELEV+BIN+COMM+CROP)

GRCTR — Price contract (PK CTRNO)

GRTKT — Scale ticket (PK TKTNO)

GRSETL — Settlement (PK SETLNO) — one row per priced ticket

GRAR — Member AR/AP ledger (PK LSEQ) — the durable running balance

GRPATR — Patronage accrual (PK FYEAR+MEMBNO)

GRGLFEED — SQL GL feed (PK GLSEQ)

Logical files (alternate access paths)

E. Operations Runbook ↑ top

The worked figures below are the exact ones the test drivers hand-derive and assert (test/gr_daily.mjs, gr_settle.mjs, gr_annual.mjs). They make the best reconciling worked-example: a single day of two cash tickets and one deferred-unpriced ticket, carried all the way through settlement and the annual close.

E.1 Day-in-the-life

Trucks come off the scale and their OPEN scale tickets are written to GRTKT (in this build the weigh-in row is written directly — there is no interactive weigh-in screen; B.1 note). Then run the daily cycle:

-- first-time only: build the objects and seed reference data
CALL GRANARY/GRSETUP
CALL GRANARY/GRREFLD

-- each day, after the day's OPEN tickets are on GRTKT:
CALL GRANARY/GRDAILY        GRGRADE -> GRPRICE -> GRTKTPR

The tested day's three tickets:

Shrink worked: T0000001 moisture 17.0% is 2.0 pts over CORN base 15.0 → 2.0×.0140=.0280; dockage 3.0% is 1.0 pt over threshold 2.0 → 1.0×.0100=.0100; total .0380 × 1000 = 38.00 bu. T0000003 sits exactly at base moisture (15.0%) and exactly at the dockage threshold (2.0%), so zero shrink either way. Its deferred contract is still CTSTAT='D', so GRPRICE defers it: no inventory, no settlement, no ledger row; the ticket stays graded.

After GRDAILY: bin A-100 holds 962.00 bu, B-200 holds 983.00 bu, A-101 holds nothing; GRSETL has 2 unpaid rows; GRAR has 2 'S' credit rows (M00001 +4329.00, M00003 +11058.75); CT000001.CTFILL=962.00, CT000003.CTFILL=983.00, CT000002.CTFILL=0. GRTKTPR reports OPEN=0 GRADED=1 PRICED=2 NETBU=1945.00.

E.2 Settlement & year-end close

CALL GRANARY/GRSETLC        GRSETLR -> GRARBAL -> GRRECON
CALL GRANARY/GRYEAR         GRPATRN -> GRGLPST -> GRRECON

Settlement. GRSETLR pays both unpaid settlements — PAID=2 TOTAL=15387.75 (4329.00 + 11058.75) — posting a 'Y' debit of −4329.00 for M00001 and −11058.75 for M00003 and flipping both SPDFLG to Y. Each member's running balance now nets to exactly zero (credit + equal debit), which GRARBAL confirms: MEMBERS=2 GRANDTOTAL=0.00.

Year-end. GRPATRN allocates a flat 0.1500/bu patronage off each active member's settled fiscal-2025 bushels — ALLOCATED=2 SKIP=2 (M00002 was never priced, M00004 had no tickets):

Then GRGLPST posts the annual GL batch 202512 (six rows, three balanced DR/CR pairs — see F.5) and GRRECON re-confirms conservation.

E.3 Reconciling figures & the grain-conservation invariant

Three invariants must hold after every cycle; the operator can read them straight off the DSPLY lines and the reports:

• Grain conservation. GRRECON (ILE COBOL) independently sums bushels ticketed in (TNETBU on every 'P' ticket) and bushels stored (GQTY across GRSTK). Both must read 1945.00 (962.00 + 983.00). Settlement and the annual close move money and equity, never grain, so this figure is byte-for-byte identical before and after those cycles.
• Settlement balance. Each priced ticket writes exactly one settlement and one ledger credit; each payment writes one equal, opposite ledger debit. A fully-paid member's running GRAR balance is 0.00, and GRARBAL's grand total is 0.00.
• GL balance. Every GRGLPST batch is matched DR/CR pairs, so total debits equal total credits (the tested year: 31,067.25 = 31,067.25).

F. Developer Reference ↑ top

F.1 The grade & price formulas

Grading (GRGRADE). Net pounds come off the scale as TNET = TGROSS - TTARE (written on the ticket). Raw bushels convert at the commodity's legal bushel weight, not the load's tested weight:

  TBU     = TNET / CBASETW                       e.g. 56000 / 56.00 = 1000.00
  moispts = max(TMOIS - CBASEM, 0)               points over base moisture
  dockpts = max(TDOCKPT - CDOCKPT, 0)            points over the dockage-free threshold
  TSHKBU  = TBU * (moispts*CSHMOIS + dockpts*CSHDOCK)
  TNETBU  = max(TBU - TSHKBU, 0)                 clamped non-negative

Test weight (TTESTWT) is sampled and stored but does not enter the pound-to-bushel conversion in this model — a bushel is fixed by the commodity's legal weight (CBASETW); test weight is a grade/discount input reserved for future quality discounting. A commodity with CBASETW ≤ 0, or a ticket whose commodity is not found, is skipped (counted in SKIP), never divided by zero.

Pricing (GRPRICE). A graded ticket prices at its contract price: SNETAMT = TNETBU × CTPRICE. A deferred contract still carrying CTTYPE='D' and CTSTAT='D' is deferred (counted in DEFERRED, ticket left graded). Otherwise pricing performs five posts in order: (a) add TNETBU to GRSTK (write the bin row if new); (b) write the GRSETL row; (c) write the GRAR 'S' credit; (d) advance CTFILL; (e) flip TSTAT to 'P'. Each of (d) and (e) re-CHAINs its record defensively, since the intervening writes moved the file cursor.

F.2 Programs

F.3 Idempotency & ledger keys

Every posting program derives a stable key from the record it processes and refuses re-entry with a CHAIN(EN) guard, so any cycle is safely re-runnable. The CHAIN(EN) polarity is the standard one: the indicator is ON when the row is NOT found (genuinely new → write) and OFF when it IS found (already posted → skip).

F.4 Engine-compatibility notes

• Subfile conditioning indicators (GRTKTD). The emulator's DDS parser reads conditioning indicators from 1-based columns 8-10/11-13/14-16 instead of the true DDS positions 7-9/10-12/13-15. The N31/31 indicators on SFLDSP/SFLDSPCTL/ SFLCLR are therefore written one column left of the standard position (the keyword itself stays in column 45), exactly as wms-app's WHPCKD documents. Without this, the subfile would never clear/reload.
• Defensive re-CHAIN. After a WRITE to a sibling file, posting programs re-CHAIN a record before updating it, since the intervening write moved the file cursor — a house convention shared with the wms-app programs.
• GL delta posting. GRGLPST tracks prior-posted per-account credit totals in SQL and posts only the movement, so re-totalling the whole ledger on a second close does not re-derive the first close's primary keys (which would be silently refused by the insert).

F.5 GL account map

GRGLPST sums the AR ledger by LTYPE and posts three balanced pairs:

1400-INV grain inventory/purchases, 2100-APM accounts payable – members, 1000-CSH cash, 6100-PEX patronage expense, 2900-PEQ member equity – patronage payable. Total debits 31,067.25 = total credits 31,067.25.

G. Glossary ↑ top

Scale ticket (GRTKT)

The record of one load of grain: gross/tare/net weight, sampled moisture/test-weight/dockage, and the computed bushels. Moves O (weighed in) → G (graded) → P (priced/posted).

Gross / Tare / Net

Loaded weight, empty-truck weight, and their difference (net pounds of grain) — all in pounds off the scale.

Grading

Converting net pounds to raw bushels at the commodity's legal bushel weight, then deducting shrink, yielding net bushels.

Shrink

Bushels deducted for moisture above the base and dockage above the free threshold, at the commodity's per-point shrink rates. Reflects that wet/dirty grain yields fewer marketable bushels.

Net bushels (TNETBU)

Raw bushels minus shrink — the bushels that actually get inventoried and paid.

Bushel / legal bushel weight (CBASETW)

A bushel is defined by a commodity's standard test weight (corn 56 lb, soybeans/wheat 60 lb). That fixed weight is the pound-to-bushel divisor.

Contract (GRCTR)

A price agreement: cash (priced now at CTPRICE) or deferred (grain stored, priced later; unpriced deferred contracts cannot settle).

Bin / grain inventory (GRBIN / GRSTK)

A storage bin holds one commodity/crop at a time; its GRSTK row is the net bushels on hand — the co-op's physical grain position.

Settlement (GRSETL)

One row per priced ticket recording what the co-op owes the grower (net bushels × price). Booked unpaid (SPDFLG='N'), then paid by the settlement run ('Y').

AR/AP ledger (GRAR)

The durable, signed, sequence-keyed running-balance trail: S settlement credit, Y payment debit, P patronage credit. A member's balance is the running sum.

Patronage dividend (GRPATR)

A co-op returns a share of margins to members by volume of business. Here: a flat per-bushel rate on each active member's settled fiscal-year bushels, accrued to member equity (MEQTY).

Member equity (MEQTY)

A member's paid-in patronage capital, grown by each year's patronage accrual.

Grain conservation

The invariant that bushels ticketed in equal bushels stored; money and equity move in settlement and the close, grain does not. Cross-checked by GRRECON.

GL feed (GRGLFEED)

The general-ledger feed table the annual close posts balanced debit/credit pairs into; every batch sums to zero.

Cycle

One of the three CL job chains: GRDAILY (grade/price), GRSETLC (settle), GRYEAR (patronage + GL close).

Idempotency guard

A stable derived key plus a status flag that lets any cycle be re-run without double-posting.