# The tool index — every tool, keyed by the need it answers

*Generated by `tools/tool_census.py` from the tree and `config/tool_dictionary.tsv`; never edited by hand (a `--check` in tools-health asserts
freshness). The derived columns come from the tree on every run; the authored ones (phase, need, portability, verdict) from the
dictionary, whose coverage is asserted both ways. Read it by NEED: find the phrase that matches what you are trying to do, then the tool,
then what proved it. The same data generates the day-one kit's manifest and its verbatim tool corpus.*

**Coverage:** 297 tool files in scope (submodules, vendored and downloaded code excluded; `find` and `git ls-files` agree) + 34 retired under `tools/sunset/`. Classes: LIVE 237 (a runtime consumer), REFERENCED 29 (a SETUP row only), ORPHAN 31 (neither) — of 297. Portability: PORTABLE 22, ADAPT 258, PROJECT-ONLY 17.

## P1 — extraction + manifest

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| build and verify a deterministic sorted checksum manifest of an extraction tree | `bfm_extract/manifest.py` | Builds and verifies a deterministic sorted SHA1 manifest of an extraction tree | extract.py, build_fuel_manifest.py, family_hseq.py, family_manifest.py (+2) | the extraction output root | LIVE |
| walk a raw data track's filesystem and extract files by name | `bfm_extract/iso9660.py` | Reusable reader for a raw 2352-byte-sector data track; walks the filesystem and extracts files by name | extract.py, extract_exe.py, extract_proto_exe.py, disc_audit.py (+1) | none | LIVE |

## P2 — the oracles + the load map

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| batch-decompile an address list into one source file per function | `ghidra_scripts/DecompileFunctions.java` | Headless batch decompile of an address list into one C file per function | build_fuel_manifest.py, prefetch_fleet.py | none | LIVE |
| batch-decompile one representative per distinct open class into a cache | `prefetch_fleet.py` | Batch headless decompilation of one representative per distinct open class into a cache | api_draft.py, ghidra_roster.py | repo paths, binary registry | LIVE |
| capture and diff live console memory across scenarios to type struct fields | `ram_probe.py` | Captures, diffs and reads emulator main RAM over its web API for field typing | — | emulator host/port, 2 MB console RAM map | ORPHAN |
| close the analysis program cleanly so its edits actually persist | `ghidra_mcp_stop.sh` | Clean save-and-close via a sentinel file; the only persistence event | Makefile, auto_supervisor.sh, ghidra_apply_symbols.sh, ghidra_export_annotations.sh (+7) | repo paths, project name | LIVE |
| create functions at externally validated entry points listed in a file | `ghidra_scripts/DefineFunctions.java` | Disassembles and creates functions at externally validated entry points listed in a file | ghidra_rebuild.sh, ApplySymbols.java, prefetch_fleet.py | repo scratch path | LIVE |
| decompile one function at a given address straight from the analysis database | `ghidra_scripts/DecompileAt.java` | Headless script decompiling the function at one address and printing its C | — | default address | ORPHAN |
| derive the hand-authored annotations by subtracting a fresh analysis baseline | `ghidra_annotations_delta.py` | Derives the hand-authored annotation rows by subtracting a fresh rebuild baseline | ghidra_rebuild.sh, ExportAnnotations.java | repo paths | LIVE |
| dump per-function fingerprints in three hash tiers for cross-binary correspondence | `ghidra_scripts/DumpFunctionSignatures.java` | Read-only per-function fingerprint dump in three hash tiers for cross-binary correspondence | Makefile, corpus.py, ExportAnnotations.java, match_protos.py (+1) | none | LIVE |
| emit function start and length seeds for the executable's own code objects | `main_seed_ends.py` | Emits function start/length seeds for the executable's game-code objects, derived from the build | Makefile | repo build paths | LIVE |
| export a program's annotations to byte-stable line-delimited records, read-only | `ghidra_export_annotations.sh` | Read-only export of a program's annotations to byte-stable line-delimited JSON | ghidra_rebuild.sh | repo paths | LIVE |
| export the analysis database's hand-authored symbols to a committable text file | `ghidra_scripts/ExportSymbols.java` | Exports user-defined symbols to a committable text file so annotations are version-controlled | — | none | ORPHAN |
| find code that materializes an absolute address, tracking registers rather than pairing windows | `find_addr_refs.py` | Register-tracked scan for code that materializes an absolute address; never window-paired | idxtab_map.py | MIPS encodings, repo binary registry | LIVE |
| generate and check a roster of committed analysis programs from the registry | `ghidra_roster.py` | Generates and checks a roster of committed analysis programs from the build registry | .github/workflows/no-rom.yml, Makefile, ghidra_rebuild.sh | repo config paths | LIVE |
| import a flat headerless blob at a given base with the right processor spec | `ghidra_import_raw.sh` | Headless import of a flat headerless blob at a given base with the right processor spec | prefetch_fleet.py | PS1 processor spec, project name | LIVE |
| import and auto-analyze a console executable headlessly with the platform loader | `ghidra_import.sh` | Headless import and auto-analysis of a console executable with the platform loader | ghidra_import_raw.sh | PS1 executable loader, project name | LIVE |
| import annotations back into a program, comparing before writing | `ghidra_scripts/ImportAnnotations.java` | Idempotent compare-before-write import of the annotation JSONL back into a program | ghidra_rebuild.sh | none | LIVE |
| name the code segments that must be split before their switch functions carve | `split_indicator.py` | Names code segments that must be split before their switch functions can be sectioned | Makefile, docs/wave-playbook.md | repo config layout | LIVE |
| print a program's language, compiler spec, image base and function count | `ghidra_scripts/DumpProgramInfo.java` | Prints program metadata: language, compiler spec, image base, function count, properties | ghidra_import.sh, ghidra_import_raw.sh, ghidra_rebuild.sh | none | LIVE |
| print the symbol name at one address for scripted persistence checks | `ghidra_scripts/GetSymbolAt.java` | Prints the function or symbol name at one address for scripted persistence checks | ghidra_mcp_verify.sh | none | LIVE |
| rank candidate load addresses for a payload that was never onboarded | `payload_base_evidence.py` | Ranks candidate load addresses for an unonboarded payload from pointers, self-calls and upper-half reach | — | the source game's payload map | REFERENCED |
| re-open read-only to confirm a symbol edit survived the save | `ghidra_mcp_verify.sh` | Read-only re-open confirming a symbol edit actually persisted after save-shutdown | ghidra_apply_symbols.sh, ApplySymbols.java, GetSymbolAt.java | repo paths, project name | LIVE |
| rebuild an analysis program from committed text plus extracted bytes, proving equality | `ghidra_rebuild.sh` | Rebuilds one analysis program from committed text plus extracted bytes, and proves equality | ghidra_annotations_delta.py, ghidra_roster.py, DefineFunctions.java, ExportAnnotations.java | repo paths, project layout | LIVE |
| resolve a vendor SDK type archive into the program's type manager | `ghidra_scripts/ImportPsyqGdt.java` | Headlessly resolves a vendor SDK type archive into the program's type manager | ghidra_import.sh, ghidra_import_raw.sh, ghidra_rebuild.sh, ExportAnnotations.java | PS1 SDK type archive name | LIVE |
| serialize types, signatures, data, comments and labels to stable records | `ghidra_scripts/ExportAnnotations.java` | Read-only serialization of types, signatures, data, comments, bookmarks and labels to stable JSONL | ghidra_annotations_delta.py, ghidra_export_annotations.sh, ghidra_rebuild.sh, ghidra_roster.py (+1) | none | LIVE |
| serve the analysis tool over an automation protocol, saving on a sentinel stop | `ghidra_scripts/BfmMcpServer.java` | The headless MCP server itself; holds an open transaction and saves on a sentinel stop | ghidra_mcp_start.sh | repo sentinel path, server port | LIVE |
| start the disassembler's automation server detached on a fixed local port | `ghidra_mcp_start.sh` | Starts the headless disassembler MCP server detached on a fixed local port | auto_supervisor.sh, ghidra_import.sh | repo paths, project name, port | LIVE |

## P3 — the all-assembly baseline

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| ask whether an object's scattered zero-init section can be placed byte-exactly | `psyq_bss_probe.py` | Asks whether an object's scattered zero-init section can be split and placed byte-exactly | psyq_bss_split.py | PS1 SDK object shape | LIVE |
| byte-verify one binary by hand the only correct way, re-extract included | `verify_binary.py` | The correct hand verification of one binary: full re-extract plus rebuild, then hash compare | — | repo make targets | REFERENCED |
| convert vendor library members to the linker's format and archive them | `psyq_build_libs.sh` | Converts vendor library members to ELF and archives them per library | Makefile, fetch_psyq.sh, gate_main_parallel.py, make_apicard_used.py (+3) | PS1 SDK, repo scratch paths | LIVE |
| extract vendor SDK library files from the vendor's runtime-library disc | `psyq_libs_from_disc.py` | Extracts vendor SDK library files from the vendor's runtime-library disc image | fetch_psyq.sh | vendor disc layout, PS1 SDK | LIVE |
| generate segment lines and a stub list for a multi-block vendor library region | `gen_lib_subsegs.py` | Generates segment lines and a stub list for a multi-block vendor library region | Makefile | repo config layout, PS1 SDK libs | LIVE |
| link a whole library's objects in place of stubs, placing data no-load | `psyq_link_region.py` | Links a whole library's objects in place of stubs, placing non-code sections as no-load | make_libgs.sh, psyq_integrate.py | PS1 SDK, repo paths | LIVE |
| link every used object of a vendor library and byte-verify each | `psyq_link_lib.py` | Driver linking every used object of a library and byte-verifying each | — | PS1 SDK, repo paths | REFERENCED |
| link one vendor object at a fixed address so its code is byte-identical | `psyq_link.py` | Links one vendor object at a fixed address so its code is byte-identical to the target | gen_lib_subsegs.py, make_apicard_used.py, make_snd_used.py, psyq_bss_probe.py (+3) | PS1 SDK, repo build paths | LIVE |
| locate where vendor library objects are linked in a target image | `psyq_identify.py` | Locates where vendor library objects are linked in a target image via relocation-masked patterns | gen_lib_subsegs.py, make_apicard_used.py, make_snd_used.py, psyq_link_lib.py (+1) | PS1 SDK objects | LIVE |
| onboard any flat blob in one command: config, registry entry, first build | `new_binary.sh` | One-command onboarding of any flat blob: config from template, registry entry, first build | Makefile, config/modules.mk, config/overlays.mk, new_overlay.sh (+1) | repo config/template paths, the source game's payload classes | LIVE |
| reorder a generated linker script to reproduce the original section interleaving | `ld_interleave.py` | Reorders a generated linker script to reproduce the original section interleaving | Makefile | repo build paths | LIVE |
| restore the assembler-reorder build path for objects originally assembled that way | `reorder_passthrough.py` | Restores the assembler-reorder build path for the objects originally assembled that way | Makefile, docs/wave-playbook.md, match_one.py, oracle_reorder.py (+1) | pinned assembler flags, repo build paths | LIVE |
| split a source file at object boundaries, preserving matched code and stubs | `split_src_region.py` | Splits a source file at object boundaries, preserving matched code and stub blocks | overlay_src_split.py | repo src/config layout | LIVE |
| split a vendor library archive into its member objects | `psyq_lib_split.py` | Splits a vendor linker-format library archive into its member objects | Makefile, fetch_psyq.sh, psyq_build_libs.sh | PS1 SDK archive format | LIVE |
| split one zero-init section of an object into per-base no-bits pieces | `psyq_bss_split.py` | Rewrites an ELF object, splitting one zero-init section into per-base no-bits pieces | Makefile, make_libgs.sh, psyq_bss_probe.py, psyq_integrate.py (+2) | ELF32 REL layout | LIVE |
| wire real library objects into the split build, replacing stub subsegments | `psyq_integrate.py` | Wires real library objects into the split build, replacing stub subsegments | Makefile, docs/wave-playbook.md, gen_lib_subsegs.py, progress.py | repo config/build paths | LIVE |
| write the generated binary-registry makefile safely, validating before replacing | `mk_write.py` | The only safe writer of the generated binary-registry makefile; validates before replacing | jr_isolate_all.py, jtbl_carve.py, jtbl_pads_fix.py | repo config path | LIVE |

## P4 — the compiler pinned; the probes

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| compare instructions with relocations masked, shared by matcher and scorer | `masked_diff.py` | Shared relocation-masked instruction comparison used by the matcher and the permuter scorer | diff_regions.py, masked_scorer.py, match_one.py, reg_renumber_swap.sh (+6) | MIPS relocation encodings | LIVE |
| compile one function standalone and compare its masked bytes to the target | `match_one.py` | Compiles one function standalone with the pinned toolchain, masks relocations, compares to target bytes | ab_score.py, api_draft.py, aprop_autodraft.py, asm_verbatim.py (+22) | compiler triple, repo build flags | LIVE |
| dump every compiler pass file for a self-contained draft | `cc1_dumps.sh` | Dumps every compiler pass file for a self-contained draft into a private directory | cc1_dumps_tu.sh, ghost_census.py | compiler triple, repo scratch paths | LIVE |
| dump every compiler pass file for the spliced real translation unit | `cc1_dumps_tu.sh` | Same pass dumps for the spliced real translation unit, the faithful compile | alloc_table.py | absolute repo path, compiler triple | LIVE |
| re-judge standalone compile failures against their real translation unit before dropping | `rtu_second_chance.py` | Re-judges standalone compile-failures against their real translation unit before dropping them | maintenance.sh | repo scratch paths | LIVE |
| reproduce an external reference toolchain locally and compare its words to target | `decompme_replica.sh` | Runs a function through an external reference toolchain build and compares words against the target | verbatim_target_s.py | pinned toolchain versions, network fetch | LIVE |
| skip a draft doomed to fail before any compile is spent | `draft_prechecks.py` | Static pre-checks that skip a draft doomed to fail before any compile is spent | api_agent.py, aprop_autodraft.py, blocker_probe.py, gate_main.py (+3) | repo symbol/config sources | LIVE |
| splice a candidate into a copy of its real translation unit and compare bytes | `rtu_match.py` | Splices a candidate into a copy of the real translation unit and checks the same bytes | blocker_probe.py, decl_from_use.py, integration_resolver.py, rtu_second_chance.py (+1) | repo src layout, compiler triple | LIVE |
| turn one function's disassembly into a C scaffold to start a match | `decompile.py` | Wrapper locating a function's disassembly and running the C-scaffold generator on it | — | repo asm paths, decompiler target name | REFERENCED |

## P5 — the census, the harness, the reports

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| answer from one derived model whether each function is open, matched or shared | `corpus.py` | The single derived model of the source tree: open, matched or shared, per function | Makefile, api_agent.py, aprop_autodraft.py, aprop_symfix.py (+67) | repo src/config layout | LIVE |
| assert every consumer knows about each newly onboarded binary | `audit_binaries.py` | Gate asserting every consumer knows about each newly onboarded binary | Makefile | repo config/registry paths | LIVE |
| assert every tracked source is plain text so text searches never skip it | `audit_text_sources.py` | Every tracked C source must be plain text, or text searches silently skip it | .github/workflows/no-rom.yml, Makefile | repo src paths | LIVE |
| check that the independent what-remains views agree with the corpus oracle | `audit_frontier.py` | Checks that the independent "what remains" views agree with the corpus oracle | Makefile | repo paths | LIVE |
| check the symbol identity the masked comparison deliberately hides | `reloc_identity.py` | Disagreeing oracle checking the symbol identity the masked comparison deliberately hides | decl_from_use.py, integration_resolver.py, maintenance.sh, sibling_lane.sh (+2) | repo build paths | LIVE |
| check whether an open target already has a draft on disk | `strand_census.py` | Lists every draft already on disk whose function is still open, with its blocker | — | repo scratch paths | ORPHAN |
| decide whether a near-miss residual is a source defect or an assembler artifact | `oracle_reorder.py` | Decides whether a near-miss residual is a source defect or an assembler artifact | Makefile, docs/wave-playbook.md, match_one.py, reorder_passthrough.py (+1) | pinned assembler flags | LIVE |
| derive the tool census, the need-keyed index, the kit manifest and the verbatim corpora from one dictionary | `tool_census.py` | Derives the tool census, the need-keyed tool index, the kit manifest and the verbatim corpora from one dictionary, coverage-asserted both ways | Makefile | repo layout (tools/, docs/SETUP.md rows, the kit paths) | LIVE |
| enumerate fleet-wide every instance of one known assembler-level blocker class | `wall_sweep.py` | Enumerates fleet-wide instances of one known assembler-level blocker class | docs/wave-playbook.md, residual_rules_b.py, triage_ladder.py | repo asm layout, toolchain quirk | LIVE |
| exercise a guarded repair path the full negative control never reaches | `test_reconcile_ledger.py` | Targeted proof of the propagation ledger guard the full control never exercised | — | repo paths | ORPHAN |
| explain with two oracles why a byte-correct draft fails the whole-binary gate | `blocker_probe.py` | Read-only two-oracle explanation of why a byte-correct draft fails the whole-binary gate | recover_integration.py | repo build paths | LIVE |
| extract one deterministic feature record per function across every registered binary | `atlas_features.py` | Extracts one deterministic feature record per function across all registered binaries | Makefile, atlas.py, len_tells.py | repo signature files | LIVE |
| join the target pool and near-miss ledger into one byte-weighted queue | `worklist.py` | Joins the target pool and the near-miss ledger into one byte-weighted ranked queue | build_fuel_manifest.py | repo scratch paths | LIVE |
| keep a ranked ledger of every close-but-not-matching attempt | `backlog.py` | Near-miss ledger: every close-but-not-matching attempt, ranked for hand sessions | Makefile, atlas.py, auto_status.sh, autopsy.py (+11) | repo scratch/doc paths | LIVE |
| name the true blocker of every remaining open function, deterministically | `frontier_classify.py` | Classifies every remaining open function by its true blocker, deterministically | — | repo paths | REFERENCED |
| negative-control the comparer: every stub's built object must equal its target | `stub_invariant_audit.py` | Negative control: for every stub the built object must equal the target assembly exactly | — | repo build paths | REFERENCED |
| negative-control the detector that decides a function's optimization level | `test_o0_detect.py` | Negative control for the matcher's optimization-level auto-detection | — | repo paths | ORPHAN |
| partition every open function into exactly one lever-labelled work group | `atlas.py` | Partitions all open functions into exactly one lever-labelled work group | Makefile, atlas_features.py, build_wave_atlas.py, main_lane.py (+2) | repo scratch paths | LIVE |
| rank unmatched functions easiest-first by size, control flow and call count | `difficulty.py` | Ranks unmatched functions easiest-first by size, control flow, table presence and call count | Makefile | repo asm layout | LIVE |
| re-score both arms of an experiment with the standalone matcher as ground truth | `ab_score.py` | Re-scores every draft of two experiment arms with the standalone matcher as ground truth | api_draft.py, train_lora.py | repo scratch paths | LIVE |
| recompute headline metrics and fail if the committed digest disagrees | `audit_digest.py` | Recomputes headline metrics from the current tree and fails if the committed digest disagrees | Makefile | repo docs paths | LIVE |
| regression-test the table-carve configuration parser with a negative control | `test_jtbl_parse_config.py` | Regression plus negative control for the table-carve configuration parser | jtbl_carve.py | repo config fixtures | LIVE |
| report byte-identical and structurally identical function groups within and across binaries | `dup_report.py` | Reports byte-identical and structurally identical function groups within and across binaries | Makefile, atlas.py, atlas_features.py, audit_binaries.py (+4) | repo signature files | LIVE |
| resolve every relocation in a draft and compare the resolved words to target | `reloc_verify.py` | Resolves every relocation in a draft and compares the resolved words to the target | — | repo build paths | ORPHAN |
| revert known answers to stubs and categorize every harness failure it exposes | `p16_improve.py` | Known-answer loop: reverts matched functions to stubs and measures the real pipeline | — | repo src/build paths | ORPHAN |
| track per-session yield and velocity so a diminishing-returns close is visible | `burndown.py` | Tracks per-session yield and velocity so a diminishing-returns close is visible | — | repo ledger paths | ORPHAN |
| unit-test a residual classifier on hand-encoded words, not its own decoder | `test_residual_class.py` | Synthetic hand-encoded unit tests for the deterministic residual classifier | — | MIPS encodings | REFERENCED |

## P6 — the multipliers: signatures, dedup, families, the reconcile ladder, the carve chain

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| answer from a prologue whether a function was built unoptimized | `o0_detect.py` | The single place that answers whether a function was built unoptimized, from its prologue | match_one.py, neighbor_ref.py, o0_boundary.py, residual_rules_b.py (+2) | compiler prologue shape | LIVE |
| apply one proven codegen lever everywhere the bytes say it belongs | `weave_sweep.py` | Applies one known prologue-scheduling lever everywhere the bytes say it belongs | — | repo src layout, compiler behaviour | REFERENCED |
| assert a read-only-data carve's interleave order equals the segment sequence | `interleave_check.py` | Asserts the carve interleave order equals the segment sequence, position by position | — | repo config layout | REFERENCED |
| bank a matched jump-table exemplar across its siblings, reverting on failure | `jtbl_family_bank.py` | Banks a matched jump-table exemplar across its structural siblings, revert-on-fail | dedup_extend.py, family_sweep.py, reloc_verify.py | repo config/src layout | LIVE |
| bank a refused draft by copying the destination unit's own declarations into it — the declaration-conflict class a canonical type layer prevents (Phase 6) | `sync_tu_decls.py` | Banks a refused draft by copying the destination unit's own declarations into it | docs/wave-playbook.md, recover_route.py | repo src layout | LIVE |
| bank every open stub that already has a banked structural twin | `twin_sweep.py` | Banks every open stub that has an already-banked structural twin, for near-zero tokens | docs/wave-playbook.md | repo signature files | LIVE |
| bind a void definition to a symbol the destination declares as returning a value | `fix_decl_mirror.py` | Binds a void definition to its symbol when the destination declares a value return | — | repo src layout | ORPHAN |
| classify drifted structural siblings by aligned words and expand their constants | `family_align.py` | Length-tolerant aligned classifier plus the mechanical constant-expansion engine for drifted members | len_tells.py | repo scratch paths | LIVE |
| classify every exclude-list entry by its current blocker and regenerate the list | `exclude_audit.py` | Classifies every exclude-list entry by its current blocker and regenerates the list | docs/wave-playbook.md, draw_waves.py | repo config path | LIVE |
| cluster the open frontier one tier looser than exact skeleton hashing | `family_cousins.py` | Similarity clustering one tier looser than exact skeleton hashing over the open frontier | Makefile, aprop_autodraft.py, atlas.py, atlas_features.py (+3) | repo signature files | LIVE |
| compute the fleet's consensus declaration for every symbol, as card fuel — the seed of a canonical type layer (Phase 6) | `decl_prior.py` | Computes the fleet's consensus declaration for every symbol, as card fuel | build_wave_atlas.py, family_remap.py, t5_cards.py | repo src layout | LIVE |
| conform a draft's data declarations to what its destination unit can see | `reconcile_tu.py` | Conforms a draft's data declarations to what the destination translation unit can actually see | gate_stage.py, harvest_verify.py, integration_resolver.py, jtbl_family_bank.py | repo src layout | LIVE |
| conform every declaration of a function fleet-wide to its byte-true definition — width and signedness proven by the bytes at bank time (Phase 6) | `conform_decls.py` | Conforms every declaration of a function fleet-wide to its byte-true definition | family_sweep.py, macro_draft.py | repo src/shared-header layout | LIVE |
| demote declaration scope as one rung of the recovery ladder | `scope_demote_drafts.py` | The scope-demote step, wired as a rung of the recovery ladder | gate_stage.py, recover_route.py | repo src layout | LIVE |
| derive an object's inter-table padding spec from the bytes instead of searching | `pads_audit.py` | Derives each object's padding spec from the bytes instead of searching for it | — | repo build/config layout | REFERENCED |
| draft a family member mechanically from a seed body and symbol rebase | `aprop_autodraft.py` | Mechanically drafts a family member from the seed body plus a positional symbol rebase | decl_from_use.py, maintenance.sh, sibling_lane.sh | repo scratch paths | LIVE |
| escape a shared-header declaration conflict locally by unmacroizing one body | `demacroize.py` | Per-binary local escape from a shared-header declaration conflict by unmacroizing one body | recover_integration.py | repo shared-header layout | LIVE |
| extend an existing code-share registry to newly onboarded binaries | `dedup_extend.py` | Extends the existing share registry to newly onboarded binaries | audit_binaries.py, share_body.py | repo config/src layout | LIVE |
| find and bank unoptimized functions stranded at an optimized region's boundary | `o0_boundary.py` | Finds and banks unoptimized functions stranded at the end of an unoptimized region | — | repo config layout | REFERENCED |
| free duplicate matches a share propagation skips as not self-contained | `inject_capped_externs.py` | Frees high-reach inline matches skipped as not self-contained by injecting their file-scope externs | — | repo shared-header layout | REFERENCED |
| infer a minimal extern for a data symbol the destination unit does not declare | `decl_from_use.py` | Infers a minimal extern for a data symbol a draft uses but its destination does not declare | aprop_autodraft.py, integration_resolver.py, residual_rules_b.py | repo src layout | LIVE |
| isolate every switch function in a binary in one multi-cut resegment | `jr_isolate_all.py` | One-shot multi-cut resegment isolating every switch function in a binary | harvest_verify.py, jtbl_carve.py, jtbl_family_bank.py, o0_subsplit.py (+1) | repo config/src layout | LIVE |
| join two related builds' signature dumps into a function correspondence | `match_protos.py` | Joins per-function signature dumps of two related builds into a function correspondence | dup_report.py | repo signature files | LIVE |
| let a unit keep calling, through per-site casts, the function it now defines | `cast_self_callers.py` | Lets a unit keep calling, through a per-site cast, the function it is about to define | docs/wave-playbook.md, recover_integration.py, recover_route.py | repo src layout | LIVE |
| lift a named list of types fleet-wide into the shared type header — the canonical type layer from the first bank (Phase 6, the multiplier); again at readability (Phase 10) | `lift_types.py` | Lifts a named list of types fleet-wide into the shared type header | build_engine_types.py, uniquify_type.py | repo shared-header path | LIVE |
| lift one matched body into a shared macro and instantiate it everywhere | `dedup_propagate.py` | Lifts one matched body into a shared macro and instantiates it at every duplicate site | auto_driver.py, bulk_harvest.py, gate_lane.py, gate_stage.py (+5) | repo shared-header/src layout | LIVE |
| materialize a shared macro body back into a compilable standalone draft | `macro_draft.py` | Materializes a shared macro body back into a compilable standalone draft | — | repo shared-header layout | ORPHAN |
| move a unit's file-scope data externs down into their consumers | `scope_tu_externs.py` | Moves a unit's own file-scope data externs down into their consumers to legalize a block-scope type | family_sweep.py, jtbl_family_bank.py, recover_integration.py | repo src layout | LIVE |
| name the one exemplar to draft per structural family, ranked | `family_manifest.py` | Ranked structural-family target manifest naming the one exemplar to draft per family | family_hseq.py | repo signature files | LIVE |
| normalize a function's own declaration when a templated definition lands in a new unit | `normalize_self_decls.py` | Normalizes a function's own declaration when a templated definition lands in a new unit | family_sweep.py | repo src layout | LIVE |
| parse C declarators once, for every declaration tool to share | `cdecl.py` | The single recursive-descent C declarator parser every declaration tool shares | Makefile, blocker_probe.py, canon_sig_reconcile.py, cast_call_sites.py (+21) | C89 grammar only | LIVE |
| partition a source file at object boundaries, aware of comment state | `overlay_src_split.py` | Comment-state-aware partition of a source file, the oracle for the split chain | jr_isolate_all.py, neighbor_ref.py, o0_subsplit.py, share_census.py (+1) | repo src layout | LIVE |
| place a templated body's data externs at a scope the destination accepts | `scope_data_externs.py` | Places a templated body's data externs at the scope the destination unit can accept | family_sweep.py, jtbl_family_bank.py, scope_demote_drafts.py, scope_tu_externs.py | repo src layout | LIVE |
| property-test the signature tool on committed fixtures, needing no compiler | `xsig/tests/test_xsig.py` | Property tests for the signature tool on committed fixtures, needing no compiler | .github/workflows/no-rom.yml, Makefile | fixture paths | LIVE |
| rank clusters of the unmatched frontier by mnemonic-skeleton hash | `family_hseq.py` | Ranked clustering of the unmatched frontier by mnemonic-skeleton hash | Makefile, audit_binaries.py, audit_frontier.py, build_wave_atlas.py (+6) | repo signature files | LIVE |
| rebase a remapped draft's stale seed symbols onto the target's own | `aprop_symfix.py` | Rebases stale seed symbols in a mechanically adapted draft onto the target's own symbols | aprop_autodraft.py, family_cousins.py, integration_resolver.py, recover_rejects.py | repo symbol/config sources | LIVE |
| reconcile a definition's typed signature with what its destination unit declares — part of banking against a canonical type layer from Phase 6; again at readability (Phase 10) | `canon_sig_reconcile.py` | Reconciles a definition's typed signature with what its destination unit already declares | family_sweep.py, jtbl_family_bank.py | repo src layout | LIVE |
| regenerate the signature tool's fixtures with the pinned toolchain | `xsig/tests/make_fixtures.sh` | Regenerates the signature-tool fixtures with the pinned toolchain | test_xsig.py | compiler triple, repo tool paths | LIVE |
| remap a matched exemplar's source onto a structural sibling by positional symbol pairing | `family_remap.py` | Mechanically remaps a matched exemplar's C onto a structural sibling by positional symbol pairing | aprop_autodraft.py, atlas.py, atlas_features.py, dedup_extend.py (+17) | repo src layout | LIVE |
| repair a shared caller's argument-count conflict for the no-prototype failure class | `fix_arity_callers.py` | Repairs the shared-caller argument-count conflict for the no-prototype failure class | docs/wave-playbook.md, cdecl.py, dedup_propagate.py, gate_stage.py (+2) | repo shared-header layout | LIVE |
| repair a stale padding spec by search plus byte proof, never by guessing | `jtbl_pads_fix.py` | Repairs a stale padding spec by search plus byte proof, never by guessing | maintenance.sh | repo config layout | LIVE |
| report which open stubs became mechanical remaps the moment one was banked | `twin_rescan.py` | After a bank, reports which open stubs just became mechanical remaps instead of drafts | — | repo signature files | REFERENCED |
| reproduce the original inter-table padding in a multi-table carve | `jtbl_rodata_pads.py` | Post-assembler filter reproducing the original inter-table padding in a multi-table carve | Makefile, compile_only.py, gate_main.py, jtbl_carve.py | compiler/assembler behaviour, repo build paths | LIVE |
| restore file-scope declarations a share propagation deleted with the body | `restore_dropped_decls.py` | Puts back file-scope declarations a share propagation deleted with the body | — | repo src layout | ORPHAN |
| retype a unit's stale forward declarations to a draft's byte-true return, reverting on failure | `fix_tu_ret_decls.py` | Retypes a binary's own stale forward declarations to a draft's byte-true return, revert-on-fail | maintenance.sh | repo src layout | LIVE |
| rewrite address-named calls in a draft to their curated symbol names | `canon_resident_calls.py` | Rewrites address-named calls in a draft to the curated symbol name when one exists | gate_stage.py, integration_resolver.py | repo symbol file path | LIVE |
| roll an unoptimized definition atomically across every binary carrying it | `rollout_o0.py` | Generalized two-file atomic rollout of an unoptimized definition across every binary carrying it | Makefile, match_one.py | repo src/config layout | LIVE |
| route an unoptimized address range sitting inside an otherwise optimized object | `o0_subsplit.py` | Routes an unoptimized address range that sits inside an otherwise optimized object | match_one.py | repo config layout | LIVE |
| set up the read-only-data carve for a binary's matched jump-table functions | `jtbl_carve.py` | Sets up the read-only-data carve for a binary's matched jump-table functions | Makefile, config/overlays.mk, build_wave_atlas.py, harvest_verify.py (+7) | repo config/build layout | LIVE |
| sign every function of a flat image at a known base, without a disassembler | `sig_image.py` | Disassembler-free per-function signer for a flat image at a known base, field-identical to the dumper | Makefile, atlas_features.py, corpus.py, dedup_extend.py (+6) | MIPS encodings, repo scratch paths | LIVE |
| sign functions with relocations masked for cross-project code identification | `xsig/xsig.py` | Relocation-masked per-function signatures for cross-project code identification | .github/workflows/no-rom.yml, Makefile, test_xsig.py | MIPS/relocation model only | LIVE |
| sweep a matched exemplar across every same-structure sibling, gate-arbitrated | `family_sweep.py` | Sweeps a matched exemplar across every same-structure sibling, gate-arbitrated | recover_integration.py, twin_sweep.py | repo src/config layout | LIVE |
| unify a draft's callee externs and its own signature to the banked-canonical set | `sig_unify.py` | Unifies a draft's callee externs and its own definition signature to the banked-canonical set | auto_driver.py, cast_call_sites.py, cdecl.py, gate_stage.py (+1) | repo shared-header paths | LIVE |
| validate a code-share registry byte-honestly, failing closed on signature drift | `dedup_integrate.py` | Byte-honesty validator for the code-share registry; fails closed on signature drift | Makefile, dedup_propagate.py, macro_to_header.py, progress.py (+1) | repo config registry path | LIVE |

## P7 — the codegen map, the dumps, the permuter

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| classify a length-drift near-miss against its own target and build its routing card | `len_tells.py` | Classifies a length-drift near-miss against its own target and builds the routing card | atlas_features.py | repo scratch paths | LIVE |
| classify a residual's shape to its documented lever, as an independent implementation | `residual_rules_b.py` | Independent second implementation of residual-shape to rule classification, for head-to-head | triage_ladder.py | repo doc paths | LIVE |
| classify where a remapped sibling's compiled bytes diverge from its target | `diff_regions.py` | Classifies where a remapped member's compiled bytes diverge from its target | — | repo build paths | ORPHAN |
| compile a permuter candidate exactly as the build rule does | `permuter/compile.sh` | The permuter's compile command, mirroring the build rule exactly so objects are build-faithful | p16_permute.py, compile_o0.sh | compiler triple, repo build flags | LIVE |
| compile a permuter candidate unoptimized, exactly as the build rule does | `permuter/compile_o0.sh` | Unoptimized variant of the same permuter compile command | p16_permute.py | compiler triple, repo build flags | LIVE |
| decide whether a residual reorder is scheduling or a register-grant consequence | `oracle/reg_renumber_swap.sh` | Mechanized oracle separating a register-allocation swap from a scheduling reorder | — | compiler triple, repo scratch paths | ORPHAN |
| drive the permuter per function, building base, target and settings | `p16_permute.py` | Per-function permuter driver building base, target and settings, then reporting closeness | auto_driver.py, grinder.py, permuter_ils.py | repo scratch paths, permuter layout | LIVE |
| find pseudo-registers with references but no remaining occurrences, and their frame slots | `ghost_census.py` | Frame-residue oracle: finds pseudos with references but no remaining occurrences, and their slots | cc1_dumps.sh | compiler pass-dump format | LIVE |
| find which words diverge when the whole-binary gate says different but not where | `diff_autopsy.sh` | Reproduces exactly what the gate saw, then decodes the diverging words and restores the tree | — | repo src/build paths | REFERENCED |
| grind the closest near-misses with the permuter and bank through the gate | `grinder.py` | Token-free permuter daemon grinding the closest near-misses and banking through the gate | auto_status.sh, auto_supervisor.sh, autopsy.py, gate_stage.py (+4) | repo scratch paths | LIVE |
| hand a batch's near-misses to the permuter, only the ones worth CPU | `permuter_sweep.py` | Hands a batch's near-misses to the permuter, but only the ones worth the CPU | docs/wave-playbook.md | repo scratch paths | LIVE |
| list each pseudo-register's refs, live length and allocation priority from compiler dumps | `alloc_table.py` | Prints each pseudo's refs, live length, block and allocation priority from compiler pass dumps | cc1_dumps_tu.sh | compiler pass-dump format, repo dump root | LIVE |
| map a residual to a named codegen class by decoding its words | `residual_class.py` | Deterministic decoder-based classifier mapping a residual to a named codegen class | autopsy.py, match_one.py, permuter_weights.py, residual_rules_b.py (+1) | MIPS encodings | LIVE |
| recompile every open draft and classify its failure into a residual corpus | `autopsy.py` | Materializes the residual corpus by recompiling every open draft and classifying its failure | grinder.py | repo scratch/build paths | LIVE |
| run the permuter with a masked scorer rebound, without patching it | `permuter/run_masked.py` | Runs the permuter with the masked scorer rebound before its entry point, without patching it | masked_scorer.py, p16_permute.py | permuter internals, repo module paths | LIVE |
| score permuter candidates on true masked code closeness, not mnemonic diff | `masked_scorer.py` | Drop-in permuter scorer scoring true relocation-masked code closeness instead of mnemonic diff | masked_diff.py, run_masked.py | permuter internals, repo module paths | LIVE |
| steer permuter mutation toward the lever family the residual class implies | `permuter_weights.py` | Directs permuter mutation toward the lever family the residual class implies | autopsy.py, p16_permute.py | permuter settings format | LIVE |
| tag every compiler-source citation with the source tree it refers to | `gccmap_cites.py` | Tags every compiler-source citation in the codegen-map docs with the tree it refers to | .github/workflows/no-rom.yml, Makefile | repo doc/reference paths | LIVE |
| turn a red whole-binary result into a named list of divergent symbols | `main_diff_locate.py` | Turns a red whole-binary result into a named list of divergent symbols | gate_main.py | repo build/config layout | LIVE |
| warm-restart the permuter from its best waypoint each cycle | `permuter_ils.py` | Iterated-local-search wrapper warm-restarting the permuter from the best waypoint each cycle | grinder.py, permuter_sweep.py | permuter layout, repo scratch paths | LIVE |

## P8 — the campaign: cards, lanes, gates, recovery, harvest

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| assert that a tool actually did the work it reports | `work_evidence.py` | Assertions that a tool actually did the work it reports | .github/workflows/no-rom.yml, Makefile, gate_stage.py, parallel_gate.py | repo scratch paths | LIVE |
| block until a background lane raises its next batch, without polling | `lanes/wait_distill.sh` | Blocks until the distillation lane raises the next batch, then exits | — | repo scratch paths | ORPHAN |
| build a wave from the frontier atlas, optimized for gate throughput | `build_wave_atlas.py` | Builds a wave from the frontier atlas, optimized for gate throughput | main_lane.py, ox_campaign.py, wave_card_fuel.py | repo scratch paths | LIVE |
| build the card fuel for one wave's own targets, keyed per binary | `t5_cards.py` | Builds the card fuel for one wave's own targets, keyed correctly per binary | docs/wave-playbook.md, build_wave_atlas.py, draw_waves.py, seed_ref.py (+2) | repo scratch paths | LIVE |
| build the per-function prompt packs a drafting agent wave works from | `claude_wave_packs.py` | Builds the per-function prompt packs an agent wave drafts from | docs/wave-playbook.md, draw_waves.py, journal_notes.py, t5_cards.py | repo scratch paths, agent harness | LIVE |
| carve, draft and bank jump-table functions as their own lane | `jtbl_lane.py` | Carve, draft and bank lane for jump-table functions, with the carve deliberately outside it | idiom_serial.py | repo config/src layout | LIVE |
| check a commit out into its own worktree and verify it there | `verify_worktree.py` | Checks a commit into its own worktree, provisions build deps, and verifies it there | jr_isolate_all.py, hash_dict.py, resolve_tokens.py | repo worktree/build layout | LIVE |
| compute in one library the per-target card fuel a prompt pack carries | `wave_card_fuel.py` | The single library computing the per-target card fuel a pack carries | build_wave_atlas.py, t5_cards.py | repo scratch paths | LIVE |
| condense a session transcript into readable text for a successor session | `transcript_dump.py` | Condenses a session transcript into readable text for a successor session | docs/wave-playbook.md | agent transcript paths | LIVE |
| decide before and after drafting whether a target needs an agent at all | `triage_ladder.py` | Zero-token pass deciding whether a target needs an agent at all, before and after drafting | docs/wave-playbook.md | repo scratch paths | LIVE |
| decide which harvested waves still need mining into the technique document | `distill_scan.py` | One pass of the distillation lane deciding which harvested waves still need mining | distill.sh | repo scratch paths | LIVE |
| detect and repair lane stalls automatically on measured conditions | `lanes/stallguard.sh` | Detects and repairs lane stalls on measured conditions every minute, logging each action | — | lane names, repo paths | ORPHAN |
| discover an executable slate's bankable drafts concurrently, then bank once serially | `gate_main_parallel.py` | Discovers the executable's bankable drafts concurrently, then banks them once, serially | — | repo build/make targets | REFERENCED |
| discover new compiler idioms from grouped near-misses with a reasoning model | `idiom_hunt.py` | Uses a reasoning model on grouped near-misses to discover new compiler idioms | gate_stage.py | provider endpoint, repo paths | LIVE |
| draft one function against any chat-completions endpoint, provider-agnostic | `api_draft.py` | Provider-agnostic single-shot drafting worker against any chat completions endpoint | api_agent.py, eval_lora.py, format_finetune.py, lora_grind.py (+2) | provider endpoint, repo doc paths | LIVE |
| drain finished drafts into the gate continuously while drafting still streams | `gater_lane.py` | Continuous gater draining a wave's finished drafts into the parallel gate, grouped by binary | — | repo scratch paths | REFERENCED |
| draw several drafting waves off the open frontier, cheapest-first | `draw_waves.py` | Draws several drafting waves off the open frontier, cheapest-first | docs/wave-playbook.md, seed_ref.py, strand_census.py | repo scratch paths | LIVE |
| drive a wave's gate accepting either result shape and an explicit draft path | `gate_lane.py` | The wave gate driver, accepting either result shape and an explicit draft path | aprop_autodraft.py, aprop_symfix.py | repo scratch paths | LIVE |
| drive batch integration recovery over a directory of correct-but-rejected drafts | `recover_integration.py` | Batch integration recovery driver over a wave directory of correct-but-rejected drafts | docs/wave-playbook.md, claude_wave_packs.py | repo scratch/src layout | LIVE |
| drive structural sibling sweeps with synthesized declarations, free of model tokens | `lanes/sibling_lane.sh` | The free sibling lane driving structural sweeps with synthesized declarations | — | repo paths | ORPHAN |
| emit the exact drafting-workflow arguments, asserting every target is still open | `wave_args.py` | Emits the exact workflow arguments for a wave, asserting every target is open | docs/wave-playbook.md, draw_waves.py, gater_lane.py, launch_check.py | repo scratch paths | LIVE |
| evaluate a fine-tuned matching model gate-truthfully on held-out banked functions | `eval_lora.py` | Gate-true evaluation of a fine-tuned model on held-out banked functions | — | dataset paths, repo corpus | ORPHAN |
| find an already-banked body that matches an open stub, near and contained tiers | `seed_ref.py` | For an open stub, finds the already-banked body that matches it, including near and contained tiers | docs/wave-playbook.md, t5_cards.py, twin_rescan.py | repo signature files | LIVE |
| fine-tune a code model into a matching specialist on a mined corpus | `train_lora.py` | Fine-tunes a code model into a matching specialist and saves the adapter | — | dataset paths, training venv | ORPHAN |
| gate a whole wave by splitting table-bearing drafts off and running lanes concurrently | `gate_wave.py` | Gates a whole wave by splitting table-bearing drafts off and running both lanes concurrently | docs/wave-playbook.md | repo scratch/config layout | LIVE |
| gate each arm on the whole binary with a tree reset between arms | `wave_judge.py` | Per-arm whole-binary gate with tree reset between arms, then gates the best-of union | claude_wave_packs.py | repo scratch/src layout | LIVE |
| gate every target list for validity before agents are spawned | `validate_targets.py` | The validity gate every target list must pass before agents are spawned | build_wave_atlas.py, wave_snapshot.py | repo scratch paths | LIVE |
| gate many binaries concurrently in isolated worktrees and merge only passers | `parallel_gate.py` | Gates many binaries concurrently in isolated worktrees and merges only the passers | docs/wave-playbook.md, gate_main_parallel.py, gate_wave.py, gater_lane.py (+1) | repo worktree/build layout | LIVE |
| gate pre-staged draft directories across distinct binaries in parallel | `sweep_parallel.py` | Gates pre-staged draft directories across distinct binaries in parallel | family_sweep.py, idiom_serial.py, integration_resolver.py, maintenance.sh (+2) | repo scratch paths | LIVE |
| gate the executable's drafts the only trustworthy way: a clean rebuild with bisect | `gate_main.py` | Gates a batch of executable drafts the only trustworthy way: a clean rebuild with bisect | Makefile, docs/wave-playbook.md, build_wave_atlas.py, decl_prior.py (+12) | repo build/make targets | LIVE |
| generate a callee-signature-aware target manifest with per-function fleet reach | `gen_harvest_targets.py` | Generates a callee-signature-aware target manifest with per-function fleet reach | cast_call_sites.py, cdecl.py, sig_unify.py | canonical source binary, repo paths | LIVE |
| give a wave its own immutable copy of the disassembly its agents read | `wave_snapshot.py` | Gives a wave its own immutable copy of the disassembly files its agents read | build_wave_atlas.py | repo asm paths | LIVE |
| give an external chat model the same multi-turn tool harness an agent gets | `api_agent.py` | Gives an external chat model the same multi-turn tool harness an agent gets | claude_wave_packs.py, idiom_serial.py, jtbl_lane.py, ox_campaign.py | provider endpoint, repo doc paths | LIVE |
| hold one reader/writer lock over the shared source state for concurrent lanes | `shared_lock.py` | One reader/writer lock over the shared source state for concurrent lanes | bulk_harvest.py, dedup_propagate.py, fix_arity_callers.py, gate_stage.py | repo lock paths | LIVE |
| keep an unattended campaign loop alive across run caps and crashes | `lanes/forever.sh` | Keeps the wave campaign running indefinitely across caps and crashes | — | repo scratch paths | ORPHAN |
| keep an unattended driver alive across crashes until a clean exit | `auto_supervisor.sh` | Keeps an unattended driver alive across crashes until a clean or requested exit | grinder.py, lora_grind.py | repo scratch paths | LIVE |
| keep drafting running continuously, touching only scratch state | `lanes/drafter.sh` | The drafting lane that must never stop; touches only scratch state | relaunch_drafter_shell.sh | repo scratch paths, provider config | LIVE |
| know authoritatively which drafting agents are currently live | `lane_inflight.py` | The authoritative ledger of which drafting agents are currently live | parallel_gate.py, r22_verify.sh, triage_ladder.py | repo scratch paths | LIVE |
| learn idioms serially so each target inherits what the previous one taught | `idiom_serial.py` | The serial idiom-learning lane where each step inherits what the previous learned | build_wave_atlas.py, campaign.sh, elastic.sh, ox_campaign.py | repo scratch paths | LIVE |
| loop a stub worklist through scaffold, draft and gate without any model | `auto_driver.py` | Autonomous model-free driver looping a stub worklist through scaffold, draft and gate | auto_supervisor.sh | canonical source binary, repo paths | LIVE |
| loop draw, draft, pre-filter, gate, commit and ledger unattended | `ox_campaign.py` | The unattended wave loop: draw, draft, pre-filter, gate, commit, ledger, repeat | idiom_serial.py, campaign.sh, drafter.sh, gater.sh (+4) | repo scratch paths, provider config | LIVE |
| mass-draft small stubs with a served model and gate them in parallel | `bulk_harvest.py` | Phase-separated bulk drafting plus a parallel gate farm, for throughput | — | repo scratch paths, GPU endpoint | REFERENCED |
| measure a change's write set and name the verification it actually requires | `blast_radius.py` | Measures a change's write set and names the verification it actually requires | sweep_parallel.py | repo tree layout | LIVE |
| measure a drafting provider's real request rate and rate-limit attribution | `api_rate.py` | Reports measured request rate and rate-limit attribution from append-only telemetry | — | repo telemetry path | ORPHAN |
| mine each function's own past-attempt history out of agent journals | `journal_notes.py` | Mines per-function past-attempt notes out of the agent journals into card fuel | docs/wave-playbook.md, claude_wave_packs.py, draw_waves.py, frontier_classify.py (+1) | agent transcript paths | LIVE |
| mine gate-verified assembly-to-source pairs into a fine-tuning corpus | `export_pairs.py` | Mines gate-verified assembly-to-source pairs into a fine-tuning corpus | — | repo src/build layout | REFERENCED |
| name the one recovery tool that actually applies to a drop verdict | `recover_route.py` | Given a drop verdict, names the one recovery tool that actually applies | docs/wave-playbook.md, gate_main.py | repo scratch paths | LIVE |
| pick the pool, emit the batch and record the cycle, deterministically | `orchestrator.py` | The deterministic half of the unattended loop: pick the pool, emit the batch, record the cycle | gate_stage.py | repo scratch paths | LIVE |
| pre-filter agents' knowledge-gap reports against the existing technique document | `gap_triage.py` | Pre-filters a wave's knowledge-gap reports against the existing documentation | — | repo doc paths | ORPHAN |
| print an unattended run's heartbeats and recent progress for a remote check-in | `auto_status.sh` | Prints the unattended run's heartbeats and recent progress for a remote check-in | auto_supervisor.sh | repo scratch paths | LIVE |
| pull newly learned idioms out of a wave's logs into candidate notes | `idiom_harvest.py` | Pulls the newly learned idioms out of a wave's shard logs into candidate notes | distill.sh, ox_campaign.py | repo log paths | LIVE |
| pull the final structured verdict out of each subagent transcript | `agent_verdicts.py` | Pulls the final structured verdict out of subagent transcripts | docs/wave-playbook.md, agent_reports.py, transcript_dump.py | agent transcript paths | LIVE |
| rank already-matched functions worth reading as worked examples for an open stub | `neighbor_ref.py` | For an open stub, ranks already-matched functions worth reading as worked examples | docs/wave-playbook.md, claude_wave_packs.py | repo signature files | LIVE |
| re-judge already byte-correct drafts and bank them for zero model tokens | `integration_resolver.py` | Zero-token lane re-judging drafts that are already byte-correct and banking them | decl_from_use.py, resolver_lane.sh | repo scratch paths | LIVE |
| re-judge, verify twice, stage and gate correct drafts for zero tokens | `lanes/resolver_lane.sh` | The zero-token resolver lane: re-judge, verify twice, stage, gate, commit | — | repo scratch paths | REFERENCED |
| re-stage only drafts that match in their real unit so one failure is isolated | `restage_matching.py` | Re-stages only the drafts that compile and match in their real unit, so one failure is isolated | — | repo src layout | REFERENCED |
| rebuild an agent's final draft by replaying its transcript writes | `agent_drafts_restore.py` | Replays an agent's writes from its transcript to rebuild its final deliverable | docs/wave-playbook.md, transcript_dump.py | agent transcript paths | LIVE |
| rebuild the executable lane's queue from the tree, never from a stale list | `main_queue_rebuild.py` | Rebuilds the executable lane's queue from the tree, never from a stale list | claude_wave_packs.py | repo src layout | LIVE |
| recover a large draft rejected only on declaration plumbing, with canonical externs | `recover_giant.py` | Canonical-extern recovery for a large draft rejected only on declaration plumbing | canon_sig_reconcile.py | repo shared-header layout | LIVE |
| refuse a draft that swallows a neighbouring symbol inside one function's range | `fragment_check.py` | Refuses drafts that subsume a neighbouring symbol, the enclosing-function trap | — | repo asm layout | ORPHAN |
| refuse to launch an agent at a target that is already banked | `launch_check.py` | Refuses to launch an agent at a target that is already banked | docs/wave-playbook.md | repo src layout | LIVE |
| report every concurrent lane with its own metrics, not only the loud one | `campaign_status.py` | One status view covering every lane, not only the loud one | — | lane names, repo scratch paths | ORPHAN |
| request a safe exit of an unattended run through a stop sentinel | `auto_stop.sh` | Requests a safe exit of the unattended run via a stop sentinel | auto_driver.py, auto_supervisor.sh, grinder.py, lora_grind.py (+1) | repo scratch paths | LIVE |
| restart the drafting lane's shell at a queue boundary so new arguments apply | `lanes/relaunch_drafter_shell.sh` | Waits for a wave to queue, then restarts the drafting lane's shell so new arguments apply | — | lane script paths | REFERENCED |
| restart the executable lane's shell at its one safe boundary | `lanes/restart_main_lane_when_idle.sh` | Restarts the executable lane's shell at its one safe boundary | — | lane script paths | REFERENCED |
| restart the gating lane's shell between gates so a jobs change lands | `lanes/restart_gater_when_idle.sh` | Restarts the gating lane's shell once the current gate finishes | — | lane script paths | ORPHAN |
| rotate binaries drafting small stubs with a served model, gating and propagating | `lora_grind.py` | Mass-run driver rotating binaries, drafting small stubs with a served model, gating, propagating | bulk_harvest.py, serve_local.py | repo scratch paths, model endpoint | LIVE |
| route a gate result set to the repair tool its own verdict names | `gate_triage.py` | Routes a gate result set to the repair tool its own verdict names | docs/wave-playbook.md | repo scratch paths | LIVE |
| run a restartable gating lane that is safe to kill at any time | `lanes/gater.sh` | The restartable gating lane, safe to kill and relaunch at any time | restart_gater_when_idle.sh | job count, repo paths | LIVE |
| run distillation beside drafting so learned idioms reach the next wave | `lanes/distill.sh` | The distillation lane, running beside drafting and never in front of it | — | repo scratch paths | REFERENCED |
| run the executable's own draft, gate and commit cadence beside other lanes | `main_lane.py` | The executable's own draft, gate and commit cadence beside the other lanes | main.sh | repo build/make targets | LIVE |
| run the executable's own lane loop on its clean-rebuild cadence | `lanes/main.sh` | The executable's own lane loop, on its clean-rebuild cadence | gate_stage.py, restart_main_lane_when_idle.sh | repo make targets | LIVE |
| run the free recovery and re-judgement passes whenever the gate is idle | `lanes/maintenance.sh` | The maintenance lane running the free recovery and re-judgement passes | — | repo scratch paths | ORPHAN |
| run the one shared recovery, byte-gate and log ladder every producer calls | `gate_stage.py` | The shared deterministic recovery, gate and log ladder every producer calls | docs/wave-playbook.md, api_agent.py, bulk_harvest.py, dedup_extend.py (+12) | repo src/config layout | LIVE |
| run the token-free permuter grinder beside a saturated gate | `lanes/grinder_lane.sh` | Runs the model-free permuter grinder beside a saturated gater | — | repo scratch paths | ORPHAN |
| run two drafting pools against one serial gate | `lanes/campaign.sh` | Dual-pool campaign lane: two drafting pools, one serial gate | forever.sh | provider config, repo paths | LIVE |
| save each subagent's full final report to one file per target | `agent_reports.py` | Saves each subagent's full final prose report to one file per target | docs/wave-playbook.md, transcript_dump.py | agent transcript paths | LIVE |
| select a worker wave's target batch from the manifest with cache filters | `wave_targets.py` | Selects a worker-wave target batch from the target manifest with cache filters | build_fuel_manifest.py, gate_stage.py, orchestrator.py | repo scratch paths | LIVE |
| serve a fine-tuned model locally behind a chat-completions endpoint | `serve_local.py` | Serves the fine-tuned model locally behind a chat-completions endpoint | bulk_harvest.py | training venv, GPU assumptions | LIVE |
| spend spare provider capacity on other work when the gate is the constraint | `lanes/elastic.sh` | Spends spare provider capacity on extra work when the main lane cannot | — | provider config, repo paths | ORPHAN |
| substitute, build, keep only if byte-identical, else revert | `harvest_verify.py` | The whole-binary byte gate: substitute, build, keep only if identical, else revert | auto_driver.py, dedup_extend.py, family_sweep.py, gate_stage.py (+5) | repo src/build layout | LIVE |
| turn mined pairs into a chat-template instruction dataset | `format_finetune.py` | Turns the mined pairs into a chat-template instruction dataset | api_draft.py, train_lora.py | dataset paths, model chat template | LIVE |
| turn pre-gate rejects back into bankable drafts for zero model tokens | `recover_rejects.py` | Turns pre-gate rejects back into bankable drafts for zero model tokens | maintenance.sh | repo scratch paths | LIVE |
| unify live stubs into one ranked, class-tagged, cache-annotated target pool | `build_fuel_manifest.py` | Unifies live stubs into one ranked, class-tagged, cache-annotated target pool | orchestrator.py, worklist.py | canonical source binary, repo scratch paths | LIVE |
| validate a batch's declaration compatibility in seconds without building it | `pregate_check.py` | Validates a batch without building it, in seconds instead of minutes | gate_main.py | repo src layout | LIVE |
| verify the whole fleet exclusively on a clean tree and clear deferred debt | `r22_verify.sh` | Exclusive clean-tree fleet verification that also clears deferred-check debt | parallel_gate.py | repo make targets | LIVE |

## P9 — publish

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| acquire and checksum-verify vendor SDK pieces for a linked build | `fetch_psyq.sh` | Optional acquisition and checksum verification of vendor SDK pieces for the linked build | Makefile, psyq_libs_from_disc.py | PS1 SDK sources, repo paths | LIVE |
| assert a documented ignore-file template equals the shipped template byte for byte | `gitignore_template_check.py` | Asserts the ignore-file template in the docs equals the kit's template byte for byte | Makefile, kit_lint.py | repo doc and template paths | LIVE |
| assert nothing purged remains in any object, message or ref | `public_rewrite/absent_scan.py` | Asserts nothing purged remains in any object, message or ref | — | repo scratch paths | ORPHAN |
| assert that the distilled kit cites or dispositions every rule and every hindsight entry of the source project (no silent gap in the distillation) | `kit_coverage.py` | Derives the rule and accelerator populations from the digest and the ledger, matches them against the kit's provenance lines, refuses an uncovered entry unless config/kit_coverage_map.tsv dispositions it | Makefile | repo digest/ledger/kit paths + the provenance citation forms | LIVE |
| build a progress timeline from the repository's own committed digests | `timeline.py` | Builds a progress timeline from the repository's own committed digests, with a self-check | Makefile | repo doc paths | LIVE |
| check that every relative link in the public docs resolves | `doc_links.py` | Checks that every relative link in the public docs resolves and the link policy holds | Makefile, wiki_render.py, wiki_sync.sh | repo doc paths | LIVE |
| compile every eligible translation unit with the pinned toolchain, using no derived bytes | `compile_only.py` | Compiles every eligible translation unit with the pinned toolchain, without any game bytes | .github/workflows/no-rom.yml, macro_to_header.py, share_census.py | compiler triple, repo makefile parsing | LIVE |
| compute and publish progress metrics as report, machine data and per-binary breakdowns | `progress.py` | Computes and publishes the progress metrics as report, JSON and per-binary breakdowns | Makefile, docs/wave-playbook.md, api_agent.py, atlas.py (+33) | repo src/config layout | LIVE |
| convert progress metrics into an external progress-report schema | `objdiff_report.py` | Converts the progress JSON into the external progress-report schema | .github/workflows/progress.yml | external report schema | LIVE |
| emit the public ordinal-to-hash map and the private old-to-new map | `public_rewrite/build_commit_map.py` | Emits the public ordinal-to-new-hash map and the private old-to-new map | probe_github.sh, resolve_tokens.py | repo doc/scratch paths | LIVE |
| gate a first push: prove no derived bytes among tracked files | `audit_public.py` | The first-push gate: no derived bytes among tracked files, four independent checks | .github/workflows/no-rom.yml, gate_scan.py | repo purge-set and path lists (the kit's template reads `config/firewall.txt` instead) | LIVE |
| gather every recorded hindsight into one document with file and line anchors | `mine_hindsight.py` | Gathers every recorded hindsight with file and line anchors into one document | — | repo doc paths | REFERENCED |
| generate a symptom-keyed index of a large technique document | `cookbook_index.py` | Generates a symptom-keyed index of the large technique document | .github/workflows/no-rom.yml, Makefile, docs/wave-playbook.md, api_agent.py | repo doc paths | LIVE |
| keep a portable starter kit free of one project's names, paths and numbers | `kit_lint.py` | Keeps the day-one kit free of the source project's names, paths, addresses and rule numbers, honours its placeholder contract, and syntax-checks its scripts | Makefile | the kit path and the source project's leak pattern | LIVE |
| map every old commit hash to an inert token, privately | `public_rewrite/hash_dict.py` | Builds the private dictionary mapping every old commit hash to an inert token | common.py, run_filter.py | repo scratch paths | LIVE |
| probe whether old commit hashes still resolve on the hosting service | `public_rewrite/probe_github.sh` | Probes whether old commit hashes still resolve on the hosting service after a purge | build_commit_map.py | hosting service API, repo name | LIVE |
| prove no derived blob is reachable from the refs about to be pushed | `public_rewrite/gate_scan.py` | History gate: no derived blob reachable from the given refs, four derived checks | audit_public.py | repo declaration files | LIVE |
| prove pairwise that a rewrite changed only what it was told to | `public_rewrite/verify_rewrite.py` | Pairwise proof that the rewrite changed only what it was told to change | build_commit_map.py | repo scratch paths | LIVE |
| prove the whole byte-identity contract end to end, step by step | `verify_contract.sh` | The recorded end-to-end verification run of the byte-identity contract, step by step | — | repo make targets, output dir | REFERENCED |
| publish progress metrics to a hosted progress service | `frogress_upload.py` | Posts the progress JSON to a hosted progress service, dry-run by default | — | service URL, project/version names | REFERENCED |
| render and publish the docs to a hosted wiki, replacing its pages | `wiki_sync.sh` | Renders and publishes the docs to the hosted wiki, replacing its pages | wiki_render.py | wiki remote URL, repo paths | LIVE |
| render doc trees into wiki page names, rewriting every relative link | `wiki_render.py` | Renders the doc trees into wiki page names with every relative link rewritten deterministically | Makefile, wiki_sync.sh | repo doc paths | LIVE |
| run a history rewrite inside a bare clone, refusing to run elsewhere | `public_rewrite/run_filter.py` | Composes and runs the history rewrite inside a bare clone, refusing to run elsewhere | — | rewrite tool version, repo scratch paths | ORPHAN |
| scrub one text with the rewrite's rules, with a sample and self-test | `public_rewrite/scrub.py` | The single scrub function of the history rewrite, plus its sample and self-test | build_commit_map.py, run_filter.py, verify_rewrite.py | purge rules, repo scratch paths | LIVE |
| set up a fresh clone idempotently: packages, environments, pinned tools | `bootstrap.sh` | Idempotent fresh-clone setup: check packages, create environments, fetch pinned tools | Makefile, compile_only.py, decompme_replica.sh, make_fixtures.sh | repo layout, package names | LIVE |
| share the purge rules and derived hash sets across the rewrite package | `public_rewrite/common.py` | Shared purge rules, derived hash sets and helpers for the history-rewrite package | absent_scan.py, build_commit_map.py, gate_scan.py, hash_dict.py (+4) | repo scratch paths | LIVE |
| turn ordinal tokens back into shortest-unique hashes at the rewritten tip | `public_rewrite/resolve_tokens.py` | Turns ordinal tokens back into shortest-unique hashes at the rewritten tip | build_commit_map.py | repo tracked text files | LIVE |

## P10 — readability

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| add per-site function-pointer casts so a draft can call a differently typed callee | `cast_call_sites.py` | Adds per-site function-pointer casts so a draft can call a differently typed callee | canon_sig_reconcile.py, cast_self_callers.py, family_sweep.py, gate_stage.py (+4) | repo src layout | LIVE |
| apply curated names and signatures inside the analysis tool and save | `ghidra_scripts/ApplySymbols.java` | The in-tool half of that mirror: apply curated names and signatures, save on exit | ghidra_apply_symbols.sh, ghidra_export_annotations.sh, ghidra_rebuild.sh, ExportAnnotations.java (+1) | none | LIVE |
| convert a shared-body macro header into per-function plain-C headers included at each site | `macro_to_header.py` | The Phase-35 converter: every DEFINE_ macro body becomes a plain-C header under src/shared/<space>/ included at its site, the legacy name-parameterized headers converted, the registry text-edited, the macro header deleted; --plan / --apply / --finalize / --verify | share_body.py | the macro form is this project's; a kit-born project shares headers from its first bank | LIVE |
| emit a function's target assembly as an inline-assembly body | `asm_verbatim.py` | Emits the file-scope inline-assembly body form from a disassembly file | docs/wave-playbook.md, draft_prechecks.py, gate_main.py, recover_route.py | repo asm layout | LIVE |
| extract inline-defined types and typedefs from a source file into a shared header | `build_engine_types.py` | Extracts inline-defined named types and typedefs from a source file into a shared header | inject_capped_externs.py, lift_types.py, uniquify_type.py | repo shared-header path | LIVE |
| flag address-named references whose address now has a curated name | `lint_symbol_refs.py` | Flags address-named references in committed sources whose address now has a curated name | .github/workflows/no-rom.yml, Makefile | repo symbol/src paths | LIVE |
| give each conflicting camp of a same-named type its own name | `uniquify_type.py` | Gives each conflicting camp of a same-named type its own name so every camp becomes liftable | — | repo src layout | REFERENCED |
| guard that every inline-assembly body still reproduces its target bytes | `verbatim_check.py` | Regression guard that every inline-assembly body still reproduces its target bytes | .github/workflows/no-rom.yml, verbatim_target_s.py, verbatim_to_stub.py | repo src layout | LIVE |
| measure duplicate function bodies across the fleet and assert one source per unique function | `share_census.py` | The census of byte-identical function classes across every binary with their source forms and verdicts, plus the S1 invariant check with its exception ledger and a fixture self-test | audit_binaries.py, dedup_integrate.py, macro_to_header.py, overlay_src_split.py (+2) | repo paths, the registry and signature schemas | LIVE |
| mirror the curated symbol file into the analysis database with a real save | `ghidra_apply_symbols.sh` | Mirrors the curated symbol file into the analysis program headlessly, with a real save | — | repo symbol path, project name | REFERENCED |
| regenerate a splitter-format target disassembly for a function no longer stubbed | `verbatim_target_s.py` | Regenerates a splitter-format target disassembly for a function that is no longer a stub; --gas emits the assemblable gas-syntax form ($-registers, .L labels, noreorder) that a web diff service accepts as a pasted target | decompme_replica.sh | repo build/asm layout | LIVE |
| share one byte-identical function class across its binaries through an include-at-site header, gated per binary | `share_body.py` | The Phase-35 successor of dedup_propagate + dedup_extend for the include-at-site form: exemplar by majority text, the header written once, every private copy replaced by the include at its position, per-binary byte gate with object comparison, bisect on red, the registry appended or extended by text, the exception ledger on refusal; --plan / --apply --bucket extend|new | share_census.py | repo paths, the registry and signature schemas | LIVE |
| turn an inline-assembly body back into a stub the toolchain can reach | `verbatim_to_stub.py` | Turns an inline-assembly body back into an include-assembly stub | — | repo src/asm layout | REFERENCED |

## PROJECT-ONLY — project-only in code (the shape is a task; the code does not transfer)

| When you need to… | Tool | What it does | Proven by | Adapt | Class |
|---|---|---|---|---|---|
| account for every byte of the medium, leaving zero unexplained residue | `disc_audit.py` | Byte partition over one disc, importing the game-specific container and compression modules — the partition itself (every byte of the medium accounted for, residue zero) is a Phase-1 task | Makefile | project-only | LIVE |
| assemble a vendor graphics library's object list and address blocks for linking | `make_libgs.sh` | Hard-codes one executable's exact vendor object list and address blocks | Makefile, fetch_psyq.sh | project-only | LIVE |
| cross-validate an extraction against an independent third-party tool | `bfm_extract/crosscheck.py` | Cross-validates against a third-party tool written for that specific game | test_lzss.py | project-only | LIVE |
| decode a bespoke compression format, cross-checked against its own length field | `bfm_extract/lzss.py` | Decoder for one game's non-generic compression semantics, verified against its own decompressor | .github/workflows/no-rom.yml, extract.py, test_lzss.py | project-only | LIVE |
| decode an on-disc index table into a payload-to-binary naming map | `idxtab_map.py` | Decodes one game's on-disc index table and its payload-to-binary naming convention — the load map itself is a Phase-2 task | find_addr_refs.py | project-only | LIVE |
| expose a disc extraction pipeline's stages as one package | `bfm_extract/__init__.py` | Package entry for one title's disc pipeline; names its own container stages | jtbl_rodata_pads.py, oracle_reorder.py | project-only | LIVE |
| extract a prototype build's executable, allowing for its known deviations | `bfm_extract/extract_proto_exe.py` | Companion for one title's prototype discs and their specific deviations | ghidra_rebuild.sh | project-only | LIVE |
| extract the console executable and hard-validate its name, size and header | `bfm_extract/extract_exe.py` | Hard-validates one executable's exact name, size, hash and header field values | Makefile, audit_public.py, extract.py, extract_proto_exe.py (+1) | project-only | LIVE |
| list a sound library's address window and per-address exclusions | `make_snd_used.py` | Hard-codes one executable's sound-library address window and per-address exclusions | Makefile, fetch_psyq.sh | project-only | LIVE |
| list the interface library's objects and address window the executable actually links | `make_apicard_used.py` | Hard-codes one executable's interface-library address window and object roster | Makefile, fetch_psyq.sh | project-only | LIVE |
| observe a live loader's requests to learn which payload loads where | `cdtrace.py` | Reads one game's loader request structures at fixed RAM addresses | — | project-only | ORPHAN |
| onboard one payload by its container and file-index naming | `new_overlay.sh` | Takes one game's container and file-index naming as its command-line contract | Makefile, config/overlays.mk, dedup_extend.py, dup_report.py (+3) | project-only | LIVE |
| parse a bespoke archive-chain header format | `bfm_extract/pac.py` | Parser for one game's bespoke archive-chain header format | crosscheck.py, extract.py | project-only | LIVE |
| read a bespoke container's table of contents to locate its files | `bfm_extract/cd_archive.py` | Reader for one game's bespoke container table-of-contents format | crosscheck.py, extract.py | project-only | LIVE |
| unit-test a bespoke compression decoder against known cases | `bfm_extract/test_lzss.py` | Unit tests for that game-specific compression variant | .github/workflows/no-rom.yml | project-only | LIVE |
| walk the whole medium and extract every file deterministically | `bfm_extract/extract.py` | Full-disc extractor bound to one disc's root file list and audio-track handling | Makefile, extract_exe.py, verify_worktree.py | project-only | LIVE |

## Retired (`tools/sunset/`) — superseded by a named successor, or a one-off whose product exists

| Tool | Verdict | Successor or product | What it did |
|---|---|---|---|
| `audit_header_sigs.py` | SUPERSEDED | tools/conform_decls.py | Finds shared-header declarations that contradict the banked definition |
| `bank_exemplar.py` | SUPERSEDED | tools/gate_stage.py | Banks one cracked exemplar through the carve, splice and staged-recovery ladder |
| `bisect_slate.py` | SUPERSEDED | tools/gate_main_parallel.py | Isolates the byte-wrong drafts in a batch, with a null control first |
| `build_wave.py` | SUPERSEDED | tools/draw_waves.py | Builds the next wave from a card pool, ranked by fleet leverage |
| `build_wave_args.py` | SUPERSEDED | tools/wave_args.py | Emits workflow arguments for a wave from the target manifest, resolving each path |
| `canon_draft_decls.py` | SUPERSEDED | tools/sig_unify.py | Canonicalizes a draft's extern and data declarations to the banked-consistent set |
| `exemplar_miner.py` | SUPERSEDED | tools/atlas.py | Routes every residual stub to its lever and ranks the highest-reach work |
| `fix_header_decl.py` | SUPERSEDED | tools/conform_decls.py | Rewrites a shared-header caller declaration to a draft's byte-true signature |
| `gen_engine_decls.py` | SUPERSEDED | tools/conform_decls.py | Declares every shared function and data symbol once, canonically, in a generated header |
| `glm_parallel.sh` | SUPERSEDED | tools/ox_campaign.py | Splits a target list into slices and runs concurrent drafting workers against one endpoint |
| `glm_reconcile.py` | ONE-OFF | the measured verdict that the declaration wall is a reconciliation problem, plus the captured reasoning distilled into the cookbook (Phase 23 T10.7 A/B) | Aims a reasoning model at the declaration wall and captures its reasoning for reuse |
| `idiom_loop.py` | SUPERSEDED | tools/idiom_serial.py | Never-ending meta-loop: drain the easy fuel, learn the next idiom, hand off |
| `jr_isolate.py` | SUPERSEDED | tools/jr_isolate_all.py | Isolates one switch function into its own code segment for an independent table carve |
| `lanes/bounce_drafter_on_queue.sh` | SUPERSEDED | tools/lanes/relaunch_drafter_shell.sh | Waits for the in-flight wave to queue, then restarts the drafting process |
| `lanes/launch_ox.sh` | ONE-OFF | the sharded overnight campaign run it launched (its key file, endpoint and model are that campaign's) | Launcher for a sharded campaign run with a tag and shard count |
| `lanes/toolwork.sh` | ONE-OFF | the tooling-design briefs it ran against an external model (its key, endpoint and model are that era's) | Runs tooling-design briefs against an external model with build config as context |
| `lenmiss_route.py` | ONE-OFF | the routed outcome of one length-drift near-miss pile (it consumes that audit's classified ledger) | Routes the length-drift near-miss pile through the documented lenses, re-verified against the tree |
| `p16_known_answer.py` | SUPERSEDED | tools/p16_improve.py | Graduated known-answer validation of the scaffold pipeline across difficulty bands |
| `plumbing_groups.py` | SUPERSEDED | tools/gate_triage.py | Groups recorded declaration-conflict failures into sweepable work groups from the ledgers |
| `reconcile_slate.py` | SUPERSEDED | tools/pregate_check.py | Drives a whole batch to declaration-compatible before any rebuild is spent |
| `recover_drafts.py` | SUPERSEDED | tools/agent_drafts_restore.py | Recovers agent-written draft files from a run's transcripts after they were deleted |
| `residual_rules.py` | SUPERSEDED | tools/residual_rules_b.py | Turns a measured residual into the specific documented lever that addresses it |
| `rtu_shadow.py` | ONE-OFF | the measured gate-inversion decision (whether the cheap real-unit check should become the gate's stage 0) | Runs the real-translation-unit check in shadow beside the gate to measure gate inversion |
| `scan_leftovers.py` | SUPERSEDED | tools/integration_resolver.py | Re-verifies every draft already on disk and banks the free wins |
| `sweep_citations.py` | SUPERSEDED | tools/gccmap_cites.py | Deterministically localizes every compiler-source citation in a document against the pinned sources |
| `symcheck.py` | SUPERSEDED | tools/reloc_verify.py | Pre-gate guard diffing the symbol set a draft references against the target's |
| `t5_bank.sh` | SUPERSEDED | tools/gate_wave.py | Post-draft half of an agent wave: refuse if unsafe, judge each arm, bank the union |
| `t5_distill_args.py` | SUPERSEDED | tools/distill_scan.py | Builds the post-wave distillation slate from a wave's directories |
| `t5_targets.py` | SUPERSEDED | tools/draw_waves.py | Draws one routed slate from the frontier classes |
| `t7_bank.py` | SUPERSEDED | tools/gate_stage.py | Batch banking driver applying reconcile-at-bank-time plus the whole-binary gate |
| `treelock.sh` | SUPERSEDED | tools/shared_lock.py | The mutex wrapper for tree-writing campaigns, with status and stale detection |
| `verify_map_findings.py` | ONE-OFF | the machine-checked verdicts of one codegen-map audit (docs/gcc-2.7.2-map/regalloc.md) | Machine-checks a codegen-map audit's findings against the actual compiler sources |
| `wall_taxonomy.py` | SUPERSEDED | tools/frontier_classify.py | Census-classifies every unmatched residual by blocker class to size each avenue |
| `warmstart.py` | SUPERSEDED | tools/permuter_sweep.py | Feeds the permuter warm-start drafts built from banked exemplars and routed fuel |