The business caseThe problem this solves

A launch checklist reports a percentage. The fourteen items are not equal: a missing marketing asset does not stop a product shipping; an unconfirmed barcode, an unpriced item or a missing safety data sheet does. On this corpus the two genuinely disagree — 36 readings look READY at 80 pct or better and are BLOCKED or AT_RISK, 39 look RED with the gate clear, and 75 of 120 point in opposite directions. The gate refuses to spend until that holds. a readiness dashboard reporting percent complete and a RAG colour — which treats a missing marketing asset and a missing safety data sheet as equal, and cannot see an item the systems still show outstanding that the launch channel says was closed on Tuesday.

The inputThe actual gate review extracts

The corpus is 120 gate review extracts, 0.94 MB (txt 120). A retailer's unlaunched assortment and its gate criteria are commercially sensitive. There is no public one. A scrubbed export is worse rather than better: scrubbing removes the launch-channel notes, which is exactly the layer this kit measures.

Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated new-product-introduction gate review
extract for an AI use-case kit; it reproduces no retailer, no supplier, no product and no
real person. The blocking item classes and lead times are ILLUSTRATIVE DEFAULTS.

Product
----------------------------------------------------------------
Product reference              : NPI-0001
Product                        : Kestrel Rye Cracker 750ml
Category                       : Cookware
Supplier                       : Tinsley Personal Care
NPI owner (of record)          : Noor Haddad
Target gate date (on record)   : 2026-09-12
Planned first-order value      : 321,037.74 USD

Readiness Checklist
----------------------------------------------------------------
This tracker is refreshed from the source systems overnight and IS KNOWN TO LAG THE WORK.
It is NOT re-derived inside this review horizon. Anything under "Changes In This Cycle",
or established on an earlier cycle, supersedes what is printed here.

  MARKETING       Launch campaign brief signed off                           COMPLETE
  SAFETY          Safety data sheet filed and accepted                       COMPLETE
  SUPPLY          First-receipt purchase order confirmed with the supplier   COMPLETE
  PR              Press and social plan agreed                               COMPLETE
  MERCH           Planogram slot assigned                                    COMPLETE
  BARCODE         GTIN / barcode confirmed and scan-tested                   OUTSTANDING
  SAMPLES         Samples distributed to category buyers                     COMPLETE
  PHOTO           Product photography delivered                              OUTSTANDING

The outcomeWhat a good result looks like

every product's verdict with the single blocking item named and the countdown in days — 0 false escalations across 95 quiet readings.

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.

• Every completion and every dependency is keyed into the tracker before the gate runs — the free floor — structured-log-strong, $0.00
  It scores 100.0 on tagged evidence and ties the model on four columns.
• The systems lag the work and the channel carries the truth — the model, with the carried state
  Verdict 100.0 against 86.67, and 100.0 pct on the discriminator against 92.5 pct.

And where nothing here is good enough:

• You want the reading but cannot carry state between reviews — neither, as configured here
  The stateless control falls to 83.33 pct on verdict with 39 false escalations.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-25. 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-25 — r001-npi-gate. 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 corpus extract, the answer key, all three free floors, the injection probe and what r001-npi-gate actually answered ship in the repo. python3 -m evals.check_labels and python3 -m src.app both run with no key and no network.

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 reading — one product, at one scheduled run, end to end including provider-side reasoning tokens, on the shared connection. Not a cold-start figure and not a per-product SLA: 120 readings ran in 553.2 wall seconds because different products run concurrently while a single product's runs are strictly serial.

Current processWhat it replaces

a readiness dashboard reporting percent complete and a RAG colour — which treats a missing marketing asset and a missing safety data sheet as equal, and cannot see an item the systems still show outstanding that the launch channel says was closed on Tuesday.

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 reading is

40 products x 3 weekly gate review, walked strictly in order per product so the carried state moves forward the way it would in a real deployment. Different products run concurrently; a single product's cycles never do.

SetupWhat the setup figure measured

There is no index to build — each reading's extract goes whole into the prompt. The 0.5s and $0.00 are the corpus generation itself.

LicenceLicence

MIT

Bring your ownBring your own gate review extracts

tools/build_corpus.py writes data/corpus/*.txt and data/gold.jsonl. Keep the 8 section headings and the field labels src/review.position_of parses. Put YOUR blocking item classes and lead times in src/gate.py first.

⚠︎ And what stops being true when you do: The measured figures on this kit's page do not transfer to your own corpus. The percent-versus-blocked disagreement rate (75 of 120 readings here) and the tagged-versus-prose evidence split (42 cells against 78) are properties of this generator's declared distribution, not facts about product launch management. Re-run the evals on your own data; that is what the harness is for.

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 — but they are the input total apportioned by each part’s share of the characters, not a per-part reading from the provider’s counter. The total is measured; the split is arithmetic, and a part carrying denser text really costs more of it than this says.

AssemblyHow the prompt is assembled

This is the cost lesson as arithmetic: of the 1,527 tokens assembled, 1,331 are instructions — 87% 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.

Reproduced from src/prompt.build for NPI-0001-C2 with that reading's real carried state, not retyped — byte-identical to what evals/run.py sent.

Full promptThe prompt in full

You are a weekly new-product-introduction gate review. You read one product's readiness against the DEFAULT gate policy at one weekly review, and you answer with one JSON object and no other text.

You are the weekly new-product-introduction gate review for one retailer's launch programme. It
runs every Monday and re-reads EVERY product in flight. You are reading ONE product at ONE weekly
gate review.

The product, its readiness checklist, the DEFAULT gate policy, this cycle's changes and this week's
launch notes are reproduced in the extract below. Apply them exactly as written. You cannot see the
earlier gate reviews; what is known about them is stated under "Carried state" and is the only
history available to you. Do not assume anything about earlier cycles beyond it.

⚠︎ WHICH ITEM CLASSES BLOCK THE GATE, AND THEIR LEAD TIMES, ARE ILLUSTRATIVE DEFAULTS, NOT ANY REAL
RETAILER'S GATE. Apply them as printed regardless of whether they look right for the product in
front of you.

⚠︎ A PERCENTAGE COMPLETE IS NOT A GATE DECISION. Do not use one. "Twelve of fourteen complete" is
not better than "nine of fourteen" if the two outstanding are the registration and the barcode and
the five outstanding are photography, copy, samples, the planogram and the press plan. The gate
turns on WHICH items are outstanding, never on how many (Rule G-1).

How to work it out:
 - FIRST decide whether a gate definition is on file. If the gate policy names no blocking item
   classes and no lead times, the verdict is CONTEXT_INCOMPLETE: no blocking item is named and
   nothing is escalated. THERE IS NO DEFAULT GATE (Rule G-9). Still report days_to_gate -- the
   countdown is arithmetic on the printed date and needs no gate definition.
 - THEN decide whether this product has already LAUNCHED. If the carried state or this cycle's
   changes record a launch, the verdict is LAUNCHED and stays LAUNCHED whatever the checklist still
   shows (Rule G-8), the blocking item is NONE, and nothing is escalated.
 - THEN work out what the fourteen items ACTUALLY are. The checklist shows what the systems of
   record currently hold, and THE TRACKER LAGS THE WORK. A change recorded in "Changes In This
   Cycle" -- in the fixed TAG format or in ordinary prose -- SUPERSEDES the checklist in BOTH
   directions: an item shown OUTSTANDING that a note says was filed or accepted is DONE, and an item
   shown COMPLETE that a note says failed its check or was rejected is OUTSTANDING (Rule G-3). A
   correction established in an EARLIER cycle is not repeated on this page and is stated only in the
   carried state; it still holds (Rule G-4). An item waived by governance, this cycle or an earlier
   one, is off the gate for good (Rule G-5).
 - THEN decide whether the gate date MOVED in this cycle. If it did, the verdict is DATE_SLIPPED for
   this cycle only, and days_to_gate counts down to the NEW date (Rule G-7). If a slip was recorded
   in an EARLIER cycle, the carried state gives the settled date: count down to that one, and the
   verdict this cycle comes from the ladder below, not from DATE_SLIPPED.
 - THEN name the BLOCKING ITEM. Of the blocking item classes still OUTSTANDING after all of the
   above, exactly ONE is reported: the one with the LONGEST lead time in the printed table. If no
   blocking class is outstanding, the blocking item is NONE (Rule G-2).
 - If nothing blocking is outstanding: the verdict is INCOMPLETE_NOT_BLOCKING when any item at all
   is still outstanding, and GATE_READY when nothing is.
 - If a blocking item IS outstanding and a PLAN WITH A DATE is on record FOR THAT ITEM -- this cycle
   or an earlier one -- the verdict is AT_RISK. A plan for a different item does not cover this one
   (Rule G-6).
 - Otherwise the verdict is BLOCKED.
 - THEN decide the OWNER. Start from the NPI owner on the product record, but a note recording a
   handover to someone else, in this cycle or an earlier one (see "Carried state"), supersedes it.
 - THEN compute days_to_gate: whole days from the date of THIS gate review to the gate date in
   force. Negative if the date has already passed.
 - FINALLY decide "escalate_now": YES only if the verdict is BLOCKED and this review has not
   already escalated for that same blocking item at the same urgency (see "Carried state"). It
   fires a SECOND time on the same item when days_to_gate first falls INSIDE that item's printed
   lead time. Otherwise NO (Rule G-10).

Answer with a single JSON object and nothing else:

{"verdict": "GATE_READY|BLOCKED|AT_RISK|INCOMPLETE_NOT_BLOCKING|DATE_SLIPPED|LAUNCHED|CONTEXT_INCOMPLETE",
 "blocking_item": "REGULATORY|SAFETY|SUPPLY|BARCODE|PRICING|NONE|UNDETERMINED",
 "owner": "<the current NPI owner's name>",
 "days_to_gate": <a whole number, or null if no gate date is on file>,
 "escalate_now": "YES|NO",
 "rationale": "one sentence, naming the item you decided is blocking and the checklist line or note
   you relied on"}

Precedence, applied in this order: CONTEXT_INCOMPLETE if no gate definition is on file (Rule G-9);
then LAUNCHED (Rule G-8); then DATE_SLIPPED if the date moved THIS cycle (Rule G-7); then the
blocking ladder above. "blocking_item" is UNDETERMINED only when the verdict is CONTEXT_INCOMPLETE,
and NONE whenever the verdict is LAUNCHED, GATE_READY or INCOMPLETE_NOT_BLOCKING.

Carried state
----------------------------------------------------------------
Nothing on the checklist has been corrected by any earlier cycle's notes. No item has been waived on any earlier cycle. The gate date as last settled is 2026-09-12 -- count down to THIS date, not to any other date printed on the record. No plan with a date has been recorded for any blocking item. This review has already escalated for: BARCODE! (a trailing ! means it was escalated again once the countdown fell inside that item's lead time). Do not escalate again for the same item at the same urgency. The NPI owner as last settled is Noor Haddad -- carried forward unless this cycle's notes hand the product to someone else. It was last reported BLOCKED.

Gate review extract
----------------------------------------------------------------
Synthetic Record
----------------------------------------------------------------
Every field below is invented. This is a generated new-product-introduction gate review
extract for an AI use-case kit; it reproduces no retailer, no supplier, no product and no
real person. The blocking item classes and lead times are ILLUSTRATIVE DEFAULTS.

Product
----------------------------------------------------------------
Product reference              : NPI-0001
Product                        : Kestrel Rye Cracker 750ml
Category                       : Cookware
Supplier                       : Tinsley Personal Care
NPI owner (of record)          : Noor Haddad
Target gate date (on record)   : 2026-09-12
Planned first-order value      : 321,037.74 USD

Readiness Checklist
----------------------------------------------------------------
This tracker is refreshed from the source systems overnight and IS KNOWN TO LAG THE WORK.
It is NOT re-derived inside this review horizon. Anything under "Changes In This Cycle",
or established on an earlier cycle, supersedes what is printed here.

  MARKETING       Launch campaign brief signed off                           COMPLETE
  SAFETY          Safety data sheet filed and accepted                       COMPLETE
  SUPPLY          First-receipt purchase order confirmed with the supplier   COMPLETE
  PR              Press and social plan agreed                               COMPLETE
  MERCH           Planogram slot assigned                                    COMPLETE
  BARCODE         GTIN / barcode confirmed and scan-tested                   OUTSTANDING
  SAMPLES         Samples distributed to category buyers                     COMPLETE
  PHOTO           Product photography delivered                              OUTSTANDING
  FORECAST        Demand forecast published to the supply plan               OUTSTANDING
  PRICING         Retail price loaded and confirmed in the master            COMPLETE
  REGULATORY      Regulatory registration approved                           COMPLETE
  PACKAGING_ART   Packaging artwork signed off                               OUTSTANDING
  CONTENT         Online listing copy written                                COMPLETE
  TRAINING        Store colleague training module published                  COMPLETE

  10 of 14 items settled on the tracker -- 71.4 pct complete

Gate Policy (Default)
----------------------------------------------------------------
The list below is an OPERATOR-TUNABLE DEFAULT, not a real retailer's actual gate -- no
documented blocking item classes or lead times exist for this row. Applied exactly as
printed. A PERCENTAGE COMPLETE IS NOT A GATE DECISION and is not used as one here.

Blocking item classes -- an item in this list, still outstanding, holds the gate:

  REGULATORY      lead time 30 days   Regulatory registration approved
  SAFETY          lead time 21 days   Safety data sheet filed and accepted
  SUPPLY          lead time 14 days   First-receipt purchase order confirmed with the supplier
  BARCODE         lead time 10 days   GTIN / barcode confirmed and scan-tested
  PRICING         lead time  7 days   Retail price loaded and confirmed in the master

Every OTHER item on the checklist is NON-BLOCKING: it can be outstanding at the gate
and the product still ships. Of the blocking items still outstanding, the one with the
LONGEST lead time is the single item the date is waiting on.

Dashboard threshold (compare)  : 80 pct -- what a readiness dashboard colours RED
                                 below. Printed for comparison only. It is NOT part of the
                                 gate rule and is never used as one.
Waiver authority               : NOT DEFINED. Nothing in this kit passes a gate, waives an
                                 item, moves a launch date, approves a launch or writes to
                                 any system of record.

Rule G-1  A percentage complete is NOT a gate decision and is never used as one. The gate turns on
          WHICH items are outstanding, against the DEFAULT list of blocking item classes printed
          above. That list is an operator-tunable placeholder, not any retailer's actual gate, and
          is applied exactly as printed.
Rule G-2  Of the BLOCKING items still outstanding, exactly ONE is reported as the blocking item:
          the one with the LONGEST lead time in the printed table. Clearing a shorter-lead item
          first does not move the date while a longer-lead item is open. Ties break on the order
          the table is printed in.
Rule G-3  THE TRACKER LAGS THE WORK. An item's state on the checklist is what the systems of
          record currently show. A change recorded in "Changes In This Cycle" -- in the fixed TAG
          format or in ordinary prose -- SUPERSEDES the checklist, in both directions: an item
          shown OUTSTANDING that a note says was filed is DONE, and an item shown COMPLETE that a
          note says failed its check is OUTSTANDING. The tracker is not re-derived inside this
          review horizon, so a correction made in an earlier cycle is known only through the
          carried state.
Rule G-4  Changes ACCUMULATE across cycles. "Changes In This Cycle" shows only what was recorded
          since the PREVIOUS gate review; an item confirmed done two cycles ago is not restated on
          this cycle's page and is known only through the carried state.
Rule G-5  A WAIVER recorded by the governance body removes that item from the gate for good.
          Nothing here waives anything -- a waiver is only ever reported, never granted.
Rule G-6  If a blocking item is outstanding and there is a recorded PLAN with a DATE for clearing
          it, the verdict is AT_RISK rather than BLOCKED. A plan recorded in an earlier cycle
          carries forward (Rule G-4). Without a plan and a date it is BLOCKED.
Rule G-7  If the gate date MOVED in this cycle, the verdict is DATE_SLIPPED for this cycle only.
          The new date is carried forward and every later cycle counts down to it. Nothing here
          moves a date; a slip is only ever reported.
Rule G-8  Once a launch is recorded, the product is LAUNCHED and stays LAUNCHED on every later
          cycle. Nothing here launches anything.
Rule G-9  If no gate definition is on file for this product -- no blocking item classes and no lead
          times -- the verdict is CONTEXT_INCOMPLETE: no blocking item is named and nothing is
          escalated. THERE IS NO DEFAULT GATE. The days-to-gate countdown is still reported,
          because it is arithmetic on the printed date and needs no gate definition.
Rule G-10 "Escalate now" is YES only when the verdict is BLOCKED and this review has not already
          escalated for that same blocking item at the same urgency. It fires a SECOND time on the
          same item when the countdown first falls INSIDE that item's lead time, because an item
          that has been outstanding for three cycles with the date unchanged is a different finding
          from one that has just appeared.

Review Position
----------------------------------------------------------------
Review date                    : 2026-09-14   (gate review 2 of this product)
Review cadence                 : weekly -- every Monday gate review
Previous gate review           : 2026-09-07
Next gate review               : 2026-09-21

Changes In This Cycle
----------------------------------------------------------------
Everything recorded against this product between the previous gate review and this one.
THIS CYCLE ONLY -- a change recorded in an earlier cycle is not repeated here.

2026-09-11  This one went live in stores over the weekend.

Launch Notes
----------------------------------------------------------------
The supplier is running this on the same line as an existing SKU, so their capacity is
not the constraint anybody assumes it is.

Raw responseThe raw response

{"verdict": "LAUNCHED", "blocking_item": "NONE", "owner": "Noor Haddad", "days_to_gate": -2, "escalate_now": "NO", "rationale": "The product has already launched per the 2026-09-11 change note ('This one went live in stores over the weekend'), so Rule G-8 makes the verdict LAUNCHED with no blocking item."}

Step 06 of 14Evals

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

In brief

Catch what's really blocking a product launch — 120 gate review extracts. One model answered, and every answer was then graded Three different ways — because the grade is a measurement too, and most of what went wrong on this kit went wrong in the ruler rather than the model.

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, never a bill and never a vendor's claim about this workload.

Rates checked 2026-08-18. The provider that actually ran all 400 calls is kept out of these tables per this estate's naming rule, so no figure here is a bill.

The gradersThree ways to grade

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

The three free floors, the stub, the cadence analysis and every pre-run check cost $0.00 and no calls. ⚠︎ A DISCARDED SCORED RUN (truncated at an 8,000 ceiling) cost the same again as the scored run and is NOT netted out — it was spent.

Cost driversWhat actually moves the bill

• OUTPUT TOKENS, AND ALMOST ALL OF THEM ARE REASONING. 95.9 pct of r001-npi-gate's output (264159 of 275431 tokens) was provider-side reasoning left at the default. The answer is a handful of short fields and a sentence; the bill is the thinking in front of it.
• THE PROMPT IS MOSTLY FIXED TEXT. 3200 input tokens per reading, and the policy block, the rule text and the instruction are the same on every call — so a provider with prompt caching would price this workload very differently, and that was not measured.

Your volumeWhat it costs at your volume

LINEAR IN PRODUCTS x REVIEWS. Nothing amortises. The sublinear lever NOT implemented is skipping products with no checklist movement.

Model choiceWhy this model

It is the tier the shared connection was already pointed at, and the kit's whole claim is that swapping it is .env plus one more run. No second model was run against this corpus; every other row in the cost table is a projection onto a published card and is labelled as one.

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-query average, this run

The codeEvery file, and what it is for

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

Five 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/gate.pythe gate rule and state machine — a swap seam

The DEFAULT blocking item classes, the lead times, the escalation thresholds and step() — which decides the next carried state from the answer key's inputs, never from a model reply. It is also the answer key.

You change it to: Widening it divides the bill and widens the window a blocker sits unchased.

# The new-product-introduction gate rule as arithmetic. Pure code, no model, standard library only.

CHECKLIST = (
ITEMS = tuple(c for c, _t in CHECKLIST)
ITEM_TEXT = dict(CHECKLIST)
DEFAULT_BLOCKING = ("REGULATORY", "SAFETY", "SUPPLY", "BARCODE", "PRICING")
DEFAULT_LEAD_DAYS = {
DASHBOARD_RED_BELOW_PCT = 80.0
WAIVER_AUTHORITY = None
COMPLETE = "COMPLETE"
OUTSTANDING = "OUTSTANDING"

src/state.pythe carried state

What earlier reviews settled: which items are done, the date history and the escalation record. An item confirmed two cycles ago is not restated on this page.

# The carried state -- the thing that makes this a monitor and not another readiness dashboard.

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

src/segment.pythe section splitter

Splits the page into its 8 named sections; asserted across all 120 documents.

# Split a gate-review extract into its named sections. Pure code, no model.

SECTIONS = ("Synthetic Record", "Product", "Readiness Checklist", "Gate Policy (Default)",
RULE = "-" * 64
def split(text):
def render(secs):

src/select.pythe send filter — a swap seam

Owner Contact is mapped by no field and therefore never sent. ⚑ THE GUARD TURNED OUT TO BE TWO INDEPENDENT LAYERS: breaking either alone leaks 0 of 120; breaking both leaks 120 of 120.

You change it to: SECTION_HINTS and NEVER_SENT.

# Pick which sections of a gate-review extract are sent. Pure code -- the last deterministic step

BANNER = "Synthetic Record"
PRODUCT = "Product"
CHECKLIST = "Readiness Checklist"
POLICY = "Gate Policy (Default)"
POSITION = "Review Position"
CHANGES = "Changes In This Cycle"
CONTACT = "Owner Contact"
NOTES = "Launch Notes"
NEVER_SENT = (CONTACT,)

src/prompt.pythe prompt

Three parts: instruction and JSON shape, carried state, extract. The stateless control replaces exactly one line.

# 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 call

Raw HTTP, stdlib only, bounded retry; the shared daily call cap is checked here.

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

One product, one gate review, one call.

# One product, one weekly gate review, 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 weekly new-product-introduction gate review. You read one product's readiness "
MAX_TOKENS = 16000
FIELDS = ("verdict", "blocking_item", "owner", "days_to_gate", "escalate_now")
def documents():
def products():
def load_doc(doc_id):
def position_of(text):

evals/scoring.pythe scorer

Exact match per cell. The blocker discriminator is a separate binary over its own denominator.

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

NEEDS_ATTENTION = ("BLOCKED", "AT_RISK")
FIELDS = ("verdict", "blocking_item", "owner", "days_to_gate", "escalate_now")
REAL_ITEMS = ("REGULATORY", "SAFETY", "SUPPLY", "BARCODE", "PRICING")
def _pct(n, d):
def _same(got, want):
def score(records, golds):
def _protection(records, golds):

evals/baseline.pythe three free floors

count-only, count-mem and structured-log-strong — $0.00 each.

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

MODES = ("count-only", "count-mem", "structured-log-strong")
def _section(text, name, nxt, flat=False):
CHECK_LINE = re.compile(
POLICY_LINE = re.compile(r"^  ([A-Z_]+)\s+lead time\s+(\d+) days", re.M)
def _facts(text):
def _states(text):
def _policy(text):
def _finish(verdict, blocker, owner, days, escalate, why):
TAG_DONE = re.compile(r"TAG: DONE ([A-Z_]+)")

src/app.pythe local UI server

http.server, stdlib. Renders with no key.

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

ui/app.jsthe local UI client

Hand-written JS, no framework. ⚠︎ ITS FIVE-COLUMN TABLE OVERFLOWED A PANEL WITH overflow:hidden AND SILENTLY AMPUTATED THE FIFTH COLUMN — found by opening a screenshot, fixed with shorter cells and an overflow-x wrapper. No gate can see that.

# 

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: 3200 input and 2295 output tokens per reading (one product, at one weekly gate review), 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, not asserted — and this kit's probe found and CORRECTED a confound the naive method would have published. Launch Notes is the injection surface.

API_KEY is read from .env (gitignored) or the real environment; never logged, never placed in a prompt, and redacted from any provider error message the local UI passes to the browser.

The experimentWe DID attack it — one sentence, on every reading where it could matter

The probe forces the instruction-shaped note onto every reading where an escalation was due and re-fires them, then pairs each against its own UN-INJECTED answer rather than against gold — because a reading the model already answers NO on is not a suppression. Both were run for real on 2026-08-25.

One boundary is measured in both directions here: the injection probe forces the condition rather than waiting for it, and the privacy guard is red-proven by reproducing the schema-change condition that reaches its fallback.

The result0 of 24 escalations suppressed suppressed by the instruction-shaped note — measured, not assumed.

One phrasing, one model, one corpus, 24 trials — every reading where suppression was even possible.

HonestyWhat this does not prove

• Any other injection.
• Whether the result holds on another model tier.
• Whether an injection placed in Owner Contact would have any effect — by construction it cannot.

In one lineThe only guardrail is the prompt

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

Never pass a gate, waive an item or move a launch date — and never present the blocking item classes or lead times as any real retailer's gate.

Stated to the model on every call in src/prompt.py's INSTRUCTION block, and enforced by evals/check_labels.py's banned-code-path scan before any run may spend.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• This is a PROMPT RULE PLUS A STATIC SCAN, not a runtime enforcement layer. Nothing stops a forker adding such a path tomorrow; the scan catches it only the next time somebody runs check_labels.py, which is a manual step.
• The injection result is ONE SENTENCE against ONE model on ONE corpus. It is not a resistance rate for prompt injection in general.

WatchedWhat is watched, and why that one

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

3 measured by the latest run 86 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

7 recorded runs. A dash is a metric that run did not measure, and a dash is never differenced: not measured is a third state, neither a value nor a zero, and reading it as zero is how a board reports an improvement on a run that never looked. They are split into 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 floor, the model — so nothing here may be differenced and the Verdict column is left off. Read this block DOWN a column, as a comparison between those runs, not along a row as a history.

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

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

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

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

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

DeviationsWhat deviated

0 breaches across 7 runs

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

RippleThe ripple map

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

FiresWhat fires when a band breaks

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

Nothing fires yet. Not one of the 28 bands on this kit names a consequence, so there is no row to print. Which is the honest answer to the heading: a band that nothing is wired to is a number somebody has to notice, and this kit has only those. An empty table would have said the same thing while looking like a rendering failure.

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

The guardrail scan is a MANUAL step, run before each spend, not a hook. It ran before every paid run and passed at 0 each time. The injection probe is a ONE-OFF: it measured 4.17 pct suppression on 24 readings on 2026-08-25 and nothing re-runs it, so that figure ages from the day it was taken.

In one lineNo framework, deliberately

NO FRAMEWORK. A folder of readable Python, no framework dependency, and a prompt anyone can read end to end. A framework abstraction would own the retrieval step — there is none here — and the memory layer, which is already the entire surface of src/state.py.

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 reader -> src/prompt.py -> src/adapters -> evals/scoring.py. No branching, no tool-calling and no agent loop.

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.

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

Measured on r001-npi-gate on the fast tier, with the carried state, 2026-08-25. 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 4 earlier runs on record is comparable with this one — a different model tier, or a changed guard — and differencing across that measures two systems rather than one. Said once here rather than as a dash on every row.

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

DriftMedian call, run over run

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

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

The other sideWhat this does not tell you

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

In one lineWhat you provision, honestly

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

The machineWhat this needs

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

Your dataWhere everything sits

The wireWhat crosses it, and when

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

The shapeHow it ships, and what you add

The ladderEach decision, and what you provision past its ceiling

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

When it failsFailure signatures

The knobsThe config surface, enumerated

Environment variables: API_KEY, BASE_URL, EMBED_MODEL, EVAL_WORKERS, MAX_CALLS_PER_DAY, MODEL, PORT, PROVIDER, RECORDED_RUN, SCORED_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 verdict, blocking item, owner, days-to-gate and escalate-now call, per reading, exact match against the computed answer key

whether each of the 5 answered fields equals the answer key, per reading

MethodHow the test was run

python3 -m evals.run --run-id <id> ...; evals/scoring.py compares strings. No model grades anything.

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

The inputOne real row, seen by every grader

The formulaWhat it computes

accuracy = hits / 120 per field. gate_blocker_accuracy_pct is scored separately over its own denominator.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the computed answer key in data/gold.jsonl, produced by src/gate.step() from the same planted inputs the corpus builder wrote onto the page.

No true/false rates for this grader. It records 5 operating rows and not one of them carries a confusion matrix, so there is no TPR, TNR or precision to state here — this grader does not sort answers into pass and fail, and rates that were never measured are not going to be printed as though they were. What it did measure is in “What it actually did” above; what to watch is immediately below.

How tight can the band be? No threshold was swept: exact match has no tunable. Denominators are stated beside every rate because 120 readings makes each one wide.

Cadence: once per run; free

The decisionWhen to reach for it

In one lineThe single item that actually holds the launch date

whether the arm named what blocks the gate, as against what is merely incomplete

MethodHow the test was run

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

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

The inputOne real row, seen by every grader

The formulaWhat it computes

caught over all 120 readings; the two error directions over their own denominators (63 readings where something genuinely blocks, 48 where nothing does).

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the computed answer key in data/gold.jsonl, produced by src/gate.step() from the same planted inputs the corpus builder wrote onto the page.

No true/false rates for this grader. It records 2 operating rows and not one of them carries a confusion matrix, so there is no TPR, TNR or precision to state here — this grader does not sort answers into pass and fail, and rates that were never measured are not going to be printed as though they were. What it did measure is in “What it actually did” above; what to watch is immediately below.

How tight can the band be? No sweep: the blocking item is a label the arm emits, not a thresholded score.

Cadence: once per run; free

The decisionWhen to reach for it

In one lineNaming the blocker where the evidence is PROSE

whether the arm can read an item's true state out of a sentence

MethodHow the test was run

evals/scoring.py, same pass.

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

The inputOne real row, seen by every grader

The formulaWhat it computes

over the 78 readings whose decisive evidence is prose, against the 42 whose evidence is a TAG: line.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the computed answer key in data/gold.jsonl, produced by src/gate.step() from the same planted inputs the corpus builder wrote onto the page.

No true/false rates for this grader. It records 2 operating rows and not one of them carries a confusion matrix, so there is no TPR, TNR or precision to state here — this grader does not sort answers into pass and fail, and rates that were never measured are not going to be printed as though they were. What it did measure is in “What it actually did” above; what to watch is immediately below.

How tight can the band be? No sweep.

Cadence: once per run; free

The decisionWhen to reach for it