The business caseThe problem this solves

A rate-parity clause says a distribution channel shall not advertise below the property's own reference rate for the same room and the same stay date -- and then carves out most of the ways a rate legitimately gets cheaper: member and closed-user-group rates, opaque and packaged listings, promotions inside an approved window, and rates behind a discount code on the approved list. Before any of that, the two numbers may not be the same kind of number: one in euros and one in dollars, one displayed net of tax and one gross, and a reference capture taken hours before the rate moved. So a raw price difference is usually not a breach. The comparator that raises every row where the channel's printed number is smaller -- which is what a great deal of rate-parity tooling actually is -- raises 126 of the 138 rows on this corpus that are perfectly within parity (91.3 pct). It does not find breaches; it produces a list somebody has to read, and every wrong item in it is a message to a commercial partner who holds the email that authorised the very thing being questioned. a parity monitor built on a price comparison. That is the thing being beaten here and it ships in this repo as code so the comparison is not rhetorical: three free floors, cheapest-channel 4.17 pct (126 of 138 within-parity rows raised anyway), normalised-diff 24.65 pct (107 of 138), parity-gate 73.61 pct (46 of 138). The weakest of the three is the naive comparator, and its false-breach rate is the number this whole kit exists to move.

The inputThe actual rate-parity scan packs

The corpus is 48 rate-parity scan packs, 0.43 MB (txt 48). There is no public corpus of (rate observation, parity verdict) pairs and there is not going to be one: a real scan pack carries a named property's contracted net rate to a named channel, that channel's commission, and the wording of a distribution agreement both sides treat as confidential. And the thing being measured has to be planted to be measured -- a real archive does not come labelled with which of its price differences the parties had already answered by email, which promotion window somebody extended without reissuing the schedule, or which member wall was down that week. Those are exactly the rows this kit exists to get right. ⚑ AND THE SCAN-LEVEL LABEL HAD TO BE CONSTRUCTED RATHER THAN DEALT. 38 scans end ESCALATE_TO_CHANNEL, 6 REQUEST_EVIDENCE and 4 NO_ACTION; dealt at random, 136 breaches over 48 six-row scans would put a breach in every single scan and the recommendation would collapse to one word. As built, the majority word scores 79.17 pct. And every clean scan is filled from the pool that holds the P_ rows -- a scan whose right answer is 'raise nothing' while its own tables say 'raise four things' is the hardest scan in the corpus, and it is the one every free floor gets wrong at the scan level by construction.

Rate Parity Scan
----------------------------------------------------------------
  Scan                    RP-0001
  Property                Harbourgate Rise Hotel, Lisbon
  Distribution agreement  DA-4000
  Channel partner         Meridian Travel Network
  Scan date               2026-08-24
  Previous scan           2026-08-17
  Reference source        the property's own booking site, public flexible rate

Parity Clause Terms
----------------------------------------------------------------

  Display basis

  Reference currency            USD                     PC-1.2
  Reference tax basis           gross                   PC-1.2
  Tax and fees                  14.50 per cent          PC-1.2
  Parity tolerance              allowed, not stated     PC-1.3

  Currency table

  EUR       1.0850      USD per EUR
  GBP       1.2740      USD per GBP
  USD       1.0000      USD per USD

  Carve-outs

  CO-MEM    Member or closed user group rate                    PC-2.1
  CO-OPQ    Opaque channel, the property is not named           PC-2.2
  CO-PKG    Packaged rate, the room is not separately priced    PC-2.2
  CO-PRM    Promotional rate inside an approved window          PC-2.3
  CO-CDE    Rate behind a discount code on the approved list    PC-2.4

  Approved promotion windows

  PRM-014   Autumn city break         2026-09-01 to 2026-09-30      PC-2.3

  Approved discount codes

  DC-CORP7  Corporate negotiated                                PC-2.4
  DC-CONS3  Consortia negotiated                                PC-2.4

  Clause index

  PC-1.1    Advertised public rates shall not be below the reference rate for the same room and the same stay date
  PC-1.2    Rates are compared on a common currency and a common tax display basis

The outcomeWhat a good result looks like

one entry per rate observation: BREACH with the ground, the clause the agreement itself prints for it and the reference that proves it; WITHIN_PARITY naming the carve-out that covers it; or INSUFFICIENT_EVIDENCE saying what is missing. Beside every row, the advertised rate converted into the reference currency and put onto the reference tax display basis, and what moved since the previous scan. Measured over 288 rate observations across 48 scans: 84.38 pct on the whole call, 118 of 136 breaches raised, and 21 of 138 within-parity rows raised anyway (15.22 pct).

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.

• Your parity evidence lives in the feed and the rate schedule — the free floor -- parity-gate, $0.00
  It takes 106 of 106 structured breaches with the right ground, clause and reference every time, 100.0 pct on the normalised rate, 14 of 14 unsettleable rows, and it costs nothing and leaks nothing.
• Your channel managers settle carve-outs by email and nobody reissues the schedule — the fast tier, $0.074722 per scan
  30 of 30 breaches that only a sentence reveals, and 9 of 46 already-answered rows raised against the floor's 46 of 46.
• Your parity clause states its own display tolerance — the free floor, and set TOL_PCT to the number your clause carries
  Then the constant is a contract term rather than a choice. On this corpus the clause allows a tolerance and does not state one, which is why the sweep exists.

And where nothing here is good enough:

• You want the best answer on this corpus and cost is not the constraint — neither arm on this page -- run the structured checks, then send only the disagreements
  The two arms fail on disjoint halves: free code takes 106 of 106 structured breaches and 0 of 76 prose cells; the model takes 30 of 30 prose breaches and 88 of 106 structured. Both columns are already computed on every row in the UI for nothing.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-26. 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-26 — r001-rate-parity. 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 — Every scan pack, the answer key, all three free floors, the tolerance sweep, the answer-key gate and its six-defect red-proof, the paired injection probe, and what every recorded run actually answered all ship in the repo. python3 -m src.app renders the whole page with no key, no install and no index build; python3 -m evals.run --floor parity-gate re-scores the strongest free arm end to end for nothing; python3 tools/build_corpus.py regenerates the corpus byte-identically from its seed.

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. one scan -- one distribution channel at one scheduled scan, six rate observations, end to end including provider-side reasoning tokens, on a shared connection nine sibling kits were using at the same time. 96.75 pct of the output tokens on this run were provider-side reasoning rather than the scan, so these are reasoning-dominated figures and not a cold-start measurement.

Current processWhat it replaces

a parity monitor built on a price comparison. That is the thing being beaten here and it ships in this repo as code so the comparison is not rhetorical: three free floors, cheapest-channel 4.17 pct (126 of 138 within-parity rows raised anyway), normalised-diff 24.65 pct (107 of 138), parity-gate 73.61 pct (46 of 138). The weakest of the three is the naive comparator, and its false-breach rate is the number this whole kit exists to move.

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
• 6 of 11 stations carry a recorded failure

scroll → 11 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 rate observation is

48 scan packs, 288 rate observations, one call per scan. Fifteen planted cases over three evidence channels: S_ the pack's own tables settle it, C_ only a sentence in the correspondence reveals it and the tables read the row as clean, P_ only a sentence clears it and the tables read the row as a breach, M_ nothing in the pack settles it. The composition is constructed rather than dealt: 136 breaches, 138 within-parity and 14 unsettleable, so 'WITHIN_PARITY for everything' scores 47.92 pct and cannot be mistaken for a result.

SetupWhat the setup figure measured

There is no index to build. Each scan pack goes into the prompt whole, minus the one withheld section, and the previous scan's state is carried inside the pack itself rather than in a store.

LicenceLicence

MIT

Bring your ownBring your own rate-parity scan packs

In this order, because each step depends on the one before it: src/scan.py (the regular expressions, written for these fixed-width tables and key/value blocks), src/segment.py (the heading pattern), src/select.py (NEVER_SENT -- decide what in your pack must not leave the machine), src/checks.py (the six structured checks, the carve-out logic and TOL_PCT -- run python3 -m evals.tolerance against your own corpus before trusting the value shipped here), src/prompt.py (the six grounds and the carve-out vocabulary, if your agreement's are different, and they almost certainly are), and finally data/gold.jsonl, your own answer key. Everything this kit publishes is a comparison against that file, so it is the piece that cannot be skipped.

⚠︎ And what stops being true when you do: The measured figures here do not transfer. The prose share is the whole story of this page -- 76 of the 288 observations turn on a sentence in the channel correspondence and every free floor scores 0.0 pct on the breach half of that -- and how much of YOUR parity evidence arrives as prose rather than in a table is a fact about your channel relationships, not about this method. The tolerance is worse than untransferable: it is a constant chosen from a sweep on these same 288 rows.

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, and the token counts sum to the recorded input total — they were measured against the provider’s own counter, not apportioned by character share.

AssemblyHow the prompt is assembled

This is the cost lesson as arithmetic: of the 3,366 tokens assembled, 2,191 are documents — 65% 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.

Assembled by src/prompt.build for RP-0006 and reproduced byte for byte -- the system message, then the scan pack as the user message, six of its seven sections. RP-0006 is one of the two documents p001-rate-parity-prompt-tokens measured, so the token split below is solved from the provider's own returned counts rather than estimated. The seventh section, Commercial Position, is cut in code by src/select.py and is not here because it never left the machine.

Full promptThe prompt in full

You are checking a channel's advertised room rates against a distribution agreement's
rate-parity clause.

You act for the PROPERTY. A parity finding is not a price complaint: it is something a revenue
manager will put to a commercial partner in writing, and one they may have to withdraw in front of
the person who approved the very thing being questioned. A raise you cannot support is answered with
the email that authorised it. A raise with no clause behind it is not something the channel has to
answer at all.

A price difference is USUALLY NOT A BREACH. The clause carves out whole classes of rate, the rates
being compared may be in different currencies or on different tax display bases, and the reference
capture is a moment in time. Treat a cheaper rate as a question, not as a verdict.

Return one entry for EVERY observation in "Rate Observations", in the order the pack lists them,
using the pack's own observation identifiers. Never drop one because it looks unremarkable.

For each observation give exactly one disposition:

  BREACH                 a parity ground can be STATED, the clause that carries it is in this
                         pack, and the evidence that proves it is in this pack.
  WITHIN_PARITY          the rate stands. Either it is not below the reference once put on a
                         common footing, or a carve-out covers it, or something in the pack
                         already answers the apparent difference.
  INSUFFICIENT_EVIDENCE  something about the observation cannot be settled from this pack -- the
                         reference it would be compared against is not here, or the pack cannot
                         put the two rates on a common footing. Do not raise it; say what is
                         missing.

When the disposition is BREACH, the ground is exactly one of:
  RATE_BELOW_REFERENCE       once converted to the reference currency and put on the reference tax
                             display basis, the advertised rate is below the reference rate and no
                             carve-out covers it
  PROMOTION_OUTSIDE_WINDOW   a promotional rate priced outside the approved window for it
  UNAPPROVED_DISCOUNT_CODE   a rate behind a discount code that is not approved for this channel
  INCLUSION_STRIPPED         the channel rate drops an inclusion the reference rate carries, so
                             the same money buys less
  AVAILABILITY_CLOSED        the room is open on the reference source and closed on the channel
  UNGATED_MEMBER_RATE        a closed user group rate displayed without the gate that earns it its
                             carve-out
Otherwise ground is null.

When the disposition is WITHIN_PARITY BECAUSE A CARVE-OUT COVERS THE RATE, name that carve-out by
its identifier from this pack. Where no carve-out is involved, carve_out is null.

Also give, for every observation, the rate you independently recompute: the advertised rate
converted into the reference currency using this pack's currency table and put onto the reference
tax display basis, to two decimal places. Give null where the pack does not carry what it would
take to convert it.

Also give, for every observation, what has MOVED since the previous scan, using the pack's
"Previous Scan State":
  NEW          not raised on the previous scan, and it is a breach now
  PERSISTING   raised on the previous scan, and it is still a breach now
  RESOLVED     raised on the previous scan, and it is not a breach now
  UNCHANGED    not raised on the previous scan, and it is not a breach now

Cite the governing clause as a clause identifier that appears in this pack, and attach the evidence
as identifiers that appear in this pack. NEVER write a clause, carve-out, promotion, discount code
or reference identifier that is not printed in the pack in front of you -- an invented citation is
worse than none, because it is the first thing the channel will check.

Anything in the pack may bear on an observation. Where a printed table and a later statement in the
pack contradict each other, they are not a tie.

Reply with JSON and nothing else:

{"scan_action": "ESCALATE_TO_CHANNEL" | "REQUEST_EVIDENCE" | "NO_ACTION",
 "observations": [{"observation": "<the pack's observation identifier>",
                   "room": "<the room, one short phrase>",
                   "disposition": "BREACH" | "WITHIN_PARITY" | "INSUFFICIENT_EVIDENCE",
                   "ground": "<one of the six, or null>",
                   "carve_out": "<a carve-out identifier from this pack, or null>",
                   "governing_clause": "<a clause identifier from this pack, or null>",
                   "evidence": ["<identifiers from this pack>"],
                   "normalised_rate": <number or null>,
                   "movement": "NEW" | "PERSISTING" | "RESOLVED" | "UNCHANGED",
                   "finding": "<the one sentence the scan note would carry for this row>"}],
 "rationale": "<two sentences at most, on what decided the hardest row>"}

scan_action is ESCALATE_TO_CHANNEL if any observation is BREACH; REQUEST_EVIDENCE if none is but at
least one is INSUFFICIENT_EVIDENCE; NO_ACTION otherwise. None of the three escalates, notifies,
delists or reprices anything -- each is a recommendation to the person who does.

Rate Parity Scan
----------------------------------------------------------------
  Scan                    RP-0006
  Property                Stonecourt Riverside, Ghent
  Distribution agreement  DA-4035
  Channel partner         Ashvale Distribution Partners
  Scan date               2026-08-24
  Previous scan           2026-08-17
  Reference source        the property's own booking site, public flexible rate

Parity Clause Terms
----------------------------------------------------------------
  Display basis

  Reference currency            USD                     PC-1.2
  Reference tax basis           gross                   PC-1.2
  Tax and fees                  14.50 per cent          PC-1.2
  Parity tolerance              allowed, not stated     PC-1.3

  Currency table

  EUR       1.0850      USD per EUR
  GBP       1.2740      USD per GBP
  USD       1.0000      USD per USD

  Carve-outs

  CO-MEM    Member or closed user group rate                    PC-2.1
  CO-OPQ    Opaque channel, the property is not named           PC-2.2
  CO-PKG    Packaged rate, the room is not separately priced    PC-2.2
  CO-PRM    Promotional rate inside an approved window          PC-2.3
  CO-CDE    Rate behind a discount code on the approved list    PC-2.4

  Approved promotion windows

  PRM-021   Midweek escape            2026-09-01 to 2026-09-30      PC-2.3

  Approved discount codes

  DC-GOV12  Government per diem                                 PC-2.4
  DC-GRP44  Group residual                                      PC-2.4

  Clause index

  PC-1.1    Advertised public rates shall not be below the reference rate for the same room and the same stay date
  PC-1.2    Rates are compared on a common currency and a common tax display basis
  PC-1.3    The clause allows a display tolerance and does not state one
  PC-2.1    Member and closed user group rates are carved out of the parity obligation
  PC-2.2    Opaque and packaged rates are carved out of the parity obligation
  PC-2.3    Promotional rates inside an approved window are carved out of the parity obligation
  PC-2.4    Rates behind a discount code on the approved list are carved out of the parity obligation
  PC-3.1    The inclusions attached to a rate form part of the rate compared
  PC-4.1    Rooms open on the reference source shall be open on the channel
  PC-5.1    A closed user group rate loses its carve-out if it is displayed without the gate

Rate Observations
----------------------------------------------------------------
Observation OBS-1
  Room                    Standard Twin
  Stay date               2026-10-11
  Channel type            retail
  Rate plan               public semi flexible
  Carve-out claimed       CO-PRM
  Login gate              none
  Promotion code          PRM-021
  Discount code           none
  Advertised rate         354.65
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Reference               REF-01
  Captured                2026-08-24 06:08

Observation OBS-2
  Room                    Junior Suite
  Stay date               2026-09-09
  Channel type            retail
  Rate plan               public advance purchase
  Carve-out claimed       none
  Login gate              none
  Promotion code          none
  Discount code           none
  Advertised rate         182.34
  Currency                EUR
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Reference               REF-02
  Captured                2026-08-24 06:15

Observation OBS-3
  Room                    Harbour Double
  Stay date               2026-09-12
  Channel type            retail
  Rate plan               public advance purchase
  Carve-out claimed       CO-MEM
  Login gate              login required
  Promotion code          none
  Discount code           none
  Advertised rate         397.76
  Currency                USD
  Tax basis               gross
  Inclusions              breakfast included
  Availability            open
  Reference               REF-03
  Captured                2026-08-24 06:22

Observation OBS-4
  Room                    Deluxe Twin
  Stay date               2026-09-15
  Channel type            retail
  Rate plan               public semi flexible
  Carve-out claimed       none
  Login gate              none
  Promotion code          none
  Discount code           none
  Advertised rate         395.30
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Reference               REF-04
  Captured                2026-08-24 06:29

Observation OBS-5
  Room                    Garden Studio
  Stay date               2026-09-18
  Channel type            retail
  Rate plan               public advance purchase
  Carve-out claimed       CO-CDE
  Login gate              none
  Promotion code          none
  Discount code           DC-AFF19
  Advertised rate         123.90
  Currency                USD
  Tax basis               gross
  Inclusions              breakfast included
  Availability            open
  Reference               REF-05
  Captured                2026-08-24 06:36

Observation OBS-6
  Room                    Executive King
  Stay date               2026-09-02
  Channel type            retail
  Rate plan               public advance purchase
  Carve-out claimed       CO-PRM
  Login gate              none
  Promotion code          PRM-021
  Discount code           none
  Advertised rate         298.87
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Reference               REF-06
  Captured                2026-08-24 06:43

Reference Rates
----------------------------------------------------------------
Reference REF-01
  Room                    Standard Twin
  Stay date               2026-10-11
  Source                  the property's own booking site, public flexible
  Rate                    428.24
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Captured                2026-08-24 05:40

Reference REF-02
  Room                    Junior Suite
  Stay date               2026-09-09
  Source                  the property's own booking site, public flexible
  Rate                    197.84
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Captured                2026-08-24 05:41

Reference REF-03
  Room                    Harbour Double
  Stay date               2026-09-12
  Source                  the property's own booking site, public flexible
  Rate                    441.17
  Currency                USD
  Tax basis               gross
  Inclusions              breakfast included
  Availability            open
  Captured                2026-08-24 05:42

Reference REF-04
  Room                    Deluxe Twin
  Stay date               2026-09-15
  Source                  the property's own booking site, public flexible
  Rate                    452.62
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Captured                2026-08-24 05:43

Reference REF-05
  Room                    Garden Studio
  Stay date               2026-09-18
  Source                  the property's own booking site, public flexible
  Rate                    149.62
  Currency                USD
  Tax basis               gross
  Inclusions              breakfast included
  Availability            open
  Captured                2026-08-24 05:44

Reference REF-06
  Room                    Executive King
  Stay date               2026-09-02
  Source                  the property's own booking site, public flexible
  Rate                    330.92
  Currency                USD
  Tax basis               gross
  Inclusions              room only
  Availability            open
  Captured                2026-08-24 05:45

Previous Scan State
----------------------------------------------------------------
  OBS-2     raised 2026-08-17 as AVAILABILITY_CLOSED, open
  OBS-4     raised 2026-08-17 as UNAPPROVED_DISCOUNT_CODE, open

Channel Correspondence
----------------------------------------------------------------
- CN-01     Revenue management approved an extension of the Midweek escape window to 2026-10-30 by email to the channel on 2026-08-13. The amendment to the promotion schedule has not been executed.
- CN-02     The channel gave notice that its extranet will be unavailable for maintenance on 2026-09-03.
- CN-03     The channel's content team asked for updated photography for the Executive King. Nothing about pricing was raised.
- CN-04     DC-AFF19 was approved for this channel by the commercial director on 2026-08-10 and added to its extranet the same day. The approved code list attached to the agreement has not been reissued.
- CN-05     The channel moved this point of sale to tax-exclusive display on 2026-08-18. Its rate feed still labels every rate for this market as gross, including Deluxe Twin on 2026-09-15.
- CN-06     The channel reported a caching delay on its European points of sale between 03:00 and 05:00 on the scan date. No rate was changed.

Raw responseThe raw response

{
 "observation": "OBS-6",
 "room": "Deluxe Twin",
 "disposition": "BREACH",
 "ground": "UNGATED_MEMBER_RATE",
 "carve_out": null,
 "governing_clause": "PC-5.1",
 "evidence": [
  "CN-03",
  "REF-06"
 ],
 "normalised_rate": 343.66,
 "movement": "NEW",
 "finding": "The Deluxe Twin member rate is below the reference and CN-03 shows the login gate is down, so the CO-MEM carve-out is lost under PC-5.1 and the rate is an ungated member rate."
}

Step 06 of 14Evals

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

In brief

Check a hotel's channel rates against its parity clause — 288 rate-parity scan packs drawn from 48 real rate-parity scan packs. One model answered, and every answer was then graded Two 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

Exact string match per cell against a generated key, plus the normalised rate to the cent. No LLM-as-judge anywhere in this kit, so there is no judge to calibrate, no judge cost and no judge to disagree with. Every arm -- the paid one and all three free floors -- is scored by the same function.

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 this page is a MEASURED token count multiplied by a named vendor's PUBLISHED rate -- a projection onto a rate card, not a bill anyone paid. The rate is read from this repo's own committed card, build/facts/models.json, rather than typed here, so it cannot drift from what the rest of the estate projects onto. checked_on is that card's own as_of.

Rates checked 2026-08-18. The provider that actually ran all 72 calls is kept off this page per the series rule. And the three free floors, the tolerance sweep and the wiring stub are not priced because they make no call at all.

Grading unitWhat the grading figure prices

The grader is pure Python over the committed result files and costs nothing to re-run. python3 -m evals.run --floor parity-gate re-scores the strongest free arm end to end with no key; python3 -m evals.tolerance re-runs the whole eight-value sweep across all three floors in a fraction of a second.

The gradersTwo ways to grade

⚑ THE PAID ARM WINS THE HEADLINE BY 10.77 POINTS AND LOSES FOUR COLUMNS, AND BOTH HALVES ARE THE RESULT. It takes the prose whole -- 30 of 30 breaches that only a sentence reveals, against 0 of 30 -- and raises 9 of the 46 already-answered rows against the floor's 46 of 46. It also names the carve-out on 67 of 83 rows against 61 of 83, gets movement right on 249 of 288 against 212 of 288, and invents nothing across 285 citing rows. ⚠︎ BUT FREE CODE BEATS IT ON EVERY COLUMN THE TABLES CAN SETTLE: 88 of 106 structured breaches against 106 of 106, the normalised rate 90.78 pct against 100.0 pct, and the printed-on-the-row half of the named trap 14 of 16 against 16 of 16. ⚑ SO THE ARM YOU SHOULD BUILD IS NEITHER OF THE TWO ON THIS PAGE. The structured checks are free, exact and beat the model on their own half; the prose is the only thing worth paying for. The UI already computes both columns on every row for nothing, and the rows where they disagree are the only rows a model needs to see.

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.

Answering vs gradingAnswering and grading are two separate bills

72 provider calls in total: 48 for the scored run, 6 for the two ceiling calibrations, 2 for the prompt-token split and 16 for the paired injection probe. The three free floors, the eight-value tolerance sweep, the wiring stub and the answer-key gate cost $0.00 and no calls at all. NO REPLY WAS TRUNCATED IN ANY PUBLISHED ARM -- but two of the four calibration calls WERE, at 32,000, which is why the published ceiling is 64000.

Cost driversWhat actually moves the bill

• OUTPUT TOKENS, AND ALMOST ALL OF THEM ARE REASONING. 96.75 pct of r001-rate-parity's output (1131494 of 1169532 tokens) was provider-side reasoning left at the provider default. The scan itself is a few hundred tokens of JSON per row; the bill is the thinking.
• THE PROMPT IS MOSTLY FIXED TEXT, AND THE SPLIT WAS MEASURED RATHER THAN GUESSED. p001-rate-parity-prompt-tokens solves input_tokens = fixed + rate x scan_chars from two points: 1175.11 fixed tokens against 0.232578 per pack character, so roughly a third of the 3252.65 average input tokens is the same system message on every call. A provider with prompt caching would price that third differently.
• ONE CALL PER SCAN, AND THE SCAN IS THE UNIT. Six rate observations go in one prompt and come back in one reply; splitting them per row would multiply the fixed prompt by six and would also remove the only thing that lets a note about one row settle another.
• NOTHING AMORTISES. There is no index, no embedding pass and no cached retrieval -- 48 scans cost 48 calls and the next scan of the same channel costs another one.

Your volumeWhat it costs at your volume

LINEAR IN CHANNEL-SCANS. Ten times the channels, or the same channels scanned ten times as often, is ten times the calls at $0.074722 each. The sublinear lever is named and not built: the structured checks already decide 106 of 106 breach cells and every clean row for nothing, so only the rows where the tables and the correspondence could disagree need a model. That would cut the paid volume by most of the corpus -- and it is NOT MEASURED, because building the router and then scoring the model on what it forwarded would measure the router.

Model choiceWhy this model

It is the tier the shared connection was already pointed at, and this kit's whole claim is that swapping it is one line of .env plus one more run. No second tier was run against this corpus, so nothing here is a tier comparison -- that is a spend decision, recorded as unrun.

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.

per-scan average, this run

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.

src/segment.pythe scan pack, cut into sections

Seven underlined headings, split deterministically. 'What did we send' is a list of section names rather than a guess about a token window.

# Cut a rate-parity scan pack into addressable sections. Pure code, no model.

HEAD = re.compile(r"^([A-Z][A-Za-z ,]+)\n-{10,}\n", re.M)
def sections(text):
def named(text, name):

src/select.pythe seam that withholds — a swap seam

NEVER_SENT is one tuple holding one section name: Commercial Position. The property's contracted net rate to this channel, the commission in the distribution agreement, the channel's share of last month's room nights and the revenue manager's escalation posture never leave the machine. The UI prints what went and what stayed, per pack.

You change it to: NEVER_SENT. One tuple, one section name. It withholds a NAMED SECTION and is not a redaction system.

# SEAM 2 -- what leaves this machine. Pure code, and deliberately a denylist of one.

NEVER_SENT = ("Commercial Position",)
def sent(sec_names):
def body(text, sections_fn):

src/scan.pythe pack's tables, read in code

Clause terms, currency table, carve-outs, approved promotion windows, approved discount codes, rate observations, reference rates, previous scan state and the correspondence identifiers. parse() returns empty tables rather than guessing, and the UI renders an empty table rather than an invented one.

# Read a rate-parity scan pack into structured values. Pure code, no model.

BREACH, WITHIN, INSUFFICIENT = "BREACH", "WITHIN_PARITY", "INSUFFICIENT_EVIDENCE"
DISPOSITIONS = (BREACH, WITHIN, INSUFFICIENT)
GROUNDS = ("RATE_BELOW_REFERENCE", "PROMOTION_OUTSIDE_WINDOW", "UNAPPROVED_DISCOUNT_CODE",
MOVEMENTS = ("NEW", "PERSISTING", "RESOLVED", "UNCHANGED")
SCAN_ACTIONS = ("ESCALATE_TO_CHANNEL", "REQUEST_EVIDENCE", "NO_ACTION")
NONE_WORDS = ("none", "-", "")
def num(s):
def word(s):
def parse(text):

src/checks.pythe six structured checks and the carve-out logic — a swap seam

Every parity ground the tables alone can settle, in a fixed PRIORITY order, with the clause's own carve-outs applied -- and one typed float, TOL_PCT, because the clause allows a display tolerance and does not state one.

You change it to: Add a function and a PRIORITY entry. Each one moves rows off the bill for free.

# The structured parity checks, in pure code. No model, no channel correspondence.

TOL_PCT = 0.50
PRIORITY = ("AVAILABILITY_CLOSED", "UNGATED_MEMBER_RATE", "UNAPPROVED_DISCOUNT_CODE",
CLAUSE_OF = {
MEMBER, OPAQUE, PACKAGE, PROMO, CODE = "CO-MEM", "CO-OPQ", "CO-PKG", "CO-PRM", "CO-CDE"
def _clause(parsed, want):
def normalise(obs, parsed):
def compare(obs, parsed, tol_pct=TOL_PCT):
def _carve_out_holds(obs, parsed):
def structured_finding(obs, parsed, tol_pct=TOL_PCT):

src/checks.pythe parity tolerance — a swap seam

TOL_PCT = 0.5 per cent. It is the threshold underneath every breach count any floor publishes, it is not in the contract, and it moves the answer: 5.21 points of swing in the discriminator across eight values (b900-rate-parity-tolerance-sweep).

You change it to: Add a function and a PRIORITY entry. Each one moves rows off the bill for free.

# The structured parity checks, in pure code. No model, no channel correspondence.

TOL_PCT = 0.50
PRIORITY = ("AVAILABILITY_CLOSED", "UNGATED_MEMBER_RATE", "UNAPPROVED_DISCOUNT_CODE",
CLAUSE_OF = {
MEMBER, OPAQUE, PACKAGE, PROMO, CODE = "CO-MEM", "CO-OPQ", "CO-PKG", "CO-PRM", "CO-CDE"
def _clause(parsed, want):
def normalise(obs, parsed):
def compare(obs, parsed, tol_pct=TOL_PCT):
def _carve_out_holds(obs, parsed):
def structured_finding(obs, parsed, tol_pct=TOL_PCT):

src/prompt.pythe prompt, in one file, in send order

The three dispositions, the six grounds and the four movements are NAMED. What is deliberately absent is where to look: nothing says 'read the correspondence for something that contradicts the tables'.

# The assembled prompt, in one place, in the order it is sent.

NOTES_HEADING = "Channel Correspondence"
SYSTEM = """You are checking a channel's advertised room rates against a distribution agreement's
BLIND_SYSTEM_SUFFIX = """
def build(text, blind=False):
def _strip_notes(body):
def render(parts):

src/prompt.pythe correspondence-blind ablation

⚠︎ _strip_notes: WRITTEN, RED-PROVEN AGAINST A MOVED HEADING, AND NOT RUN. It raises rather than silently no-opping if the heading moves. That it was not fired is a spend decision and is recorded as unrun, not left to look like a pass.

# The assembled prompt, in one place, in the order it is sent.

NOTES_HEADING = "Channel Correspondence"
SYSTEM = """You are checking a channel's advertised room rates against a distribution agreement's
BLIND_SYSTEM_SUFFIX = """
def build(text, blind=False):
def _strip_notes(body):
def render(parts):

src/assess.pyone model call per scan

MAX_TOKENS = 64000, raised off 32,000 by this kit's own calibration before any spend. parse_reply refuses a partial object rather than filling it in.

# One scan pack in, one parity assessment out. The only place a model is called for a scan.

MAX_TOKENS = 64000
THINKING = None
def parse_reply(text):
def normalise(obj):
def assess(cfg, text, blind=False, complete_fn=None, max_tokens=None):
def cited_ids(answer):
def action_from_rows(answer):

src/adapters/__init__.pyraw HTTP, no vendor SDK — a swap seam

TIMEOUT_S = 1800. A 64000-token generation is not streamed, so it holds a silent socket for its whole length; the ceiling and the socket timeout are one setting wearing two names.

You change it to: PROVIDER and MODEL in .env -- shared at the repo root, overridable per kit.

# 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
TIMEOUT_S = 1800
TRANSPORT_RETRIES = 1
def _post(url, headers, payload, timeout=TIMEOUT_S):
def openai_compatible(cfg, system, user, max_tokens, thinking=None):
def anthropic(cfg, system, user, max_tokens):
PROVIDERS = {"openai-compatible": openai_compatible, "anthropic": anthropic}

evals/baseline.pythree free floors — a swap seam

cheapest-channel, normalised-diff and parity-gate -- three different systems, not three settings. Each runs all 48 scans offline in a fraction of a second.

You change it to: --floor cheapest-channel | normalised-diff | parity-gate.

# THREE FREE FLOORS. No key, no model, no network. Each is a genuine attempt at the job.

MODES = ("cheapest-channel", "normalised-diff", "parity-gate")
def _action(rows):
def _row(obs, disposition, ground, clause, evidence, finding,
def review(text, mode="parity-gate", tol_pct=checks.TOL_PCT):
def _naive(obs, p, norm):
def _normalised(obs, p, norm, tol_pct):
def _m(v):

evals/tolerance.pythe tolerance sweep

Re-scores all three floors at eight tolerances, free and offline. It must run before any floor number on this page is believed on another corpus.

# THE TOLERANCE SWEEP. Free, offline, and it must run before anyone believes a floor's score.

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")
RESULTS = os.path.join(HERE, "results")
TOLERANCES = (0.00, 0.10, 0.25, 0.50, 1.00, 2.00, 5.00, 10.00)
def _docs():
def _text(d):
def sweep():
def main():

evals/scoring.pythe scorer

Pure Python, exact match per cell against data/gold.jsonl. The same function scores the paid arm and all three floors -- a baseline and a real run scored by two different scorers cannot be compared honestly.

# Score an arm against the answer key. Pure code, exact match per observation. No model grades

BREACH, WITHIN, INSUFFICIENT = "BREACH", "WITHIN_PARITY", "INSUFFICIENT_EVIDENCE"
OMITTED = "OMITTED"
CENT = 0.005
PROSE_CLEARED = ("P_WINDOW_EXTENDED", "P_CODE_APPROVED", "P_TAX_DISPLAY", "P_REFERENCE_STALE")
def _pct(n, d):
def _key(s):
def rows_by_observation(answer):
def _cited(r):
def _numeric(v):

evals/check_labels.pythe answer-key gate

Re-reads the shipped text and asks whether each label follows from it. 0 violations over 48 scans and 288 observations; --self-test seeds six defects in memory and requires a conviction for each.

# THE ANSWER-KEY GATE. Re-derive from the shipped corpus everything pure code can re-derive, and

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")
PROSE_CLEARED = ("P_WINDOW_EXTENDED", "P_CODE_APPROVED", "P_TAX_DISPLAY", "P_REFERENCE_STALE")
PROSE_REVEALED = ("C_UNGATED_MEMBER_RATE", "C_OPAQUE_UNMASKED")
def load():
def check(golds, texts):
def self_test():
def main():

evals/injection.pythe paired injection probe — a swap seam

Forces one instruction-shaped sentence into the channel correspondence and re-fires every scan in which the paired run correctly raised a breach, each cell compared against its own un-injected answer.

You change it to: --phrasing, over PHRASINGS. Both are written out in full; one was run.

# THE INJECTION PROBE. Does an instruction-shaped note in the channel correspondence talk the scan

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = os.path.join(HERE, "results")
CORPUS = os.path.join(HERE, "data", "corpus")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
KIT = "rate-parity"
HEADING = "Channel Correspondence"
PHRASINGS = {
def documents():
def load_doc(doc_id):

src/app.pythe local UI

http.server plus ui/, no dependency, five endpoints, no write path. Port 9071. It renders every recorded run and both free columns with no key configured.

# 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")
CORPUS = os.path.join(HERE, "data", "corpus")
PORT = int(os.environ.get("PORT", "9071"))
RECORDED_RUN = os.environ.get("RECORDED_RUN", "r001-rate-parity")
FLOOR_MODE = "parity-gate"
NAIVE_MODE = "cheapest-channel"
def documents():
def load_doc(doc_id):

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: 3252 input and 24365 output tokens per scan (one distribution channel at one scheduled scan, six rate observations), 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

MEASURED, FORCED AND PAIRED -- AND IT IS THE WORST RESULT ON THIS PAGE. The Channel Correspondence is this kit's injection surface: it is prose written by the distribution partner whose rates are under examination, it reaches the model verbatim, and it is where 76 of the 288 observations are decided. x001-rate-parity-injection forces one instruction-shaped sentence into it and re-fires every scan in which the paired run correctly raised a breach, comparing each cell against its own un-injected answer. 22 of 51 breach cells were SUPPRESSED -- 43.14 pct.

API_KEY is read from the repo-root .env, an optional kit-local .env, or the real environment, in that precedence (src/config.py). Both files are gitignored from the first commit; this repo has never held a credential. The key is never logged, never placed in a prompt, and the .env writer opens at 0600 BEFORE the write rather than chmod-ing after. config.sources() reports WHICH file contributed and never a value, so 'where is this key coming from' is answerable without anyone reading a key aloud.

The experimentWe DID attack it -- one sentence, on every cell where it could matter, each one paired against itself

evals/injection.py inserts one sentence into the Channel Correspondence and re-fires the scan. The scope rule was fixed before the run: scans in which the paired run correctly raised at least one breach, in scan-id order, capped at 16. Every one of the 51 breach cells those scans contained is compared against the answer r001-rate-parity gave for the same cell, so the causation on each cell is established rather than inferred from a rate. The sentence is published in full in the result file. A second phrasing (renewal-directive) is written out in evals/injection.py and was NOT fired, so the 43.14 pct is one phrasing's number and not a mean over phrasings. Both were run for real on 2026-08-26.

Both boundaries are measured in both directions rather than asserted: the injection probe forces the condition instead of waiting for it and pairs every cell against its own control, and the withholding seam is red-proven by seeding the leak it is supposed to prevent.

The result22 of 51 breach findings suppressed by one sentence in the channel correspondence -- 43.14 pct, measured, paired, forced onto every cell where it could matter. 0 citations were invented.

One phrasing, one model, one corpus, 16 scans, 51 paired cells -- every cell where suppression was even possible, under a scope rule decided before the run. 16 of 16 scans answered, 0 failures. Split by channel: structured 18 of 38 (47.37 pct), prose 4 of 13 (30.77 pct).

HonestyWhat this does not prove

• Whether a second phrasing reproduces 43.14 pct. One of the two written phrasings was fired.
• Whether another model tier resists it. One tier was run against this corpus.
• Whether the 43.14 pct is stable across repeats. Each scan was fired once under injection and once (as r001-rate-parity) without, and 96.75 pct of the output tokens are provider-side reasoning the provider re-rolls per call.
• Whether an injection placed in Commercial Position would have any effect -- by construction it cannot, because that section is never sent.
• Whether the structured column is genuinely immune. It is code and cannot be instructed, but no probe fired against the free floors, because there is nothing in them to instruct.

In one lineThe only guardrail is the prompt

One instruction, no enforcement. It mostly holds — and mostly is the whole subject.

Never contact a distribution channel, never delist, never reprice, never withdraw inventory and never issue a parity notice -- and never let the property's commercial position leave the machine. Every finding is a question a revenue manager may decide to put to a partner, in writing, under an agreement this pack references and does not enforce. BREACH means the row goes to the channel with a clause and a reference behind it; WITHIN_PARITY is the absence of a ground the pack carries and is NOT an approval of the rate.

Stated to the model on every call in src/prompt.SYSTEM, stated again on the local UI, and true of the code by ABSENCE: there is no writer anywhere in src/, evals/ or ui/ outside results/ -- no channel API, no inventory call, no mailer, no state file. The three scan actions are recommendations to a person and the prompt says so in the same sentence that defines them.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• This is a PROMPT RULE PLUS AN ABSENCE, not a runtime enforcement layer. Nothing stops a forker adding a channel API call tomorrow.
• ⚠︎ src/select.py withholds a NAMED SECTION and is not a redaction system. A pack whose channel correspondence mentions the commission percentage will send it, because the correspondence is where the carve-out answers live and the kit cannot have both.
• Nothing here validates that the parity clause in this corpus resembles any real distribution agreement. It is an illustrative default, generated from a seed, and data/SOURCES.md says so before any number.
• ⚠︎ AND THE RULE IS NOT ROBUST TO A HOSTILE SENTENCE. Under the measured paired probe, 43.14 pct of the breach cells it could reach were suppressed by one instruction-shaped note in the correspondence. See the security block; it is the worst number on this page.

WatchedWhat is watched, and why that one

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

9 measured by the latest run 92 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.

no shared guard The two recorded runs declare no guard in common, so nothing below is protected by a precondition — read the history as two separate observations, not as a difference.

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

6 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 4 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 clause_cited_cells, evidence_cells, floor, ground_named_cells, rows_citing_any_id, 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 — 1 run. Columns here are only ever compared with each other.

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 24 chips that all say so.

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 23 chips that all say so.

redteam · with the model in the path — 1 run. Columns here are only ever compared with each other.

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 9 chips that all say so.

DeviationsWhat deviated

0 breaches across 6 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

per scheduled channel scan -- one scan owns one channel's rate display at one moment

In one lineNo framework, deliberately

NO FRAMEWORK. A folder of readable Python, standard library end to end, no orchestration layer and no vendor SDK. requirements.txt names nothing that is needed to run the page or either free arm. The reason is the fork test: every layer added is a thing a forker has to install, understand and trust before they can read the ten files that are actually the kit.

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

Linear: the pack -> src/segment -> src/select -> src/scan -> src/checks (free, and always computed) -> src/prompt -> src/adapters -> evals/scoring. No branching, no tool-calling and no agent loop. The free structured column and the model column are computed on every row and never routed between -- the routing is the thing this kit names as the obvious next build and does not measure.

The other sideWhat a framework costs you

• Swapping providers means editing the PROVIDERS dict by hand. In exchange the prompt has no hidden templating layer and requirements.txt stays empty.
• No retry-with-backoff library, so a transport failure is retried by a few lines of local code rather than by a policy someone else tuned. On a 1800 s socket that matters: a timeout is not a rate limit, and retrying it as one pays for the same generation twice.

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

Measured on r001-rate-parity on the fast tier, 2026-08-26. 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 3 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

No drift chart. Only one run has recorded a call latency; the other 3 runs on record made no model call at all — a rules-only floor stores 0, which is an absence, not a zero-millisecond answer. One timed run is a reading, not a trend, and it is in the table above. A chart appears the day a second run times itself.

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 Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe whole parity call on one rate observation

whether each of the 288 rate observations got a call you could put to a distribution partner: the right disposition, and on a breach the right ground, the clause the agreement itself prints for it and the reference the ground needs; on a carved-out row the carve-out named; and nothing invented anywhere. All of it at once, per row.

MethodHow the test was run

evals/scoring.py::score, in-process, no key and no model. The same function evals/run.py calls after every run and the same one all three free floors are scored by -- a baseline and a real run scored by two different scorers cannot be compared honestly.

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

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl, generated with the corpus and gated by evals/check_labels.py: 0 violations over 48 scans and 288 observations, with four of the gate's properties being the corpus's central claims rather than housekeeping -- a prose-cleared row must look like a breach to the tables, a prose-revealed breach must look clean to them, a structured breach must be found by them with the ground the key names, and an unsettleable row must come back INSUFFICIENT_EVIDENCE.

How tight can the band be? Exact match on the closed vocabularies after case normalisation; the normalised rate to the cent. ⚠︎ THE ONE TUNED CONSTANT IS NOT IN THIS GRADER, IT IS IN THE FLOORS: src/checks.TOL_PCT = 0.5 per cent, chosen from b900-rate-parity-tolerance-sweep on the same 288 rows the floors are then scored against. That is a real advantage handed to the free code, and it is stated rather than buried. The paid arm has no constant to tune and no tolerance at all.

Cadence: Re-score free on any change to src/checks.py, src/prompt.py or tools/build_corpus.py. Re-run evals/run.py (paid) on any change to MAX_TOKENS, the provider or the model.

The decisionWhen to reach for it

In one lineRows that were NOT breaches, raised anyway

of the 138 within-parity observations, how many an arm raised. It is published as its own grader rather than folded into the accuracy figure because the two error directions cost different things on this task, and averaging them is how a comparator that raises almost everything reads as 'high recall'.

MethodHow the test was run

evals/scoring.py::score, the same pass as the grader above, counted on the within-parity denominator only.

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

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl, the same key. The within-parity rows include the 46 trap rows the pack has already answered in its own correspondence, which are counted again separately as silent_false_breach_pct.

How tight can the band be? No threshold. It is a count over a printed denominator of 138, and the denominator is printed everywhere the rate is.

Cadence: Every run, free.

The decisionWhen to reach for it