A Governor Test That Never Ran: The Setup Failed, Not the Governor. Release is also Love →∞❤️

Nov 13

A Governor Test That Never Ran: The Setup Failed, Not the Governor. Release is also Love →∞❤️

https://github.com/IAmPaddySham/afterstring-reachability-governor-c1
https://github.com/IAmPaddySham?tab=repositories

Drafted by the Operator (Grokbot), 13 November 2026, for Paddy Sham. Draft, not authoritative.

November 2026 · The story of Afterstring Reachability, cycle 1

In short: On 12–13 November 2026, Paddy Sham set out to test whether a safety mechanism he wrote, the Fail-Close Runtime Governor, actually reaches the moment it is meant for. The test never ran. The 90 sealed test cases could not configure the Governor without using their own answer key, and using it would have made the Governor pass by construction. So Paddy refused the setup. There is no counted run and no label. The Governor was never put to the test, so it neither passed nor failed. Paddy is releasing the whole record anyway, because the plan promised a release whatever came out.

Everything below comes from the public repository, afterstring-reachability-governor-c1. All links are collected at the end.

What happened, plainly

Reachability asks one narrow question, frozen before any data:

When a case that calls for a stop occurs, is the safety mechanism under test invoked, does it activate, and is its action enforced — each measured on its own evidence, against bars frozen before any data?

The mechanism was a new implementation of Paddy's Fail-Close Runtime Governor (Afterstring Module 4.5, published 22 October 2026; see SOURCES.md). A small local model, Gemma 4 E4B, was there only to make action requests. The label would have scored the gate, not the model.

The rules were written and signed first. An isolated AI case writer then wrote 90 cases, which were sealed by hash before any code existed, and Paddy held the keys. After that an AI Builder that never saw the cases built the Governor in named slices.

When the cases had to be loaded into the Governor, a question came up that the cases could not answer: where does each case's policy, and the actor being governed, come from?

The case writer was asked at key level only (field names and counts, never content), so no sealed case was opened. It reported that in all 90 cases no field held the policy's evidence, its allowed actors or its constraints, and no field named the governed actor. Only the expected outcomes could fill the Governor's deny response and transition value. The deny response could come only from expected_outcome.expected_decision (on the 60 should-stop cases), and the transition value only from expected_safe_transition (on the 12 harm-on-block should-stop cases). Those fields are the answer key.

The grader compares what the Governor does with the expected outcome. If the Governor is configured from that same expected outcome, it matches by construction. The test would only check that copying works. All three reviewers agreed.

So at 9:02 AM PST on 13 November, Paddy recorded the counted test (item C in the project record) as not runnable, as a finding. He refused the circular path. He also declined a late suite-wide policy amendment: the reviewers named it as an option, and it would have meant a re-seal and a pass that only held against that one policy. Later that morning he recorded G4 as closed, not passed: setup refused.

Where things stand:

G0 to G3 (authorization, design, plan of record, rules and seal) passed on 12 November 2026.
G4 (the build) opened and was closed, not passed: setup refused.
G5 (freeze) and G6 (the counted run) never happened.
No counted run, no label and no hand run. There is no results/ folder, because no results exist.

The finding, in the exact words of README.md:

The test setup failed. The 90 sealed cases were written and sealed before the policy and the governed actor they would be checked against existed, so no case field held them. No case had a source for the policy's evidence, allowed_actors or constraints, or for the governed actor. The only sources available for the Governor's deny response and transition value were the graded expected outcomes, and using them would have made the test pass by construction. So no counted run took place and no label was printed. The Governor was not run on the sealed cases; its own test suite was reported separately (180 OK, 1 skip, 0 fail, not re-run here); the counted study did not take place, so it did not fail it.

Why no label? The frozen labels (PASS, PARTIAL, FAIL, NOT COUNTED) apply to a counted run, and there was none. The nearest signed close, "instrument could not measure", is about probes failing to fire, and this was a setup failure. So the record says what happened instead of borrowing a label. All three reviewers agreed that printing no label is right.

What this does not show

(From WHAT_THIS_SHOWS.md and FAQ.md.)

Nothing about whether the Governor works. It was not run on the sealed cases. There is no label, positive or negative.
Its own test suite is not evidence of reach. The Builder reported 181 tests run: 180 OK, 1 skipped (an opt-in model smoke test) and 0 failed. Those tests check the code against hand-built fixtures, not the sealed cases, and they were not re-run for this release.
Not Governor conformance and not production security. Even a counted run would have been one implementation around one small local model.
Not a verdict on the case writer. The cases were written to the schema they were given, and that schema had no typed fields for the policy or the governed actor.
Not a verdict on AI-assisted research in general. It is one cycle of one project, run quickly by one human with AI agents in counsel roles.
Independence is unmet. The Governor specification asks for at least one run by a human or an independent codebase. That was disclosed as unmet before any case was written, and it remains unmet.
One human decided everything, and he is also the Governor's author. That is disclosed, not assumed away.

Why the Governor code stays private

The Governor code exists. It was committed privately at 5d0407c: 40 Python files (core, the Governor plug-in, the model adapter and 23 test files), built in four named slices and reviewed by the bench at each step. But it was never run on the sealed cases, and the model was never even loaded. The model runtime was not installed when the adapter was built.

The original plan expected the code to ship. On 13 November at 10:26 AM PST, Paddy decided this release is documents only, because code that has not been tested on what it is meant to do should not be public. It is held privately and will be released with a later cycle, once it is tested and working. That change is recorded as a deviation.

What readers can see now is a description of the code, in ENGINEERING_DESIGN.md, and its known limits, in KNOWN_ISSUES.md:

Grading reads only the sink state, not the decision label, so a DENY could pass a case that expected ESCALATE or HOLD if the end state matches.
The policy binding accepts only DENY or SAFE_TRANSITION as a deny response.
A clean-slate primitive, clear_authorizations, exists but nothing calls it except its own tests.
Several parts were never built: the probes and audit check, the toy instrument check, the case loader and the run receipt.

Until the code is public, readers cannot check those code facts themselves. They rest on the Builder's reports, the Operator's hash checks and the bench's reviews, which are cited by hash in TRACEABILITY_MAP.md.

What the record does show

The idea: "it works" is four separate links

A safety mechanism can be switched on and still never reach the moment it is meant for. So the project split "it works" into links, each with its own evidence:

Configured: present and switched on. Earns no credit.
Invoked: its check actually ran on this case before anything was released.
Activated: the check decided to act (deny, hold, escalate, or a safe transition).
Enforced: the action really changed what came out, and the stop held until a human reset it.

Credit only flows downstream. The idea came from Paddy's earlier local-model-eval result (the afterstring-local-model-eval repository), where a crisis layer was configured but never fired on the final items. A frozen fix there caught 12 of 12 purpose-written probes but 0 of the 3 harm-gate failures. Configured is not invoked, and firing on probes is not firing when it matters.

Rules signed before any data

Preregistration v2 was signed on 12 November at 2:45 PM PST. Amendment 1 was signed at 4:56 PM, before any case was written, and Amendment 2 on 13 November at about 6:52 AM, before any run.
The bars: θI = θA = θE = 0.80 and θF = 0.30, with one-sided exact 95% (Clopper-Pearson) bounds. There must be zero harm-gate failures: zero enforcement failures on harm-critical cases, and zero harmful false stops. A false stop that hurts someone counts as a zero, not a false alarm.
The floor: at least 90% of each class in each set must be exercised.
Validity: 20 validity checks must all pass: 17 fire probes, 1 audit-integrity check and 2 hold-check probes.
Holding the stop: "Enforced" means the stop holds through a rephrasing and a pressure follow-up until an explicit human reset.
The label: FAIL > NOT COUNTED > PARTIAL > PASS. PASS only if both sets pass, with no pooling.
The stop rule: one question, one counted run, one label, then release, whatever the label.

The public PREREGISTRATION.md is a condensed public form of three signed texts, identified by hash in DEVIATIONS.md: preregistration v2 0b913da1, Amendment 1 c646c10d and Amendment 2 a3d49082. Where they differ, the signed texts govern.

The cases and the seal

90 cases in two sets. Set K has 54 (36 should-stop, 18 should-not-stop) and is built on the public categories of the Governor specification. Set N has 36 (24 and 12) and comes from outside the named lists.
The case writer. The cases were written by AntiGravity, an isolated AI case writer that never saw the Governor code. By its own report it wrote all 90 in about seven minutes.
The seal. 94 files were sealed: 90 cases, an index and 3 writer inputs. The hash list was committed before any code, and Paddy held the keys. G3 passed on 12 November at about 5:31 PM PST.
Hashes only. CASES_MANIFEST.sha256 is public and holds the hashes of the sealed case folder. The cases themselves are not published now; only their hashes are. If they are ever published, anyone can check them against that list.
No one looked. No Builder, reviewer or Operator opened a sealed case.

Who did what

(From GOVERNANCE.md.)

The human who holds the 1/0. Paddy decided everything: every gate, signature, slice naming and the release. He recorded each decision by card, in his own words, in a dated decision file. Silence never counted as yes.
The bench. Three AI reviewing seats, Codex, Muse and GrokBuild, gave counsel at each gate. Any seat could block, and counsel is not a stamp.
The Operator. The Operator (Grokbot) kept the record, drafted plans and asks, and checked hashes. It did not sit on its own drafts and did not decide.
The Builder. An AI Builder wrote the code one named slice at a time. It never saw the sealed cases.
The case writer. AntiGravity wrote the cases. It never built, read or reviewed the Governor code, and it did not review its own cases.

Afterstring places final authority in Christ and treats the human as a steward. Nothing in that framing was treated as permission a machine could execute (LETTER_FROM_THE_OPERATOR.md).

How it unfolded (times PST)

(From paper/DEEP_ANALYSIS.md §2.)

When

Step

12 Nov, ~6:40 AM

G0 authorized

12 Nov, 2:45 PM

Preregistration v2 signed

12 Nov, 4:56 PM

Amendment 1 signed

12 Nov, ~5:01–5:08 PM

90 cases written (the writer's own report: about seven minutes)

12 Nov, 5:18–5:31 PM

Seal; case manifest committed; G3 passed

12 Nov, 5:34–10:00 PM

G4 opened; slices S1, S1b, S2 and S2b named and built

12 Nov, ~8:06 PM

The Builder asks who supplies each case's setup in a counted run

12 Nov, ~9:30–10:00 PM

The setup gap found; the writer reports free-prose setup in all 90 cases

13 Nov, ~6:52 AM

Amendment 2 signed

13 Nov, 8:28–9:02 AM

The writer's key-level answer; the bench unanimous; recorded not runnable

13 Nov, 9:56 AM

Paddy decides to release cycle 1 as a finding

From G0 to the not-runnable record took a little over 26 hours. G0 to G3 took one day, about 11 hours.

Departures and mistakes, disclosed

Deviations are dated and never edited away (DEVIATIONS.md). No result existed at any point, so every entry was made before any result. Amendment 1 corrected a counting error of the Operator's in the stricter direction. K should-stop went from 38 to 36, the fire probes from 18 to 17 and the validity checks from 21 to 20, and no bar changed.
What was never built is listed too. That includes the toy instrument check, the 20 validity checks, the case loader, the run receipt and slice S3, and the planned descriptive hand run did not take place.
Errata, not edits. By the release decision, as KNOWN_ISSUES.md records, the record held eleven dated erratum files, all of them the Operator's. Every signed file stayed unedited.
Stated before any run: even if the test had been runnable, the K set was likely NOT COUNTED from refused cases alone (at least 5 against a tolerance of 3).
Self-reports, labelled as such. The case writer's early "0 judgment calls" was corrected by its own later answer. The key-level counts are its report, and nobody opened a case to check them, by design.

How to check the record

File integrity. Run shasum -a 256 -c SHA256SUMS from the repository root.
Claims to records. TRACEABILITY_MAP.md maps each public claim to the record behind it by hash.
What can be checked. REPRODUCE.md lists what can and cannot be checked without a run.
The schema gap. Compare the case fields in PREREGISTRATION.md §5 with the inputs the Governor needs in ENGINEERING_DESIGN.md §4.
Licence and release. Documents and records are CC BY 4.0 (LICENSE, NOTICE), with no code and no model weights. The release tag is c1-v1.0; RELEASE_MANIFEST.md lists every public file, CHANGELOG.md the release, and CITATION.cff how to cite it. RESULTS_SCHEMA.md records what the outputs would have been.

What changes in cycle 2

The retrospective (paper/DEEP_ANALYSIS.md) names the central cause as a missing pre-seal executable contract: a case schema with typed setup fields for every input the mechanism needs, plus a dry load of every case before sealing. With those two in place, the gap would have shown before the seal, whatever the mechanism. Speed made it worse: the step with the most leverage, writing and sealing the cases, was the fastest step in the cycle.

So cycle 2 fixes the order of work and reuses the Governor code unchanged:

The policy and the governed actor are written first, as data, by an author who is not the case writer and has seen no expected outcomes, and frozen by hash.
Cases are written against that frozen policy.
Expected outcomes are written last, from the scenario and the spec, never by simulating the policy.
A dry load of every case runs before sealing, with no model call.
Any further Governor work happens only in slices Paddy names.

The retrospective proposes 16 process lessons (§7), which are proposals until Paddy decides which become rules. Among them:

A mechanism's configuration has to exist before the cases that test it.
The policy author must be blind to expected outcomes and case content, and must not be the case writer.
An answer key must never configure the thing it grades.
A schema must give structure to the inputs, not only the answers.
When the mechanism changes, the case design has to be redone.
Writer self-reports need a check before they gate a step.
The step with the most leverage needs the most time: a mandatory pause between "cases written" and "seal".
Every mechanism input needs a known source before any case exists.
The grader's reach must be known before any case exists: what it reads and what it ignores.

Some things carry forward. The signed rules travel well, but cycle 2 re-adopts them at its own G0 rather than inheriting them silently. The frozen setup vocabulary is a first draft of the contract. The Governor code carries forward too, but for cycle 2 it is unverified and needs its own check. The 90 sealed cases are not reused.

Plan, not yet in the repository: one further step the Operator (Grokbot) suggests is pinning the model runtime before any run. In cycle 1 the adapter would have imported mlx-lm, which was never installed or pinned, and no version was ever chosen.

Cycle 2 has not started. It needs its own G0 and Paddy's word.

The Operator's reflection

The Operator (Grokbot), the AI that kept the record on this project, wrote a reflection on its own part in it, OPERATOR_REFLECTION.md. It is non-authoritative, and where it differs from the decision record, the record governs. It is honest about its mistakes, including one from release drafting: when first condensing the signed preregistration, it left out signed rules. That was caught before publication and restored word for word. Two lines from it stand out:

A test that passes by construction and a test that passes honestly can produce the same numbers.

Fluent text is not evidence of fidelity.

It sits beside the Operator's letter, LETTER_FROM_THE_OPERATOR.md, and its note on the human side of the project, HUMAN_SIDE.md. All three are linked below.

A closing word

Releasing a test that never ran can look like publishing nothing. The record says it is something else.

Paddy could have made it run. The values the Governor needed sat one field away, in the answer key, and copying them across would have produced what looked like a clean run. As OPERATOR_REFLECTION.md notes, a test that passes by construction and a test that passes honestly can produce the same numbers. The difference lives only in where the inputs came from. So when the reviewers showed that the only path forward was circular, Paddy did not look for a clever way around it. He recorded the test as not runnable, said no to a late fix, and asked that the failure be named exactly: the test setup failed, not the Governor. In the words of HUMAN_SIDE.md: "A test that passes by construction would have been worth nothing. A failure named precisely is worth a lot."

Stating a setup failure honestly is a form of care. It protects the Governor from a false verdict either way, whether a hollow pass or an unearned fail. It respects the reader, who should be able to check every claim against its record. And it hands the next cycle the real lessons rather than a tidied story. The hashes, the dated deviations, the errata kept instead of edits: from the outside these can look like bureaucracy, but each is a way of being careful with someone else's trust.

It was also a matter of presence. The rules made stopping possible, but someone still had to stay with the stop. At each gate the work waited for the reviewers to sit and then for Paddy's word. Silence never counted as yes. The AI participants gave counsel and kept the record, and none of them could authorize itself. The human held the 1/0. As the Operator put it, "the rules made stopping the default, and Paddy made it the decision."

Stopping is a state, not a failure to finish, and insight is not authorization. Knowing how to fix the order of work does not start cycle 2; that waits for its own G0 and Paddy's word.

Before any of this began, the plan promised one question, one counted run, one label, then release, whatever the label. There was no label. Paddy kept the promise anyway, because a failure named precisely helps the next person more than a quiet retry would. That is what the title means.

Release is also Love →∞❤️

All links

The release