BFM-decomp/phase-ends/PhaseEnd_Phase36.md

# PhaseEnd — Phase 36: Levers off — every compiler-forcing construct out of the matched C, to its measured floor
**Date:** 2026-09-11 · **Project Version:** 2.2.0 · **Phase Status:** Complete (milestone as AMENDED at S104, confirmed by Drew at gate 2 — 2026-09-11, "confirmed for phaseend") · **Generation:** Gen3 (the second phase; Drew's order dedup → **pins** → structs → names)

> Chartered at gate 1 (S97, 2026-09-09, plan mode, Max) from `docs/gen3-handoff.md` §5–§7 and `docs/gen3-standards.md`, widened by
> Drew at the gate from "pins off" to **every lever class** — register pins, `asm` statements of every kind (barriers, launders,
> keep-alives, hand-placed instructions, the GTE coprocessor idiom), volatile levers, bare `register` — with decision 2 "grind to zero"
> and the marking rule "ban the silence, not the lever". Ran **nine sessions (S97–S105, 2026-09-09 → 2026-09-11)** and **575 commits**
> (`63b886626..db212f167` on the baseline `e6d98dd1d`, Drew's P35 close; 320 of them are single-function banks through the whole-object
> gate). The granular trail — every batch's verify line, every agent landing with its pass and `file:line`, every instrument defect
> with its cause — is at **`phase-ends/logs/Phase36.md`** (R19, on demand; ≈3,300 lines). Owner decisions (Drew): gate 1's three forks
> (scope A–D now, E–G deferred; grind to zero; byte-needed `volatile`/`register` kept unmarked and ledgered) and the verbatim
> confirmation; T1b (the in-function verbatim form, "confirmed per your recommendations"); T7's start rule ("dont start ultra code wave
> for reshaping without my direct approval"); the T7 operating procedure ("always have an agent running … prove the rule, harvest the
> idiom, start a new agent"); the burst of 20; the cap 5 → 2 → 1 → none; the S104 rulings read against sotn-decomp (do-while and dead
> initialisers stay as marked ordinary C; GTE deferred; every site reducible to C, the unclosed ones carried to the structs phase — the
> **milestone amended** from "0 pins, 0 asm" to "every survivor marked, counted, attributed and named for the structs phase"); the
> S105 close ("confirmed per your recommendation. wait for the last agent to finish, then do all the things and no more agents this phase").

## Build Log

**The phase in one line:** the census found **53,234** compiler-forcing sites (37,720 register pins + 15,514 asm statements) in 15,679
matched function bodies; a deterministic ladder — a byte oracle on the build's own recipes, a mechanical strip, the GTE header, shape
recipes, a permuter rung, a guided search — and then one-agent-per-translation-unit readings of the compiler's own source took them to
**4,010** (2,141 pins + 1,869 asm in 1,980 bodies, −92.5 %), every step proven by the 218 hashes from a clean rebuild, every survivor
marked with the compiler pass that needs it and the instrument that judged it, and the remainder bucketed by what it needs (a signature,
a struct, a carve, a GTE macro decision) for the structs phase.

**Files created/changed and complete — do not recreate** (category summaries; the per-commit list is `git log e6d98dd1d..db212f167` and
the archived log):

- **The instruments (T1–T3, extended through T7).** `tools/lever_census.py` (the self-asserting census: every `asm`/`register`/
  `volatile`/`__builtin_*`/`__attribute__` token roled once, per-line coverage against the raw text, four known-true controls keyed on
  their T1 hashes, the `// !FAKE:` split, orphan-marker detection, cross-file macro names, the src stamp, `--check` / `--check --strict`,
  `--sites`, `--selftest`; a `make tools-health` rung since T8); `tools/delever_oracle.py` (every object's exact build command captured
  once by `make -n -W`, candidates compiled IN PLACE with the output redirected, whole-object byte equality against the fleet run's
  object; `--calibrate` 177/177 + a positive control; COMPILE-CRASH apart from COMPILE-ERROR, R103; `--snapshot-baseline` — the baseline
  under `.run/P36/delever/baseline/`, so a clean fleet rebuild can run beside scoring agents); `tools/delever.py` (the engine: positional
  rewrites per lever class with a token-mismatch REFUSAL, rung A strip-all, rung B greedy, the file as the write unit and its final
  compile as the proof, the ledger keyed by body hash before/after, `inflight.json` as the only restore (R102), `--scrub`, `--apply-body`,
  `--propagate` (class remap by address, the allowance derived from the exemplar's surviving markers), `--port-scan`, `--recipes` (rung
  R, TU-parallel), `--repair-nhash`, `--selftest`; **the generator registry R2–R46** — every family with a selftest fixture and a
  known-true run on the body it came from); `tools/delever_cycle.sh` (the unattended batch cycle with FINISH and REDRAW modes, the stale
  `.git/index.lock` wait); `tools/gte_consolidate.py` (T5: the signature engine on the build's own tail, one canonical text per
  signature, Sony's names, lever variants `_m`/`_v`, `--sweep`, `--remark`); `tools/delever_permute.py` (rung D: the permuter on a
  lever-free draft with the tree's own body as `target.o` and a positive control); `tools/delever_search.py` (rung G: the object-scored
  beam search with a reloc-masked edit distance, the residual classifier, `--explain`, `--try` — the agents' scorer, per-function scratch,
  parallel-safe); `tools/delever_regen.py` (the read-only regen of newly harvested families over the whole residue, forked worker
  processes, `--bank`); `tools/delever_pack.py` (the agent packs: `neighbours.txt`, `related.txt`, `best_body.c`, `ORDER.tsv`);
  `tools/argcheck.py` + `tools/decl_repair.py` (S102: the lying call declarations — 16,759 repaired byte-identically across 3,439 units;
  K&R definitions read since S103); `tools/localalloc_sim.py` (c26's local-alloc simulator, promoted after 0 mismatches over 150 blocks;
  the three-quantity switch modelled at S104); `tools/alloc_table.py` (gcc's truncated integer priority, TIE flags); `tools/cc1_dumps_tu.sh`
  (`-dt -dJ -dd`, `-Isrc/shared`, takes a `.c`); `tools/lever_progress.py` + `docs/levers.md` + `docs/lever-progress.tsv` (the series, 78
  milestone rows, rendered as state transitions); `tools/readability_progress.py` + `docs/readability.md` + `docs/readability-progress.tsv`
  (the second Gen3 series); `tools/verbatim_check.py` (the in-function form, `--update` keeping order and UTF-8, `--strict` in tools-health).
- **The tree.** `include/gte_inline.h` (50 GTE macros under Sony's names for what were 9,102 per-TU definitions; 8,951 deleted, 629 of
  699 `"memory"`-clobber variants proven byte-neutral and dropped, 70 kept as marked `_m` levers; 575 direct GTE statements as
  canonical calls); `config/verbatim_manifest.json` (49 rows: 27 PERMANENT-VERBATIM incl. the 22 per-overlay scratchpad stack-switch
  trampolines the file-scope detector never saw, 8 SDK-VERBATIM libgs renderers, 11 DECOMPILE-NOW, 3 UNCERTAIN — T1b's finding that "every
  game-code function is C" had been measured by file-scope instruments); **`src/`: 53,234 → 4,010 lever sites** — the survivors marked
  `// !FAKE: <kind> <detail> — <pass, file:line> (P36 <rung|agent>)`, 2,693 files' stale `@stuck:` header notes retagged `@unstuck(P36):`
  (30,138 notes, comment-only), 16,759 call declarations made honest, four `do { } while (0)` and dead-initialiser fakes marked per sotn's
  rule; the ledger `.run/P36/delever/ledger.jsonl` (one row per judgement, the rung, the calibration id, every site's verdict).
- **The record.** Cookbook **§454** (rungs D/R: the instrument lessons — a disassembly is not a target), **§455** (rung G, the object-scored
  search), **§456** (S104's move catalog under ~205 levers), **§457** (S105's catalog: the loop family, cse's address fold, sched1's
  birthing boost in both directions, combine's narrow-load split, local-alloc arithmetic, the parameter shapes), §197-A superseded;
  `docs/decision-log.md` P36 S99 / S101 / S104 / S105; `docs/accelerators.md` P36 S99 / S101 / S105; `.run/P36/agents/METHOD_S103.md`
  (the agents' method, steps 1–25, every emitter and register-order move with its `file:line`); `docs/SETUP.md` P36 rows for every tool;
  the wiki (`Where-the-project-goes-next` item 2 + the table row) and the Gen3 charter pages date-stamped; `docs/tool-index.md` + the kit
  corpus regenerated; `config/kit_coverage_map.tsv` (the P36 accelerator entries dispositioned); 333 agent packs with `mechanism.md`.
- **Evidence (`.run/P36/`, allowlisted text):** `baseline/` (every R22 log), `census/`, `probe/`, `delever/` (batch records, apply logs,
  the calibration), `permuter/`, `engine/` (run logs, outcomes, traces, `residual_moves.md` — lane B's 58-row residual → source-move map
  with its verification ledger), `regen/`, `s103/` `s104/` `s105/` (per-session R22 logs, bank lists, known-true candidates, the picker,
  the briefs, `attribution_check.py`, `unstrippable.json`, the tools-health logs), `agents/` (the packs).

**Tools/packages installed:** none external (no apt/pip). `tools/reference/sotn-decomp` shallow-cloned (ignored; X2 — data) at S104 to
read Drew's four questions against its tree (R106).

**Verification results (literal, at close — S105, HEAD `db212f167`, tree clean):**
- R22 from clean after the last `src/` change (`fe4a62420`, the comment-only retag): `extract-all: 217 extracted, 0 failed of 217 (+ main,
  serial)` · **`check-all: 218 passed, 0 failed of 218`** · `real 1m27.146s` · `exit=0` (`.run/P36/s105/r22_l.log`); every batch of the phase
  — 15 T4 batches, 3 T5 batches, every rung-D/R/G run, every agent bank — carried the same line.
- **`lever_census --check: 4,010 pin/asm sites, 4,010 marked !FAKE, 0 UNMARKED — OK`** (exit 0; orphans 0; GTE levers 450 inside the
  number; `--strict` NOT claimed — by the S104 amendment "0 pins, 0 asm" is the structs phase's finish line). `verbatim_check --strict`:
  no drift (49 rows).
- **`make tools-health: OK — sigs fresh; corpus(+resident) + cdecl + binaries + report(lint+dedup) + cookbook-index all green.`** (run 4,
  `.run/P36/s105/tools_health_t8d.log`; the new rung inside it; S1 10,180 / 10,180, 0 violations; sdk-dual OK; kit_coverage OK; runs 1–3
  were red on the day's own record — three Reference-index rows, one kit_lint LEAK, two undispositioned accelerator entries — each fixed).
- **Attribution (milestone item 2):** `.run/P36/s105/attribution_check.py` → `4026 counted lever sites, 4026 attributed {rung B 2,620 ·
  S103 933 · T5 450 · S105 22 · S104 1}, 0 without an instrument` (measured at 4,026, before f11's last 16 rung-B sites came off).
- Published (R75): README line 30 `Levers off (Phase 36, snapshot 2026-09-11): 2,141 register pins and 1,869 asm statements remain in
  1,980 functions (674 distinct bodies), 4,010 of them marked …`; `docs/progress.json` `counts.levers`; `docs/levers.md` (78 rows,
  `lever_progress --check: OK`); `docs/readability.md` (33 lying declarations left in 25 pinned bodies, from 461 in 314 at S102).
- `delever --selftest: OK` · `lever_census --selftest: OK — 24 sites, 2 defs, 2 asm macros` · `share_census --selftest 7/7` · `doc_links
  --strict: OK` · `kit_lint: OK` · `kit_coverage: OK` · `tool_census --check: OK` · `cookbook-index OK (1,175 sections)`.
- The headless Ghidra MCP was never used (no RE work) and was stopped cleanly at the S105 close ("Save succeeded", R23).

**Milestone achieved (gate 2 — Drew, 2026-09-11; each item with its literal output above):** (1) as AMENDED at S104 — every surviving
register pin and asm statement outside the GTE header is marked, counted and named for the structs phase: `lever_census --check` 4,010 /
4,010 / 0 UNMARKED, the counts published with the dated snapshot, the manifest unchanged; (2) the ledger names, for every site, the rung
and the instrument that judged it — 4,026 of 4,026 attributed; (3) `check-all: 218 passed, 0 failed of 218` from clean, `make tools-health`
OK with the new rung, the GTE macros in one header (314 per-TU asm macro definitions remain, each tied to a surviving marked lever or an
`h_text` homonym — stated at T5's close, not zero); (4) the record written, this PhaseEnd, the DIGEST append, the log archived; v2.2.0.

**Next:** **Phase 37 — the structs phase** (Drew's Gen3 order; R95's canonical type layer is its core). Open a fresh session in **plan
mode, Max** (Tier 1) from `docs/gen3-handoff.md` (item 4, the types doctrine) + `docs/gen3-standards.md`, with this phase's residue as its
acceptance test: 4,010 sites = 1,548 drawable singletons (472 classes) + 691 in 24 parked classes (six signature changes with ready
patches — func_800385C0, func_80029D3C, func_80180FA4, func_80180A54, func_80188DF4, func_80183CC4, func_801A1E94/func_801A5C44, func_80035210,
func_800384A8, func_80188A30, func_8017FC5C/func_80180200, func_80185578, func_80157D20, func_80168828; the carve change func_80186CE0; the
proven-irreducible heads func_8013CF68 ×134, func_80178970 ×127 + four same-shape families, func_8013F350's head) + ~1,150 minimum-lever
survivors in five head classes (func_8013D9B0 ×125 — the `gte_stORGB` respelling question of T5; func_80177B5C, func_80140958, func_8012E364,
func_8013F350) + 450 GTE clobber variants + 94 `$4`–`$7`-only pins (the missing-parameter shape, ~158 estimated across `src/`). d10's
register-union proof (func_8017EF88), a18's `extern u16 X[]` close, f10's three type closes and f3's `s16[3]` finding are the phase's
evidence FOR the struct hypothesis; `tools/argcheck.py` (98,648 lying declarations over 1,609 callees) and the raw-cast census
(411,850 against 177,902 struct member reads) are its starting instruments. Inherited by name: the kit split, xsig v2, the §396(a)
correction owed since S104 (the refuting body was not identified — R14), the 15 remaining UNSTRIPPABLE packs (one-off instructions,
macro-carried and multi-output launders), a refusal-reason histogram for `delever_regen`, a "local vs global" column for `alloc_table`.

## Roadmap delta (what Phase 36 changed about the road ahead)

- **Gen3 item 2 is at its measured floor, and the floor has a shape.** The phase did not reach zero and says so: the last third of the
  residue is not a codegen problem the pin lane can read its way out of — it is wrong signatures (a `(void)` function that reads `$a0`, a
  `void` one that returns `$v0`), missing struct types (the compiler's own alias tests, `sched.c:837-863`, `expr.c:4568-4577`, decide by
  `MEM_IN_STRUCT_P`), carved data that a struct copy would address in one relocation, and one GTE macro spelling. Each is the structs phase's
  by construction, and the phase leaves it a list with patches, readings and byte proofs rather than a number.
- **The doctrine is written where the next project starts:** `docs/levers.md` §5 — "ban the silence, not the lever": a lever is allowed only
  marked, ledgered and published from the first bank, with a one-compile bank-time trial ("does it still match without this?") that would
  have refused 37 % of this population while the context was hot; blanket prevention would have stalled Phase 18. The kit's DK entries and
  the wiki carry it.
- **The compiler map grew by a catalog of moves with their passes** (§454–§457, METHOD steps 1–25): the loop family's biv law, cse's address
  fold and its inverse, sched1's birthing boost in both directions, combine's narrow-load split, local-alloc's arithmetic (`find_free_reg`'s
  lowest-free rule, `update_equiv_regs` doubling a constant's life, the three-quantity birth order), the call-signature class (a truncated
  declaration DELETES an instruction). Every entry names its `file:line` in gcc 2.7.2 and its byte witness.
- **What the readability series now measures for the structs phase:** the struct debt (411,850 raw cast dereferences vs 177,902 struct
  member reads) and the declaration debt (98,648 lying declarations, 33 of them still in pinned bodies).
- **Scale, honestly (R41):** the plan priced the mechanical floor at 3 sessions and called T7 "open-ended, to zero"; the phase took 9 sessions,
  575 commits, ~200 agent draws (S102 22, S103 56, S104 ~105, S105 11 TU batches of 4–7 classes) and roughly 15–20 M agent tokens across
  the three agent sessions (S105 measured ≈3.5 M for 56 classes). The mechanical rungs took 37 % of the sites for ~20 CPU-hours and no
  tokens; the search engine took another 6 % for ~5 CPU-hours and no tokens; the agents took the rest — and the closes per agent rose from
  1 (S102) to 4–7 (S104–S105) as the TU batch and the method file matured.

## Deviations

| Item | Plan (gate-1 plan) | Actual | Reason |
|---|---|---|---|
| The milestone | 0 register pins, 0 asm statements outside the GTE header (decision 2, "grind to zero") | **amended at S104 by Drew:** every surviving site marked, counted, attributed and named for the structs phase; 4,010 remain | S103/S104 read the head classes to proven irreducibility in plain C, and Drew's (c)/(d) rulings — read against sotn-decomp, which keeps `INCLUDE_ASM` stubs rather than pins — moved the unclosed sites to the structs phase |
| T7's shape | Ultracode waves (Workflow fan-out), prompted | the Agent tool, one agent per residue class, then one per TU with 4–7 classes; caps 5 → 2 → 1 → none | Drew's rule "one agent at a time so the methodology is honed at each landing" (S101), then his cap retunes; a Workflow was never the right unit for a reading |
| T6's permuter rung | the residue exemplars through the permuter, time-boxed | 5 of 16 closed (0.69 h); its two prior campaigns were the instrument (a disassembly is not a target, §454); rung R closed 134/134 of the class it found, then 0 of 300 on the residue | the permuter is a replication engine after a shape is known, not a discovery engine; the guided search (rung G) replaced it |
| Sessions | mechanical floor 3; T7 open-ended | 9 (S97–S105) | T7 was 5 of the 9 |
| The call-signature turn | not planned | `argcheck` + `decl_repair`: 16,759 lying declarations repaired byte-identically in 3,439 units (S102); R19/R25 generators | six independent agent cracks in one burst were the same class — a truncated declaration deletes an instruction the pin then faked |
| The minimum-lever bank | not planned | the S103 pivot: the best honest plain-C body plus only the marked lever(s) it cannot do without, `allow_residue`, propagation deriving the allowance from the exemplar's markers | four 130-copy classes at 4–34 levers per copy became 1–2 |
| The in-function verbatim form (T1b) | 5 PERMANENT file-scope rows | 49 manifest rows; 22 per-overlay trampolines + 8 SDK renderers + 11 DECOMPILE-NOW + 3 UNCERTAIN | the census's structural detector found what the file-scope detector never had (P9: the P32 "every game-code function is C" was blind to it) |
| Rules | R100–R106 ratified at gate 1 | R100–R106 ratified; **eleven** candidates proposed below | the phase generated governance from its instrument failures, as every phase has |
| The §396(a) correction | owed at T9 (S104) | **not written** — carried by name | the refuting body was not identified from the record; a correction needs its bytes (R14) |

## What we believed, what failed, and what we would do sooner (for the retrospective; the detail is in `docs/decision-log.md` P36)

- **Believed (gate 1):** the pins would come off mechanically, family-batched, because Phase 32's last four functions had. **The strip took
  37 % of the sites and freed 20 % of the bodies; the rest was 1,803 distinct shapes**, each a reading of a compiler pass. **Sooner:** the
  probe (T2) said exactly this on day one — price the residue by distinct SHAPES, never by bodies.
- **Believed (S99–S100):** the permuter and a recipe sweep would discover shapes. **They replicate, they do not discover** (134/134 on a
  known shape, 0/300 on unknown ones); and two permuter campaigns had scored against a disassembly that was not a target (24 wrong words
  from `move` vs `or`). **Sooner:** a known-true case — the tree's own body must score 0 — before any campaign; the guided search with the
  object as the scorer.
- **Believed (S101):** a wider search would close the head. **112,216 compiles bought 62 bodies**; the head needed readings. **Sooner:** the
  lane B map (the gcc source read for residual → move) before the wide search, and agents on the head from the first day of T7.
- **Believed (S102, the night of three agents):** one agent at a time meant one agent, then a sweep, then the next. **It meant learning
  between landings, not an empty slot** — six of eight hours had no agent running. **Sooner:** Drew's rule as written at S102: the slot is
  refilled in seconds; sweeps never stand between two agents; one writer.
- **Believed (S102–S104):** every `NO-CANDIDATE` was a property of the population. **R22 was refusing for three unrelated regex reasons for
  two sessions**, found only when agents closed by its own move and the generator was run on their start text. **Sooner:** a negative-
  control corpus per generator; refusal reasons as a histogram; the known-true run at every landing.
- **Believed (S102):** the pins were codegen. **The biggest single class was a wrong DECLARATION** — a truncated `(void)` deletes an
  instruction the pin was hired to fake; 16,759 of them were repaired in an afternoon for zero bytes. **Sooner:** `argcheck` at Phase 17
  (the canonical type layer, R95) — the same lesson the S91-b hindsight recorded, now with a number.
- **Believed (S104):** the residue could be ground to zero by more agents. **The residue's last third is signatures, structs, carves and one
  GTE spelling** — the structs phase's material; the drawable rest is singletons at ~3 sites each. **Sooner:** the bucketing that S105 did
  on Drew's "stalling?" question, done at every wave close as the stop-rule's input.
- **Cost:** the phase's real expense was the agent sessions (S102–S105, ~15–20 M tokens for ~200 draws) and the coordinator's landing
  loop; the instruments were cheap and paid every day — a calibration line after every commit, a positive control in every scorer, a
  selftest with a known-true run in every generator. The mistakes that cost the most were each a scorer that read the wrong thing (a
  disassembly, another agent's object, a stale baseline) and each was caught by a check that read the artifact rather than the intent.

## Commit Message
```
(Phase 36 landed as 575 commits 63b886626..db212f167, 2026-09-09 → 2026-09-11 (S97–S105). This close = the archived log + this
PhaseEnd + the DIGEST update + the kit's record copies, Drew's milestone-close commit, then the v2.2.0 tag.)

chore(phase-36): CLOSE — levers off to the measured floor: 53,234 → 4,010 register pins + asm statements (−92.5 %), every survivor
marked with its pass and its instrument and named for the structs phase; the GTE idiom in one header; 16,759 lying call declarations
repaired; the lever series and the readability series published; 218/218 at every step (v2.2.0)

- PhaseEnd_Phase36.md written; CURRENT_PHASE.md archived to phase-ends/logs/Phase36.md (R19); DIGEST §0/§2/§3 appended (step 3b)
- T0–T10 across S97–S105: the census (T1/T1b, 49 verbatim rows), the oracle + probe (T2), the engine + cycle (T3), the mechanical
  campaign (T4, 15 batches, −36.8 %), the GTE header (T5), rungs R/D (T6), rung G + the agent lane at caps 5→2→1 (T7, ~200 draws,
  generators R15–R46, the call-signature turn, the minimum-lever pivot), the gate rung + attribution (T8), the record (T9)
- close: check-all 218/218 from clean; lever_census --check 4,010 / 0 UNMARKED (exit 0); make tools-health OK (run 4); attribution
  4,026/4,026; tools-health, doc_links, kit_lint, kit_coverage, tool_census all OK
- rules: R100–R106 ratified at gate 1; candidates (a)–(k) proposed for Phase 37 gate 1
- v2.1.0 -> v2.2.0
```

## Rules Added This Phase

**Ratified at gate 1 (2026-09-09):** **R100–R106** (the PhaseEnd_Phase35 candidates (a)–(g)); full text in `phase-ends/DIGEST.md` §3.

**Candidates recorded in the log, for Drew to accept, modify or reject at Phase 37 gate 1 (P10):**

| Rule | Reason |
|---|---|
| **(a) Ban the silence, not the lever:** a compiler-forcing construct is allowed in a banked body only marked, ledgered and published from the first bank, with a one-compile bank-time trial of the body without it. | `docs/levers.md` §5: 37 % of 53,234 sites came off with no understanding at all once tried; the levers propagated with every family remap (1,758 distinct bodies became 12,578) because nothing ever asked. |
| **(b) A generator ships with a negative-control corpus of real bodies where it must fire, and a regen pass reports its refusal reasons as a histogram.** | R22 refused three ways for two sessions (`&&` as `&p`, the literal base, a cast store as a set); every `NO-CANDIDATE` had been read as a property of the population (accelerators P36 S105). |
| **(c) At every landing, run every registered family on the agent's START text before banking** — a close by a move the registry claims is the cheapest instrument check in the loop. | It found all three R22 defects and banked shared headers IDENTICAL on 141 objects each. |
| **(d) A scorer's target is the tree's own bytes compiled by the build's own tail, never a disassembly** — a known-true case (the tree's body scores 0) before any campaign. | Two permuter campaigns scored 28 for a byte-identical body: `objdump`'s `move` assembled as `or`, resolved `%hi/%lo` pairs (§454). |
| **(e) Scratch is keyed by the unit of work, never by a worker tag or a file** (R48 extended). | Nine burst agents shared one scratch object and two scored candidates against another agent's function; the search's `g0.o` was keyed by a worker index. |
| **(f) A gate's baseline is a snapshot, not the build directory** — a clean rebuild never runs where a live scorer reads `build/`. | `--try` scored against half-written objects during a fleet gate until `--snapshot-baseline` (S102). |
| **(g) A lever's marker names its PASS and its INSTRUMENT** (R65 for markers), asserted by an attribution check at the close. | 4,026 of 4,026 sites attributed; the S103 minimum-lever markers and the T5 remark were the only way a later reader knows which compiler decision each survivor stands for. |
| **(h) A ledger's "done" is per body (unit, function, after-hash), never by text alone.** | The T4 preflight drew 2,204 files where 2,583 were owed: every fleet-wide copy of an all-NEEDED exemplar passed as done by its text hash. |
| **(i) A long unattended run is DETACHED with a progress log, never a harness background task** (R55 operated). | The harness's low-memory guard killed the batch cycle mid-apply and two 30-byte waiters with 22–27 GB free; a SIGKILL skips a restore. |
| **(j) A marked ordinary-C fake (do-while, dead initialiser) is counted apart from levers and never an orphan; an invented condition, a dead store or a dummy reassignment is never banked.** | Drew's S104 ruling (a), read against sotn's `docs/STYLE.md`; a14/d20/c9/c13 refused on exactly this line. |
| **(k) A "stalling?" question is answered with the residue bucketed by what each bucket needs before any plan is proposed.** | S105: 1,548 drawable singletons / 691 parked / ~1,150 proven / 450 GTE / 94 missing-parameter — the close decision took one message. |

*(Techniques stay in the cookbook §454–§457 and METHOD steps 1–25; strategy in `docs/decision-log.md` (R31) and `docs/accelerators.md`;
the portable form is for the kit at its split.)*

## PhaseEnd Changelog
**v2.1.0 → v2.2.0 — Phase 36 complete (Gen3's second phase).** The compiler-forcing constructs in the matched C — register pins, asm
barriers, launders, keep-alives, hand-placed instructions, the GTE coprocessor idiom — were censused with a self-asserting instrument
(53,234 sites in 15,679 bodies; 44 whole-body assembly routines inside C shells found on the way and put in the verbatim manifest), then
taken off in a ladder that never changed a byte: a byte oracle on the build's own recipes, a mechanical strip (−37 %), one GTE header for
9,102 per-TU macro definitions, recipes, a permuter rung, an object-scored guided search (−6 %, no tokens), and ~200 agent readings of gcc
2.7.2's own source (one agent per class, then per translation unit) that closed 56 of 56 in the last session. 4,010 remain (−92.5 %), each
marked with the pass that needs it and the instrument that judged it, and bucketed for the structs phase: wrong signatures with ready
patches, missing struct types, a carve, one GTE spelling, and 1,548 singleton sites. On the way: 16,759 lying call declarations repaired
byte-identically, the lever series and the readability series published, the generator registry R2–R46 with a known-true run for each, and
the doctrine "ban the silence, not the lever" written for the next project's day one. R100–R106 ratified; eleven candidates proposed.

## Plain-English Recap
When this decompilation reached 100 %, thousands of its functions still carried little hacks — instructions to the compiler that forced
a particular register or ordering so the bytes would match — that a real programmer in 1998 never wrote. This phase counted them
honestly (fifty-three thousand), then removed them in stages while re-checking every one of the 218 game files byte for byte after every
step. A third came off just by asking the compiler "do you still produce the same bytes without this?". The rest needed understanding:
first a search program that scores each candidate rewrite against the real object, then agents reading the compiler's own source code to
find WHY the original bytes came out the way they did — a wrong function signature, a missing struct type, a loop written a different way
— and spelling the C the way the original author plausibly had. About four thousand hacks remain, each now labelled with the exact
compiler decision that needs it, and sorted by what would remove it. Most of those need the next phase's work — real struct types and
correct function signatures — which is why the phase stops here rather than grinding on. The count over time is published as a chart, and
the lesson for the next project is written down: allow such hacks only when they are marked and counted from the first day.

## 🛑 Stop Here
PhaseEnd written; `CURRENT_PHASE.md` archived → `phase-ends/logs/Phase36.md` (R19, via `git mv`); `phase-ends/DIGEST.md` §0/§2/§3
appended (step 3b); R100–R106 dispositioned in `config/kit_coverage_map.tsv` (kit_coverage OK); the timeline regenerated (76 rows, the
P36 row); the kit's record corpus regenerated (`make kit-corpus`, `tool_census --check: OK`) — **all left uncommitted for Drew's milestone-close commit**
(R6 gate-2 sign-off; the message is above). The Phase-36 work is committed across the sessions (`63b886626..db212f167`; not pushed). The
headless Ghidra MCP is stopped (R23); nothing under `ghidra/` is tracked. **Drew, from the repository root:**

```
git add -A phase-ends decomp-architect config/kit_coverage_map.tsv docs/story-timeline.md docs/story-timeline.svg
git commit -m "chore(phase-36): CLOSE — levers off to the measured floor: 53,234 → 4,010 register pins + asm statements (−92.5 %), every survivor marked with its pass and its instrument and named for the structs phase; the GTE idiom in one header; 16,759 lying call declarations repaired; the lever and readability series published; 218/218 at every step (v2.2.0)"
git tag -a v2.2.0 -m "v2.2.0 — Phase 36: levers off to the measured floor (53,234 → 4,010); 218 binaries byte-identical"
git push origin main --tags
```

Gen3 continues — do **NOT** start Phase 37 here. Start a **fresh session** (effort **Max**, **plan mode**) for **Phase 37 — the structs
phase**, planning from `docs/gen3-handoff.md` and `docs/gen3-standards.md` with this PhaseEnd's residue list as the acceptance test. Keep
this file forever.