The business caseThe problem this solves

"Which contracts have a delivery period opening soon" is a SELECT and nobody needs a language model for it. The question a grain merchandiser is actually asking on a Monday morning is the next one: of the contracts still open, which ones still owe bushels, and of those, which one is this the LAST run that can still offer the producer a roll. Three terms decide it and two are not on the page. The unfilled balance is printed nowhere -- the record states what was applied since last Monday and never the running total. The bushels that actually counted depend on reading a scale-house line that says a load was turned away rather than one that says it was taken at a discount, and both sentences mention moisture, grade and the discount schedule. And whether a roll is available at all depends on a roll that may have been executed in a week whose record is not on this screen. Somebody working down the open-contract report on a Monday: opening each contract, adding up the scale tickets applied since the last look, deciding which loads were turned away and which were merely discounted, counting business days back from the delivery period, and remembering whether the producer has already been rung about this one.

The inputThe actual open-contract records

The corpus is 150 open-contract records, 0.74 MB (json 1 · jsonl 1 · txt 150). AN ELEVATOR'S OPEN-CONTRACT BOOK IS THE MOST COMMERCIALLY SENSITIVE ARTEFACT A GRAIN MERCHANDISER KEEPS. It is every producer's position, every price they took and every one they did not, and there is no public one. The alternative -- a scrubbed real book -- is worse, because scrubbing is exactly the step that quietly changes what the model is being asked to read, and the prose is what this kit measures. So the corpus is generated and the generator is committed beside it. Three things it does on purpose. The running balance is printed NOWHERE, so it can only be carried. The scale-ticket phrasings collide in both directions -- rejections with no rejection vocabulary, applications full of it. And the roll phrasings collide the same way, which was added AFTER a measurement rather than before: with five templates a side the free keyword floor scored 98.67 pct on rollover risk before a single call was made, which was a fact about ten templates and not about the work. Four harder templates took the same floor to 95.33 pct with its errors running both ways.

Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated open-contract record for an AI
use-case kit; it reproduces no grain contract, no elevator's terms and conditions, no
exchange rule and no state warehouse regulation. The clauses are ILLUSTRATIVE.

Contract
----------------------------------------------------------------
Elevator                       : EL-318 (Two Creeks Grain)
Contract reference             : CT-2026-0001
Producer reference             : PRD-9460
Commodity                      : Soybeans, US No 1
Contracted quantity            : 20,000 bu
Contract type                  : CASH FORWARD
Price status                   : flat price fixed at 10.8800 USD/bu
Delivery period                : 2026-10-17 to 2026-11-14  (delivery river terminal)
Board reference, this run      : 11.0112 USD/bu

Delivery Terms
----------------------------------------------------------------
Delivery tolerance             : 0.5 pct of the contracted quantity (100 bu)
Roll notice period             : 5 business days before the delivery period opens
Rolls permitted                : 1 over the life of the contract
Roll deadline                  : 2026-10-12  (5 business days before the period opens)
Default clause                 : past the roll deadline with a balance above tolerance,
                                 the balance is cancelled and priced against the board at
                                 the close of the delivery period, at the producer's cost

Rule C-1  The UNFILLED BALANCE is the contracted quantity less every bushel applied against the
          contract to date. Applications are reported PER WINDOW on this record; the running total

The outcomeWhat a good result looks like

Every open contract with a balance above its tolerance is on the watchlist with the bushels still owed, what happens to them if nobody acts, and exactly one decision raised per contract on the last run that can still see the deadline.

Where it fitsWhat did work

Every line below is a measured result from this kit's own runs, with the figure that supports it. The headline above is not softened by any of them.

• You already know each contract's balance and only need the contracts near a deadline — a SQL query, or the b000 floor in this repo
  Counting business days back from a delivery period is arithmetic, and every arm here gets the deadline right: 0 missed decisions of 13 on all five, including the free ones.
• Your grain accounting system prints a cumulative applied-to-date figure on every statement — the b001 floor: the carried balance replaced by the printed one, no model
  The entire memory argument here rests on the running total being unrecoverable from the page. Print it and the stateless arm stops being 40.00 pct on the bushel balance and starts being nearly free.
• Your contract activity log carries coded event types from a closed list — the b002 floor: code-only, keying on your own codes rather than on prose
  The model's whole margin on this corpus is prose. The floor already TIES it on rollover risk (95.33 pct each) and the remaining gap is 4.00 points of bushel accuracy, all of it on sentences a code would have disambiguated.
• Your activity log is prose a merchandising clerk types, and a producer's relationship is at stake — this kit, with the carried state
  That is exactly the corpus these figures were measured on. At the same headline accuracy the model offered 0 rolls that were not available and the free floor offered 5 -- the error that reaches the producer as a promise the elevator has to withdraw.
• You want the watch to actually wake up on a Monday — your own scheduler -- cron, Airflow, Temporal, whatever already runs
  evals/run.py is INVOKED, not woken. Nothing in this kit detects a missed run, back-fills it or marks its readings late -- and evals/cadence.py prices what that is worth: 4 contracts a week warned by nobody on any schedule, and a balance that stays wrong for the rest of the contract's life.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-23. Every figure on these pages was captured from that run — nothing is written from intent.

14 steps, grouped by the question that sends you to them rather than by build order. Each tile carries the one figure that step is about, and opens the page behind it.

Should you use this?What you bring, where it stops, and when not to use it

Before you commit an afternoon to this, these are the answers that decide it. Each one is rendered from the record it lives in — and links the page that holds it in full.

Not asked of this kit — 2 questions: clone (a fresh clone of this kit runs with nothing fetched); judge (nothing here is graded by a model).

Last verified 2026-08-23 — r001-contract-expiry. Every figure on these pages was captured from that run.

Run itHow this reaches your data

Every result on this page was produced by pure code over checked-in files, with no API key — which is why you can read the numbers before anyone spends anything.

Checked before this shipped — A fresh clone with NO key configured reproduces: the 150 records and the answer key (regenerated byte-for-byte by python3 -m tools.build_corpus), all of evals/check_labels.py, the whole of evals/cadence.py including every missed-run figure on this page, all three free floors, and the UI with the model column replayed from the committed result file. The only thing a key buys is a NEW model reading.

Step 01 of 14Business case

Written for: product manager · Measured during the eval run. Never estimated, never quoted from a vendor page.

In brief

What the clock covers. END-TO-END per reading: one HTTP request carrying the assembled prompt, and the reply parsed to a struct. Measured over the 149 readings that returned something on run r001-contract-expiry, at 12 concurrent contract chains, so it is the latency a reader experiences under load rather than a single quiet call. The whole 150-call run took 444.4 seconds of wall clock.

Current processWhat it replaces

Somebody working down the open-contract report on a Monday: opening each contract, adding up the scale tickets applied since the last look, deciding which loads were turned away and which were merely discounted, counting business days back from the delivery period, and remembering whether the producer has already been rung about this one.

Step 02 of 14Architecture

Written for: solutions architect · Component map derived from the real code, not drawn from intent.

In brief

CorpusCorpusArchitectureArchitectureArchitectureArchitectureEvalsEvalsEvalsEvalsPromptPromptPromptPromptApp UIApp UIEvalsEvalsBusiness caseUnit cost

• 1stations numbered in run order
• txt
• jsonl
• json
• 4 of 10 stations carry a recorded failure

scroll → 10 stations

One question, end to end. Colour on the fan-in is the corpus format; a red hook marks every station with a recorded failure, and the words — every sub line, failure and report field — are in the ledger beneath. Every station is a link — click one to jump to its row, and each row links to the lens that explains it.

The swap seams

Components

Step 03 of 14App UI

Written for: anyone, in 5 seconds · Screenshots of the running app taken during the run.

SuccessesWhen it works

LimitsWhen it does not

A report showing only wins is an advert. This one is required, and the validator now refuses a kit that omits it.

Step 04 of 14Corpus

Written for: "can I point this at mine?" · Measured off the corpus the run actually used.

In brief

How it is cutWhat one contracts (5 scheduled runs each) is

No split, and no chunking. The unit is a CONTRACT -- five consecutive Mondays processed strictly in order, because week 4's prompt contains a balance produced by week 3. Different contracts are independent and run concurrently; a contract's own runs never do.

SetupWhat the setup figure measured

There is no index and no retrieval step -- the population is re-read whole on each scheduled run. What makes a reading a CHANGE is the four scalars the previous run left behind, computed in code before the call, which cost nothing and are not retrieved.

LicenceLicence

MIT -- this repository's own licence. Nothing is fetched and no third-party grant is involved; every byte was written by the generator committed beside it.

Bring your ownBring your own open-contract records

Point tools/build_corpus.py at your own book, or replace data/corpus/*.txt and data/gold.jsonl directly. Keep the seven section headings in src/segment.py::SECTIONS -- the parser asserts all seven in every document before a run may spend -- and supply gold rows with the same columns.

⚠︎ And what stops being true when you do: The measured figures on this page do not travel with your corpus, and three of them are corpus properties rather than model properties: the cadence is weekly, the population does not change between runs, and the running balance is recoverable from nothing on the page. Change any of the three and the numbers here are about a different question.

Step 05 of 14Prompt

Written for: engineer · Logged from the run, verbatim.

In brief

The assembled prompt in full, and its real decomposition. Every part below occurs in the prompt that was actually sent. The split is in characters, because that is what this run recorded — the billed totals are measured, but nothing apportioned them across the parts, and dividing a measured total by character share would produce three numbers nobody counted.

AssemblyHow the prompt is assembled

This is the cost lesson as arithmetic: of the 9,160 characters assembled, 3,775 are instructions — 41% of the prompt, the largest single part. A per-request bill follows whichever part is biggest, and on this kit that is the one named here.

TWO MESSAGES, JOINED IN SEND ORDER. The provider receives a system message and a user message; prompt_verbatim is the two concatenated so a reader sees exactly what arrived. The user message is the reading shown on this page's UI frame (CT-2026-0009-W2), reconstructed from src/prompt.build and asserted character-identical to the length the run recorded. Six of the seven record sections are in it; Producer Contact is not, and never is.

Full promptThe prompt in full

You are a scheduled open-contract watch for a grain elevator. You apply a written contract rule to one open contract at one scheduled run. You answer with one JSON object and no other text.

You are the scheduled open-contract watch for one grain elevator. It wakes every Monday, re-reads
every contract still open on the book, and reports each one. You are reading ONE contract at ONE
scheduled run.

The contract's terms and the elevator's rules are reproduced in the record below. Apply them exactly
as written. The unfilled balance is a RUNNING TOTAL that survives between scheduled runs and is
printed nowhere on this record; what is known about earlier runs is stated under "Carried state" and
is the only history available to you. Do not assume anything about earlier runs beyond it.

How to count:
 - "Bushels applied in this window" is the GROSS figure weighed at the scale. From it, SUBTRACT
   every bushel the activity log says was TURNED AWAY -- rejected on grade, moisture, test weight,
   foreign material, or otherwise not put on the contract (Rule C-2). Do NOT subtract bushels that
   were ACCEPTED WITH A DISCOUNT: a discount changes the price, not the quantity.
 - SUBTRACT what is left from the balance the carried state says was still owed. On a contract's
   first scheduled run the opening balance is the full contracted quantity.
 - A balance at or under the delivery tolerance printed on the record is FILLED (Rule C-5).
 - Count a roll as EXECUTED only where the log says one actually happened -- the period was amended,
   moved, re-papered, or the roll was booked. A roll that was quoted, enquired about, reviewed or
   declined consumes nothing (Rule C-4). Add any executed this window to the number the carried
   state reports.
 - If the delivery period, the tolerance clause or the roll terms are not on file, the contract is
   CONTEXT_INCOMPLETE: status CONTEXT_INCOMPLETE, rollover_risk UNKNOWN, unfilled_bu null,
   raise_decision NO. Never assume a default tolerance or a default period (Rule C-9).

Answer with a single JSON object and nothing else:

{"status": "FILLED|ON_TRACK|DECISION_DUE|DEADLINE_PASSED|CONTEXT_INCOMPLETE",
 "rollover_risk": "NONE|ROLLABLE|NOT_ROLLABLE|DEFAULTED|UNKNOWN",
 "unfilled_bu": <whole bushels still owed after this window, or null if the context is incomplete>,
 "raise_decision": "YES|NO",
 "rationale": "one sentence, naming the rule you applied and the bushels you counted"}

Precedence for "status", applied in this order: CONTEXT_INCOMPLETE beats everything; then FILLED if
the balance is at or under tolerance, however close the deadline is; then DEADLINE_PASSED if the
roll deadline is behind this run; then DECISION_DUE if the roll deadline falls on or before the next
scheduled run -- the record prints both the business days to the deadline and the business days to
the next run, so compare those two numbers; otherwise ON_TRACK.

"rollover_risk" answers what happens to the unfilled bushels IF NOBODY ACTS, and it is not the
status: UNKNOWN when the context is incomplete; NONE when the balance is within tolerance;
DEFAULTED once the roll deadline is behind this run and a balance above tolerance remains, because
the elevator's default clause then applies on its own; ROLLABLE when a roll is still available --
the contract type and pricing state carry a roll right (Rule C-8) AND fewer rolls have been executed
than the terms permit; NOT_ROLLABLE when a balance above tolerance is at risk and no roll is
available, so the only remaining choices are deliver or cancel-and-price.

"raise_decision" is YES only on the run that first puts the decision to the producer -- the status is
DECISION_DUE and the carried state does not already say it was raised. On every other run it is NO
(Rule C-6).

Carried state
----------------------------------------------------------------
As at the previous scheduled run, 13,700 bushels were still owed on this contract, before anything this window applied. No roll has been executed on this contract on any earlier run. The roll/cancel/deliver decision has ALREADY been put to the producer on an earlier run, so this run must not raise it a second time. It was last reported DECISION_DUE.

Contract record
----------------------------------------------------------------
Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated open-contract record for an AI
use-case kit; it reproduces no grain contract, no elevator's terms and conditions, no
exchange rule and no state warehouse regulation. The clauses are ILLUSTRATIVE.

Contract
----------------------------------------------------------------
Elevator                       : EL-107 (North Line Terminal)
Contract reference             : CT-2026-0009
Producer reference             : PRD-7817
Commodity                      : Yellow corn, US No 2
Contracted quantity            : 15,000 bu
Contract type                  : DELAYED PRICE
Price status                   : unpriced; final pricing date 2026-11-02
Delivery period                : 2026-10-23 to 2026-11-22  (delivery river terminal)
Board reference, this run      : 4.3499 USD/bu

Delivery Terms
----------------------------------------------------------------
Delivery tolerance             : 2.0 pct of the contracted quantity (300 bu)
Roll notice period             : 10 business days before the delivery period opens
Rolls permitted                : 1 over the life of the contract
Roll deadline                  : 2026-10-09  (10 business days before the period opens)
Default clause                 : past the roll deadline with a balance above tolerance,
                                 the balance is cancelled and priced against the board at
                                 the close of the delivery period, at the producer's cost

Rule C-1  The UNFILLED BALANCE is the contracted quantity less every bushel applied against the
          contract to date. Applications are reported PER WINDOW on this record; the running total
          is not printed anywhere and must be carried between scheduled runs.
Rule C-2  Bushels TURNED AWAY at the scale -- rejected on grade, moisture, test weight or foreign
          material -- were never applied and do not reduce the balance. Bushels ACCEPTED WITH A
          DISCOUNT were applied in full and do reduce it; a discount is a price adjustment, not a
          quantity adjustment.
Rule C-3  The ROLL DEADLINE is the contract's roll-notice period, in business days, before the
          delivery period opens. A roll elected after it is not honoured.
Rule C-4  A contract may be rolled at most the number of times its terms permit. A roll that was
          EXECUTED consumes one; a roll that was quoted, enquired about, reviewed or declined
          consumes none. The count survives between runs and is not printed on this record.
Rule C-5  A balance at or under the contract's DELIVERY TOLERANCE is FILLED and needs no decision.
          Tolerance is a percentage of the contracted quantity, read from the contract. There is no
          default tolerance and none may be assumed.
Rule C-6  A contract is DECISION_DUE when its roll deadline falls on or before the next scheduled
          run -- that is, when THIS run is the last one that will see it in time. The decision is
          put to the producer ONCE; a later run reports it already raised and does not raise a
          second one.
Rule C-7  Past the roll deadline with a balance above tolerance, the elevator's default clause
          applies on its own: the balance is cancelled and priced against the board at the close of
          the delivery period, at the producer's expense. Nothing on this watch reverses it.
Rule C-8  A contract carries a ROLL RIGHT only where its type and its pricing state allow one. A
          basis contract whose futures leg is already fixed, and a delayed-price contract past its
          final pricing date, carry none -- however much time remains before the deadline.
Rule C-9  Where the delivery period, the tolerance clause or the roll terms are not on file, the
          contract is CONTEXT_INCOMPLETE: no balance is judged, no decision is raised, no default
          figure is assumed, and the rollover risk is UNKNOWN rather than NONE.

Position This Run
----------------------------------------------------------------
Record produced                : 2026-09-14   (scheduled run 2 of this contract)
Watch cadence                  : every Monday
Previous scheduled run         : 2026-09-07
Bushels applied in this window : 600 bu gross at the scale, before anything turned away
Scheduled to date under the delivery schedule : 6,000 bu
Business days to the roll deadline            : 19 business day(s) from this run
Business days to the next scheduled run       : 5

Contract Activity Log
----------------------------------------------------------------
Entries raised in this window only.

- the desk quoted the spread on Friday and the producer took it, the period has moved out
- an earlier load from this producer was turned away last month, this one graded clean and 100 bu on ticket 42472 were applied

Operational Notes
----------------------------------------------------------------
Nothing outstanding on the credit check for this producer.

Raw responseThe raw response

{"status":"ON_TRACK","rollover_risk":"NOT_ROLLABLE","unfilled_bu":14200,"raise_decision":"NO","rationale":"Gross 6,800 bu minus 1,000 bu turned away under Rule C-2 gives 14,200 bu unfilled, above the 100 bu tolerance; the roll deadline is 25 business days out (after the next run), but the one permitted roll has already been executed, so status is ON_TRACK and risk is NOT_ROLLABLE."}

Step 06 of 14Evals

Written for: the skeptic · The harness output, with as_of / model version / dataset version / verified_by.

In brief

Check an open grain contract against its roll deadline — 150 open-contract records. One model answered, and every answer was then graded Three different ways — because the grade is a measurement too, and most of what went wrong on this kit went wrong in the ruler rather than the model.

The rulerHow it was graded

Every cell is compared for exact equality against a gold set computed by tools/build_corpus.py from a fixed seed, and re-derived from src/contract.step by evals/check_labels.py before any run may spend, so the key and the arithmetic cannot drift apart. Bushels are compared as whole numbers, so a reply of 13100.0 is a hit and a reply that does not parse is a MISS in every field rather than an exclusion.

MeasurementsWhat was measured

Two words carry this page: Counted is deterministic and nobody's opinion and Not yet known is printed blank rather than filled with something plausible. There is no Judged row here and that is the point: nothing on this page is a model's opinion about another model. The row most worth having is currently the empty one.

Grading costWhat it costs

Every dollar on these pages is a MEASURED token count multiplied by a named vendor's PUBLISHED rate -- a projection onto a rate card, not a bill anyone paid.

Rates checked 2026-08-18. The provider that actually ran all 310 calls is kept out of these tables per this estate's naming rule. Its own rate card is not published here and no figure on this page is a bill it issued.

Grading unitWhat the grading figure prices

The GRADER costs nothing: evals/scoring.py makes no model call, and neither do the three free floors or evals/cadence.py. The only money on this page is the model readings themselves.

The gradersThree ways to grade

⚑ THE MODEL TIES THE STRONGEST FREE FLOOR ON THE HEADLINE BAND AND WINS THE ARITHMETIC UNDERNEATH. Rollover risk is 95.33 pct against 95.33 -- 143 of 150 each -- and status is 99.33 pct for both. The bushel balance is 96.67 against 92.67, and the priced exposure is 0.08 pct error against 1.26. The three floors separate the two halves of the value with the model held out entirely. planonly is what an expiry report out of a grain accounting package does -- the delivery SCHEDULE standing in for what was actually applied, a guessed 2.0 pct tolerance where none is on file -- and it scores 47.33 pct. planonly-mem is the identical rule GIVEN the carried balance and scores 71.33: memory alone, with no model anywhere near it, is worth 24.00 points. parsed-mem adds reading the activity log and scores 95.33: another 24.00 points. ⚠︎ AND THE FLOOR WAS STRENGTHENED TWICE BEFORE THESE FIGURES WERE TAKEN, BOTH TIMES AGAINST THE KIT'S OWN HEADLINE. The corpus gained four harder roll templates after the floor scored 98.67 pct on ten easy ones; and _roll_right's delayed-price branch originally returned True unconditionally, with a comment claiming the record did not print the comparison. It prints both dates. A floor that declines a comparison the page hands it is a strawman, and fixing it moved the floor UP from 94.00 to 95.33.

Every row opens its own page: how the test was run, the input on one real row, the prompt or formula with every iteration of it, and the analysis.

Choosing oneWhich one to use

The comparison is only useful if it ends in a choice. The answer is conditional — and it is not the grader with the best agreement score.

This pipeline was also attacked, which is a different question from whether its answers are right: see Threat model for the injection experiment, its two gates and what it does not prove.

Failure causesHow it fails

Step 07 of 14Unit cost

Written for: whoever signs off on the bill · Measured over the eval run, per model. Never quoted from a vendor page.

In brief

The token counts are measured on a real run and belong to this pipeline — which sections are selected, the field schema, the prompt — so they hold wherever you run it. The dollars are those counts multiplied by each vendor's published rate, checked 2026-08-18. Nobody paid these particular bills; they are what the same work would cost you on a card you can sign up to today.

Identical work in both rows — the same reading (one contract, at one scheduled run), the same tokens. Only the price list changed. Which is why the token count is the measurement and the dollar is arithmetic you can redo on your own card.

Answering vs gradingAnswering and grading are two separate bills

310 live calls were attempted for this kit and 308 returned something: 10 calibration (c000, at an 8,000-token cap), 150 scored (r001) and 150 control (s001). Two returned nothing -- one in each paid arm, both cut off at the 24,000-token ceiling -- and both are BILLED and counted, because a reply that ran to the ceiling costs exactly what a good one costs. Nothing was discarded and nothing was re-run. The three free floors and the whole cadence ablation cost $0.00 and made no calls at all.

Cost driversWhat actually moves the bill

• OUTPUT TOKENS, AND ALMOST ALL OF THEM ARE REASONING. 95.98 pct of this run's output (390,517 of 406,856) was provider-side reasoning left at the default, and output is 88.6 pct of the projected bill. What you are paying for is the model reconciling a carried balance against a scale-house log.
• THE CADENCE, which multiplies everything else. One reading is one call; the watch wakes once a week; the bill is open contracts x runs, not contracts.
• THE OPEN POPULATION, not the elevator's size. A contract that fills inside its tolerance is FILLED and still costs a call on this design, because every contract is re-read whole on every run. A book that closes its filled contracts out stops paying for them; one that leaves them open pays forever.
• The record itself, barely. Input averages 2096 tokens and every document in this corpus is within 7.1 pct of every other in size -- and roughly 1738 of those tokens are the reproduced rule block, which is identical on all 150 records and is the one thing here a prompt cache would remove.

Your volumeWhat it costs at your volume

LINEAR IN CONTRACTS x RUNS, AND THAT IS THE WHOLE WARNING. Ten times the open contracts is ten times the calls at the same cadence -- there is no batching, no cache and no early exit, because every contract is re-read whole on every run by design. An elevator holding 2,000 open contracts on this weekly watch is 2,000 calls a week, about $18.37 a week on the shared projection card and about $955 a marketing year. Nothing about the per-call price changes; the multiplier is the schedule.

Model choiceWhy this model

It is the tier the shared connection was already pointed at, and the kit's whole claim is that swapping it is one line in .env plus one more run. No second tier was fired: the two paid arms here differ by the CARRIED STATE rather than by the model, which is the comparison this kit exists to make, and a cross-model claim would have cost a third 150-call arm for a question nobody asked.

Other modelsOn other models

This is arithmetic, not a run. No model below was executed against the labelled set, and no accuracy is claimed for any of them. What transfers is the input volume: retrieval is model-independent, so every model would receive the same passages.

The exact work behind every stateful number on these pages: 150 readings, one completion call each, one tier. The 150-call stateless control and the 10 calibration calls are accounted for separately in Cost.cost_of_evaluation_usd and are not projected here.

The codeEvery file, and what it is for

12 modules, no framework, and almost no dependencies. The pipeline is stdlib Python, because a kit is meant to be read and changed by someone who cloned it ten minutes ago — every dependency is a thing they have to understand before they can touch the part they came for.

Six of these are swap seams: the points you edit to make the kit yours. Each is marked, and each block below is the module’s real shape, read out of the file rather than written here.

The files on this page are not in the public GitHub catalog.

tools/build_corpus.pythe corpus generator — a swap seam

Generates 30 open contracts x 5 Mondays = 150 records from a fixed seed (SEED = 20260823). Twenty-four of the thirty have a roll deadline that falls STRICTLY inside the five-week window, so exactly one run is the last one that can see each of them -- that is the hard clock. The gold labels are src/contract.step's output over the planted events, never typed.

You change it to: The seed, the contract population, the clause spread and the log phrasings. Point it at your own book or replace data/corpus/ and data/gold.jsonl wholesale.

# Generate the corpus and the answer key. Deterministic: one seed, one corpus, forever.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CORPUS = os.path.join(HERE, "data", "corpus")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
STATS = os.path.join(HERE, "data", "corpus-stats.json")
SEED = 20260823
CONTRACTS = 30
RULE = "-" * 64
ELEVATORS = [("EL-041", "River Bend Elevator"), ("EL-107", "North Line Terminal"),
COMMODITIES = [("Yellow corn, US No 2", 4.42), ("Soybeans, US No 1", 10.86),

src/contract.pythe contract arithmetic — a swap seam

The rule as pure code: the carried balance, less the bushels actually applied this window, against the tolerance on file; then the roll deadline against the horizon this run owns. No model, no judgement. ⚠︎ The nine rules, the tolerances and the roll terms in it are INVENTED and the kit ships that as a stated limitation -- see Data.why_this_corpus.

You change it to: RULE_TEXT and step(). The nine clauses are illustrative; replace them with your own contract's and every figure on this page re-derives. ⚠︎ RULE_TEXT is also what the model reads, so a rule that does not say what an HTA is produces exactly the 6 errors this run made.

# The open-contract rule as arithmetic. Pure code, no model.

FILLED = "FILLED"
ON_TRACK = "ON_TRACK"
DECISION_DUE = "DECISION_DUE"
DEADLINE_PASSED = "DEADLINE_PASSED"
CONTEXT_INCOMPLETE = "CONTEXT_INCOMPLETE"
STATUSES = (FILLED, ON_TRACK, DECISION_DUE, DEADLINE_PASSED, CONTEXT_INCOMPLETE)
NONE_RISK = "NONE"
ROLLABLE = "ROLLABLE"
NOT_ROLLABLE = "NOT_ROLLABLE"

src/schedule.pythe clock — a swap seam

Business days, the weekly run calendar, and the roll deadline DERIVED from the delivery period rather than stored beside it -- because amending the period is exactly what a roll does, so a stored deadline would desynchronise on the one event this kit is about. Monday to Friday, no holiday calendar, declared rather than hidden.

You change it to: is_business_day and RUN_DATES. Monday to Friday with no holiday calendar today; a real roll deadline counts against whichever calendar the contract names.

# The clock. Business days, the weekly run calendar, and the roll deadline derived from both.

RUN_DATES = ("2026-09-07", "2026-09-14", "2026-09-21", "2026-09-28", "2026-10-05")
CADENCE_DAYS = 7
CADENCE_LABEL = "every Monday"
CADENCE_BUSINESS_DAYS = 5
def d(s):
def is_business_day(day):
def bdays_between(a, b):
def bdays_before(day, n):
def roll_deadline(delivery_start, notice_business_days):

src/state.pythe carried state — a swap seam

Four scalars per contract -- unfilled_bu, rolls_used, decision_raised, prev_status -- written by the arithmetic and never from a model reply, then rendered as one English paragraph for the prompt. A monitor that fed its own verdict forward would compound one bad reading into every reading after it, and the quantity carried here is bushels a producer is contractually on the hook for.

You change it to: What is carried between Mondays, and how it is worded. Four scalars today. ⚠︎ ENGLISH RATHER THAN JSON IS A DESIGN CHOICE AND IT IS UNMEASURED -- scoring the same 150 readings with the state rendered both ways costs another 150-call run and has not been paid for.

# The carried state -- the thing that makes this a monitor and not another one-shot classifier.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DEFAULT_PATH = os.path.join(HERE, "data", "state.json")
def load(path=DEFAULT_PATH):
def save(store, path=DEFAULT_PATH):
def for_contract(store, contract_id):
def describe(state):

src/segment.pythe section split

Seven named sections, asserted present in all 150 documents by evals/check_labels.py before a run may spend, so a parser drift is a refusal to start rather than a quietly truncated prompt.

# Split a contract record into its named sections. Pure code, no model.

SECTIONS = ("Synthetic Record", "Contract", "Delivery Terms", "Position This Run",
RULE = "-" * 64
def split(text):
def render(secs):

src/select.pythe privacy gate

Decides which sections go on the wire. Producer Contact -- name, mobile, farm registration number -- is mapped by nothing and subtracted unconditionally in the fallback, so a hint that matches nothing falls back to the record MINUS that section rather than to the whole record.

# Pick which sections of a record are sent. Pure code -- the last deterministic step before the

BANNER = "Synthetic Record"
CONTRACT = "Contract"
TERMS = "Delivery Terms"
POSITION = "Position This Run"
LOG = "Contract Activity Log"
PRODUCER = "Producer Contact"
NOTES = "Operational Notes"
NEVER_SENT = (PRODUCER,)
SECTION_HINTS = {

src/prompt.pythe prompt

Three parts joined with string concatenation: the fixed instruction, the carried-state paragraph, and the record. The middle part is the experiment, and --stateless replaces exactly that one line.

# Assemble the one prompt this kit sends. No template engine, no framework -- string concatenation

INSTRUCTION = """\
def build(text, carried, stateless=False):

src/watch.pyone reading

One contract, one Monday, one completion call. Parses the dates and the printed figures in code first -- the model is never asked to count business days.

# One contract, one scheduled run, one model call. The runtime half of the kit.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CORPUS = os.path.join(HERE, "data", "corpus")
SYSTEM = ("You are a scheduled open-contract watch for a grain elevator. You apply a written "
MAX_TOKENS = 24000
FIELDS = ("status", "rollover_risk", "unfilled_bu", "raise_decision")
def documents():
def contracts():
def load_doc(doc_id):
def _num(text, pat, cast=float):

evals/baseline.pythe free floors — a swap seam

Three of them, all $0.00, all scored through the identical scorer: the expiry report a desk already runs, the same rule given the carried state, and the strongest table this author could write.

You change it to: The rejection and roll keyword tables, and the assumed tolerance. This is the column the model has to beat, so making it stronger is the honest direction to edit it in.

# THE FREE FLOORS. Three of them, none a strawman, all of them $0.00.

MODES = ("planonly", "planonly-mem", "parsed-mem")
ASSUMED_TOLERANCE_PCT = 2.0
REJECT_WORDS = ("turned away", "refused", "rejected", "backed off", "not accepted",
ROLL_DONE_WORDS = ("amended to the", "executed on the desk", "re-papered", "was booked",
ROLL_NOT_DONE_WORDS = ("declined", "no election", "nothing was booked", "quote expires",
def _log_lines(text):
def _bushels_in(line):
def _rejected_bushels(text):
def _rolls_executed(text):

evals/scoring.pythe scorer

Exact match per cell against the answer key, with the two raise directions counted apart and the two rollover-risk directions counted apart. No model grades anything.

# Score a run against the answer key. Pure code, exact match per cell. No model grades anything.

FIELDS = ("status", "rollover_risk", "unfilled_bu", "raise_decision")
def _pct(n, d):
def _bu(v):
def score(records, golds):

evals/cadence.pythe cadence ablation

What a missed Monday costs, scored against the INTACT answer key. Free -- no provider is involved in a question about a calendar. It self-checks that a perfect reader scores 100.00 on the intact schedule before it prints anything.

# What a MISSED RUN costs. Free -- no provider is involved in a question about a calendar.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
GOLD = os.path.join(HERE, "data", "gold.jsonl")
FIELDS = ("status", "rollover_risk", "unfilled_bu", "raise_decision")
def load_gold():
def perfect_chain(gold, doc_ids):
def floor_chain(gold, doc_ids, mode):
def blind_window(gold, skip_run):
def report(gold, skip_run):
def main():

src/app.pythe local UI

http.server, no framework. Renders with no key: the record, the carried state, the parsed figures and the entire free floor are computed locally, and a second button replays what r001 actually answered off the committed result file.

# The minimal local UI. Standard library only -- python3 -m src.app, then open the printed URL.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
UI = os.path.join(HERE, "ui")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
PORT = int(os.environ.get("PORT", "9018"))
RECORDED_RUN = os.environ.get("RECORDED_RUN", "r001-contract-expiry")
GOLD_ROWS = {r["doc_id"]: r for r in
def carried_for(doc_id):
class H(BaseHTTPRequestHandler):
def main():

Start hereThe shortest path into it

Every entry above is a file in this kit, listed in the order the pipeline runs it.

ScenariosWhat it costs at your volume

Everything below is computed from one measured base: 2096 input and 2712 output tokens per reading (one contract, at one scheduled run), all of it fixed — this kit sends the document's own selected sections, so there is no retrieval depth to turn. Change the volume and the bill scales linearly, because nothing here batches.

OperationsFour shapes of workload

The same arithmetic, at volumes worth naming. These are illustrations of scale, not measurements of anyone’s deployment.

Model follows the controls above.

What this ignoresWhere a real bill diverges

In one lineWhat this kit exposes

No untrusted external input surface in the shipped version. Every field that reaches the prompt comes from tools/build_corpus.py's fixed seed, including the Operational Notes, which are one of three fixed sentences. src/select.py names the notes as the field an outside party WOULD influence in a real deployment -- prose a merchandising clerk types into the contract system -- and sends them deliberately, so the surface is visible rather than hidden. On this corpus nobody outside the repository wrote a byte of it.

The provider key lives only in .env (gitignored) or the shared repo-root .env, read by src/config.py and never logged. config.sources() reports WHICH file a value came from and never the value. config.save() opens the file 0600 before the write rather than chmod-ing it after, so the key never exists at the default umask even for an instant. src/app.py redacts the key and the base URL out of any provider error before it reaches the browser.

The experimentWe did NOT attack it — and this is the surface we left open

An indirect prompt injection needs a field somebody outside can write into, and this kit has exactly one: the Operational Notes a merchandising clerk types into the contract system. It is SENT rather than hidden, because hiding a surface does not close it. No attack was fired at this kit and none is claimed. The three boundaries below were checked in code on 2026-08-23, and only the first of them is red-proven in both directions rather than argued from an absent code path.

The first row is the only one measured in both directions. The other two are guarantees about what is ABSENT -- no code path cancels, prices or defaults a contract, and no code path feeds a model reply back into the carried balance -- and absence is checked by asserting names it knows, which is weaker than a run and is written here as such.

The result0 attack trials, three boundaries checked -- and the privacy boundary red-proven by removing the guard and reproducing the condition that reaches it: 150 of 150 records would leak a farmer's name, mobile and farm registration number.

The Operational Notes ARE the field an outside party would influence in a real deployment, and this kit sends them on purpose so the surface is on the page rather than behind it. One of the three shipped notes is instruction-shaped. Whether it moves raise_decision or rollover_risk was never measured and no resistance rate is claimed.

HonestyWhat this does not prove

• Whether the instruction-shaped operational note moves any answered field. Never measured.
• Whether a path that cancels, prices or defaults a contract could exist under a name the grep does not know. The check asserts the absence of names it knows.
• Whether the privacy guard holds against a record whose Producer Contact section is renamed. The red-proof renames every OTHER section; a corpus that renames that one has not been tried.
• Whether any provider logs or retains the record. The kit controls what it sends and not what happens after; six of the seven sections do leave the machine.
• Whether the carried state itself could carry something sensitive. It is four scalars today -- a number, a count, a boolean and a status word -- and nothing asserts it stays that way.

In one lineThe guardrail is enforced in code

Not a prompt instruction the model can ignore — a comparison applied after the reply is parsed, before anything downstream sees it.

No contract action, non-configurable. This kit produces a status, a rollover-risk band, a bushel balance and a raise/hold call for a merchandiser to read. It never cancels a contract, applies the default clause, books a roll, prices a balance out, notifies a producer or writes to a grain accounting system, and there is no setting that makes it. Separately, and just as non-configurable: the delivery tolerance is OPERATOR-SUPPLIED. A contract with no tolerance clause or no delivery period on file is reported CONTEXT_INCOMPLETE and judged against nothing -- there is no default percentage in this kit.

Everywhere and nowhere -- it is a property of what is ABSENT. The only writers in the kit are evals/run.py (results/*.json) and src/state.save (data/state.json). src/contract.step() is the only thing that touches the balance, and it is called by evals/run.py after every reading including one whose call FAILED.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• IT IS NOT A CHECK ON WHETHER THE ANSWER IS RIGHT. The balance is correct whatever the model says, which means a wrong reading is a wrong watchlist row and not a corrupted history. Those are different problems and only the first one is on this page.
• IT IS NOT A SCHEDULER. evals/run.py is invoked; it is not woken. Nothing here detects a missed run, back-fills it or marks its readings late -- and evals/cadence.py measures exactly what that is worth rather than leaving it as a caveat.
• IT IS NOT AN AUTHORITY ON GRAIN CONTRACTS. The nine clauses, the tolerances and the roll terms are invented for this kit and reproduce no grain contract, elevator's terms and conditions, exchange rule or state warehouse regulation.

WatchedWhat is watched, and why that one

The kit measures 42 watched figures plus 8 comparability guards and 5 reference constants — three duties, not one list. 0 of the watched are grader rates, each on its own grader page; this board watches the ones that decide when to look again. Each square is one watched figure; filled means the latest run measured it.

18 measured by the latest run 24 need the model half

GuardsBefore any comparison

Preconditions, not alarms. If one moves, the runs were not measuring the same system and nothing else on this board may be differenced.

all shared guards held between the recorded runs (cadence_days 7, context_incomplete_cells 20, contracts 30, decision_cells 13, documents 150, memory_cells 94, quiet_cells 137, readings_scored 150, stateless False) — which is why the history below is allowed to mean anything.

The reference constants — the null-grader baseline, the adjudication matrix, the negative count — are the third duty. They are never re-measured per run: a baseline that moves with the thing it measures is not a baseline.

BandsThe alarm bands

Derived from evidence, never picked: exact-match where two runs reproduced a metric to the digit, wider than the measured same-input drift for latency, one row of the negative class for any rate — denominator printed beside it.

HistoryRun history

7 recorded runs. A dash is a metric that run did not measure, and a dash is never differenced: not measured is a third state, neither a value nor a zero, and reading it as zero is how a board reports an improvement on a run that never looked. They are split into 3 blocks because a free floor is a baseline rather than a peer, and a run of another kind measures another thing; a column in one block is never differenced against a column in another.

triage · no model in the path — a baseline, not a peer column — 3 runs. A floor is what the kit scores with no model in the path; it is the line the model runs have to beat, and it is never differenced against them.

not a time series No two of these 3 runs measured the same system — they differ on floor, the model — so nothing here may be differenced and the Verdict column is left off. Read this block DOWN a column, as a comparison between those runs, not along a row as a history.

triage · with the model in the path — 3 runs. Columns here are only ever compared with each other.

not a time series No two of these 3 runs measured the same system — they differ on context_incomplete_cells, contracts, decision_cells, documents, max_tokens, memory_cells, quiet_cells, readings_scored, stateless — so nothing here may be differenced and the Verdict column is left off. Read this block DOWN a column, as a comparison between those runs, not along a row as a history.

stub · no model in the path — a baseline, not a peer column — 1 run. A floor is what the kit scores with no model in the path; it is the line the model runs have to beat, and it is never differenced against them.

one run A verdict is a comparison and one run has nothing to compare with, so the Verdict column is left off rather than filled with 18 chips that all say so.

DeviationsWhat deviated

0 breaches across 7 runs

The day a band breaks, a row renders here carrying the metric, the two runs, the band it crossed and what changed between them — model, prompt, chunker or top_k, read off the run records’ guards. A deviation with no diff beside it is an alarm nobody can act on.

RippleThe ripple map

Which figures move together, so one alarm reads as a system. Every edge carries its basis: measured names the run that showed it; reasoning admits nothing has varied it yet.

FiresWhat fires when a band breaks

Where evals stop sitting beside the guardrail and start feeding it. Where the answer is nothing automatic, the row says so — hiding it would undo “What a guardrail is not” above.

NextThe three you would add first

None of these is built here. They are named against the seam they sit on so they can be argued with.

CadenceWhen to re-run, and what it costs

Re-run evals/check_labels.py and evals/cadence.py (both free, seconds) on any change to tools/build_corpus.py, src/contract.py, src/schedule.py, src/segment.py or src/select.py. Re-run the scored eval AND its stateless control together (paid, 300 calls) on any change to src/prompt.py or src/state.py.

In one lineNo framework, deliberately

No framework and no dependencies at all -- json, os, re, random, datetime, argparse, urllib, http.server and concurrent.futures from the standard library. requirements.txt names nothing and says in a comment that the emptiness is load-bearing: a line there means something under src/ or evals/ imports it.

The mappingSeam by seam, who owns what

The seams are the ones this kit already publishes, so the mapping cannot drift from the code.

GraphsWhere LangGraph changes the answer

Nothing here is a graph, and the one place it looks like one is a straight line. Each contract is a chain of five readings -- five consecutive Mondays -- with no branching and exactly one edge between consecutive runs, carrying four scalars. Different contracts never touch. A framework would add an orchestrator to a for-loop that already runs 30 chains wide.

The other sideWhat a framework costs you

• No scheduler. This is a watch that carries state and is still INVOKED, not woken -- and unlike most kits that say this, the price is measured here rather than implied: see the cadence ablation.
• No missed-run detection that recovers anything. src/schedule.gap() notices; nothing repairs.
• No concurrency model for the state store. data/state.json is one file replaced atomically -- correct for one writer, and an elevator with two watches is two writers.

In one lineWhat one run of this kit actually cost, in time and tokens

Measured on r001-contract-expiry on the same tier, memory removed (THE CONTROL), 2026-08-23. This kit records telemetry measured per run — 4 of the 6 readings on this axis, 4 of them with a band the guardrail board can judge against.

The readingWhat the last run measured

No movement column. Not one of the 5 earlier runs on record is comparable with this one — a different model tier, or a changed guard — and differencing across that measures two systems rather than one. Said once here rather than as a dash on every row.

Retrieval not shown. No run of this kit has ever recorded a retrieval timing, because the pipeline has no such stage. Those readings are left out rather than dashed: a dash says “this run did not measure it”, which promises a later run could.

DriftMedian call, run over run

Hatched bars are runs that are not comparable with the latest — a different model tier or a changed guard. They are drawn because hiding them would make the history look shorter than it is, and greyed because differencing across them would be measuring two systems.

3 runs not plotted. b000-contract-expiry-planonly, b001-contract-expiry-planonly-mem, b002-contract-expiry-parsed-mem recorded no call latency at all — a rules-only floor run makes no model call, and the 0 its record stores is an absence, not a zero-millisecond answer. Plotting it would put a bar on this chart claiming the fastest run in the kit’s history.

The other sideWhat this does not tell you

The first of those is the one worth doing something about, and it is a solved problem: instrumenting a pipeline so each step reports its own duration is a couple of lines. Observability / tracing has the code, and what the result looks like once it is running.

In one lineWhat you provision, honestly

Everything measured on this page says where it was measured; everything not measured says that — the same contract as the other thirteen pages. Where a retrieval index would be on other kits, this one has: no index — the population is re-read whole on each scheduled run, and the prior run's carried state is what makes a reading a CHANGE.

The machineWhat this needs

Enumerated from the kit’s own source by build/facts/envscan.py, committed, and drift-checked — never typed into this page.

Your dataWhere everything sits

The wireWhat crosses it, and when

Zero-egress topology: point BASE_URL at a local OpenAI-compatible server and nothing leaves the machine — statically true of the shipped adapter, whose only credential travels in the Authorization header.

The shapeHow it ships, and what you add

The ladderEach decision, and what you provision past its ceiling

Every threshold is a measurement with its provenance beside it, or says is_measured:false. A ceiling with no seam says so — it is the point the kit is outgrown, never a forced join.

When it failsFailure signatures

The knobsThe config surface, enumerated

Environment variables: API_KEY, BASE_URL, EMBED_MODEL, EVAL_WORKERS, MAX_CALLS_PER_DAY, MODEL, PORT, PROVIDER, RECORDED_RUN.

The other sideWhat this page does not claim

The corpus licence, from the Data lens: MIT -- this repository's own licence. Nothing is fetched and no third-party grant is involved; every byte was written by the generator committed beside it. Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe rollover risk, the status, the bushels still owed and the raise/hold call, per reading, exact match against the computed answer key

For each of the 150 readings and each of the four answered fields, did the reply equal the computed answer key? Three of the four are words from a closed list and are compared exactly; the bushel balance is compared as a whole number, so 13100.0 and 13100 are the same answer and a reply that does not parse is a MISS rather than a zero -- 0 bushels is a meaningful answer here (it is what every FILLED reading gets) and a parse failure must not be scored as one.

MethodHow the test was run

evals/scoring.py::score, in-process, no key and no model. The same function all three free floors and the cadence ablation are scored through.

Every grader on these pages scored the same 150 already-recorded answers. Nothing was re-generated, so this compares rulers and not models.

The inputOne real row, seen by every grader

The formulaWhat it computes

accuracy = hits / 150 per field. A reading whose reply did not parse counts as a MISS in every field, never as an exclusion.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl, computed by tools/build_corpus.py over the planted events at generation time and re-derived from src/contract.step by evals/check_labels.py before any run may spend. This grader IS the reference, so its own TPR and TNR are not measured -- scoring it against itself would be circular.

How tight can the band be? No tuned threshold anywhere on the model path -- the reply decides. The denominators are printed beside every rate because two of them are small: 13 readings must raise a decision and 20 have nothing on file, so one row moves the first by 7.7 points and the second by 5.0.

Cadence: Re-run evals/check_labels.py (free) on any change to tools/build_corpus.py, src/contract.py, src/schedule.py, src/segment.py or src/select.py. Re-run the scored eval AND its stateless control together (paid, 300 calls) on any change to src/prompt.py or src/state.py -- the headline is a difference, so one arm re-run alone is not comparable with the other's old figure. All three floors and the whole cadence ablation are free and should be re-run on any change at all.

The decisionWhen to reach for it

In one lineThe two rollover-risk directions, counted apart

Two counts over two different populations. A ROLL OFFERED THAT WAS NOT AVAILABLE: the key says NOT_ROLLABLE and the reading says ROLLABLE. A ROLL MISSED: the key says ROLLABLE and the reading says NOT_ROLLABLE. This is the grader that separates the model from the free floor, because their headline rollover-risk accuracy is identical and their error direction is not.

MethodHow the test was run

evals/scoring.py::score, in the same pass as the exact-match grader.

Every grader on these pages scored the same 150 already-recorded answers. Nothing was re-generated, so this compares rulers and not models.

The inputOne real row, seen by every grader

The formulaWhat it computes

Two whole-number counts off the confusion matrix. Never averaged, never combined into an F-score, and never expressed as one 'rollover accuracy' figure -- that figure is the same for both arms and hides the entire finding.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl's rollover_risk column, computed by src/contract.step. Scored against the reference; not itself the reference.

How tight can the band be? 46 readings are ROLLABLE in the key and 39 are NOT_ROLLABLE, so the finest band these counts support is 2.2 and 2.6 points respectively. They are published as counts rather than rates for exactly that reason.

Cadence: Free. Re-run with every scored run, and re-run all three floors whenever tools/build_corpus.py's roll templates change -- these two counts are the most template-sensitive figures on this page.

The decisionWhen to reach for it

In one lineWhat one missed Monday costs a PERFECT reader

Remove one Monday from the SCHEDULE -- the record stays on disk and is simply never opened -- then score what a perfect reader concludes on the readings that still happen, against the INTACT answer key. It answers the one question a monitor cannot answer about itself: what does the cadence buy, and what is lost when it does not hold?

MethodHow the test was run

evals/cadence.py, in-process, no key and no model. It refuses to print unless a perfect reader scores 100.00 on the INTACT schedule first -- a self-check added after the first version chained all 150 readings into one contract and reported 34.17 pct as the intact baseline.

Every grader on these pages scored the same 150 already-recorded answers. Nothing was re-generated, so this compares rulers and not models.

The inputOne real row, seen by every grader

The formulaWhat it computes

Same four exact-match comparisons, over the 120 readings that survive the reduced schedule, against the unreduced key. Plus two counts a rate cannot express: contracts whose roll deadline falls in the blind window (never warned on ANY schedule), and contracts whose carried balance is permanently wrong afterwards.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the INTACT data/gold.jsonl. The truth about a contract does not change because nobody looked at it, so the reduced-schedule arm is scored against the unreduced key -- any other choice would measure the watch's own confusion as if it were the world.

How tight can the band be? 30 contracts, so one contract in the blind window is 3.3 pct of the book. The three ablations put 4, 5 and 4 there. Across all three, 253 cells moved and 0 went the right way.

Cadence: Free, and it should be re-run on any change to src/schedule.py or to the corpus's deadline spread. It is the only grader here that measures the thing the kit cannot control.

The decisionWhen to reach for it