81 KiB
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: 294 tool files in scope (submodules, vendored and downloaded code excluded; find and git ls-files agree) + 34 retired under tools/sunset/. Classes: LIVE 234 (a runtime consumer), REFERENCED 29 (a SETUP row only), ORPHAN 31 (neither) — of 294. Portability: PORTABLE 22, ADAPT 256, PROJECT-ONLY 16.
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 (+64) | 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 | 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, split_src_region.py | 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 (+5) | 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, progress.py | 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 | 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 (+32) | 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 |
| 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 |
| 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 |
| 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 |