# What this lane got wrong, what it would have claimed if nobody had stopped it, and what you will find in the first hour

Written 2026-09-04, at the end of the program. Everything below was found by this lane's own instruments,
by an orchestrator's check this lane then reproduced, or by measurements run today for this file, in a
fresh clone of the branch a reader would receive. Every item names its receipt. None of it is softened, and
none of it was found by a customer.

If anything on our public surfaces contradicts this file, this file is right.

---

## Part 1 — What we would have claimed if nobody had stopped us

**A 30.5% knee uplift on a real production trace.** That was our first headline. The replay bridge that
turned block ids into text mapped **13,712 distinct ids onto 33 distinct texts**, so nearly every request
shared a prefix with nearly every other. The tell was arithmetic available before the run: the engine
reported a hit rate of **0.3865** against a theoretical maximum for that stream of **0.1687**. A hit rate
above the cold-miss ceiling is not a strong result, it is a broken instrument. The bridge had a gate; the
gate checked that blocks sharing an id share their text, and not that blocks with distinct ids have
distinct text. Both directions are asserted now, before a replay serves anything
(`results/d1_engine_hit_rate.json`, `bench/trace_io.py`, `NEGATIVE_RESULTS.md` Part II·X).

**Then +7.9%, from a single replicate.** Rebuilt on the fixed bridge the effect measured 7.9% at n=1. We
would have published it. At **n=8** the paired median ratio is **0.949884**, ci95 **[0.906346, 1.065434]**,
**p = 0.62503** — and the run had been sized against the wrong variance: the plan sized n=8 on the collapsed
stream's `s_y` of **0.047**, while the fixed bridge's is **0.0967**, so it could resolve **11.83%** where
the bar was written for **5.58%**. The knee uplift is not a result at this size
(`results/s06_c1_fixed_bridge_n8.json`, `results/s46c_apc_fixed_bridge_n8.prereg.json`).

**That the two red certificates could be quietly repaired.** Two n=8 certificates carry an empty
`does_not_prove` because our own config derivation dropped the limits block. The proposed fix was to copy
the text into the certificates afterwards, with a field recording that it had been stamped. That was
refused. A certificate is a record of what a run knew when it ran. We fixed the six configs so every future
run carries its limits, added a test that fails when a sealed config has an empty block, and left the two
certificates red (`STALE_CLAIMS.md`, `tests/test_sealed_config_limits.py`).

**That a plan is a receipt.** Our push list said the lane branch had never been pushed. When the one
approved push ran, the branch was **already on the remote**, at a commit we had never pushed, and the
owner's branch had moved on the same remote in the same window. One push from a shared working tree would
explain both and we cannot see who ran it from inside the repository. "Nothing has left this repo" was true
of our actions and false of the remote, and only the remote decides
(`reaudit/s12b_push_line1.json`).

**Two counts, in the first hour the barrier between lanes opened.** We published that we held 138 non-raw
certificates and that one bound a Lean theorem by name. Re-measured before they were cited: **142**
certificates and **exactly four** naming a Lean declaration. The second number matters to another lane that
is being asked to make that field load-bearing (`CROSS_LANE_CITATIONS_2026-09.md`).

**Six more, inside the content package, caught by a gate we wrote to fail first.** Two indictments cited
config files that do not exist. The hero credited one certificate with two numbers that live in two. Three
Bailian figures were wrong in the third decimal against their own certificate — **15.183, 14.998, 12.254**
where the receipt says **15.182, 14.995, 12.25**. A statement asserted 58 certificates with absolute paths
and 24 with an unknown git revision; re-measured over **142** non-raw certificates today, **44** carry an
absolute filesystem path and **36** carry an unknown git revision, and since no file carries either pair the
package no longer states them. Those counts come from a command, not a file, so here it is — and the first
version of this sentence said 35 rather than 44, because the sentence was written from an earlier narrower
pattern than the command printed beneath it. The second self-check pass ran the command and caught it:
`python3 -c "import json,glob,re;C=[json.load(open(p)) for p in glob.glob('results/*.json') if 'raw' not in p];A=re.compile(r'\"/[A-Za-z]+/[A-Za-z]+/');print(len(C), sum(bool(A.search(json.dumps(d))) for d in C), sum(d.get('git_rev')=='unknown' for d in C))"` A negative-results row
counted rows the certificate does not count (`site-program/package.json`, `tools/check_site_package.py`).

## Part 2 — The instruments that were wrong, including one that was measuring us

**The stranger's verifier was refused twice, for two independently sufficient reasons.** Its parity bar
failed: **68 of 96** stored measurements recompute and **no committed certificate exercises one of its four
rules** (`results/s06_verifier_parity.json`). Separately, run the way a stranger would run it — as a file,
from the repository root, with nothing on the path — it **crashed on all five test inputs**, exit 1, no
verdict at all.

**The estate's own cross-lane instrument measured us in the wrong environment, and said so.** The
orchestrator's cross-verification matrix reported that our verifier returned exit 0 on every input. That is
true only with the repository on the path, which is how our own bench script imports it, so that is how it
was run. Run as a stranger would, it crashed instead. Same defect, two faces; the estate's instrument saw
one, we measured the other, and the correction was written into the matrix against its author's name. An
instrument that reproduces a developer's environment is measuring the developer
(`reaudit/s08_verifier_contract_before.log`).

**The page could never have loaded.** `verifier/index.html` fetched **four** files into the browser while
one of them imported a **fifth** that the page never fetched. The S06 parity certificate had called that
same bundle **3 of 3 byte-identical** to the repository modules and could not see it, because byte-identity
is not self-containment. Both are fixed and the verifier is still not shipped
(`results/s08_verifier_contract.json`, `oss/outbox/verifier/NOT_BUILT.md`).

**Three of four refusal rules have never refused anything.** All four are tripped by a forgery built from a
real certificate. But the seal check, the replicate floor and the cost identity are **never exercised in the
refusing direction by any committed certificate in this repository**. They are real, they are tested, and
they have never fired on our own data (`results/s08_parity_bar.json`).

**A certificate kept a number the prose had retracted.** An audit found the minimum-detectable-effect
formula anti-conservative and every figure in the documents was recomputed exactly. The three certificates
those figures came from were never re-stamped: **28 rows** still carry the retracted values. It went unseen
for six days because the check compared the re-derivation against the *document* and never against the
certificate's own field (`NEGATIVE_RESULTS.md` Part II·XI).

**An instrument reported OK on a stream with nothing to measure.** The fleet report was pointed at a control
whose block ids never repeat, where the correct answer is a cold-miss floor of 1.0 and no cache helps. The
instrument returned OK; the runner around it refused the file, which is how the control was caught
(`results/s06_bailian_fleet_audit.json`).

**A paid run that measured nothing, twice.** A scraper was added to a module and a GPU run was launched to
collect engine counters; it returned nulls because the code path meant to call the scraper never called it.
Exit 0, no data, **$0.86**. A later attempt read a Prometheus `_created` timestamp as a counter and produced
a hit rate of 1.0 with caching switched off. Both failed attempts are kept under their own names
(`NEGATIVE_RESULTS.md` Part II·IX, `results/d1_engine_hit_rate.attempt2_timestamp_as_counter.json`).

**The spend figure was wrong in four documents at once** — roughly $6.8, roughly $7, about $10.7, and in one
recollection about $85 — against a ledger floor recomputed from wall-clock and rate of **$11.4106**, whose
own rate table reads `pricing_verified: false` (`results/spend_ledger.json`).

**A sealed bar with a clause nobody ever ran.** `results/s06_verifier_parity.prereg.json` seals five
substantive clauses. The certificate evaluates four. The fifth, `browser_run` — "owner-run in a browser; the
page reports PASS/FAIL" — was never executed, and the certificate's verdict is silent about it rather than
recording it as unevaluated. Given what we later learned about the page, it could not have been satisfied.

**Machine-checked is not meaningful.** We elaborate our own Lean corollary and print the kernel's axiom
footprint. That proves the proof is a proof. It does not prove the statement describes anything real:
elsewhere in this estate a kernel-clean theorem describes a domain that does not exist
(`reaudit/lake_axioms_attained.log`).

## Part 3 — Filters we wrote that suppressed signal along with noise, measured

**The package's number gate does not look at the honesty section.** It visits the hero, theorems,
indictments, envelope, artifacts, opening result and negative results. It never visits `honesty.confession`
— which is this file, and holds more numeric tokens than any other section — nor the **5** in the verifier
section nor the **2** in the open questions. The part of the package fed verbatim to a website is the part
whose numbers no gate checks. They were checked by hand for this file, twice, which is weaker
(`tools/check_site_package.py`).

**It skips two classes of number by construction:** a four-digit year, and a bare zero. A wrong year or a
wrong zero passes silently. We do not print the counts here, because this file is embedded in the package it
describes and every count of it changes when the count is written into it — a document cannot be its own
fixed point. Compute them at any commit with
`python3 -c "import json,sys;sys.path.insert(0,'tools');import check_site_package as C;p=json.load(open('site-program/package.json'));print(sum(len(list(C.numbers_in(s))) for _,s in C.walk(p)))"`
and compare against the gate's own reported total.

**Its first binding rule was a tolerance band, and the band was the defect.** A number bound if any float in
a cited receipt fell within 2e-3 relative. The self-test caught a planted **0.0912** binding to a
certificate that never states it, because a certificate holds enough floats that something lands in any
band. Binding is now exact or by rounding to the decimals the sentence itself states. The first version
would have passed a wrong number and called it checked.

**Its path detector required a directory separator**, so it never saw `STALE_CLAIMS.md`, `README.md` or
`NEGATIVE_RESULTS.md`. Widened, receipt references went from **166** to **278**. Everything it found in the
gap was a real reference it had not been resolving.

**A generator fallback that hid a dangling receipt.** The envelope builder takes the first backticked path
in a row *that resolves on disk*, and falls back when none does. A row whose only receipt is a missing file
would therefore have been rendered with a silent substitution. One such row existed and was caught only
because the widened detector found the path in the row's prose instead. Of **58** rows in the stale-claims
ledger, **3** carry a backticked repository path that does not resolve: the one now corrected, a glob, and one
naming a file under a `scratchpad` directory that sits outside the repository entirely — **a receipt no
reader will ever have**.

**The I8 scan checks a fixed list of six markers.** Anything harmful that is not on the list is not
detected. It is public-by-default, which is the part that matters, but its vocabulary is ours.

**The register's own gate 2 examines 150 of 171 entries.** It reports PASS on the examined subset. Twenty-one
entries are waived with a written reason and are not examined by it (`reaudit_explained.json`).

## Part 4 — The numbers in the content package we are least sure of, and what would settle each

1. **The model's 0.038678 against the engine's 0.0385.** The engine value is measured at n=8 on the fixed
   bridge; the model value comes from the earlier n=1 run on the same trace and bridge, so the comparison
   crosses two runs. *Settled by:* recomputing the hash-only model from the n=8 run's own raw and comparing
   within a single run. It costs nothing and has not been done
   (`results/s06_c1_fixed_bridge_n8.json`, `results/s46b_engine_hit_rate.json`).
2. **The four Bailian headroom figures.** They are what an LRU model says about a provider's own hashes, and
   LRU stands in for a real engine's prefix tree. That stand-in is corroborated on one trace against one
   engine. *Settled by:* the provider running its own engine's counters against the same window. The traces
   carry no prompt text, so nobody outside that provider can do it
   (`results/s06_bailian_fleet_audit.json`).
3. **176,406,170,212 HBM token-seconds.** An unbounded pool, a one-hour hold, and wait classes inferred from
   the previous request's stop reason because the corpus carries no tool identities. *Settled by:* an
   operator replaying it against a real pool with a real eviction policy (`results/s06_weka_residency.json`).
4. **The 2.745% order-effect bound.** It is what thirty A/A replicates on one rig can exclude on one metric,
   not a property of the harness. *Settled by:* replication on a second GPU class (`results/order_effect.json`).
5. **The 1.6484 active-expert ceiling.** One model, and the decomposition beneath it is this machine's
   kernel timing. *Settled by:* the same decomposition on a second model family
   (`results/active_expert_ceiling.json`).
6. **The 12.0-point gate every Bailian file clears.** We chose 12.0. It is the S50 gate carried forward, not
   a threshold any operator gave us, so "all four clear the bar" means all four clear *our* bar
   (`results/s06_bailian_fleet_audit.prereg.json`).
7. **0.965737 reproducing a published 0.9657.** It reproduces the publisher's number under the publisher's
   definition. The corpus hashes are scoped per trace, so cross-session sharing is not measurable in it at
   all, and our agreement says nothing about that (`results/s06_weka_prefix_hit_rate.json`).

## Part 5 — What a buyer's engineer finds in the first hour that we did not mention

Measured today, in a fresh clone of the branch a reader would receive: **648 tracked files, 224 MB**
(`git clone --branch site-program/2026-09 --single-branch <repo> && git ls-files | wc -l && du -sh .`).
Every number in this part comes from a command run in that clone, and each command is named beside its
result, because a scratch log on our machine is not a receipt a reader can open.

**1. The first command in our README reports that the repository does not reproduce.** `make sprint53` is
the ten-minute reproduction the README leads with. Run in the fresh clone, it prints `9 of 9 headline artifacts
present`, then `tests PASS · audit FAIL · orphans 0`, then **`TIER 0 DOES NOT REPRODUCE`**, and exits 2. It
is behaving exactly as designed — it goes red when anything is red, and two certificates are red on purpose
— but a reader running our own headline command first sees a failure, and nothing in the README or the
content package warns them. That is the single thing we would most want back.

**2. The test suite does not give 615 on your machine.** README says 615 tests. With the estate fixture
absent, which is every machine but this one, `python3 -m pytest tests/ -q` gives **1 failed, 601 passed, 13
skipped in 524.13s**. On a machine that does have the estate mounted, reproduce it by making that one path
report absent: put `import pathlib; _r=pathlib.Path.exists; pathlib.Path.exists=lambda s: False if "untitled
folder 5" in str(s) else _r(s)` in a file on `PYTHONPATH` and run pytest with `-p` that module. Thirteen skip cleanly with `estate fixture not mounted`. The one failure is real:
`tests/test_trace_io.py::test_slice_provenance_cannot_be_mistaken_for_the_whole_capture` guards its first
half and then calls `load_any("mooncake_timed", ...)`, which needs the whole 12,031-request capture that
this repository does not ship — only the 600, 300 and 200-request slices are committed.

**3. Without scipy, our verifier accuses our own certificates.** The package tells a stranger to run
`python3 verifier/verify_core.py` on a sample certificate. With scipy present, `results/s01_aa_null_sharded.json`
comes back **VERIFIED, 12 checks, 0 failures**. With scipy absent, the same file comes back **FAILED, 8 of 12
MDE checks failing** — reproduce by blocking the import: run `verify_core.verify_path` in a process whose
`sys.meta_path` refuses `scipy` and `numpy`, or simply in an environment without them. The library is honest — it labels its fallback `mde_method: normal_approximation` and
returns **5.573** where the exact noncentral-t returns **5.589** — but the verifier never reads that label and
compares the approximation against a recorded exact value at a 1e-6 tolerance. A reader without scipy is told
eight of our stored measurements do not recompute, when what actually happened is that our verifier silently
used the very formula this estate retracted. It should refuse rather than grade when the exact path is
unavailable; that fix is one line and is not made.

**4. Our own S08 contract battery never caught number 3**, because it ran in an environment that has scipy.

**5. The browser page needs a web server and does not say so.** `verifier/index.html` loads its bundle with
`fetch()` on relative paths. Opened from a `file://` URL, which is what double-clicking gives you, browsers
refuse those requests, so the page stops at "loading" and the buttons never enable. It needs to be served
over HTTP, and nothing in the page or the repository says that. **No receipt of any browser run exists
anywhere in this repository**, and the sealed clause that required one was never evaluated. The pinned
pyodide build is at least live: the CDN returns HTTP 200
(`curl -s -o /dev/null -w '%{http_code}' https://cdn.jsdelivr.net/pyodide/v0.27.7/full/pyodide.js`).

**6. A shared gate reports three of our register rows as unreceipted.** `check_status_vs_receipts` reads
`out/run_receipts.json`, which holds **85** receipts, and reports `0 contradiction(s), 3 unreceipted RAN
claim(s)` — the three S08 entries. Their receipts exist and record all three as REPRODUCED, in
`reaudit/gate4_s08.json`, which is not the file the shared gate reads. The gate is right that it cannot see
them. Merging them is not done.

**7. Nothing here is publicly reachable.** The one pushed target is a private backup whose unauthenticated
API returns 404. Every other artifact in the package reads `planned`, two of them carry an organisation name
in their own distribution name that nobody has settled, and the browser verifier is deliberately not shipped
at all (`reaudit/s12b_push_line1.json`).

## Part 6 — What is still red, on purpose

`make verify` ends `615 passed in 532.08s`, both README counts matching, and **2 FAILURES**, which the
audit prints by basename and which live at `results/s46c_apc_fixed_bridge_n8.json` and
`results/s47b_aa_fixed_bridge_n8.json`: `does_not_prove is present but EMPTY`.
Those two stay red. The parity bar reports **28** disagreements over **115** checks on **27** certificates
and does not gate them away. The verifier is not shipped. The knee uplift is not a result. We would rather
publish all of that than a page that reproduces on one machine.