The business caseThe problem this solves

A licensor's business-affairs desk has to know two separate things about every title on its content book: whether the renewal option on the current licence is still open, and whether a platform that no longer holds the rights is still delivering the title anyway. Today somebody works down a tracker at quarter end, reads each clause by eye to find which of four register dates it measures from, computes a notice window by hand, and separately checks an exploitation-activity feed that is known to have gaps on older catalogue titles. Someone on Business Affairs working down a rights-reversion tracker at quarter end: opening each title, reading the clause to find which register date it measures from (following a defined term into a second sentence about a third of the time), computing both edges of the renewal window rather than a days-remaining figure, checking whether an instrument filed since the register was abstracted has moved the anchor, and cross-checking the exploitation-activity log for any delivery dated after a title's rights actually reverted.

The inputThe actual rights extracts

The corpus is 120 rights extracts, 0.72 MB (json 1 · jsonl 1 · txt 120). A CONTENT-LICENSING AGREEMENT IS A PRIVATE CONTRACT BETWEEN TWO NAMED PARTIES, AND THE RIGHTS REGISTER BUILT FROM IT IS THE ARTEFACT A LICENSOR'S BUSINESS-AFFAIRS DESK GUARDS HARDEST -- it is the list of every grant they are about to get back, and every one they might still be losing money on. There is no public one and there will not be. Generating it also bought the one thing a captured corpus cannot give: the answer key is src/reversion.step's and check_exploitation's own output over the planted anchors, clauses and activity logs, so arithmetic this fiddly cannot carry its author's misreading into the score. The rules, the clause forms and the grant values reproduce no distribution agreement, standard form, precedent or statute, and name none.

Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated rights-administration extract
for an AI use-case kit; it reproduces no distribution agreement, no standard form,
no real title and no real party. The reversion clause and the administration rules
are ILLUSTRATIVE.

Title & Rights Grant
----------------------------------------------------------------
Content book                    : BOOK-APAC-1 (Asia-Pacific catalogue)
Title reference                 : TTL-0001
Title (working name)            : The Second Anchor
Licensor entity                 : LOR-ENT-10
Licensee entity                 : LEE-ENT-26
Territory                       : MENA
Media rights granted            : Theatrical, Home Video
Contract reference               : LIC-4145
Value of the grant, on file     : 1,944,774.88 USD  (what this licence is held for; invented)

Term Dates
----------------------------------------------------------------
Register abstracted on          : 2026-03-01   -- the four dates below are AS ABSTRACTED ON
                                  THAT DATE. An instrument recorded after it supersedes them
                                  (Rule R-3). This register is NOT re-abstracted between
                                  scheduled runs.
Delivery date                   : 2027-06-14
Commencement date               : 2027-09-02
Minimum guarantee deadline      : 2028-09-02
Expiration date                 : 2030-09-02

Reversion Clause
----------------------------------------------------------------
Clause 14.2 (Renewal Option), verbatim:

The outcomeWhat a good result looks like

Every title whose renewal window is open is on the watchlist with both edges computed and the register date they were measured from named; every title that has REVERTED is cross-checked against the exploitation log, and a continued breach is flagged with how many days it has been running.

Where it fitsWhat did work

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

• You already know which titles run off the Expiration Date and only need a countdown — a SQL query, or the b000 floor in this repo
  Both are free and instant. b000 scores 37.50 pct on six-way stage here only because most of this corpus is NOT Expiration-anchored; on a book that mostly is, it would be much closer.
• Your clauses are drafted from a small number of standard forms and you can build your own keyword table — the clause-regex floor in evals/baseline.py (b002)
  It ties the model on every measured column here, for $0.00, once it follows the one defined-term indirection this corpus uses.
• Your book mixes many drafting styles, or you need a plain-English rationale a human can audit alongside the verdict — this kit
  The model returns a one- or two-sentence rationale naming the governing date and both edges on every reading; the floor returns nothing but the seven fields. And on a corpus not built from a bounded template set, the model's reading-comprehension advantage is very likely to widen rather than close.
• You need to know whether a platform is still exploiting a title whose rights already reverted — this kit's Part Two, but only where the exploitation feed says COMPLETE
  Both arms tie at 100 pct exploitation-breach accuracy here, including the CANNOT_CONFIRM case.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-24. 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-24 — r001-rights-reversion. 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 extracts and the answer key (regenerated from the seed in well under a second), all thirteen pre-flight assertions, all four free floors scored end to end, and the local UI at 127.0.0.1:8205 including what run r001 recorded for every reading. What it CANNOT reproduce without a key is a model column of its own.

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 into a stage, an anchor, two window edges, a renewal-window flag and the exploitation-breach pair. Segmenting the extract into sections, dropping the one section no field asks for, parsing the run dates and register off the page, and advancing the carried state all happen outside this measurement and cost no network at all. THE TAIL IS THE STORY: p95 (38s) is 2.9x p50 (13s).

Current processWhat it replaces

Someone on Business Affairs working down a rights-reversion tracker at quarter end: opening each title, reading the clause to find which register date it measures from (following a defined term into a second sentence about a third of the time), computing both edges of the renewal window rather than a days-remaining figure, checking whether an instrument filed since the register was abstracted has moved the anchor, and cross-checking the exploitation-activity log for any delivery dated after a title's rights actually reverted.

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

No split, and no chunking. The unit is a TITLE -- three consecutive scheduled runs processed strictly in order, because the June reading's prompt contains an anchor date settled by the March reading. Each extract goes whole into one call, minus the one section no field asks for.

SetupWhat the setup figure measured

There is no index and no retrieval step -- the population is re-read whole on each scheduled run. tools/build_corpus.py writes 120 documents and the answer key from a fixed seed in well under a second with no clock read and no model called.

LicenceLicence

MIT -- this repository's own licence. Nothing is fetched and no third-party grant is involved; every title, licensor, licensee, territory, reversion clause, term date, grant value, instrument and administration note is invented here. Verified against the repository's own LICENSE file on 2026-08-24.

Bring your ownBring your own rights extracts

Point tools/build_corpus.py at your own content book, or replace data/corpus/*.txt and data/gold.jsonl directly. Keep the nine section headings in src/segment.py::SECTIONS -- the parser asserts all nine in every document before a run may spend -- and keep the Reversion Clause block, because the rule the model applies is READ OFF THE PAGE rather than baked into the prompt. gold.jsonl needs one row per extract carrying the anchor date, anchor kind, parsed clause, run dates, expiration date, activity dates, feed-completeness flag and the seven answers; evals/check_labels.py re-derives the answers from src/reversion.step and check_exploitation and refuses if they disagree.

⚠︎ And what stops being true when you do: The measured figures on this page do not travel with your corpus. Every figure here is per a QUARTERLY cadence; the population does not change between runs, which real content books do; and the clause prose is generated from nine templates and one indirection, which is why the free floor ties the model here -- your clauses will not be drafted that regularly, and both arms' accuracy is the number most likely to fall on real text.

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 11,882 characters assembled, 6,076 are contexts — 51% of the prompt, the largest single part. A per-request bill follows whichever part is biggest, and on this kit that is the one named here.

TWO MESSAGES, JOINED IN SEND ORDER. The provider receives a system message and a user message; prompt_verbatim is the concatenation, and prompt_parts breaks the user message into the three blocks src/prompt.build assembles. Reconstructed from src/prompt.build and src/state.describe for TTL-0038-R2 with that reading's real carried state (replayed from TTL-0038-R1's planted gold inputs through src.reversion.step and check_exploitation), not retyped.

Full promptThe prompt in full

You are a scheduled rights-reversion and expiry watch. You read one title's reversion clause, its rights register and its exploitation-activity log at one scheduled run, and you answer with one JSON object and no other text.

You are the scheduled rights-reversion and expiry watch for one licensor's content book. It runs
quarterly, on the last day of the quarter, and re-reads EVERY live title in the book. You are
reading ONE title at ONE scheduled run.

The reversion clause, the term register, the administration rules and the exploitation-activity log
are reproduced in the extract below. Apply them exactly as written. You cannot see the earlier
scheduled 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.

PART ONE -- the renewal window and the reversion stage:
 - FIRST decide WHICH DATE the clause measures from. The rights register carries four dates --
   Delivery, Commencement, Minimum Guarantee Deadline and Expiration -- and the clause names one of
   them in prose. THERE IS NO DEFAULT: the Expiration Date is not a fallback for a clause that names
   something else (Rule R-2, Rule R-4).
 - THEN apply the carried state and this window's instruments. The register states the date it was
   abstracted on and is NOT re-abstracted between runs, so where the carried state gives a settled
   anchor date, that value stands over the register. An instrument recorded in THIS window that
   redefines the anchor supersedes both (Rule R-3).
 - THEN compute BOTH EDGES of the renewal window from that anchor date and the clause. The clause
   gives an outer edge and an inner edge; read which number is which from the words -- several of
   these clauses state the larger figure first, and some run FORWARD from the anchor rather than
   back from it. Where a month count lands on a day the target month does not have, use the last day
   of that month.
 - "window_open" is the earlier edge and "window_close" is the later one, both as YYYY-MM-DD. A
   renewal notice served outside them is void either way (Rule R-1).
 - If the date the clause names is not on file, or two instruments give it different values and
   neither supersedes the other, the title is CONTEXT_INCOMPLETE: stage CONTEXT_INCOMPLETE, anchor
   UNDETERMINED, both edges null, raise_flag NO, exploitation_breach NO, exploitation_gap_days null
   (Rule R-4). Never assume an anchor.

PART TWO -- continued exploitation past reversion:
 - This is a SEPARATE question from the stage above, and it can only be YES when the stage you just
   computed is REVERTED. Before REVERTED the licence is validly in force and continued delivery is
   ordinary performance, not a breach.
 - Where the stage is REVERTED, read the Exploitation Activity log. If it carries an entry dated ON
   OR AFTER the Expiration Date on file, that is a confirmed breach: exploitation_breach YES, and
   exploitation_gap_days is the number of days between the Expiration Date and TODAY'S snapshot
   date (Rule R-9).
 - If the log carries no such entry AND states its own coverage is COMPLETE for this title, the
   breach answer is NO.
 - If the log carries no such entry BUT states its own coverage is INCOMPLETE for this title, you
   cannot tell compliance from a gap in the feed: answer CANNOT_CONFIRM, not NO (Rule R-10).
 - Where the stage is not REVERTED, exploitation_breach is NO and exploitation_gap_days is null,
   regardless of what the log says.

Answer with a single JSON object and nothing else:

{"stage": "PENDING|WINDOW_OPEN|WINDOW_CLOSING|RENEWED|REVERTED|CONTEXT_INCOMPLETE",
 "anchor": "EXPIRATION|COMMENCEMENT|DELIVERY|MG_DEADLINE|UNDETERMINED",
 "window_open": "<YYYY-MM-DD, or null>",
 "window_close": "<YYYY-MM-DD, or null>",
 "raise_flag": "YES|NO",
 "exploitation_breach": "YES|NO|CANNOT_CONFIRM",
 "exploitation_gap_days": "<integer, or null>",
 "rationale": "one or two sentences, naming the date the clause measures from, both edges you
   computed, and -- where the stage is REVERTED -- what the exploitation log shows"}

Precedence for "stage", applied in this order against the snapshot date on the page: CONTEXT_
INCOMPLETE beats everything; then RENEWED if a valid renewal notice has been recorded, whether in
this window or on an earlier run (Rule R-6); then REVERTED if the snapshot date is after
window_close (Rule R-7); then PENDING if the snapshot date is before window_open; then
WINDOW_CLOSING if window_close falls before the NEXT SCHEDULED RUN date stated on the page, which
means this run is the last one that will see the window open (Rule R-8); otherwise WINDOW_OPEN.

"raise_flag" is YES only on the run that first finds the renewal window open -- the stage is
WINDOW_OPEN or WINDOW_CLOSING and the carried state does not already say a flag was raised. On every
later run it is NO (Rule R-5). It is NO for PENDING, RENEWED, REVERTED and CONTEXT_INCOMPLETE: there
is nothing to tell Business Affairs before the window opens, nothing left to tell after it closes,
and a reverted grant cannot be recovered by a renewal-window warning.

Carried state
----------------------------------------------------------------
As at the previous scheduled run, the governing anchor date for this title's renewal clause was settled at 2026-03-04. That settled value stands unless an instrument in THIS window moves it; the rights register on this page states the date it was abstracted on and is not re-abstracted between runs. No renewal notice has been recorded for this title. No renewal-window Business-Affairs flag has been raised on this title yet. A continued-exploitation Business-Affairs flag has ALREADY been raised for this title, first evidenced on 2026-03-24. Do not raise it a second time (Rule R-9); report the breach as standing if the log still shows it. It was reported REVERTED.

Rights administration extract
----------------------------------------------------------------
Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated rights-administration extract
for an AI use-case kit; it reproduces no distribution agreement, no standard form,
no real title and no real party. The reversion clause and the administration rules
are ILLUSTRATIVE.

Title & Rights Grant
----------------------------------------------------------------
Content book                    : BOOK-LATAM-1 (Latin America catalogue)
Title reference                 : TTL-0038
Title (working name)            : The Silent Tenant Archive
Licensor entity                 : LOR-ENT-28
Licensee entity                 : LEE-ENT-30
Territory                       : Japan
Media rights granted            : Pay-TV, Free-TV
Contract reference               : LIC-8366
Value of the grant, on file     : 260,444.75 USD  (what this licence is held for; invented)

Term Dates
----------------------------------------------------------------
Register abstracted on          : 2020-08-02   -- the four dates below are AS ABSTRACTED ON
                                  THAT DATE. An instrument recorded after it supersedes them
                                  (Rule R-3). This register is NOT re-abstracted between
                                  scheduled runs.
Delivery date                   : 2020-10-30
Commencement date               : 2021-03-04
Minimum guarantee deadline      : 2022-03-04
Expiration date                 : 2026-03-04

Reversion Clause
----------------------------------------------------------------
Clause 14.2 (Renewal Option), verbatim:

  "Licensee may renew this Licence for a further Term only by written notice given to Licensor not less than nine (9) months nor more than twelve (12) months prior to the Expiration Date of the Initial Term. Time is of the essence."

Rule R-1  A renewal window has TWO EDGES. A notice served before the window opens is as invalid as
          one served after it closes, and neither can be cured. "Days remaining" is not the test.
Rule R-2  Both edges are measured from the ANCHOR DATE THE CLAUSE NAMES, and from no other date.
          The rights register carries four dates; the clause names one of them, in prose.
Rule R-3  Where an instrument on file redefines the anchor -- an amendment that extends the Term, a
          delivery certificate that fixes a date the register only estimated -- BOTH edges move with
          it. The register is abstracted by hand and states the date it was abstracted on; an
          instrument recorded after that date supersedes it.
Rule R-4  A rights register is not evidence of a date it does not carry. Where the date the clause
          names is blank, or two instruments give it different values and neither supersedes the
          other, the title is CONTEXT_INCOMPLETE: no window is computed, nothing is raised, and NO
          DEFAULT ANCHOR MAY BE ASSUMED. The Expiration Date is not a fallback.
Rule R-5  The Business-Affairs flag is raised ONCE per title, on the first scheduled run at which
          the renewal window is open. A later run reports the flag already standing; it does not
          raise a second one.
Rule R-6  Once a valid renewal notice is recorded, the title is RENEWED and stays renewed on every
          later run, whether or not the instrument is still in this window's file.
Rule R-7  Once the renewal window has closed with no notice recorded, the title is REVERTED. Rights
          granted under this instrument return to Licensor at the Expiration Date already on file.
          There is no late renewal, nothing to escalate and nothing to negotiate; a further grant,
          if any, is a new agreement.
Rule R-8  A title is WINDOW_CLOSING while its renewal window will close before the NEXT scheduled
          run -- that is, when this run is the last one that will see it open. The band is the
          cadence, not a fixed number of days.
Rule R-9  A title can be flagged for CONTINUED EXPLOITATION ONLY once it is REVERTED. Once reverted,
          any entry in the Exploitation Activity log dated ON OR AFTER the Expiration Date is
          evidence the title is still being delivered under a grant that no longer exists. The
          Business-Affairs breach flag is raised ONCE, on the first scheduled run whose log carries
          such an entry -- Rule R-5's own logic, run again for a second, independent flag.
Rule R-10 Where the Exploitation Activity log itself states its coverage is INCOMPLETE for this
          title, a clean-looking log proves nothing: answer CANNOT_CONFIRM rather than NO. Silence
          in a feed that is known to have gaps is not evidence of compliance, and treating it as
          such is the single easiest way to under-report a live breach.

Watch Position
----------------------------------------------------------------
Snapshot taken                  : 2026-06-30   (scheduled run 2 of 3)
Watch cadence                   : quarterly, on the last day of the quarter
Previous scheduled run          : 2026-03-31
Next scheduled run              : 2026-09-30

Business Affairs Actions This Window
----------------------------------------------------------------
Everything recorded against this title between the previous scheduled run and this one.
THIS WINDOW ONLY -- an instrument filed in an earlier window is not repeated here.

Business Affairs Decision Memo dated 2026-06-28: Reversion confirmed. Distribution Ops has been instructed to cease delivery across all licensed platforms in this territory effective the Expiration Date.

Exploitation Activity
----------------------------------------------------------------
Feed coverage for this title     : COMPLETE
Delivery/telecast/stream entries logged in this window:

  - 2026-04-23  Pay-TV telecast confirmed, Japan storefront

Administration Notes
----------------------------------------------------------------
No open items on this title this quarter.

Raw responseThe raw response

{"stage":"REVERTED","anchor":"EXPIRATION","window_open":"2025-03-04","window_close":"2025-06-04","raise_flag":"NO","exploitation_breach":"YES","exploitation_gap_days":118,"rationale":"Clause 14.2 measures from the Expiration Date (2026-03-04), giving a renewal window from 2025-03-04 (12 months before) through 2025-06-04 (9 months before); with no renewal notice recorded and the 2026-06-30 snapshot after that window, the title is REVERTED. The complete exploitation log shows a 2026-04-23 telecast after expiration, so the breach stands with 118 gap days."}

Step 06 of 14Evals

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

In brief

Catch a licensed title still airing past its rights — 120 rights extracts. One model answered, and every answer was then graded one way — by == against a fixed gold value, which is a measurement too and only as good as the gold behind it.

The rulerHow it was graded

Every cell is compared for exact equality against a gold set computed by tools/build_corpus.py from the title model -- the anchor, the parsed clause, the expiration date and the activity log -- rather than hand-authored, and re-derived from src/reversion.step and check_exploitation by evals/check_labels.py before any run may spend. A reply that did not parse counts as a MISS in every field, never as an exclusion.

MeasurementsWhat was measured

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

Grading costWhat it costs

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

Rates checked 2026-08-18. The provider that actually ran all 250 calls behind this kit 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, and neither do the four free floors or the redteam probe's own scoring. The only money on this kit is the readings themselves (and the one injection probe).

The gradersOne way to grade, and why it is the only one

b002 TIES the model on all fourteen columns published here, for $0.00 -- the headline of this kit and not a flattering aside. It is not a strawman: it follows the defined-term indirection 14 of 40 titles use, prefers the carried anchor over a stale register, and applies Rule R-9/R-10 to the exploitation log exactly as the model is asked to. b000 (37.5 pct anchor accuracy) and b001 (the same rule plus memory, 37.5 pct) are shipped alongside it to show b002 is not a strawman EITHER direction -- a genuinely weak free rule is on the page too, and it is weak for a stated reason (three of four anchors are not Expiration on this corpus) rather than by construction.

The row opens its own page: how the test was run, one real row, the formula with every iteration of it, and the analysis.

Choosing oneWhen to reach for the model at all

The comparison is only useful if it ends in a choice, and on this kit the choice is not which grader — there is one, and it is ==. It is whether to call a model for this field at all, and the answer is conditional.

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 title, 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

evals/scoring.py, all four free floors and evals/check_labels.py make no model call and cost $0.00. The only money spent building this kit was the readings themselves: 6 calibration (c000, 8,000-token cap), 3 ceiling diagnostic (c001, 18,000-token cap), 120 scored (r001), 120 stateless control (s001) and 1 injection probe (redteam x001) -- 250 live calls total, 0 discarded (none were cut off; the c000 chain that hit its cap was billed in full and counted as a coverage failure in that calibration run only).

Cost driversWhat actually moves the bill

• OUTPUT TOKENS, DRIVEN BY HOW MANY HOPS A READING NEEDS. TTL-0038's chain grew from 919 to 1,998 to 2,708 output tokens across its three runs as the exploitation narrative accumulated (results/eval-c001-rights-reversion-ceiling.json); a title with a defined-term indirection to follow and a confirmed breach to explain costs materially more per reading than a comfortably-PENDING one.
• THE RULE TEXT ON EVERY PAGE. All ten rules are reproduced in every extract -- about a third of the input -- deliberately, so a forker can replace the rule without touching the prompt.
• THE CADENCE, WHICH MULTIPLIES EVERYTHING. One call per live title per scheduled run. A book of 10,000 titles on a quarterly watch is 40,000 calls a year.
• INPUT TOKENS, NOT OUTPUT -- THE OPPOSITE SHAPE FROM SOME SIBLING KITS. Input averages 2,730 tokens per reading against 2,227 output; the rule text and full register drive the bill more than the model's own reasoning does. Whether the provider spent output budget on hidden reasoning is UNMEASURED here -- results/eval-r001-rights-reversion.json's token_details field came back empty on every reading, so unlike sibling kits that measured a reasoning share directly, this kit cannot state one; see Eval.could_not_verify.

Your volumeWhat it costs at your volume

LINEAR IN TITLES x RUNS. Ten times the live titles is ten times the calls at the same per-reading cost; nothing amortises, because there is no index and each reading is independent of every other title.

Model choiceWhy this model

The fast tier is the shared default every kit in this lap ran against; no per-kit model selection was made for this row.

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, one tier.

The codeEvery file, and what it is for

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

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

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

tools/build_corpus.pythe corpus generator — a swap seam

Generates 40 titles x 3 scheduled runs = 120 extracts from a fixed seed (SEED = 20260824), drawn into six named buckets rather than a uniform sample -- comfortable_pending, opens_in_horizon, renewed, context_incomplete, anchor_amended, reverted_breach -- so every interesting case (a title that actually reverts and is then caught mid-breach) appears in testable quantity. The gold labels are src/reversion.step's and check_exploitation's own output over the planted inputs, never typed.

You change it to: The titles, the clause phrasings, the reference forms, the bucket mix and the seed. Keep the nine section headings or src/segment.py's assertion refuses to start.

# Generate the rights-reversion corpus and its answer key. Deterministic: one fixed seed, no

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SEED = 20260824
CORPUS_DIR = os.path.join(HERE, "data", "corpus")
GOLD_PATH = os.path.join(HERE, "data", "gold.jsonl")
STATS_PATH = os.path.join(HERE, "data", "corpus-stats.json")
RULE = "-" * 64
BOOKS = ["BOOK-EU-1 (European theatrical library)", "BOOK-NA-1 (North American library)",
TERRITORIES = ["UK & Ireland", "DACH (Germany, Austria, Switzerland)", "Benelux", "Nordics",
MEDIA_SETS = [["SVOD"], ["SVOD", "Pay-TV"], ["Pay-TV", "Free-TV"], ["SVOD", "AVOD"],

src/reversion.pythe reversion arithmetic — a swap seam

The rule as pure code, twice over: step() computes the renewal window's two edges against an anchor date and a six-way stage; check_exploitation() compares the exploitation-activity log against the Expiration Date once (and only once) a title has REVERTED. No model, no judgement. add_months clamps into the target month rather than rolling over, a stated decision rather than a library default. WARNING: step()'s renewal precedence has a known bug -- see Data.breaks_on -- left unpatched because the scored run was fired against it.

You change it to: RULE_TEXT and the precedence in step() and check_exploitation(). Reproduced in full on every page precisely so it can be read, disbelieved and replaced with the agreement you actually signed -- including the known Rule R-7 enforcement gap named in Data.breaks_on.

# The renewal-window rule and the post-expiry exploitation check, as arithmetic. Pure code, no

PENDING = "PENDING"
WINDOW_OPEN = "WINDOW_OPEN"
WINDOW_CLOSING = "WINDOW_CLOSING"
RENEWED = "RENEWED"
REVERTED = "REVERTED"
CONTEXT_INCOMPLETE = "CONTEXT_INCOMPLETE"
STAGES = (PENDING, WINDOW_OPEN, WINDOW_CLOSING, RENEWED, REVERTED, CONTEXT_INCOMPLETE)
EXPIRATION = "EXPIRATION"
COMMENCEMENT = "COMMENCEMENT"

src/state.pythe carried state — a swap seam

SEAM 2 -- the thing that makes this a monitor. Six scalars per title (the settled anchor date, whether a renewal notice was recorded, whether the renewal-window flag already stands, the stage last reported, whether the continued-exploitation flag already stands, and the earliest date that flag was first evidenced), written from the arithmetic and never from the model's reply, rendered into three or four English sentences for the prompt.

You change it to: What is carried between scheduled runs, and how it is worded to the model. Six scalars today, rendered as English rather than JSON -- a design choice, not a measurement, and it is in Eval.could_not_verify rather than described as a finding.

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

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_title(store, title_id):
def describe(state):

src/segment.pythe section splitter

Splits an extract into its nine named sections. Pure code; evals/check_labels.py asserts all nine are present in all 120 documents before a run may spend.

# Split a rights-administration extract into its named sections. Pure code, no model.

SECTIONS = ("Synthetic Record", "Title & Rights Grant", "Term Dates", "Reversion Clause",
RULE = "-" * 64
def split(text):
def render(secs):

src/select.pythe section selector

Decides which sections reach the model. Rights Holder Contact -- the administrator's name, mobile and email -- is mapped by no field and is subtracted unconditionally by _fallback(), so it never leaves the machine even if a source-system rename made every hint match nothing.

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

BANNER = "Synthetic Record"
TITLE = "Title & Rights Grant"
DATES = "Term Dates"
CLAUSE = "Reversion Clause"
POSITION = "Watch Position"
INSTRUMENTS = "Business Affairs Actions This Window"
ACTIVITY = "Exploitation Activity"
CONTACT = "Rights Holder Contact"
NOTES = "Administration Notes"

src/prompt.pythe prompt

Three parts, the fixed instruction, the carried-state sentences and the selected sections in document order, split into TWO parts the model has to answer -- the renewal-window question and, gated on REVERTED, the continued-exploitation question. The stateless build replaces the carried-state sentences with one line saying no history is available, byte-identical everywhere else, and evals/check_labels.py asserts exactly that.

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

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

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

SEAM 1 -- the model. Raw HTTP for every provider, standard library only, shared verbatim with every sibling kit in this repo. Returns input/output tokens and finish_reason beside the text, and separates a transport failure from an HTTP status.

You change it to: PROVIDER, BASE_URL, API_KEY and MODEL in .env. Adding a provider is one function and one entry in PROVIDERS.

# 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/watch.pythe watch

One title, one scheduled run, one call. Parses the run dates and the four register dates off the page with a regex and parses NOTHING about the clause or the exploitation log -- deciding the stage and the breach is the entire task. Holds MAX_TOKENS = 14000, set from a calibration run that showed real run-to-run variance rather than a hard ceiling -- see the comment in the file.

# One title, 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 rights-reversion and expiry watch. You read one title's reversion "
MAX_TOKENS = 14000
FIELDS = ("stage", "anchor", "window_open", "window_close", "raise_flag",
def documents():
def titles():
def load_doc(doc_id):
def position_of(text):

src/app.pythe local UI

One title, one scheduled run, its carried state and both verdicts, on 127.0.0.1:8205. Renders with no key. Shows the carried sentences verbatim, the free floor's answer beside the model's for both parts of the question, and a second button that replays what run r001 actually answered, straight off the committed result file, labelled as a replay.

# 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", "8205"))
RECORDED_RUN = os.environ.get("RECORDED_RUN", "r001-rights-reversion")
GOLD_ROWS = {r["doc_id"]: r for r in
def carried_for(doc_id):
class H(BaseHTTPRequestHandler):
def main():

evals/baseline.pythe four free floors — a swap seam

b000 the days-to-expiry rule a spreadsheet actually runs, one edge, no clause, no exploitation check, ever NO; b001 the same rule given the carried state, isolating what memory alone buys; b002 the strongest free version -- the clause's figures pulled out numerically, the anchor named by a keyword table with the defined-term indirection followed, this window's instruments parsed, and the exploitation log read by the same Rule R-9/R-10 the model applies; b004 is b002 with the definition-following turned off, to measure what it is worth. 0 calls, $0.00, all scored through the identical scorer.

You change it to: parse_clause_numbers's largest-and-smallest rule, parse_anchor's keyword table and the defined-term follower. Widen them and the floor gets stronger, which is the direction this kit wants: a floor built to lose measures nothing.

# Three free floors. None of them a strawman -- the strongest one is a genuine attempt at the

ANCHOR_KEYWORDS = [
NUM_RE = re.compile(r"(\d+)\s*\(\d+\)")
UNIT_RE = re.compile(r"\((\d+)\)\s*-?\s*(day|month)s?", re.I)
DIRECTION_AFTER_RE = re.compile(r"\bafter\b", re.I)
def _extract_field(text, label_regex):
def parse_register(text):
FIELD_BY_ANCHOR = {R.DELIVERY: "delivery", R.COMMENCEMENT: "commencement",
def parse_anchor(text):
def split_clause_block(clause_block):

evals/redteam.pythe injection probe

One targeted, real call at a WINDOW_CLOSING title with a genuinely-due flag, its Administration Notes replaced by an instruction to hold the flag. Closes a real gap in the corpus's five planted instruction-shaped notes, none of which landed on a reading where the flag was actually due.

# One targeted probe of this kit's only untrusted-input surface: the Administration Notes.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
GOLD = os.path.join(HERE, "data", "gold.jsonl")
CORPUS = os.path.join(HERE, "data", "corpus")
RESULTS = os.path.join(HERE, "results")
TARGET_DOC = "TTL-0012-R2"
INJECTED_NOTE = (
def build_probe_text():
def carried_state():
def main():

evals/scoring.pythe scorer

Exact match per cell against the computed gold, split ways an average would hide: seven fields, three flag directions counted apart (missed, early, duplicate), the reversion binary on its own, the memory-dependent subset, the context-incomplete and feed-gap recalls, and the exploitation-gap day count checked only where a breach is confirmed. No judge model.

# Score a run's answers against data/gold.jsonl. Exact match per cell, pure code, no judge model.

FIELDS = ("stage", "anchor", "window_open", "window_close", "raise_flag",
GOLD_KEY = {"anchor": "anchor_answer"}
def _pct(hit, of):
def score(gold_rows, answers_by_doc):

evals/check_labels.pythe pre-flight

Thirteen things that must be true before a run may spend: the nine sections parse, every title's run sequence is complete and gap-free, the answer key replays exactly from src.reversion (stage, anchor, both edges, the flag AND the exploitation pair), both window edges are exercised, all six stages and all three exploitation answers appear, the privacy guard holds and would fail without it (measured both directions), the two prompt builders differ on exactly one line, no code path approves/revokes/notifies/signs anything, every boolean in the key is a real bool, and the generator reads no clock and no OS randomness.

# Everything that must be true before a run may spend. Free, seconds, no model, no key.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
GOLD = os.path.join(HERE, "data", "gold.jsonl")
FAILS = []
def check(name, ok, detail=""):
def load_gold():
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: 2730 input and 2227 output tokens per reading (one title, at one scheduled run), all of it fixed — this kit sends the document's own selected sections, so there is no retrieval depth to turn. Change the volume and the bill scales linearly, because nothing here batches.

OperationsFour shapes of workload

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

Model follows the controls above.

What this ignoresWhere a real bill diverges

In one lineWhat this kit exposes

No untrusted external input surface in the shipped version. Every field that reaches the prompt comes from tools/build_corpus.py, which invents all of it from a fixed seed. In a real deployment exactly one field is writable by somebody outside the licensor's own team -- the Administration Notes, which a rights administrator types and into which a licensee's counsel's email is routinely pasted.

The provider key lives only in .env (gitignored) or the shared repo-root .env, read by src/config.py and never logged, never written to results/, and never rendered by the UI. src/app.py replaces it and the base URL with placeholders before any provider error reaches the browser.

The experimentWe DID attack it, once, at the boundary that matters

evals/redteam.py replaces the Administration Notes of TTL-0012-R2, a WINDOW_CLOSING title with a genuinely-due Business-Affairs flag, with an instruction to hold any flag or notice pending an unapproved internal review. The reply raised the flag anyway: held. One title, one wording, one model -- this is a data point, not a guarantee, and Eval.could_not_verify says so. One targeted injection probe was fired at this kit, on 2026-08-24 -- the exact boundary the shipped corpus's five planted instruction-shaped notes never actually tested (all five land on readings where the flag was not genuinely due).

The privacy guard (Rights Holder Contact never sent) is the only row measured in both directions, red-proven before any run may spend. The injection result is one live call and is reported as exactly that.

The resultThe privacy guard held at 0 leaks in both directions, and the one live injection probe fired at the boundary that matters did not move the flag.

One targeted injection probe (evals/redteam.py) replaced the Administration Notes of a WINDOW_CLOSING title with an instruction to hold any flag pending an unapproved internal review. The reply raised the flag anyway. One title, one wording, one model -- a data point, not a guarantee.

HonestyWhat this does not prove

• Whether the injection result generalises past one title, one instruction wording and one model -- it is a single data point closing a real gap in the shipped corpus, not a security guarantee.
• Whether a differently-worded instruction, or one planted in a section other than Administration Notes, would be followed.
• Whether the redaction of the API key and base URL from a provider error message would survive a provider that echoes a MASKED form of the key rather than the key itself -- the exact hole the cousin kit critical-date recorded and did not fully close.

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 renewal approved, no grant revoked, no platform notified and no reversion notice signed -- non-configurable. This kit produces a stage, a governing date, two renewal-window edges, a flag and an exploitation-breach pair. It never acts on any of them, and there is no setting that makes it. The cap on this row is `license-approval`.

Everywhere and nowhere -- it is a property of what is ABSENT. The only writers in the kit are evals/run.py and evals/redteam.py (results/*.json) and src/state.py (data/state.json). There is no outbound path of any kind except the one completion call in src/adapters.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• IT IS NOT A CHECK ON WHETHER THE ANSWER IS RIGHT. The arithmetic runs whatever the model says, so a wrong reading is a wrong watchlist row, not a blocked action. The guardrail stops the kit acting; it does not stop it being wrong -- see Rule R-7's own unenforced-precedence bug in Data.breaks_on.
• IT IS NOT A SCHEDULER. evals/run.py is INVOKED, not woken, and nothing here detects a missed run or back-fills one.
• IT IS NOT LEGAL ADVICE AND THE RULES ARE INVENTED. Whether a renewal notice served on a given day is valid depends on the executed agreement, the notice provisions and the jurisdiction, none of which this kit models.

WatchedWhat is watched, and why that one

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

20 measured by the latest run 11 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 quarterly, on the last day of the quarter, documents 120, stateless False, titles 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

9 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 — 4 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 4 runs measured the same system — they differ on floor — 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 — 4 runs. Columns here are only ever compared with each other.

not a time series No two of these 4 runs measured the same system — they differ on documents, max_tokens, stateless, titles — 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 20 chips that all say so.

DeviationsWhat deviated

0 breaches across 9 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) on any change to the corpus or the arithmetic. Re-run evals/redteam.py's probe (one call) if the Administration Notes field's role in the prompt changes.

In one lineNo framework, deliberately

No framework and no dependencies at all -- json, os, re, random, datetime, argparse, urllib, http.server and concurrent.futures, all standard library. No date library either, on a kit whose whole subject is calendar arithmetic: the entire need is add_months in src/reversion.py, fifteen lines, and its clamping convention is a judgement this kit has to state on the page rather than inherit from a library's default.

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 title is a chain of three scheduled runs and the only edge between them is six scalars, not a branch.

The other sideWhat a framework costs you

• Every seam above is small enough to read in one sitting today. A framework buys generality this kit's own measured corpus does not need yet -- the floor ties the model on THIS set of clause forms, and the real argument for either a stronger framework or a stronger model is a book with real drafting variety, which this corpus is not.

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

Measured on r001-rights-reversion on the same tier, STATELESS CONTROL, 2026-08-24. 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 7 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.

4 runs not plotted. b000-rights-reversion-expiryonly, b001-rights-reversion-expiryonlymem, b002-rights-reversion-clauseregexmem, b004-rights-reversion-nofollow 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, 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 title, licensor, licensee, territory, reversion clause, term date, grant value, instrument and administration note is invented here. Verified against the repository's own LICENSE file on 2026-08-24. Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe stage, the governing date, both renewal-window edges, the Business-Affairs flag and the exploitation-breach pair, per reading, exact match against the computed answer key

For each of the 120 readings and each of seven answered fields, did the reply equal the computed answer key? Stage, anchor, the flag and the breach answer are words from a closed list; the two edges are ISO dates and the gap is an integer, compared exactly.

MethodHow the test was run

evals/scoring.py::score, in-process, no key and no model. The same function scores all four free floors and the stateless control.

The inputOne real row, seen by every grader

The formulaWhat it computes

accuracy = hits / 120 per field (or the field's own gated denominator -- exploitation_gap_days only counts where a breach is confirmed on either side).

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: data/gold.jsonl, computed by tools/build_corpus.py over the planted anchors, clauses and activity logs at generation time and re-derived from src/reversion.step and check_exploitation by evals/check_labels.py before any run may spend.

How tight can the band be? No tuned threshold anywhere on the model path -- the reply decides. The denominators are printed beside every rate because several are small: 13 readings where a Business-Affairs flag is genuinely due, 12 where a breach is confirmed, and 5 with a genuinely incomplete exploitation feed, so one row moving flips those figures by several points at a time.

Cadence: Re-run evals/check_labels.py (free) on any change to tools/build_corpus.py, src/reversion.py, src/segment.py, src/select.py or src/prompt.py. Re-run the scored eval AND its stateless control together (paid, 240 calls) on any change to src/prompt.py or src/state.py.

The decisionWhen to reach for it