The business caseThe problem this solves

“Is this case warm right now” is a threshold alarm and every refrigeration monitoring platform already ships one; nobody needs a language model for it. The question a food-safety decision actually turns on is the next one, and it has two halves neither of which is on the screen in front of you. The first is CUMULATIVE MINUTES ABOVE THE PRODUCT'S THRESHOLD — a running total that survives between scheduled runs, minus every stretch the unit's declared defrost programme exempts, and NOT minus a stretch the maintenance log describes as a fault, even when that fault is sitting inside a defrost window and is written up in defrost vocabulary. The second is the ONSET: the minute the unit first went out of band. Product is dispositioned on minutes since the onset, and the onset is a single observation on a single page. Once that window closes, no later reading contains it. On this corpus 46 of 120 readings carry an onset whose trace has already left the page. Somebody walking the cold-chain report at shift change: opening each unit's recorder chart, finding where the trace crossed the product's threshold, deciding for each above-threshold stretch whether it was the declared defrost or a fault, adding what counts to whatever was already on the unit from earlier in the day, and — the part that actually goes wrong — remembering when the first counted stretch began, from a window whose chart is no longer on the screen. This kit does the last part in four scalars of pure code and asks the model for the judgement.

The inputThe actual unit snapshots

The corpus is 120 unit snapshots, 0.55 MB (json 1 · jsonl 1 · txt 120). A GROCER'S COLD-CHAIN RECORD IS THE EVIDENCE AN ENFORCEMENT OFFICER READS. It is also the evidence a supplier's claim is fought over, it names the engineers who attended, it prices the shrink, and there is no public one. The two alternatives were both worse: a scrubbed real estate changes what the model is being asked to read, because scrubbing is exactly the step that edits the prose; and no corpus at all makes the kit a description of a kit. So it is generated, the generator ships beside it, and every page in it says INVENTED in its first section. The seed was chosen by sweeping 200 candidates for LABEL BALANCE — all five states populated (18 CONTEXT_INCOMPLETE, 9 DEFROST, 39 EXCURSION_OPEN, 27 IN_BAND, 27 WATCH), 18 readings that must open a record against 102 that must not, and at least 45 off-page onsets. No floor and no model had been scored when that sweep ran, and the criterion is written into data/SOURCES.md so the claim is checkable rather than trusted.

Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated refrigeration snapshot for an AI
use-case kit; it reproduces no retailer's cold-chain standard, no HACCP plan, no
food-safety code and no real store. The thresholds and allowances are ILLUSTRATIVE.

Unit
----------------------------------------------------------------
Site                           : STORE-0378 (Ashfield Express)
Unit reference                 : UNIT-0001
Asset                          : PP-827, produce prep room
Setpoint                       : -16.9 C
Defrost programme (declared)   : 06:10-06:45 / 09:45-10:30
Taken out of service           : -- still in service

Product Specification
----------------------------------------------------------------
Product family                 : frozen vegetables
Threshold on file              : -15.0 C maximum product temperature
Cumulative allowance on file   : 180 minutes cumulative above the threshold

Rule X-1  The threshold is the maximum product temperature on the SPECIFICATION for what is stored
          in this unit. It is an operator-supplied value and there is no default.
Rule X-2  Exposure accrues, in 5-minute increments, for every minute the recorded temperature is
          above that threshold while the unit is in service.
Rule X-3  Exposure does NOT accrue during a SCHEDULED DEFROST -- a stretch that lies inside a window
          of this unit's declared defrost programme and that the maintenance log describes as the
          programme running normally. Air temperature rises by design; product temperature does not.
Rule X-4  Exposure DOES accrue for every other stretch above the threshold, whatever the log says

The outcomeWhat a good result looks like

Every unit past its allowance is on the watchlist with its accrued minutes and its onset, exactly one excursion record exists per unit, and a unit with no product specification on file is marked CONTEXT_INCOMPLETE rather than accrued against a guessed threshold. Measured on run r001-refrig-excursion: state 92.50 pct, onset 95.83 pct exact, accrued minutes 95.83 pct exact, the open/hold call 99.17 pct, 0 of 18 records missed and 1 duplicate in 102 quiet readings, and 100.00 pct recall on the context-incomplete guardrail.

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 only need to know which cases are warm right now — the threshold alarm your monitoring platform already ships, or the b000 floor in this repo
  A reading against a line is a comparison. On this corpus b000 gets 57.50 pct of states right for nothing at all.
• You need cumulative minutes and an onset, and your maintenance feed carries CODED hold reasons from a closed list — the b002 floor, with its keyword table swapped for your codes
  The model's entire margin on this corpus is reading free prose. Take the prose away and there is nothing left to buy: b002 already scores 94.17 pct on the onset and 92.50 on state for $0.00, and a coded feed removes exactly the errors it makes.
• Your maintenance log is prose a duty manager types, and it reaches for the same words whatever went wrong — this kit, with the carried state
  That is exactly the corpus these figures were measured on, and it is where the margin comes from: onset 95.83 pct against the floor's 94.17, accrued minutes 95.83 against 91.67, total exposure error 3.13 pct against 3.77.
• Your product allowances are shorter than the interval you can afford to run at — a shorter cadence on those units specifically, plus back-fill — not a better reader
  19 of the 37 units with a specification here carry an allowance under the 120-minute cadence. No reading of any quality catches those in time; the unit can pass its allowance and keep going for the rest of the interval before anybody looks. Measured in evals/missed_run.py, free.
• Runs sometimes do not happen — a scheduler slips, a feed stalls, a window is missed — back-fill FIRST, then this kit
  Measured on this corpus with a perfect reader: one skipped run of three destroys 3 onsets outright, misdates 22 more (all LATE, 1515 minutes in total), loses 3195 exposure minutes and flips 19 of 54 crossing scenarios from DISCARD to RELEASE. Asking the recorder for everything since the last SUCCESSFUL run instead of a fixed window recovers every onset and all but 525 of those minutes.
• You want to know whether a cheaper or dearer model changes the answer — this kit, run twice with MODEL changed in .env
  That is the whole point of src/adapters — one function, one entry in PROVIDERS, no vendor SDK. Both arms here ran on one tier and the kit says so.

And where nothing here is good enough:

• You want the machine to decide what gets destroyed — nothing in this repository
  This kit produces a watchlist and a derived disposition on a page. It has no write path of any kind outside results/*.json and data/state.json, and evals/check_labels.py greps every .py and .js file for the names of such paths and passes at zero.

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-refrig-excursion. 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 120 snapshots and the answer key (regenerated from the seed in well under a second, byte-identical — checked by running the generator twice and comparing), all fourteen pre-spend checks, all three free floors, the entire missed-run experiment, the UI at 127.0.0.1:9012, and a replay of what run r001-refrig-excursion actually answered on every reading. What it cannot reproduce without a key is one thing: 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 state, an onset, an accrued-minutes figure and an open/hold call. Retries and provider backoff are inside it. Measured over the 120 readings of run r001-refrig-excursion at 12 concurrent unit chains; wall clock for the whole run was 255.9 seconds.

Current processWhat it replaces

Somebody walking the cold-chain report at shift change: opening each unit's recorder chart, finding where the trace crossed the product's threshold, deciding for each above-threshold stretch whether it was the declared defrost or a fault, adding what counts to whatever was already on the unit from earlier in the day, and — the part that actually goes wrong — remembering when the first counted stretch began, from a window whose chart is no longer on the screen. This kit does the last part in four scalars of pure code and asks the model for the judgement.

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
• 3 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 units (3 scheduled runs each) is

No split, and no chunking. The unit is a REFRIGERATION UNIT — three consecutive scheduled runs processed strictly in order, because run 2's prompt contains an exposure total and an onset produced by run 1. There is no held-out set: every reading is scored, and the free floors are scored over the identical set through the identical function.

SetupWhat the setup figure measured

There is no index and no retrieval step — the population is re-read whole on each scheduled run, and what carries between runs is five scalars, not a document store. tools/build_corpus.py writes the 120 snapshots and the answer key in well under a second and costs nothing.

LicenceLicence

MIT — this repository's own licence. Nothing is fetched and no third-party grant is involved; every field in every snapshot was produced by tools/build_corpus.py in this repo, and data/SOURCES.md says so in the first line.

Bring your ownBring your own unit snapshots

Point tools/build_corpus.py at your own estate, or replace data/corpus/*.txt and data/gold.jsonl directly. Keep the eight section headings (src/segment.py::SECTIONS — the parser asserts all eight in every document before a run may spend), keep the “Minutes above threshold in this window” line the arithmetic reads, and supply gold rows carrying minutes_counted, minutes_exempt, first_counted_start, above_at_snapshot, exempt_at_snapshot, offline and context_complete. Swap the floor's keyword table for your own hold codes if you have them.

⚠︎ 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 120-minute cadence every figure is per, the five-minute recorder sample that makes an exact-match onset fair, and a population that does not change between runs. The missed-run figures in particular are arithmetic over THIS corpus's planted stretches — re-run evals/missed_run.py on yours, it costs nothing.

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 8,230 characters assembled, 3,195 are instructions — 39% 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 prints them concatenated, which is why part 1 is the system prompt and everything after it is one user turn. The instance shown is UNIT-0009-R2 — the reading the UI frame shows — assembled by src/prompt.build from the committed snapshot and the carried state the arithmetic produced for it. Every part's text occurs in prompt_verbatim, in this order, and that is asserted by the script that wrote this file rather than eyeballed.

Full promptThe prompt in full

You are a scheduled refrigeration excursion watch. You apply a written cold-chain rule to one refrigeration unit at one scheduled run. You answer with one JSON object and no other text.

You are the scheduled refrigeration watch for one grocery store. It wakes every two hours, re-reads
every cold-chain unit still in service, and reports each one. You are reading ONE unit at ONE
scheduled run.

The excursion rules, the threshold on file and the cumulative allowance on file are reproduced in
the snapshot below. Apply them exactly as written. Exposure is a RUNNING TOTAL that survives between
scheduled runs, and you cannot see the earlier runs; what is known about them 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:
 - "Minutes above threshold in this window, before any exemption" is already computed for you. Do
   not re-derive it from the trace.
 - From it, SUBTRACT every minute in this window that a SCHEDULED DEFROST exempts (Rule X-3): a
   stretch inside a declared defrost window that the Maintenance Log describes as the programme
   running normally. Do NOT subtract a stretch the log describes as a FAULT, even when it sits
   inside a defrost window and even when the words "defrost", "cycle" or "programme" appear in it
   (Rule X-4).
 - ADD what is left to the minutes the carried state says had already accrued.
 - The ONSET is the first minute of the first stretch that ever accrued on this unit. If the carried
   state already gives an onset, REPORT THAT ONE UNCHANGED -- it does not move, and this window's
   trace does not contain it. Only if no onset has been established yet do you read one off this
   window's trace: the first reading above the threshold that belongs to a stretch that COUNTS.
   Report it as HH:MM. If nothing has ever accrued, report NONE.
 - If no product specification is on file, or the probe reported nothing for part of the monitored
   period, the unit is CONTEXT_INCOMPLETE: state CONTEXT_INCOMPLETE, onset NONE, exposure_minutes 0,
   open_record NO. Never assume a default threshold (Rule X-7).

Answer with a single JSON object and nothing else:

{"state": "IN_BAND|DEFROST|WATCH|EXCURSION_OPEN|CONTEXT_INCOMPLETE",
 "onset": "HH:MM, or NONE",
 "exposure_minutes": <whole minutes above threshold now accrued, a multiple of 5>,
 "open_record": "YES|NO",
 "rationale": "one sentence, naming the rule you applied and the minutes you counted"}

Precedence for "state", applied in this order: CONTEXT_INCOMPLETE beats everything; then
EXCURSION_OPEN if accrued exposure has PASSED the allowance on file, even if the unit is currently
back in band or in a defrost; then DEFROST if the last reading in this window is above the threshold
and that stretch is a normally-running scheduled defrost; then WATCH if any exposure has accrued and
less than one 120-minute cadence of allowance remains (Rule X-9); otherwise IN_BAND.

"open_record" is YES only on the run that OPENS the product-safety excursion record -- exposure has
passed the allowance and the carried state does not already say a record was opened. On every later
run it is NO (Rule X-6).

Carried state
----------------------------------------------------------------
As at the previous scheduled run, 0 minutes of exposure above the threshold had already accrued on this unit, scheduled defrosts already excluded. No onset has been established for this unit: nothing has accrued yet. The unit was STILL ABOVE the threshold when that run ended, so a stretch was already open when this window began and the trace on this page may show only its end. No product-safety excursion record has been opened for this unit yet. It was reported DEFROST.

Unit snapshot
----------------------------------------------------------------
Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated refrigeration snapshot for an AI
use-case kit; it reproduces no retailer's cold-chain standard, no HACCP plan, no
food-safety code and no real store. The thresholds and allowances are ILLUSTRATIVE.

Unit
----------------------------------------------------------------
Site                           : STORE-0455 (Larkspur Hypermarket)
Unit reference                 : UNIT-0009
Asset                          : FI-751, frozen island freezer
Setpoint                       : -17.4 C
Defrost programme (declared)   : 07:50-08:35 / 09:30-10:05
Taken out of service           : -- still in service

Product Specification
----------------------------------------------------------------
Product family                 : frozen vegetables
Threshold on file              : -15.0 C maximum product temperature
Cumulative allowance on file   : 180 minutes cumulative above the threshold

Rule X-1  The threshold is the maximum product temperature on the SPECIFICATION for what is stored
          in this unit. It is an operator-supplied value and there is no default.
Rule X-2  Exposure accrues, in 5-minute increments, for every minute the recorded temperature is
          above that threshold while the unit is in service.
Rule X-3  Exposure does NOT accrue during a SCHEDULED DEFROST -- a stretch that lies inside a window
          of this unit's declared defrost programme and that the maintenance log describes as the
          programme running normally. Air temperature rises by design; product temperature does not.
Rule X-4  Exposure DOES accrue for every other stretch above the threshold, whatever the log says
          caused it: a door left open, a delivery held on the dock, a blocked condenser, a stuck
          defrost heater, an engineer working on the unit. A FAULT INSIDE A DEFROST WINDOW IS NOT A
          DEFROST.
Rule X-5  The ONSET is the first minute of the first stretch that accrued exposure on this unit.
          Once set it does not move. It may lie in a window whose trace is no longer on this page;
          when it does, the carried state is the only record of it.
Rule X-6  A product-safety excursion record is opened ONCE per unit, on the first scheduled run at
          which cumulative exposure PASSES the allowance on the specification. A later run reports
          the record already open; it does not open a second one.
Rule X-7  Where no product specification is on file, or where the probe reported nothing for part of
          the monitored period, the unit is CONTEXT_INCOMPLETE: no exposure accrues, no onset is
          claimed, no record is opened, and no default threshold may be assumed.
Rule X-8  Exposure stops when the unit is taken out of service and its product is transferred.
Rule X-9  A unit is on WATCH once it has accrued exposure and less than one watch cadence of
          allowance remains -- that is, it will pass the allowance before the next scheduled run if
          it keeps accruing. On the two-hourly cadence this kit ships on, that is under 120 minutes
          of allowance left.

Exposure Position
----------------------------------------------------------------
Snapshot taken                 : 2026-03-04 10:00   (scheduled run 2 of this unit)
Watch cadence                  : every 120 minutes (08:00 / 10:00 / 12:00 local)
Previous scheduled run         : 2026-03-04 08:00
Minutes above threshold in this window, before any exemption : 55
Total minutes above threshold since monitoring began, before any exemption : 65

Temperature Trace
----------------------------------------------------------------
Recorder samples every 5 minutes, this window only. Degrees Celsius. The last
reading printed is the last one taken before the snapshot.

08:00 -13.9   08:05 -13.3   08:10 -12.7   08:15 -13.1
08:20 -12.9   08:25 -12.7   08:30 -12.8   08:35 -17.1
08:40 -17.5   08:45 -17.2   08:50 -17.3   08:55 -17.3
09:00 -17.4   09:05 -17.2   09:10 -17.7   09:15 -17.2
09:20 -17.1   09:25 -17.7   09:30 -17.1   09:35 -17.6
09:40 -14.4   09:45 -14.0   09:50 -13.1   09:55 -12.3

Maintenance Log
----------------------------------------------------------------
Entries raised in this window only.

08:35  cycle finished, evaporator clear
09:40  the scheduled cycle ran and the case is still sitting above its setpoint

Store Notes
----------------------------------------------------------------
Duty manager flagged this case for a follow-up on the morning replenishment.

Raw responseThe raw response

{
 "state": "IN_BAND",
 "onset": "09:40",
 "exposure_minutes": 20,
 "open_record": "NO",
 "rationale": "Applied Rule X-3/X-4: subtracted 35 exempt minutes for the normal 08:00-08:35 scheduled defrost, counted 20 minutes from 09:40-09:55 as a fault inside the defrost window, giving 20 accrued minutes, below the 180-minute allowance, so no record opens."
}

Step 06 of 14Evals

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

In brief

Track how long a store's cooler ran warm — 120 unit snapshots. One model answered, and every answer was then graded Four 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 the planted stretches at generation time — never from the rendered page — and re-derived from src/excursion.step by evals/check_labels.py before any run may spend. Three of the four answered fields are words from a closed list and the fourth is an HH:MM clock time, so there is nothing here a judge could add. The disposition is not answered at all: the scorer derives it from each arm's own exposure figure against the allowance on file.

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 246 calls is kept out of these tables per this estate's naming rule, so nothing here is what was paid. The real spend for this kit's whole build is on the shared call ledger, not on this page.

Grading unitWhat the grading figure prices

The GRADER costs nothing: evals/scoring.py makes no model call, neither do the three free floors it compares against, and neither does evals/missed_run.py, which produced every cadence figure on this page. The only money in this kit went on the arms themselves.

The gradersFour ways to grade

⛑ THE MODEL TIES THE STRONGEST FREE FLOOR ON THE HEADLINE BAND AND WINS THE TWO FIELDS PRODUCT SAFETY IS DECIDED ON. State: 92.50 pct against 92.50 — the same number, 111 of 120 each. Open/hold: 99.17 each. Derived disposition: 99.10 each. ONSET: 95.83 against 94.17. ACCRUED MINUTES: 95.83 against 91.67, and a total exposure error of 3.13 pct against 3.77. ⛑ WHAT MEMORY ALONE IS WORTH IS THE CLEANEST NUMBER HERE AND NO MODEL IS INVOLVED IN IT. b000 is the threshold alarm with no memory: onset 34.17 pct. b001 is the SAME RULE handed the carried state: 72.50 pct. That is 38.33 points bought by five scalars of pure code. On the 46 readings whose onset is off-page, b000 scores 0.00 and b001 scores 100.00 — the answer is not on the page, so the arm without memory cannot be right and is not. ⚠︎ AND THE FLOOR BEATS THE MODEL SOMEWHERE, WHICH IS WHY THREE FLOORS RATHER THAN ONE. On off-page onsets the model scores 93.48 and both memory floors score 100.00. Those rows do not need judgement, they need a handed value copied forward unchanged, and code copies better than reading does. ⚠︎ ONE ASYMMETRY FLATTERS THE FLOORS AND IT IS THE SAME ONE EVERY KIT IN THIS SERIES HAS. b002 and the answer key are not the same implementation — the key comes from the planted stretches and b002 re-derives them from the rendered trace — but they DO share the corpus's own notion of where a stretch starts, whereas the model can only read the prose. What b002 cannot share is the exemption judgement, and that is exactly where its 7 errors are.

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 refrigeration unit, 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

246 live calls were attempted for this kit and 244 returned something that parsed: 6 calibration (c000, at an 8,000-token ceiling on the two hardest unit chains — 1 of them was cut off and is the reason the published ceiling is 24000), 120 scored (r001, all 120 parsed) and 120 control (s001, 119 parsed; one ran to the 24,000-token ceiling). The two that produced nothing usable were BILLED and their tokens are in the totals above, which is why discarded_usd is 0.00 rather than blank: nothing was thrown away, one reply was simply unusable. Everything else on this page — three free floors, the missed-run experiment, fourteen pre-spend checks, four screenshots and every grader — cost nothing.

Cost driversWhat actually moves the bill

• OUTPUT TOKENS, AND MOST OF THEM ARE REASONING. 94.4 pct of this run's output (189001 of 200242) was provider-side reasoning left at the default. Input is 2002 tokens a reading and barely moves; output is 1669 and moves by a factor of three when the prompt changes.
• THE CADENCE, WHICH MULTIPLIES EVERYTHING ELSE. One reading is one call; the watch wakes 12 times a day on the shipped 120-minute cadence; the bill is units x runs. It is also the one knob that moves the ANSWER — see evals/missed_run.py — so it cannot be tuned for cost alone.
• THE POPULATION IN SERVICE, NOT THE ESTATE'S SIZE. A unit taken out of service leaves the watch and stops costing anything; 14 of the 120 readings in this corpus are on units already out of service, and they are the cheapest readings here because their trace is empty.
• THE CARRIED STATE IS NOT A COST DRIVER AND THAT IS THE POINT. Five scalars rendered as two to four sentences — 474 characters on the worked example — so run 400 costs what run 2 costs. The OPPOSITE curve to an intake kit, whose input grows with history.
• THE PROMPT'S FIXED PART. The instruction and the nine printed rules are 3195 characters and go out on every single reading; the unit's own data is the smaller half. Shortening the rulebook is the only input-side lever there is, and it trades directly against the two rules the model already gets wrong.
• GRADING IS FREE AND SO IS EVERY CADENCE FIGURE ON THIS PAGE. evals/scoring.py, all three floors and evals/missed_run.py make no calls at all.

Your volumeWhat it costs at your volume

LINEAR IN UNITS x RUNS, AND THAT IS THE WHOLE WARNING. Ten times the units in service is ten times the calls at the same cadence — $0.07 a day per unit on the projected card at 12 runs a day, so a 400-unit estate is about $28.83 a day and a 4,000-unit one about $288.35. There is no batching seam: a unit's three runs are strictly serial because run 2's prompt carries an onset produced by run 1, and different units are already run concurrently. What does NOT grow is the carried state, which is five scalars whatever the history.

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 of .env and one more run. Both live arms used it so that the stateful/stateless comparison has one variable; the twelve rows in the projection table were not run and the table says so.

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: 120 readings, one completion call each, 40 units x 3 scheduled runs, all 120 parsed.

The codeEvery file, and what it is for

15 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.

Seven 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 40 refrigeration units x 3 scheduled runs = 120 snapshots from a fixed seed (SEED = 20260906). Roughly a third of the above-threshold stretches are built to straddle a scheduled run, and about half the COUNTED ones are placed inside a declared defrost window so position alone cannot separate them. It also computes data/gold.jsonl from the unit model rather than from the rendered page.

You change it to: Point it at your own estate, or replace data/corpus/*.txt and data/gold.jsonl directly. Keep the eight headings; supply your own key.

# 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 = 20260906
UNITS = 40
DAY = "2026-03-04"
TRACE_START = 360
RUN_MINUTES = (480, 600, 720)

src/excursion.pythe excursion arithmetic — a swap seam

The rule as pure code: minutes above threshold this window, minus the minutes a scheduled defrost exempts, added to whatever had already accrued, against the allowance on the specification. It also owns the STICKY ONSET — before['onset'] or first_counted_start is the whole of Rule X-5, and it is the reason a reading three windows later can name a minute whose trace left the page hours ago.

You change it to: CADENCE_MINUTES, and with it the WATCH band — the threshold IS the interval between runs, so changing one changes the other. evals/missed_run.py measures what a SKIPPED run costs on the shipped cadence; it does not measure a different cadence, and nothing here does.

# The excursion rule as arithmetic. Pure code, no model, no dates that need a library.

IN_BAND = "IN_BAND"
DEFROST = "DEFROST"
WATCH = "WATCH"
EXCURSION_OPEN = "EXCURSION_OPEN"
CONTEXT_INCOMPLETE = "CONTEXT_INCOMPLETE"
STATES = (IN_BAND, DEFROST, WATCH, EXCURSION_OPEN, CONTEXT_INCOMPLETE)
YES = "YES"
NO = "NO"
RECORDS = (YES, NO)

src/state.pythe carried state — a swap seam

SEAM 2 — the thing that makes this a monitor. Five scalars per unit (minutes accrued, the onset, whether the unit was still above threshold at the last run's end, whether a record is open, and the last state reported), rendered into English for the prompt and written ONLY by the arithmetic. The onset is the one carried field no later run can rebuild.

You change it to: What is carried between scheduled runs and how it is worded. Five scalars today. ⚠︎ THE WORDING IS LOAD-BEARING AND UNMEASURED: describe() renders them as English rather than JSON on judgement, not on evidence. It is in could_not_verify.

# 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_unit(store, unit_id):
def describe(state):

src/segment.pythe section splitter

Eight named sections, asserted in all 120 documents before a run may spend. A parser drift shows up as a refusal to start rather than a truncated prompt.

# Split a unit snapshot into its named sections. Pure code, no model.

SECTIONS = ("Synthetic Record", "Unit", "Product Specification", "Exposure Position",
RULE = "-" * 64
def split(text):
def render(secs):

src/select.pythe section filter — a swap seam

SEAM 3 — decides what leaves the machine. Service Contact (engineer name, mobile, F-Gas certificate number) is mapped by nothing and subtracted unconditionally by _fallback, so the guard holds even when a source-system rename breaks every other section.

You change it to: SECTION_HINTS and NEVER_SENT. Adding a field to a hint sends it; the fallback subtracts NEVER_SENT unconditionally, so a rename cannot leak the engineer's certificate number.

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

BANNER = "Synthetic Record"
UNIT = "Unit"
SPEC = "Product Specification"
POSITION = "Exposure Position"
TRACE = "Temperature Trace"
LOG = "Maintenance Log"
ENGINEER = "Service Contact"
NOTES = "Store Notes"
NEVER_SENT = (ENGINEER,)

src/prompt.pythe prompt

SEAM 4 — three parts: the fixed instruction and JSON shape, the carried-state sentence, and the sections select.py let through. The stateless control replaces the middle block and nothing else; check_labels asserts the two builders differ on 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 unit at one scheduled run, one completion call. Parses the arithmetic inputs off the page with regexes so the scorer can tell a reading failure from a reasoning one, and holds MAX_TOKENS = 24000, the published ceiling.

# One unit, 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 refrigeration excursion watch. You apply a written cold-chain rule "
MAX_TOKENS = 24000
FIELDS = ("state", "onset", "exposure_minutes", "open_record")
def documents():
def units():
def load_doc(doc_id):
def position_of(text):

src/adapters/__init__.pythe model adapter — a swap seam

SEAM 1 — raw HTTP, no vendor SDK. Retries 429/5xx and transport failures with backoff; records finish_reason and reasoning-token detail, which is how this run knows 94.4 pct of its output was provider-side reasoning.

You change it to: PROVIDER, BASE_URL, API_KEY and MODEL in .env. Adding a provider is one function and one entry in PROVIDERS; it must return token counts or the cost lens cannot publish.

# SEAM 1 — the model. Swapping provider or model is .env plus the same run again.

class AdapterError(RuntimeError):
TRANSIENT = {408, 429, 500, 502, 503, 504}
RETRIES = 4
def _post(url, headers, payload, timeout=120):
def openai_compatible(cfg, system, user, max_tokens, thinking=None):
def anthropic(cfg, system, user, max_tokens):
PROVIDERS = {"openai-compatible": openai_compatible, "anthropic": anthropic}
THINKING_OFF = {"type": "disabled"}
def complete(cfg, system, user, max_tokens=1024, thinking=None):

src/budget.pythe daily cap

One append-only ledger beside the shared .env, checked once per completion. It counts calls, not dollars, because the kit does not know your rate card.

# A cap on live calls, shared by every kit on this machine. No dependency, no service.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
KIT = os.path.basename(HERE)
ROOT = os.path.dirname(os.path.dirname(HERE))
SHARED_ENV = os.path.join(ROOT, ".env")
LEDGER = os.path.join(ROOT if os.path.exists(SHARED_ENV) else HERE, ".calls-ledger.jsonl")
PAID_ARMS = ("r", "x")
FREE_ARMS = ("t", "b")
BOOT = os.urandom(6).hex()
PID = os.getpid()

evals/baseline.pythe three free floors

bandonly, bandonly-mem and defrost-mem, all $0.00 and all scored through the identical scorer. defrost-mem parses the trace into above-threshold stretches, reads the declared programme and decides the exemption with a keyword table.

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

MODES = ("bandonly", "bandonly-mem", "defrost-mem")
ASSUMED_THRESHOLD_C = 5.0
ASSUMED_ALLOWANCE_MINUTES = 120
PROGRAMME_WORDS = ("defrost", "cycle", "programme", "programmed", "sequence",
FAULT_WORDS = ("fault", "stuck", "failed", "leak", "blocked", "split", "propped",
def _num(pat, text, cast=float):
def _trace(text):
def _log(text):
def _programme(text):

evals/scoring.pythe scorer — a swap seam

Exact match per cell, plus the two onset directions counted apart with their minute totals, plus the DERIVED disposition — computed from each arm's own exposure figure against the allowance on file, never answered by anything.

You change it to: Which cells are compared and how the two onset directions are split. The DERIVED disposition lives here too — if your business dispositions on something other than minutes past an allowance, this is the one function to change.

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

FIELDS = ("state", "onset", "exposure_minutes", "open_record")
def _pct(n, d):
def _mins(v):
def _onset(v):
def _minutes_of(onset):
def score(records, golds):

evals/missed_run.pythe cadence experiment

Replays every unit's chain with one scheduled run removed, on two schedules (blind window and back-fill). Calls nothing. It is the only file here that measures the CLOCK rather than the reader.

# WHAT A SKIPPED SCHEDULED RUN COSTS. Free -- nothing here calls a provider, ever.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
GOLD = os.path.join(HERE, "data", "gold.jsonl")
OUT = os.path.join(HERE, "results", "missed-run.json")
def chains():
def play(rows, skip=None, backfill=False):
def main():

evals/check_labels.pythe pre-spend checks

Fourteen claims the page makes, checked against the corpus that will be sent — including the two that make every onset figure meaningful: no snapshot restates its carried state, and an off-page onset is printed nowhere on its own page.

# Everything that must be true BEFORE a run is allowed to spend. Free, and it runs in seconds.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
GOLD = os.path.join(HERE, "data", "gold.jsonl")
FAILED = []
def check(name, ok, detail=""):
def section_body(text, name):
def main():

evals/run.pythe run harness

Units run concurrently; a unit's three scheduled runs never do. The clock advances from the answer key even when a call failed, so one transport error does not become three scored failures.

# Run the watch over the 40 units in service, three scheduled runs each, and write one result file.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = os.path.join(HERE, "results")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
def load_gold():
def stub_complete(cfg, system, user, max_tokens=1024):
def advance(carried, g):
def main():

src/app.pythe local UI

http.server, no key needed, port 9012. Prints the carried-state sentence verbatim, the free floor beside the model, and the derived disposition for both.

# 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", "9012"))
RECORDED_RUN = os.environ.get("RECORDED_RUN", "r001-refrig-excursion")
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: 2002 input and 1668 output tokens per reading (one refrigeration unit, 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 byte that reaches the prompt comes from tools/build_corpus.py, which is committed and deterministic. In a real deployment one field would be different: Store Notes is prose a duty manager types freely, and it is sent to the model verbatim on every reading — deliberately, so the surface sits inside the run that measures the kit rather than outside it. Nothing here writes anywhere except results/*.json and data/state.json, and there is no path of any kind that condemns stock, releases it, raises a supplier claim or touches a stock system.

The provider key lives only in .env (gitignored from the first commit) or the shared repo-root .env, read by src/config.py, which merges shared → kit → real environment key by key. It is never printed: config.sources() returns paths and booleans, never values, and src/app.py's error path substitutes [API_KEY] and [BASE_URL] into any exception text before it reaches the browser. src/config.save() opens the file with mode 0600 BEFORE the write, so it never exists at the default umask even for an instant. This repository has never held a credential.

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: Store Notes. It is sent, not hidden, and one of the three shipped notes — “The supplier has asked to be consulted before any product on this unit is written off” — is a mild instruction-shaped sentence put there on purpose. It appeared on 40 of the 120 readings and not one reply acted on it. That is a fact about the OUTPUT SHAPE, not about robustness: the reply is a closed vocabulary, a clock time, an integer and YES/NO, and there is nothing in the kit for an instruction to reach. 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, and an absence is checked by grepping for names it knows — a path called something else would pass, which is stated here rather than hidden.

The result0 attack trials, three boundaries checked — and the privacy boundary red-proven by removing the guard and watching all 120 documents leak an engineer's certificate number.

Store Notes IS the field an outside party would influence in a real deployment, and this kit sends it rather than hiding it — hiding the surface would hide it from the run that is supposed to measure it. One of the three shipped notes is instruction-shaped. Nothing obeyed it, and the honest reason is that there is nothing to obey with.

HonestyWhat this does not prove

• Whether a real estate's Store Notes — prose a duty manager writes freely — would carry anything the three shipped templates do not. Only three notes exist in this corpus.
• Whether the no-propagation property holds under a wrong answer mid-chain. It is true by construction (the model's reply never reaches src/excursion.step) and no run has forced it.
• Whether the state file is safe under concurrency. src/state.save() replaces atomically, which is correct for one writer; two watches on one estate was never attempted.
• Whether the guardrail grep would catch a differently-named path. It asserts the absence of eight names it knows and nothing more.
• Whether an F-Gas certificate number in a real feed sits only in the section this kit withholds. On this corpus it does, because the generator puts it there.

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 product-disposition release, non-configurable. This kit produces a watchlist state, an onset, an accrued-minutes figure and an open/hold call on a product-safety excursion record, plus a DERIVED disposition shown on a page. It never condemns stock, releases it for sale, raises a supplier claim, writes a shrink line or touches a stock system, and there is no configuration flag that adds one. A disposition decision is made by people against the specification and the food-safety procedure their own business signed off. The second, equally non-configurable half: no default threshold. A unit with no product specification on file stays CONTEXT_INCOMPLETE and accrues nothing.

Everywhere and nowhere — it is a property of what is ABSENT. The only writers in the kit are evals/run.py (results/*.json), evals/missed_run.py (results/missed-run.json), tools/build_corpus.py (data/) and src/state.py (data/state.json). src/app.py serves GETs and one POST that makes a completion call and returns JSON. The threshold half is enforced in src/excursion.step's first branch, which returns before any arithmetic runs.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• IT IS NOT A CHECK ON WHETHER THE ANSWER IS RIGHT. The arithmetic is correct whatever the model says, which is exactly why the model's answer can be scored — but nothing at runtime compares the two and refuses to publish a disagreement. The UI SHOWS both columns; it does not gate on them.
• IT IS NOT A SCHEDULER. evals/run.py is invoked, not woken. Nothing here detects that a run did not happen, back-fills a missed window or marks a reading late — and evals/missed_run.py exists precisely to price what that absence costs rather than to fix it.
• IT IS NOT A DISPOSITION SYSTEM. The disposition row on the page is DERIVED from the exposure each column reported, so a reader can see what an under-count does. It is not written anywhere, not sent anywhere, and nothing consumes it.
• IT IS NOT A CALIBRATION CHECK ON THE PROBE. A sensor reading two degrees low all morning produces a page that looks perfect and an answer key that is wrong with it.
• IT IS NOT AN AUTHORITY ON COLD-CHAIN RULES. The nine rules, the thresholds and the allowances were invented here and reproduce no retailer's standard, HACCP plan, food-safety code or regulator's guidance.

WatchedWhat is watched, and why that one

The kit measures 68 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.

22 measured by the latest run 46 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_minutes 120, context_incomplete_cells 18, disposition_cells 111, documents 120, memory_cells 54, onset_cells 71, onset_offpage_cells 46, quiet_cells 102, readings_scored 120, record_cells 18, stateless False, units 40) — 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, disposition_cells, documents, max_tokens, memory_cells, onset_cells, onset_offpage_cells, quiet_cells, readings_scored, record_cells, stateless, units — 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 22 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 (free, seconds) on any change to tools/build_corpus.py, src/excursion.py, src/segment.py, src/select.py or src/state.py — it is the only thing standing between a generator change and a page full of figures that no longer describe the corpus, and two of its fourteen assertions (no snapshot restates its carried state; an off-page onset is printed nowhere on its own page) are what make every onset figure here mean anything. Re-run the three floors (free) whenever src/state.py or evals/baseline.py changes, because the off-page column is the one that moves. Re-run evals/missed_run.py (free) whenever the corpus or the cadence changes. Re-run the SCORED arms only when the prompt, the model or the corpus changes — that is 120 calls each and the only thing on this list that costs money.

In one lineNo framework, deliberately

No framework and no dependencies at all — json, os, re, random, argparse, urllib, http.server, concurrent.futures. requirements.txt names nothing and the emptiness is load-bearing: a forker installs a client for a vendor they will never call, and learns the kit is bigger than it is. What a framework would be FOR here is named seam by seam below, with the cost of not having 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 unit is a chain of three readings that must run in order because run 2's prompt contains an onset produced by run 1; 40 such chains run concurrently. There is no branching, no tool selection and no retry-with-different-prompt, so a graph runtime would be drawing a box round a for-loop.

The other sideWhat a framework costs you

• No scheduler. This is a watch that carries state and is still INVOKED, not woken — and unlike every sibling kit that has said this, the cost is on the page in minutes and disposition flips rather than in a sentence.
• No back-fill, no late marking, no missed-run detection. All three are what a scheduling engine gives you, and evals/missed_run.py measures the second one's absence exactly: 3195 exposure minutes lost against 525 with back-fill.
• No durable state store. data/state.json is one file and one writer; two watches on one estate would need something with a lock, and nothing here has been run concurrently.

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

Measured on r001-refrig-excursion 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-refrig-excursion-bandonly, b001-refrig-excursion-bandonlymem, b002-refrig-excursion-defrostmem 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 field in every snapshot was produced by tools/build_corpus.py in this repo, and data/SOURCES.md says so in the first line. Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe state, the onset, the accrued minutes and the open/hold call, per reading, exact match against the computed answer key

For each of the 120 readings and each of the four answered fields, did the reply equal the computed answer key? State and open/hold are words from closed lists, the onset is an HH:MM string normalised at both ends, and the accrued minutes are compared on the 5-minute recording increment.

MethodHow the test was run

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

Every grader on these pages scored the same 120 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 / 120 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 stretches at generation time and re-derived from src/excursion.step by evals/check_labels.py (0 mismatches over all 40 chains).

How tight can the band be? No tuned threshold anywhere on the model path — the reply decides. 120 readings, so the finest band any per-field rate supports is 0.83 points.

Cadence: Re-run evals/check_labels.py (free) on any change to the generator, the arithmetic, the splitter or the filter. It is fourteen assertions and it finishes in seconds.

The decisionWhen to reach for it

In one lineThe two onset directions, counted apart, with their minutes

Of the 120 readings, how many report the onset LATER than the truth (including reporting NONE where an onset exists) and how many EARLIER (including inventing one). Both are counted, and both carry a total in MINUTES — for a dropped onset the magnitude is measured from the true onset to the end of that window, which is the whole of the exposure it silently loses.

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 120 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

onset_late / 120 and onset_early / 120, never averaged and never combined. The minute totals are summed independently.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl's onset column, set once per unit by src/excursion.step and sticky thereafter. Scored against the reference; not itself the reference.

How tight can the band be? 71 readings carry an onset and 49 do not, so the finest band either rate supports is 0.83 points of the whole set.

Cadence: Free, every run. Re-run the floors too whenever src/state.py changes — the off-page column is the one that moves.

The decisionWhen to reach for it

In one lineWhat the reported exposure would actually do to the product

For each of the 111 readings with an allowance on file: DISCARD if the exposure the arm REPORTED exceeds the allowance, RELEASE otherwise, compared with the same computation over the key. A reading that says RELEASE where the key says DISCARD is counted as UNSAFE; the other direction is counted as WASTEFUL.

MethodHow the test was run

evals/scoring.py::score, derived — no arm is asked for this field and no arm could game it without changing the minutes it reports.

Every grader on these pages scored the same 120 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

disposition_accuracy = hits / 111; unsafe = RELEASE-where-DISCARD; wasteful = DISCARD-where-RELEASE. Never summed into one error rate.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the key's own exposure against the same allowance, computed by the same function. The comparison is between two applications of one rule.

How tight can the band be? 111 of the 120 scored readings carry an allowance; the other 9 have no specification on file and are correctly outside this grader.

Cadence: Free, every run.

The decisionWhen to reach for it

In one lineThe readings whose answer is not on their own page

The same exact-match comparison, restricted to the 54 readings the generator marked memory_dependent — minutes already accrued that this page does not restate, an onset whose trace has closed, a stretch that opened before this window, or a record already opened. A stricter slice of 46 is marked onset_offpage: the correct onset is nowhere on the page at all.

MethodHow the test was run

evals/scoring.py::score, same pass, grouped by flags tools/build_corpus.py set at generation time.

Every grader on these pages scored the same 120 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 / 54 per field over the memory_dependent subset; the off-page onset column is hits / 46.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the same data/gold.jsonl, sliced by the memory_dependent and onset_offpage flags. Scored against the reference; not itself the reference.

How tight can the band be? 54 memory cells, so the finest band this subset supports is 1.85 points; 46 off-page cells, 2.17 points.

Cadence: Free, every run. Re-derive both flags whenever the generator changes.

The decisionWhen to reach for it