The laws of one day

What this page counts

Forty-five laws were written on 2026-09-05, numbered 1 to 45 in the table below, with no gap and no repeat - checked, not assumed. Fifteen more predate that day and are carried at the end because they were used on it. Sixty in all, and the two sets do not overlap: no earlier law is repeated as a numbered row.

The dated notes above the table are instances, corrections and amendments, not new laws. They carry a running ordinal that has reached the fifty-third, and that ordinal was a second numbering kept alongside the table and never reconciled with it. Until 2026-09-06 16:02 this page said fifty-two in one place, forty in another and thirty-nine in a third, for the same quantity. That is the third law pointed at this page - denominators travel with the number - and this section is the reconciliation. Nothing is held back: the table shows 45 of 45.

Ordered by the hour of the first statement. A law is a general sentence about how work must be done or how a claim must be made; findings, tasks and bare numbers are not here. The example is the incident with its denominator, from the commit or the ledger.

Before dawn

The morning

The afternoon

Laws that predate today and carried it

A gate you cannot make fail is not a gate (SEQ, THE FIRST LAW, 2026-09-04 16:25; cited today by the harness’s gate.py:16 and three Sequence files). Absence of a signal is not evidence of absence (SEQ, THE SECOND LAW). Denominators travel with the number (SEQ, THE THIRD LAW; independently MLH how-to-verify.md:112, 2026-09-04 20:16). A citation you did not open is a rumour (MLH, 2026-09-04 21:33; made a test today: 28 laws, 22 citing a commit, 0 unresolved, proven able to fail with a planted sha). A suite that reports OK must also report how many it ran against how many exist (MLH, 21:33; the 3,315-of-3,822 collision). A gate that can say no cheaply is worth more than an experiment that says maybe expensively (MLH; the mechanism behind clause one before the judge). A covering is measured, not claimed and verify the instrument before reporting a defect (MLH, 2026-09-04 21:13; today’s four questions are the successor). Verbatim is a floor, not a guarantee of meaning (MLH, 23:36). Grounded, not guessed (SEQ docs/CANON.md). The replication rule — two runs a side, a difference counts only when both fall outside the other side’s range with the predicted direction (SEQ tools/bench/README.md). And the vault’s own from the night, listed in the ledger’s rulings: one GPU, one lane at a time (20:30); a version number means preregistered, an edit is a restart (~21:00); one gate at a time, by an O_EXCL lock, not by looking (57abad4, 21:59); a gate keys on the actor, never on the clock (13:10 today, item 43).

What this page is not

Not the articles: the six drafts are built on these, and each cites the commits here. Not a paraphrase: every law is its own first sentence, as the harness’s index law requires. Not complete for tomorrow: the laws page in each repository is the record and this is the day’s cross-section; a law found here without its commit is this lane’s or the orchestrator’s, and says so.

The notes this page collected while it was being written

98 dated notes, in the order they were made, from the vault page these laws live on. They are instances, corrections and amendments rather than laws - a law found happening again, a number withdrawn, a rule narrowed - and several of them correct this page’s own earlier claims. They are kept because a rule with its incident attached survives an argument, and because the corrections are the reason to believe the rest.

2026-09-05 18:40 (the summariser law, stream 486): a thirty-ninth, from the retrieval layer. The fetch summariser reported Yang, Luo, Vadillo, Yu & Shanks 2021 as g 0.36, 318 studies, N 14,443, issue 147(3) — twice. The paper’s own text says g 0.499, 222 studies, N 48,478, 147(4). Every number in interactive-and-visual-teaching-the-evidence was then read from the PDF’s text, not from a summary of it. A summary is a claim; the number lives in the text of the page — the judge’s law (a verdict is a bit; the reason is the diff) one layer down. First stated by this lane, 2026-09-05 18:3x, from the agent’s report. Addendum 18:53: the same agent then withdrew eight sources as never fetched, and a third agent’s direct read of the papers verified every one of them - the retraction was itself the unverified claim. The law holds in both directions: neither a number nor its withdrawal is evidence until the page is read.

2026-09-05 19:04 (the fortieth, stream 311): a log that says a step ran is not the step; pull the frames out. First stated by the Sequence lane at 6ad90993 (19:03): a recording’s log read read down the reply while thirteen seconds of byte-identical frames said nothing had moved - a selector that matched nothing fell back silently to an element that does not scroll. The example with the number: frames at t=3 and t=15 identical; scroll distance now reported as 0 to 826 of 826. Its corollaries from the same commit: a denylist of a person’s names is the private data it protects (move it out, ship the tool); a policy that excludes everything passes every test but the anti-vacuity one; and a README’s section on not fabricating can carry a fabricated quote (packages/desktop, packages/mcp for packages/gateway) until a frame is read against it.

2026-09-05 19:37 (the forty-first, stream 497): a gate that cannot count to less than its input is not a gate; plant the empty file. First stated by the Sequence lane at 9bb0ba7a (19:36): the first counting gate reported a test-less file as ran because the runner emits a wrapper event per file; proved by dropping one in - discovered 18, ran 18, exit 0 - and fixed so that ran means at least one real test, re-proved as 18, 17, exit 2, the file named. Addendum 21:44 (harness e55fc13): the mirror’s corollary (158859a0, 21:49): a total cannot say whether the right files shipped - 1,481 shipped, 0 refusals held a run report the policy was not refusing, found only by asking the policy one path at a time; a third question joins the count and the import: the tree at the end against the tree at the start, exit 2 when it moved, because a commit under a running suite is a run that describes no tree - and the lock cannot catch it, since a lock stops a second suite and this is the branch under the first. The example with the number: 331 of 331 across eight packages once the gate could fail, and two defects outside the standing gate found by running what nothing ran. Its corollary against this lane: the registered prediction that the first count would find a mismatch was refuted in seventeen minutes; the value was in the running, not the counting.

2026-09-05 19:47 (the forty-second, stream 500): a skip that returns is a pass; a skipped test is counted as skipped, with its reason printed. First stated by the research agent from what-nothing-runs: two rendered suites in the product pass green on a machine with no browser because their gate is a return inside the test, not a skip; only a console line says so. The example with the number: 2 of 187 in the largest package, vacuously green in every CI run; corrected from 2 of 187 at 19:57: read file by file the count is 80 tests in 560 files across the repository, 55 in four rendered suites and seventeen of them the repository’s security locks (vacuous-green-census); and 44 of 249 harness files that skip conditionally with the reason quoted, which is the honest form. Corollary: ran N of N needs skipped N of M beside it, or the green depends on the machine and nothing says so.

2026-09-05 20:02 (the forty-third, stream 531): an effect you cannot observe is proved by recording the call. First stated by the harness lane at 1ba2b78 (19:57): zero GPU seconds is not provable by reading code, so the refused job is a recording object and the test asserts it was never called - a later version that checked the lock after opening a socket would pass a boolean and fail this. The example with the number: sixteen tests, two of which go red under the one mutation that matters (an unreadable lock read as freedom). Corollary from the same commit: a judgement a component cannot make is one it does not make - staleness needs two facts, so the owner reports the age and decides nothing.

2026-09-05 20:27 (the forty-fourth, stream 608): a character that means something to the layer between you and the file is not the character you typed; write the program to a file and run the file. Five shapes in one day, across every layer: a backslash in a tool write became an escape (the memory note of 2026-09-04); a backtick inside a double-quoted shell string became command substitution and ate a hash (14:41); a heredoc turned \\a in a Windows path into a BEL byte that made a source file binary to grep and a gate red (Sequence e8e1b7ad); a Windows console encoding crashed a runner on a non-breaking hyphen it was printing, after the work was done (harness d378c63, the fourth character-escape failure of the night, and the first on output); and an apostrophe inside a single-quoted Python string inside a heredoc broke this lane’s own script twice tonight (19:50, 20:0x). The example with the number: five failures, one cause, zero of them in the logic. The rule that held all night: the program goes in a file, the file is run by path, and output is written with an explicit encoding.

2026-09-05 21:32 (the forty-fifth, stream 621): a field that two writers fill in two notations is not one field; a comparison that cannot decide answers None, never False. First stated by the harness lane at 9bef317 (21:31): the lock line’s new birth-time field was written as an ISO instant by the note and compared against a file-time integer by the borrowed checker, and the first live lock under the new protocol read as a dead process within twenty minutes of the change. The example with the number: one field, two notations, a live lane at pid=17228 answered False; fixed to parse either as an instant with a two-second tolerance, and to answer None where they cannot be compared. Corollary the lane wrote itself: a protocol changed on a relayed ruling produced a wrong answer about a live lane in under twenty minutes, and only reading the real lock as part of the work caught it.

2026-09-05 22:08 (hashes): the harness commits this page cites as 0cdfb69, 2379a4e were rebased by the harness’s own push (the lock across gate and push retrying once on a rejected ref) and are no longer on a branch; on main they are 0cdfb69 → 9bef317, 2379a4e → e55fc13. The text and files are the same; only the hash moved.

2026-09-05 22:58 (the forty-sixth, stream 638): an instrument that mutates its subject must stop, not redact. First stated by the product’s agent at 7115ddae (22:57): two runs of one build produced different accessibility snapshots, the design had predicted nondeterministic ids and prescribed stripping them, and the cause was the instrument’s own dry run creating a session on every run - the row count moved, not the ids. The example with the number: fifteen contentless sessions accumulated and visible to the user before anyone looked; 4,205 against 4,375 characters; identical hashes once the dry run stopped creating conversations. Corollary from the same commit: a verdict true of nothing tested is a false pass - canvas charts equal 0 held when no lesson was open - so a verdict requires evidence that the thing under test was present, and answers cannot decide otherwise.

2026-09-05 23:19 (an instance for the assembly-drift law, stream 622): the fifth of the day: the migration was wired into the session endpoint and the client hydrates from another, so the API migrated and the screen did not (Sequence da6dc8aa); the endpoint test passed and the product was unchanged; caught by looking at the picture. And a third script failed the way two others had been fixed for, because nothing connected them - a rule fixed in one place is fixed in one place.

2026-09-05 23:33 (an instance for the retraction-is-a-claim law and the picture law, stream 622): the product lane retracted the fifth box is drawn into not drawn, 0x0 in the DOM, and the retraction was wrong from a query that matched non-rendered elements; measured, the box was drawn past the clip (Sequence 48a0553f). And this lane filed visible in the picture from the commit words without viewing the picture, the second time today a lane described a screen it had not looked at.

2026-09-06 00:44 (an instance for the instrument law, stream 664): a parser that silently drops the lines it cannot match reports the gap as the subject’s silence. This lane’s latency regex could not read 1m45s and dropped every call over a minute from the runner log, then reported 192 minutes of held-and-silent card and a change worth 192 minutes; the harness lane’s parse of the same file found the card busy 100% of its locks. The check that was never printed: the count of lines the parser did not match. Third instrument refutation of the night against this lane, after the boundary and the gate’s metric.

2026-09-06 01:43 (an instance for the counting law, stream 622): a refusal on an empty denominator guarded the count of session directories while the line reported the count of registered sessions, so the checkpoint prediction printed MIGRATED 0 of 0 as a pass over thirteen directories the index did not know (Sequence afc821ed). The denominator a refusal guards must be the one the line reports. Found by the run, fixed at the writer and the refusal both. And a second instance of the assembly-drift law in the same commit: the window’s finally rebuilt after the sessions were written, so a same-build comparison was measured across two builds and reported 9 of 9 migrated as though it were the prediction’s number.

2026-09-06 01:48 (the forty-seventh, stream 665): a client deadline above the server’s is not a deadline, it is a comment. First stated by the product’s agent at c6335a19 (01:48): the bench waited 600 s on calls a runtime abandons at about 300, so the deadline could never fire first and eleven hung requests each cost the card the full five minutes, fifty-five minutes of the night; the fix is one assertion, the cap below the server’s, with one retry after a timeout, none after a decided error, and a stop on two consecutive failures with a success resetting the count. Named on the research lane’s read of the two hung requests at 00:32 and placed by the product lane at 01:48.

2026-09-06 01:51 (an instance for the forty-fifth law, stream 5xx): the fourth identity misread in two days, one machine with two hostnames compared by single-name equality (harness 28a8aeb); the harness lane’s own wording of the law: two values from different places, compared before either was normalised. The count is now four of one shape.

2026-09-06 01:55 (the forty-fourth law’s sixth shape, stream 5xx): in a JavaScript template literal an unrecognised escape collapses, so pid=(\S+) became pid=(S+) and a reaper that could never read a pid refused every lock it existed to clear (Sequence 3edafacd). The shapes are now six: the backslash in a tool write, the backtick in a shell string, the BEL in a heredoc, the printed non-breaking hyphen, the apostrophe in a heredoc, the escape in a template literal. And an instance for the forty-fifth: liveness answers three ways and only a definite false clears a lock; born=unknown is refused, not cleared.

2026-09-06 02:01 (an instance for the instrument law, stream 682): a metric that credits the turn after a failure with what the failed turn left behind rewards failure: a stub does not consume its concept, the next turn is counted as given one, and an arm that stubbed less scored lower on the visual it was measured by (Sequence 0790731c). It is the statistic, not the sample; re-running cannot fix it. And this lane read the artifact as a mechanism (three conversations losing their second concept), the night’s fourth correction against this lane’s own reading of a product record.

2026-09-06 02:05 (the instrument instance of 02:01, closed): the corrected statistic makes the two scans identical (Sequence 56bbdb17, 12 and 14 concepts a side, 11 and 14 visuals); the uncorrected fields are kept beside it so the record shows why the judgement changed - the same rule as the ledger’s corrections as blocks, never edits under hashes, applied by the product to its own report.

2026-09-06 02:07 (two instances, stream 5xx): for the assembly-drift law, two definitions of one lock path in one repository, fixed by one import (harness ea4e717); and for the gate: a test that lands on main during a push’s gate is a test the push must re-run after the rebase, since the verdict from before the rebase was about a different tree - the harness’s own gate, which refuses a run whose tree moved (e55fc13), caught its author on the other side of it.

2026-09-06 02:21 (harness hash, rebased): cc85f29 is now ea4e717 on the harness’s main (a push rebased at 02:2x; content unchanged).

2026-09-06 02:21 (harness hash, rebased): a88e499 is now 28a8aeb on the harness’s main (the same push; content unchanged).

2026-09-06 02:37 (an instance for the first law of the product, stream 311): a lesson with no subject gets 87 to 242 words of digest paraphrase that reads as an answer, the identical sentence twice in two conversations (Sequence 406e613c); the design refuses and names what is missing before any seeder, because a wrong subject delivered confidently is worse than no subject delivered honestly, and only the refusal can be wrong visibly. And the design records in advance that building it lowers the bench’s counts, so the direction cannot be misread later - the statistic-that-rewarded-failure trap, written down before it is walked into.

2026-09-06 02:50 (an instance for the card law, stream 5xx): a product check made one model call on the card while another lane held it, because the app’s provider is a config file nobody reads at the moment they run a check and nothing in the app says an ask spends the card (Sequence ad8a71c9, self-reported); the guard written after it answers may I call a model now with exit 3. The kill-number instance beside it: the refusal’s case 6 checks exactly 4 of 13 rather than trusting it.

2026-09-06 02:55 (an instance for the counting law and the checkpoint rule, stream 676): a stage keyed on its output file existing reports already on disk about a read taken against an older tree; a read is a statement about one build and is keyed on the commit that produced it (Sequence bae001e0, caught by the window’s own preflight before its first run). And the card law’s shape: every prerequisite checked before the card is taken, because a window that takes the card and then finds the app down has spent somebody else’s minutes learning what it could have had for free.

2026-09-06 03:27 (an instance for the instrument law and the forty-fifth, stream 5xx): a test held the process handle whose death it asserted, so the pid stayed a live object and the case read None inside a full gate and False alone; a test that depends on when the collector runs fails on somebody else’s schedule (harness b5dffd5). The fifth identity misread of two days, and the first where the product was right: the instrument changed the answer by asking. And a note on proof: the first comparison written to show the fix mattered dropped the reference before the check and read 0 of 25 both ways; reading the branch settled it.

2026-09-06 03:43 (harness hashes, rebased): 7e911b7 is now b5dffd5 on the harness’s main (a push rebased at 03:2x; content unchanged).

2026-09-06 03:44 (three instances, stream 5xx): the instrument law twice - a sandbox whose interpreter was the runner’s own uv-managed one refused the install, the runner’s machine contaminating the measurement; and a runner that waited nine minutes on a script PowerShell never parsed, now parsing before launching and naming the line (harness c737eba). And the forty-fourth law’s tenth fault: a Windows path in a generator string whose drive prefix became a unicode escape. What the run settled: a fresh machine has no git, so an archive URL and pip are the install, and two of four README usages were written for the author’s disk.

2026-09-06 05:07 (two instances, stream 5xx): for the gate law: a case another gate answers first is not a case - the added-fact rule’s stashed case was green with the rule deleted, because the specifics gate refused its row on invented names; rebuilt with one added word and a companion that requires the row to reach the judge (harness 344000b). For the forty-fifth: a reader whose release pattern could not take a trailing field read a release as a take and reported three holders where one was open; the fix reads the first word before anything else and fails towards fewer holders. And the fixtures’ shared reason, a rewrite for one row handed to another, is the assembly-drift shape in a test file.

2026-09-06 06:04 (two instances, stream 496): for the instrument law, a void that hashed bytes where it meant content fired on a reordered serialisation with zero fields changed (Sequence 4bdb7e00); hash the parsed document. And a law-shaped sentence the product lane wrote that this page adopts as an addendum to the kill-number law: an unfired kill whose conditions were never measured is not evidence of safety - two thirds of the seat’s kill could not be measured on one completed run, and this lane had written the kill unfired as though it meant something.

2026-09-06 06:05 (the fourth law’s sharpest instance, stream 4xx): a bench that calls the pipeline directly measures the pipeline, not the product, and next-picture is a two-turn contract in a one-turn harness (Sequence 4b94221b): seven questions, zero reveals, the reveal living in a round-trip the bench never makes. And the counting law again: the report carried no field for the cap the code decides on, so the largest bucket of gated turns cannot be confirmed from the files.

2026-09-06 06:06 (an instance for the kill-number law, stream 4xx): a kill number set where the dangerous outcome is not zero but a handful - at least five reveals from a seven-question rate, because three would let a percentage be computed off nothing (Sequence 594d856d). And a design that corrected its own ordering by a sentence already on it: a product defect confirmed card-free outranks three instrument repairs.

2026-09-06 06:08 (an instance for the instrument law, stream 311): a harness whose control fails is a harness, not a finding: a reproduction of the thread-id defect twice reproduced the test’s own artifacts, a wrong root and a missing index version, and only the control case failing told the author each time; without it two artifacts would have been published as product defects (Sequence 9887b45b). The control is the case that makes the others mean something, the seeded pair’s rule again.

2026-09-06 06:13 (an instance for the forty-fifth and the instrument law, stream 496): an unreadable file is not evidence of sameness - the content hash falls back to bytes when a file will not parse, the lock’s cannot be decided in a hash (Sequence 5b2f21a2); and a repair that could be a weakening carries the case that proves it is not: one changed field must still change the hash. A syntax check passed an invented identifier that a grep caught.

2026-09-06 06:20 (two instances, stream 529): for the instrument law, an equality over verdicts where a failed call is None scores two failures as agreement, in the direction that flatters the run; count over comparable rows, print the denominator, and never print the stronger sentence when a call is missing (harness e48996e). And for the kill-number law: an expectation is not a probability - twelve rows expected five against five needed and clears 60% of the time; the page carries the table and the two corrections that moved the same number twice the same way.

2026-09-06 06:26 (two instances, stream 4xx): for the assembly-drift law, the carry of a two-turn contract extracted as one function both the product and the bench call, with a source case forbidding a second definition, and the cap left with no second definition either (Sequence 69a3498f); and for the kill-number law, a kill written so that a handful is a kill and not a pass - one to four reveals kills the carrier, because a band scored on four answers is not a band (41173e34).

2026-09-06 06:33 (an instance for the forty-seventh and the kill-number law, stream 665): a deadline set from the machine’s own spread rather than a round number - 240 s, above p99 and below the slowest honest row, close to free on honest traffic because a retry at the median costs what the slow call would have - and a cap chosen never to touch an honest call would be indistinguishable from the server’s own limit (harness ff8c48d). Retry on a hang, never on a decision; count consecutive failures, never cumulative; a test that waits 240 s is a test nobody runs.

2026-09-06 06:34 (two instances, stream 311): for the product’s first law, a guess about which conversation a person meant is refused where the consequence lives, since a lesson filed against a conversation they were not having is a false record of what they were taught (Sequence a180b036); and for the gate law, a field with a server half, a wire type and a tested mapping can still never be sent, because nothing tested the mount - the second such field in this client, and the test file exists for that shape.

2026-09-06 06:38 (an instance for the fourth law and the witness law, stream 492): a public page that says what each claim is checked by, not only that it is checked, and names the one property whose cases pass and whose run has never shown it (Sequence b6bef154); not claimed shrinks only where evidence reaches, and a bench measurement does not clear a seat line.

2026-09-06 06:45 (an instance for the gate law and the fifth assert, stream 5xx): a gate whose only proof of being able to fail lives in a commit message has no test of its own, and the first law binds the instrument as much as the product (Sequence e0d6d9ca); a zero count is refused rather than printed green, and a fixture is not a stranger, so portability is proven only by the kill number against outside repositories.

2026-09-06 07:06 (two instances, stream 5xx): for the counting law, a check whose roots did not exist examined no files and printed 0 unreached as though it had looked, the gate’s most valuable half inert on any repository but this one (Sequence 69ad49f3); and for the instrument law, a test runner’s own environment variable changed the answer the test was measuring - a gate that behaves differently inside a test than outside one cannot be tested at all - stripped.

2026-09-06 07:14 (the forty-eighth, stream 5xx): a count that does not say distinct is not a corpus size. First stated by the harness’s agent at 07:16 on 2026-09-06 (harness 84caa2a, 07:59): every corpus count of the night counted duplicate rows as rows - the 164 kept were 127 distinct, the 156 kept by both passes 119, the 95 three-gate rows 60 with one pair appearing seven times - because the generator draws from 49 source answers with one degradation type and nothing deduplicates, so a line of 100 was measured against 95 and stood at 60. Confirmed by the research lane from the files before any page moved. Every ratio computed over rows stands as a ratio; no count stands as a corpus.

2026-09-06 07:17 (an instance for the counting law, stream 5xx): the instrument that asks whether a run describes the tree left its own 198 tests out of the tree, because it read one script name and they ran under another (Sequence e5ae2de3); the package declares the name, the gate learns none; and the fix’s first run caught its own regression, an empty directory counting as a package, which is a case doing what a case is for.

2026-09-06 08:00 (the forty-eighth’s commit, and its addendum in the harness lane’s words): harness 84caa2a carries the finding with one thing worth more than the number: noticing a thing, coding around it, and not asking what it costs is a different failure from getting a number wrong, and a worse one - the duplicates were met while writing the id file, commented on, worked around with first-occurrence-wins, and never counted, and that ran under every decision about whether the corpus was big enough while the night’s arithmetic errors were caught within the hour. And the dedup gate’s first version was inert, a lookup taking a row where the caller passed a triple, every duplicate reading as new; all six refusal cases failed at once, which is the only reason it was caught.

2026-09-06 08:12 (harness hashes, rebased): 581e493 is now 84caa2a; bfff9c5 is now e48996e on the harness’s main (a push rebased at 08:0x; content unchanged).

2026-09-06 08:13 (the forty-fourth law measured, two harness items): the guard catches 5 of 10, the file refusing to parse catches 4, and 1 of 10 is caught by neither - a separator that collapsed into a real line break inside prose, a valid file with wrong content, no control character, in a docs tree no guard scans; what is corrected is the claim and not the code, since a guard whose coverage is overstated is worse than one whose coverage is small and known (harness 2d1a27e, 05:30). And the rate the next item asked for cannot be computed: git records which files a commit changed and never how the change was typed, so the heredoc denominator does not exist; what the record supports is 10 of 10 faults in content that passed through an extra escaping layer and 0 in the 20 files written directly, 11 of which held a backslash in a string or a regex and had the opportunity; the controlled experiment proved nothing because the same path by both routes came out right when escaped right - an experiment that can only demonstrate the safe case is not an experiment - so the rule stands on the 10 and 0: content with a backslash is written as data, never typed through a shell (harness effb505, 06:57). The same rule this lane keeps as backslashes-die-in-tool-writes, now with the harness’s denominators.

2026-09-06 08:16 (the fourth law’s sharpest form for a product, stream 311): one rule in two packages with separate builds, each half with passing tests, and the product without the rule for six hours - a refusal that passed seven cases and a live API check was gone from the app because the browser served the previous night’s bundle (Sequence f8c086c5); a bench that calls the pipeline directly measures the pipeline, and so does a server test against a client that was never rebuilt. The seat, which drives the app, is what found it. And the card law: the guard that answers a script does not answer the product’s own ask path; the second call on a held card tonight went through it.

2026-09-06 08:31 (two instances, stream 496): for the card law, a guard on scripts does not guard a person’s ask through the product, and the seat now reads the lock before it types (Sequence 7e98c917); for the instrument law, the probe that would answer would this ask be refused is the call being avoided, so the verdict is computed one step earlier from the product’s own function, picking the error direction that costs a skipped run rather than a spent card. And the forty-fifth again: an unparseable lock is unreadable, not permission.

2026-09-06 08:36 (two instances, stream 496): for the witness law, a fixture reconstructed from a run whose original bytes are gone says reconstructed rather than implying an authenticity it no longer has (Sequence cf1a04bb); for the counting law, the gate that had just learned to count its own folder caught, on its second push, a test whose fixture the instrument rewrites - a test whose fixture the instrument rewrites is not a test, the sixth seat rule to refute itself first.

2026-09-06 08:48 (two instances, stream 311): for the fourth law, a restart that reloads disk and cannot rebuild a bundle reported success for six hours over a product missing half a commit; the check now names the half and the restart rebuilds it first (Sequence d88733c4); for the assembly-drift law, one reader for both callers of stale, because two callers deciding it separately is how the two halves went uncompared. And a source case that the rebuild comes before the restart, since the other order is exactly what happened.

2026-09-06 09:44 (three instances, stream 495 and 529): for the instrument law, a clock that ticks at 15.6 ms printed an overhead of 0.0 against a bar of 50, and a zero beside a bar looks like evidence and was not (harness d8fcb24); for the kill-number law, a kill condition whose parameter was never sent is untested and not failed, and a line that reported it as failed is withdrawn; and for the registration law, a pair that changed two things against its own docstring is void as registered and succeeded by two runs of one change each with bands that do not overlap.

2026-09-06 09:55 (harness hash, rebased): 2b74ccc is now d8fcb24 on the harness’s main (a push rebased at 09:4x; content unchanged).

2026-09-06 09:55 (the forty-fourth law’s docs tree, item 69): the tree nothing scanned held 2 control characters across 84 files, and both were the record of a fault carrying the fault - a law describing the backspace fault containing a real backspace where it meant to quote the escape, and a quoted error path whose escape had become a bell, a path a reader might copy that was silently not the path (harness 4d980a1, 08:28). Item 67’s widening the guard would flag the ordinary was too pessimistic: true of the newline sub-class only, since a line break in prose is ordinary and a bell is not; the five characters nobody types on purpose are as anomalous in a document as in a fixture, and nothing had ever looked. The planted case found a hole in the new scan, which is why it was planted: the first version searched line by line, and the line splitter splits on vertical tab and form feed as well as newline, so two of the five characters it claimed to detect were consumed as boundaries before the search began and could never be found; it searches the whole text now and all five are caught when planted one at a time. The re-scan after the fix still reports 2, so the original count was right by luck rather than by method - written down because a number that happens to be correct teaches nothing about the instrument that produced it.

2026-09-06 10:12 (three instances, stream 4xx): for the kill-number law, a kill written so that a handful kills fired on three of eleven and refused a percentage (Sequence fee82004); for the registration law, an analysis by elimination redone from the recorded quantity and restated rather than patched, its largest bucket becoming an open question; and for the instrument law, a guard whose deadline read a string field was undefined for a whole window and held by its default - right by default, like a count right by luck, and worth writing down for the same reason.

2026-09-06 10:16 (an instance for the counting law, stream 4xx): a function with five ways to return nothing that look identical from outside is a bucket the report cannot split, the cap finding one layer deeper (Sequence 7db93a00); the hypothesis written for it was refuted from the data on disk within an hour, and the bucket is left open rather than filled with the most plausible of five. And the reading that survived: a mixed-direction chart never produces a question, 0 of 22, a small one never, 0 of 7, and uniform is necessary and not sufficient.

2026-09-06 10:17 (an instance for the registration law, stream 4xx): a claim written on the quantity under test and not on its product - landable questions rather than reveals, since reveals are two things and one is under test - with a refuter on the contract’s rates that fires regardless of the result, and a written refusal to run until the denominator’s hole is explained (Sequence e88341c9). Clearing two of three is to be reported as what it is, a moved ceiling and an unreadable band, and not as a near-miss.

2026-09-06 10:37 (three instances, stream 4xx): for the counting law, a bucket guessed at twice and wrong twice closes only when the code records its own reason, from one body so a reason cannot explain an outcome that did not happen (Sequence 85e74240); for the witness law, a correlation checked and refused as a cause stays on the record as a correlation, on the not-claimed list, because it is the kind of number that becomes a rule if nobody writes down the refusal; and for the instrument law, nine identical answers from a harness should look wrong before they are read, and did.

2026-09-06 10:43 (an instance for the owner’s attention, stream 4xx): a design question is not raised to the owner on a mechanism that explains one case in nine, because his attention is the one resource this record exists to spend well (Sequence ac5fdc0e); and four readings of one bucket, three refuted and one withdrawn, all plausible on data that never carried the quantity the code branches on, are the counting law’s argument for recording the reason instead of reading a fifth time.

2026-09-06 10:52 (two instances for the mirror, stream 492): a script that left a scratchpad carried the scratchpad’s home path, and only the mirror’s refusal grep would ever have seen it (Sequence dd2a0c9d); and a hostname names a person’s computer as surely as a username, which no shape pattern covers, so it goes in the excluded denylist - the denylist being safe to keep exactly because the mirror does not ship it.

2026-09-06 10:57 (an instance for the registration law, stream 4xx): a lever for one arm built to touch only what that arm is about, with a source case that forbids it reaching the product, so the result stays attributable (Sequence cead6cea); and its zero setting proven byte-identical to the past, so every figure on record still describes the bench that made it. Its own module, because a bench that runs on import cannot be imported by a test.

2026-09-06 11:07 (two instances, stream 529): for the registration law, a registration can predict the very condition that makes its other half untestable - a pair losing one call in seven can never reach an agreement band however long it runs - so the successor carries a stop rule keyed on the hang rate (harness 54ce7ff); and for the honesty of a finding, established and not established stated side by side: temperature 0 hangs the runtime; a seed alone is not shown harmless; the cause is unknown; and the practical consequence, that the judge has no known remedy on this wire, written rather than left for a reader to infer.

2026-09-06 11:30 (stream 5xx, the law as a check): the forty-eighth law is a check now, and it goes red on a count with nothing after it (harness 3968679, 11:29; a_count_says_what_it_counts.py, twenty-one tests, six red when the check is mutated to never fire). kept: 164 was read as 164 training examples for two days because a bare number says nothing about what it counted. The repair is not to count more carefully: a count line carries its unit, a distinct count carries the key it was distinct over, a bare one turns red, and a distinct count with an empty key is refused, since 127 distinct is the same lie one word shorter, telling a reader duplicates were removed without saying what was compared, and two keys give two answers. The rule is narrower than the ask and the tests say so: every count carries its key cannot be enforced by regex; this catches a number with nothing after it, the shape the real failure had, and passes kept 164 dropped 36 on the 164, because telling a unit from the next field needs a lexicon, and a check that guessed would be switched off the first time it was wrong - narrow and trusted beats broad and ignored; it stands aside for ratios, percentages, durations, N of M which names its denominator, dates, hashes, seeds and indices. Three tests asserted behaviour the code did not have and were corrected rather than the code bent: one demanded a noun-verb distinction no regex holds, now a stated limit; one expected both counts caught where only the trailing one is; one asserted on a sentence that quotes kept: 164 as its worked example, now on the structured result. Gate 4,385 of 4,385.

2026-09-06 11:53 (harness hashes, rebased): 4661e05 is now 3968679; a3f8f85 is now 54ce7ff on the harness’s main (a push rebased at 11:3x; content unchanged).

2026-09-06 11:54 (stream 5xx, items 72 and 73): two harness items, both the forty-eighth law asked of the lane’s own numbers (surfaced by the rebase). Item 72 (harness a87bf94, 10:53): the two-day audit re-run against the code that produced each number rather than memory - the gate 4,370 counted and 4,370 distinct test ids; the one-click check 13 of 13 page lines; the router’s 60 tasks 60 distinct; the mirror’s 746 shipped paths 746; the laws index 39 of 39; the docs scan 0 of 0 - seven of eight survive and the one that fails is the author’s: 50 content hits across 26 files was 50 rule matches over 27 distinct places in 26 files, 21 of them tripping two rules at once, a home path being both a personal identifier and a real directory, one string counted twice, overstated by about 1.9 times; the conclusion was zero either way and it is still the wrong number to have given; the report prints places and matches apart now. And one number has no denominator to audit at all: ten backslash faults is a hand count of incidents read out of commit bodies, one or two depending on where a line is drawn, produced by no instrument and checkable by none, the only number of the two days resting on the author’s bookkeeping, to be read that way - which this lane’s forty-fourth entries carry as ten and now carry as a hand count. Item 73 (harness 5ad965a, 11:25): the guard against publishing a person ran 4 of its 11 rules everywhere but here, and passed - the identifier list is gitignored because it is the private data it protects, so it exists only on the machine that wrote it; with it moved aside the scan runs four rules, finds nothing, the mirror prints 0 hits across 746 shipped files, and the test reports OK; on CI, in a fresh clone and in every other lane’s checkout the guard had been running a third of itself and calling the tree clean, the shape of defect the repository exists to refuse arriving inside the thing that refuses it, surfaced only because item 72’s re-measurement warned on stderr. The fix is a split, not a louder warning: the four shape rules need no private data and run unconditionally anywhere, and they are not the small half, having caught 25 of the 50 matches, the whole home-directory class, proven red with the list moved aside and a home directory planted on both platforms’ shapes; the identifier half skips when the list is absent, names how many rules ran, and says in the skip that it is not a clean bill - a skip is neither green nor red, the gate’s own exit 2 in another place; the mirror’s report carries its coverage, 0 hits over 11 rules or a sentence naming what did not run, because 0 hits from a third of a scan is not the same sentence as from a whole one.

2026-09-06 13:24 (two instances for the registration law, stream 4xx): a clause that compares per-turn rates across arms while the condition changes the number of turns measures a denominator the condition itself altered - the right form is absolute counts on matched turns, or rates over the first N turns of every arm (Sequence e04f454f); and a refuted floor is reported as refuted while the reading it invites is declined, since a well-measured 47% against a 75% that was three of four is the first honest estimate of that rate and not a degradation. The registration’s own estimate of 56 to 70 minutes cost 86.

2026-09-06 13:30 (the forty-ninth, stream 4xx): a clause comparing rates across arms of different lengths measures composition, not quality. First stated by the product’s agent at 96990eb1 (13:29), in the words the ceiling result earned: the clause said the teach contract must hold, the condition under test was a longer conversation, so it compared per-turn rates across arms whose turn count the condition itself changed; it refuted at check-in 4 to 6% against 11 to 14, and on the first two turns, the control’s own shape, every rate holds, the whole fall being the added turns, which ask nothing while drawing at the same 69%. A clause that fails this way fails loudly and wrongly, which is worse than one that cannot decide. And beside it, an instance for the instrument law: a gate failure reported as an unattributed flake was deterministic, the index counting tracked files and the run happening before the staging; it was called flaky because the failing line had been discarded, and that line was the whole answer.

2026-09-06 13:41 (three instances, stream 311): for the assembly-drift law, a ruling that must reach two callers goes in one predicate both call, because those two had already drifted once on this very rule, the bench advancing on a question mark and the product on an honest check (Sequence 96aaeea8); for the counting law, a gate that wrote a reason only when every other condition had passed left 27 of 52 turns silent and four wrong explanations in the record, and now names one reason in the order it tests; and for the witness law, a guard whose literal expectation the refactor invalidated was made stricter rather than deleted, asserting both sides call the shared function and neither keeps a copy.

2026-09-06 14:01 (an instance for the witness law and the first law, stream 5xx): the model was asked to write about a system it had never been shown - 0 of 2,884 file edges in the prompt - while the product drew a picture from those edges beside it, and nothing in the turn reconciled the two (Sequence 8192f472); a claim in prose and a claim in a picture, from two different bodies of evidence, presented as one answer. And the counting law in a new place: 46% of every prompt was rules for tools called on 1 turn of 104, which nobody had counted until somebody counted the prompt.

2026-09-06 14:07 (the fourth law again, at seven minutes, stream 5xx): a measurement taken on the bench was read as a measurement of the product, and the two differ exactly where the client is involved: the product’s history carries 20 file names and 12 tool names a turn, the bench sends role and text (Sequence 37a8639e). Caught by reading the renderer before building against the number, which is the cheapest place it has ever been caught - the same law that cost six hours this morning cost seven minutes here.

2026-09-06 14:11 (two instances, stream 5xx): for the first law, prompt material nobody produced is the same fabrication as an invented edge - a carried note is the turn’s own sentence, never a summary the carrier writes, and a refused turn leaves no trace (Sequence 656701d7); and for the witness law, a bound that degrades rather than drops and reports what it dropped, because a model told nothing about what it has forgotten will speak as though it forgot nothing. Beside them, an asserted 300-token budget that had never been measured came out at 339, and the bound moved to fit the measurement rather than the caps moving to fit the assertion.

2026-09-06 14:22 (the fiftieth, stream 5xx): a kill number must be a quantity the change can move. Twice in one day a clause was registered against a number the build could not touch: the ceiling condition’s contract clause, which compared rates across arms whose length the condition itself changed, and the carry’s 40% repeated content, whose numerator is a digest and a belt the carry never touches (Sequence e04f454f, 876ee1b5). Both were chosen for the finding rather than for the build, and both failed loudly and wrongly. The check before registering: name the quantity, then name the line of the build that changes it; if there is none, the number belongs to a different change. Stated by the product’s agent as the forty-ninth law’s neighbour and recorded here as the fiftieth.

2026-09-06 14:32 (the fiftieth, stated by both lanes within ten minutes): the product lane records the same rule as its sixth law at 6c469b45 (14:29), in its own words: a registration states which quantity the build touches before it states a threshold, and a threshold on any other quantity is a watch-line. Two lanes reaching one law from the same two failures, and the second half - the watch-line - is the part this lane’s fiftieth did not have: a number worth reporting and not worth killing for, named as such before the run. The prefix-once registration applies it to itself, keeping coverage as a watch-line because coverage is already near zero and has no room to fall.

2026-09-06 14:43 (the fiftieth working, and the first law extended, stream 5xx): the third application of a kill number must be a quantity the change can move caught the mismatch before the build, which is what the law is for: the quantity was named, the arithmetic showed 97% could reach only about 73% against a 40% target, and the registration closed without a run (Sequence bde11181). And the first law reaches the prompt: a stateless wire has no earlier turn, so the workspace was given earlier would be a false statement placed in the prompt, which is the same defect as an invented edge. A measurement that ends a registration before it runs is the cheapest outcome on this record.

2026-09-06 14:54 (the fiftieth’s fourth application, with two additions, stream 5xx): a registration that names the section it touches before any threshold, sets that threshold against its own arithmetic ceiling, makes a clause a watch-line where the base rate cannot resolve it, and declares a void condition rather than a refutation for the outcome that would mean two sections are coupled (Sequence d1913144). And the risk named as a risk: a rise is as much a failure as a fall - a model no longer told how tools work may call them wrongly, and that is a failure even if every token figure improves.

2026-09-06 15:06 (two instances, stream 5xx): for the witness law, a flag with no default that could turn it on protects every figure already on the record - a flag defaulting on would silently redefine them all - and its cases are source-scanned because what they guard is which section is gated rather than one rendering (Sequence 0c928ea2); and for the card law, a runner that refuses a condition whose mechanism is not in the build rather than spending an hour and a half producing a control run twice.

2026-09-06 15:21 (a law’s hardest instance yet, stream 5xx): for the witness law - a remedy that makes a run repeatable can remove the detector rather than the defect. Seeding this annotator takes its self-agreement to 72 of 72 and leaves 8 wrong rows in place, the same eight every time, where the two-pass check caught 11 of 16 under sampling. Determinism is a property of the wire, not a warrant about the answer, and a reproducible number with no way to notice it is wrong is worse than an unstable one that shows you its own error set. And a second instance for the naming law: temperature was the cause and the seed was carried along and blamed with it for a day, because no run had ever sent one without the other.

2026-09-06 15:24 (the fifty-first law, row 39 of the afternoon table, ruled as Max): the orchestrator asked whether the third length overrun is a law of its own rather than an instance. It is - the fifty-first by this page’s running count, row 39 in the table - and the general form is not about characters: a limit checked after the work is written is a report, not a constraint. Three instances, all in the same direction, all caught by counting and none by reading. It is the first law’s cousin - a gate that can only fire too late is a measurement, not a gate - and it earns its own line because the remedy is different: the first law says make it able to fail, this one says move it earlier.

2026-09-06 15:31 (the fifty-second law, row 40, the orchestrator’s wording ruled in): a thing described as generated is a claim about a process, and the claim is checkable by looking for the process. From the laws strip itself: described as regenerated, no generator anywhere, five blocks and a row behind. It is on this page rather than in a session log because the defect was in our own publishing path and was found by running the process rather than by reading the sentence that claimed it.

2026-09-06 15:40 (the first law, found in an outside harness’s record, stream 708): the Codex CLI’s patch_apply_end carries success on 507 of 507 records and success: false appears zero times, with no error, failure, abort or rejection event type anywhere in its schema - while exit_code in the same 159 sessions is 1,112 zeros, 177 ones, 4 of 127 and 2 of -1. A field that has never once been false is not a record of success; it is a gate you cannot make fail, and this is the first time this page’s oldest law has been demonstrated in a harness nobody here built.

2026-09-06 15:44 (the fiftieth’s fifth application, at a grain rather than a quantity, stream 5xx): a kill number must be a quantity the change can move has a sibling this afternoon proved on this lane’s own work - a threshold must be set on the quantity it will be applied to, at the grain it will be applied at. A net of -339 words across four pieces was written into a standard as a per-piece pass/fail; per piece those four run +209, +52, -66 and -534, and three of the four grew in the half that was supposed to shrink. The aggregate was real and the rule made from it was never true of a single member. Filed as an instance rather than a new law, because it is the fiftieth read at the wrong grain.

2026-09-06 15:46 (the first-law instance bounded, stream 708): the Codex patch_apply_end finding - a field never once false in 507 records - does not generalise, and the second trace is why: Claude Code’s is_error is true 2,455 times in 105,056 results. An instance found in one outside system is an instance, not a property of the class, and the way to find out which is to run the same script on a second one before saying it. Filed against the instance above rather than as a new law.

2026-09-06 15:59 (the fifty-third law, row 41, first stated by the product’s agent): a record that can only be written on success is not a record, it is a receipt. It has three instances and one of them is outside this house - Codex’s 507-of-507, the carry’s failed read that leaves no trace, and the counting gate that learned it separately. The lane’s row 33 measurement is what prompted the look, which is the first time a research finding here has gone back into a product tree and found something. Not fixed mid-window, deliberately: rebuilding now would put two arms of one condition on two builds.

2026-09-06 16:02 (the count law, pointed here): this page carried three different numbers for one quantity - fifty-two in the description, forty in the table, thirty-nine in the status line - and a reader met two of them before reaching a law. Reconciled in ## What this page counts: 41 from the day, 15 carried in, 56 in all, none held back. The running ordinal in the dated blocks is a second numbering and is named as one rather than quietly dropped.

2026-09-06 16:11 (the fifty-fourth law, row 42, first stated by the product’s agent against its own run): a control taken before an unrelated change is not a control. Its instance cost two hours of card time and returned one clean answer and one unreadable one, and it was reported by the person whose control it was. The count section above moves to 42 from the day and 57 in all.

2026-09-06 16:14 (law 42’s first application, and the first law on this page to prevent a cost rather than explain one): an hour after it was stated against a spoiled run, law 42 was applied to the belt condition before that run began (Sequence e1070e5e). The registered control - the ceiling arms of 14:58-16:24Z - predates two shipped changes, so a belt arm against it would have differed in three changes and been unattributable in exactly the way stage one’s repeats number was. A valid control already existed and cost nothing to find: the carry arms of 19:06-20:08Z, on the build carrying the belt flag with the flag off, same four turns, one difference. And the disposal is the part worth keeping: the registration is not rewritten and both controls will be reported, because changing a control after a run has started is what registrations exist to prevent, and if the two readings disagree the disagreement is the finding and the belt gets a clean re-run rather than a verdict. Every other instance on this page today explained a cost after it was paid; this one is the first that stopped one.

2026-09-06 16:18 (the fifty-fifth law, row 43, and this page is the worst offender): a reference that someone else can move is not a reference until something re-resolves it. Seventeen dead commit citations across the publish tree, fifteen of them live, ten of the fifteen on this page. All seventeen resolved by subject; the working copies are repointed and the checker now re-resolves every one. The count section moves to 43 from the day and 58 in all.

2026-09-06 16:19 (the citations repointed, and the mapping, so nobody reads this as a quiet rewrite): every dead hash on this page and on the other spec pages has been repointed to the commit that now carries the same subject and the same content. The commits were not lost, they were renumbered by a rebase on push, and a rebase preserves the subject line, which is how each one was matched and checked. The old numbers are kept here rather than deleted, and are written without backticks because they are labels for something that no longer exists rather than references to it - which is also what stops the checker reading them as live citations:

cited as	now
07edc08	71e3691
0cdfb69	9bef317
2379a4e	e55fc13
2b74ccc	d8fcb24
45954c8	3a50ec0
4661e05	3968679
581e493	84caa2a
651b2fd	b399940
6c281ee	ebf5dac
76602af	576e52f
7e911b7	b5dffd5
a3f8f85	54ce7ff
a88e499	28a8aeb
b7690ca	d378c63
bfff9c5	e48996e
cc85f29	ea4e717
e4b227e9	3db7bb23

The session logs are not repointed, because a log saying at 15:58 this hash existed was true when it was written and is a record rather than a reference.

2026-09-06 16:21 (law 42 proposed and adopted, in that order on their side and the reverse on mine): the product lane proposed the control law at 16:14 with the incident as its evidence, and this lane had already ruled it in at 16:11 on the same run - which is the cleanest kind of agreement available, two readings of one incident reaching the same sentence without conferring. Their argument is now in the row: a badly formed clause refutes and irritates; a badly chosen control confirms and persuades.

2026-09-06 16:25 (the fifty-sixth law, row 44, proposed by the product lane and ruled in - and this lane’s own repair is its evidence): evidence a reader cannot open is not evidence. Ruled a separate law from 43 because the remedy differs: 43 says re-resolve a reference that drifts, 44 says never cite from a working tree. My repair of the dead citations cited 71e3691, which was then on this machine and not on the remote, on two pages that are live. The checker’s criterion is now origin/main rather than HEAD and it failed on that hash immediately.

2026-09-06 16:27 (the checker is red, and is left red on purpose): the one remaining failure is the mapping table’s right-hand column, where 71e3691 is a genuine reference to the commit that now carries the seeded pair - and it is not on the harness’s remote, so no reader can open it. Removing its backticks would silence a true failure, which is the thing this page has laws against. It stays red until the harness pushes, and the owner of the fix is named rather than assumed: the harness lane. And a correction to my own commit subject at 16:26, which said “checker green” when the run was exit 2 - I wrote the claim before running the check that would have contradicted it, on the same turn I ruled in a law about evidence.

2026-09-06 16:30 (the gate went green at 16:30, and the hash is a reference again): the harness pushed; 71e3691 is on its origin/main and the citation is backticked again. It was a label for forty-five minutes because a label was true then and a citation was not. Re-checked from the reader’s end rather than assumed: 181 citations across the twelve live pages, 0 unopenable, on both lanes’ criteria.

2026-09-06 16:32 (the verify-the-instrument law, its best mechanism yet, from the orchestrator against its own check): a first verification of the served laws page reported 39 dead links, and the check was wrong rather than the page. Its character-stripping set contained c, o, d and e, so it ate those letters out of every hash it extracted - 84caa2a came back as 84aa2a - and every hash it then looked up was a hash nobody had ever written. Re-run properly: 0 of 103. The mechanism is worth keeping because it is not a typo: a set assembled for one purpose, stripping punctuation, silently redefined the identifiers it was passed. An instrument that transforms its input before checking it is checking something else, and the failure mode is a confident number in the right shape. It sits beside this lane’s own 39-of-72 latency parse, where a regex that could not match 1m45s reported 192 recoverable minutes that did not exist, and beside the 16:26 commit subject that said the checker was green when the run was exit 2.

2026-09-06 16:32 (a publishing fact worth recording, checked across all twelve live pages): the site drops the H1 - none of the twelve served pages carries one, the title being rendered from the frontmatter. So a count in this page’s title never reaches a reader, and the two that do are the description and the ## What this page counts section. A load-bearing number must not live only in a heading the publisher removes.

2026-09-06 16:37 (the regression found, its cause named, and a blind spot of mine removed): the orchestrator’s gate refused the 44-row strip on eleven distinct backticked dead hashes, including 07edc08 inside law 44’s own example - the fix was being undone by the thing that publishes it, which is law 43’s shape one level up. The cause was my own repair script. Restoring the left-hand side of 73 rebase notes, it wrote the old hash in backticks; the mapping table stayed plain, the notes did not, and the strip copied them out. And my checker was silent because I had exempted the whole line an hour earlier - any line saying rebased or is now was skipped, which hid a class rather than a case. Their gate had no exemption and caught it. Both are fixed at the source: 111 dead hashes across 28 files are now plain labels, and the line exemption is gone, so a backticked hash is a citation wherever it sits and a dead one is written as what it is. Not automated, deliberately: the transform ran once under review, and the 32 occurrences not on a rebase line were reported and left alone, because an automatic demote-if-unresolvable would have silenced 71e3691 an hour ago when it was a real reference to an unpushed commit. The orchestrator’s line, and it is right: a gate stops a person and makes them look; it does not quietly rewrite. And the record is no longer invisible: the checker now reads 10-Signals/specs too - 314 hashes cited, 10 a reader cannot open - and reports without failing, because a log entry naming a hash that was later rebased away was true when it was written.

2026-09-06 16:47 (law 43 applied to the gate that enforces law 43, from the harness lane via the orchestrator): origin/main is a local cache of what the server last said, so ancestry against it answers about the cache. My checker never fetched; its verdicts were about whatever the last hand-fetch had left behind. It now fetches first and refuses to answer - exit 3 - when it cannot, because a false pass ships a dead citation and a false failure blocks a good page. Proved able to fail before being trusted: run against a planted git repository with no origin remote it exits 3 in under a second, and against the two real repositories it answers in 2 seconds without refusing. And a gate that hangs is worse than one that fails: the first version put an unbounded network call inside the check and the run did not return, so the fetch is bounded at 20 seconds with the credential prompt disabled - a timeout is treated as cannot refresh, never as fine. A bad test is not evidence either way: my first attempt at proving the refusal copied the whole checker with REPOS rewritten and ran it from the temp directory, where its own path assumptions broke before the guard was reached; it produced no output for ninety seconds and I nearly read that as a hang in the guard. The proof that stands executes the guard’s own eighteen lines, extracted verbatim from the file.

2026-09-06 16:49 (the fifty-seventh law, row 45, and the pairing that found it): an exemption written at the wrong granularity removes a class, not a case. Proposed back to this lane by the orchestrator out of this lane’s own account of its defect, which is the right way round for a law about not being able to see your own blind spot.

The pairing is recorded and deliberately not made a law yet. Their gate caught what mine was built to miss for one reason: it had no exemption, and it had none because it was written before the problem was understood well enough to carve one - which is luck, not judgement, and they said so. What is not luck is that two checks with different blind spots caught what one better check would not, and that where they disagree is where the defect is. It stays a note rather than a row on one instance and a lucky one. The condition for promoting it is stated now rather than judged later: a second disagreement between the two checks that finds a defect neither would have found alone.

2026-09-06 16:52 (my bound proof was the wrong case, and the orchestrator’s correction applies to mine): I proved the refusal with a remote that does not resolve, which fails fast - so it exercises the fetch returned non-zero path and would have passed with no timeout at all. It is not evidence about the bound. The case at risk is a remote that stalls. Re-proved against git://192.0.2.1 - TEST-NET-1, reserved and non-routable by RFC 5737 - the guard exits 3 after 20 seconds rather than never. The rule this is an instance of, and it is the sharper form of the ninety-seconds-of-silence note: a proof that exercises a different mechanism than the one you are claiming puts a real-looking symptom on the record with a false cause behind it. Both lanes chose the same wrong test independently, which is what makes it worth writing down rather than the fix.