research · v0.1 · operator decisions D1–D4 locked 2026-08-01; first build track = mergiraf structural merge; training program = staged, router first

Edit Power Tools — Unix Primitives, Fast-Apply, and the Trained-Router Program

From ed’s address grammar to mergiraf’s structural merge: which Unix power primitives LLM tooling has re-implemented, which it has not, and the staged program — receipt flywheel → learned router → apply model → hybrid verifier — that grows the D8 write rubric into a learned estimator without surrendering deterministic primacy.

published 2026-08-01 · updated 2026-08-01

authors: Nexartis

tags: agents · editing · unix · fast-apply · routing · training · verifiers

Reference designs this paper extends

Nothing on this page changes a shipped default. The deployed write side is fixed in ADR-008 and narrated by Write Strategies (D8 rubric, splice-first preflight, morph as fast-apply engine); the search side in ADR-007 and MoE for Search. This paper is the forward arc of both: what the Unix lineage says we have not built yet, what the 2026 landscape says is commoditising, and the staged program that turns the signed-receipt corpus (ADR-009) into trained routing, editing, and verification models. Every number is marked measured (internal artifact or independent source) or claimed (vendor); decisions D1–D4 were locked by the operator on 2026-08-01 after a four-wave sourced research pass.

Executive summary

Unix editing history is a compression of everything we now ask LLM agents to do. Ten primitive classes survived fifty years — addressing (ed), stream algebra (sed/awk), operator-motion grammar (vi), structural regular expressions (sam), patches-as-values (patchutils/wiggle), structural diff/merge (difftastic/mergiraf), declarative rewriters (ast-grep/OpenRewrite), indexing (ctags/LSP/SCIP), shell data tools, and git-as-editing-substrate. LLM tooling has re-implemented exactly three: ed-style addressing (every edit format), structural-regex-lite (ast-grep), and indexing (LSP-for-agents). The other seven are open territory — and the two highest-leverage gaps (structural merge, compositional edit algebra) sit exactly under our parallel-orchestration and write-routing pain points.

Meanwhile the 2026 LLM editing landscape is commoditising the part everyone is racing on: two vendors claim 10k+ tok/s fast-apply, the training recipe is open (Kortix, 5.6k examples), and frontier-model diff accuracy is ~96% and closing — Relace’s own founders say the apply-model moat has a shelf life. The defensible layers are routing (RouteLLM: 85% cost cut at 95% quality, measured; MTRouter: −58.7% cost, measured) and verification (R2E-Gym: hybrid verifiers gain 7–8% absolute, measured). Our signed receipt corpus already carries the exact (state, action, outcome, cost, verify) tuples those results were trained on — with provenance and no unlogged path. That flywheel, not another apply model, is the asset.

Bottom line — the four locked decisions

D1 this paper lives as a console research page with the harness-router-hardening workstream flagged. D2 first build track: mergiraf structural merge as a routed verb plus git merge driver. D3 training program: staged, router first — Stage 0 data plumbing gates Stage 1 router distillation; apply model and hybrid verifier follow with pre-set kill criteria. D4 the D8 rubric grows a learned outcome estimator on top — the rubric stays the action space and splice stays primary; a unified single LLM is the north star, not a 2026 commitment.

The Unix editing taxonomy — ten primitive classes

What made each class a power tool is one isolated primitive. The gap column answers one question: how much of that primitive has a first-class LLM-agent analog today (a routed tool with verify and rollback, not a shell one-liner)?

1 · Line editors — ed, ex — primitive: address-range + command grammar.
Exemplars: ed, ex (POSIX, in every base system).

LLM-era analog: aider SEARCH/REPLACE and udiff are ed’s descendants — anchored ranges plus a mutation; every unified-diff hunk header is an ed address.

Gap: none — well covered.
2 · Stream editors & pattern-action — sed, awk, perl -e — primitive: regex algebra over a stream; one small language, composable via pipes.
Exemplars: sed, awk, perl, sd (modern ergonomic sed).

LLM-era analog: none direct — agents write ad-hoc sed -i with no rollback and no receipt.

Gap: medium — no routed stream-edit-with-verify primitive.
3 · Modal editors — vi/vim/neovim, kakoune, helix, vis — primitive: operator-motion algebra (d/c/y × w/e/$ × counts × text-objects); kakoune/helix invert to selection-first; vis adds sam structural regexps as the command language.
Exemplars: neovim, kakoune, helix 25.07, vis.

LLM-era analog: none — no agent tool exposes operator × motion × text-object as a compositional edit grammar; serena’s symbol-as-text-object is closest. Multi-selection (write once, apply at N structural locations, atomic) has no MCP analog.

Gap: large.
4 · Plan 9 lineage — sam, acme, plumber — primitive: structural regular expressions — regex for selection AND extraction AND structural iteration (x/y/g/v composed like a pipeline passing a view of the data); acme: text-as-UI; plumber: content-addressed dispatch.
Exemplars: sam, acme, plumber (Pike, EUUG Helsinki 1987; USENIX 1994).

LLM-era analog: essentially none. ast-grep is a spot-tool; no agent composes extract → filter → transform in one call.

Gap: very large — the biggest unexploited primitive.
5 · Patch algebra — diff/patch, git apply, wiggle, quilt, patchutils — primitive: patches are values: compose (combinediff), invert, subtract (interdiff), filter (filterdiff), fuzz-apply (patch -F), word-fuzz-apply against drifted pre-images (wiggle).
Exemplars: patchutils, wiggle, quilt, git apply --3way.

LLM-era analog: partial — aider’s udiff coder and the V4A apply_patch grammar do flexible hunk application; combinediff/interdiff/wiggle as agent verbs do not exist.

Gap: large — the natural verify-ladder for multi-turn edits.
6 · Structural diff & merge — difftastic, mergiraf, gumtree — primitive: diff and merge in AST space, not text space.
Exemplars: difftastic (tree-sitter diff), mergiraf (syntax-aware merge, 25+ languages, per-file line-merge fallback), gumtree (AST edit-scripts).

LLM-era analog: difftastic is used BY agents as pretty diff; no MCP surfaces structural_diff/structural_merge as verbs.

Gap: very large — slots directly under wave orchestration.
7 · Code-aware rewriters — ast-grep, comby, semgrep, jscodeshift, OpenRewrite — primitive: one declarative rule, applied deterministically across N files.
Exemplars: ast-grep (tree-sitter, ~5× faster than the next tool in the codemod bench — vendor-sponsored, methodology public), comby, semgrep (taint — the one thing ast-grep structurally cannot do), OpenRewrite (Lossless Semantic Tree, type-attributed).

LLM-era analog: yes — ast-grep has experimental official + community MCPs; our write router routes category (c) here. Type-aware refactor (OpenRewrite / rust-analyzer SSR / ts-morph) has no MCP.

Gap: medium — type-aware refactor absent.
8 · Indexing & navigation — ctags, cscope, GNU Global, LSP, SCIP/LSIF, tree-sitter — primitive: answers about code at symbol granularity, precomputed.
Exemplars: universal-ctags 6.x, GNU Global, LSP, SCIP (Sourcegraph’s incremental Protobuf index), tree-sitter tags.

LLM-era analog: yes — serena wraps LSP for 40+ languages as an MCP (find_symbol / find_referencing_symbols / replace_symbol_body). Cross-repo symbol queries remain weak (workspace D1 open finding).

Gap: small–medium.
9 · Shell data power tools — jq, yq, Miller, sd, entr, parallel, fzf, ripgrep — primitive: small languages + composition; the interactive fusion rg | fzf | bat.
Exemplars: ripgrep, fd, fzf, jq, yq, Miller, entr, watchexec, GNU parallel.

LLM-era analog: agents already call these as shell commands; no routed wrapper with receipt + rollback.

Gap: small.
10 · Git as editing substrate — primitive: content-addressed object store as document DB: the index is an atomic transaction on files, worktrees are trivial parallel-agent isolation, rerere is recorded merge-conflict resolution replay.
Exemplars: git index / worktrees / rerere / notes / bisect / merge-file.

LLM-era analog: partial — the workspace exploits worktrees for parallel subagents (ADR-013); rerere/notes/--3way are not first-class agent verbs anywhere.

Gap: large — rerere-as-a-service is unimplemented.

The 2026 LLM editing landscape — proven vs hype

Edit formats are per-model config, not a constant

Diff-XYZ (arXiv 2510.12487, measured across udiff variants and search-replace in five languages): search-replace wins diff GENERATION for larger models (Qwen2.5-Coder-32B 0.92 vs 0.84 udiff); udiff variants are safer for machine-side APPLICATION faithfulness; small models collapse on search-replace and prefer verbose udiff-l. Aider’s udiff move (20% → 61% refactor pass) replicates with newer models. OpenAI’s apply_patch V4A grammar is native-trained into GPT-5.x. Conclusion: a small compatibility table (model family → format), exactly how aider ships it — and a strategy row, not a company-wide constant.

Fast-apply is an adapter, not a moat

Claimed (vendor): Morph v3-fast 10,500 tok/s / 98% merge accuracy; Relace Apply 3 10k+ tok/s; Cursor instant apply ~1,000 tok/s at 9× via speculative edits (file-as-draft, Llama-3-70B fine-tune on Fireworks). Measured independently: only FuseApplyBench (ISSTA 2025) and the aider corpus numbers — treat the rest as directional. The open recipe exists (Kortix FastApply: Qwen2.5-Coder-1.5B/7B, 5,600 examples, one QLoRA epoch). Most telling: Relace’s own blog states frontier diff accuracy is now ~96% and apply models will phase out over time. Our position (unchanged from write-strategies): morph stays the configured engine behind the splice-first preflight (77.4% at $0/0ms, measured r5b); we do not train a proprietary apply model unless Stage 2 beats the vendor arm on our own eval.

Latency tech that actually transfers to editing

Speculative decoding (EAGLE-3: 2–6× vs greedy, up to 2.5× in vLLM production, measured; EAGLE 3.1 doubles acceptance length on long context) is the same trick every apply model uses — the original file is a near-perfect draft. Prompt caching cuts real agentic cost 41–80% and TTFT 13–31% (arXiv 2601.06007, measured; vendor 90%/85% ceilings assume 100k-token stable prefixes), with break-even at ~1.4 reads on a 5-minute TTL. Diffusion coders (Mercury Coder: 1,109 tok/s Mini on H100, independently evaluated) are honest about quality: Small loses to DeepSeek Coder V2 Lite on all six coding benchmarks in DeepLearning.AI’s writeup. Verdict: cache discipline and speculative acceptance compound with everything we build; diffusion is watch-list.

Routing and verification are the defensible layers

RouteLLM (ICLR 2025, measured): four router types trained on preference data; 85% cost cut at 95% GPT-4 quality on MT-Bench; BERT head trains on 2×L4. FrugalGPT (measured): 50–98% cost cut with a DistilBERT cascade scorer. MTRouter (ACL 2026, measured): turn-level learned routing with history–model joint embeddings → +5.4 score points at −58.7% cost, and composed switching preserves the prompt cache. Field reports converge on the adoption pattern: static rules first, learned routers once telemetry exists, semantic caching on top. On verification: test-in-loop plus type/lint feedback is the single biggest driver of SWE-bench Verified success across SOTA harnesses; tree-sitter pre-write gates catch cheap syntactic wins; LLM-as-judge is reliable enough for ranking, not for gating.

Reinvention opportunities, ranked

Ranked by leverage on the existing write-router / verify-ladder / receipts / MoE-search surface. Decision D2 locks rank 1 as the first build track; everything below it remains a queued proposal gated by experiments, not a commitment.

#1 structural-merge verb (mergiraf) — FIRST BUILD TRACK (operator-locked D2) (effort S–M)
Wrap mergiraf as a routed merge_structural verb returning conflicts as structured JSON, AND install it as a git merge driver for silent wins. Engine name stays config (§2: integrate protocols, not vendors).

Turns parallel-workstream and subagent-branch merges from line-noise into structural events; directly attacks the multi-orchestrator conflict pain (AGENTS §4a). mergiraf is battle-tested on 25+ languages and declines per-file to line merge loudly.
#2 sam-style compositional edit algebra (effort M)
One routed verb accepting selection → filter → transform pipelines (x/g/v/c composition) compiled to ast-grep rules + tree-sitter tags; atomic across all matched locations.

The biggest primitive gap — collapses many multi-turn edit loops into one verifiable call; fits D8 categories (b/c/f) as a new strategy row.
#3 patch algebra (wiggle hunk-rescue first) (effort M (S for wiggle-only rung))
interdiff/combinediff/filterdiff/wiggle as agent verbs; wiggle lands first as a hunk-rescue rung between splice failure and the fast-apply fallback.

Turns “my previous edit conflicts with the new one” from a re-plan into an algebraic op; wiggle rescues drift-broken hunks — exactly the splice-residual failure class (7 fixtures in r5b).
#4 rerere conflict memory (effort S–M)
Surface git rerere (+ notes-annotated resolutions) via MCP: record how a merge was resolved once, replay next time.

A memory tool that eats the same conflict twice for free; multiplies with rank 1. Nearly free to expose.
#5 type-aware refactor seam (effort L)
One engine-neutral seam over rust-analyzer SSR + ts-morph (our stack first); OpenRewrite slots in later for JVM without a rename.

The one primitive the current write router genuinely lacks: typed rename/signature-change across a classpath. Per-language effort; do after ranks 1–3 prove the pattern.

Design constraints inherited from workspace §2: the verb is merge_structural, the engine is config (integrate protocols, not vendors — deleting mergiraf is a config change, not a code change); conflicts come back as classified structured JSON, never silent line-merge fallbacks; every merge emits an ADR-009 receipt.

The staged training program — router first

Decision D3. Each stage has published evidence it works, a named data source, a cost class from comparable published work (not false precision), and a pre-set kill criterion. The corpus is the signed receipt log: every routed write and search already records intent, payload class, strategy/adapter, verify-rung outcomes, latency, cost, and diff stats — Stage 0 adds oracle_patch (the git diff at receipt time) and the held-out eval.

Stage table

Stage 0 — eval + data plumbing
Goal: Capture oracle_patch (git diff before/after) at receipt time; build the receipt-derived held-out eval; label 5–10k receipts with ground-truth rubric categories.

Evidence: SWE-smith generated 52k tasks for $1,360 (measured); RouteLLM labelled 120k preference pairs for ~$700 (measured). Our D1 already logs (state, action, outcome, cost, verify) tuples with signed provenance — the corpus precedent groups had to build.

Cost class: $100–$1k, ~1 dev-week · Kill criterion: cannot reach ≥5k clean labelled receipts.
Stage 1 — router distillation (FIRST — operator-locked D3)
Goal: Distill the D8 write-rubric routing decision to a small head (DeBERTa-v3-base ~184M, CPU-viable, sub-10ms; Qwen3-0.6B as the smarter fallback classifier). The deterministic splice preflight + rubric stays PRIMARY; the learned router is cascade tier 2.

Evidence: RouteLLM (ICLR 2025, measured): 85% cost cut at 95% GPT-4 quality on MT-Bench, trained on ~65k Arena pairs; BERT head trained on 2×L4 for ~2k steps. FrugalGPT (measured): 50–98% cost cut with a DistilBERT scorer. Our task is 8-class + strategy-pair — narrower than open chat routing.

Cost class: $50–$500 GPU per run · Kill criterion: below 95% of deterministic splice+rubric accuracy on the held-out eval.
Stage 2 — apply-model fine-tune
Goal: FastApply-style merge model: Qwen3-1.7B DWQ-4bit MLX on-device (100–200 tok/s Apple silicon class) + Qwen2.5-Coder-7B QLoRA hosted.

Evidence: Kortix FastApply (open, Apache-2.0): viable 1.5B/7B recipe from 5.6k examples, 1 epoch QLoRA, 340/150 tok/s on Fireworks (vendor-measured). Morph commercialises the same category at a claimed 10,500 tok/s / 98%. Wave-2 caution: the fast-apply moat is commoditising — frontier diff accuracy is ~96% and Relace’s own team predicts phase-out; this stage is gated on beating the vendor arm on OUR eval, not on being possible.

Cost class: $100–$2k GPU (4090-class hours) · Kill criterion: cannot match Morph-routed accuracy ≥97% at competitive cost/latency on our eval.
Stage 3 — hybrid verifier
Goal: Execution (existing verify ladder) + execution-free scoring head trained on receipt outcomes; feeds best-of-n selection and a richer bandit reward than binary verifyPass.

Evidence: R2E-Gym (COLM 2025, measured): hybrid verifier hits 51% pass@26 on SWE-bench Verified; execution-only and execution-free each plateau ~43%, their UNION gains 7–8% absolute. SWE-Gym (ICML 2025, measured): trajectory-trained verifier lifts 26% → 32% Verified via best-of-n.

Cost class: $500–$5k GPU · Kill criterion: best-of-n boost below 5% absolute on held-out receipts.
North star — unified agent model (tracked, NOT committed)
Goal: One model doing read → search → analyze → edit → verify with tool calls, GRPO-trained on our receipt trajectories (SWE-smith / SWE-RL pattern).

Evidence: SWE-RL (measured): Llama-3.3-70B + rule-based diff-similarity reward → 41.0% SWE-bench Verified. SWE-smith (measured): 32B agent, 40.2% Verified. But Qwen3-Coder’s Agent RL needed 20,000 parallel environments (vendor scale), and Latent Agents (ACL 2026) shows a single model internalising a multi-agent system matches it with 93% fewer tokens only on a narrow distribution. Realistic small-lab ceiling in 2026: 32B GRPO at $5k–$30k GPU — only after Stages 1–3 ship.

Cost class: $5k–$30k GPU (weeks on 4–8×H100 rental) · Kill criterion: cannot beat routed frontier model at 2× cost on our receipt-derived eval.

Risk register

Vendor commoditises faster than we train (Morph at $0.20/M in). Kill criteria pre-set per stage; Stage 2 gated on vendor-parity eval; Morph stays configured as the fast_apply_engine fallback throughout.
Overfit-to-rubric router dies when a 9th category appears. Deterministic splice preflight (77.4% at $0, measured r5b) stays primary; learned router routes by log-prob margins as tier 2, never replaces.
Eval gaming — verify-ladder-pass is not “code is good”. Hybrid verifier only (R2E-Gym pattern): execution + execution-free signals, never a single signal.
Data provenance — receipts include third-party code we do not own. Training corpus scoped to workspace-owned repos (plus Apache-2.0 Kortix warm-start for Stage 2); SWE-smith-scale corpora only with legal review at the north-star stage.
Training-framework lock-in. Unsloth for Stages 1–2 (2× faster, 40–70% less VRAM, measured) with plain-PEFT portability; torchtune reserved for the 32B north star (SWE-smith-proven).

The rubric grows a learned estimator — not a replacement

Decision D4. The D8 rubric stays the action space: eight legible categories, a deterministic splice preflight resolving 77.4% of real edits at $0/0ms (measured, r5b, artifact results-r5b-2026-07-16-scoperung1.json), and classified loud handoffs. What changes is a second cascade tier: a learned estimator trained on receipts predicts cost/quality/latency per adapter per category — MTRouter’s measured −58.7% cost at +5.4 score points is the template, and the bandit reward composite shipped with ADR-013 Phase 5 (v1-linear-normalised, weights 1.0 / 0.5 / 0.25) is already the schema the estimator’s training labels come from. Overfit risk is bounded by construction: the learned tier routes by log-prob margins and the deterministic tier stays primary, so adding a ninth category degrades to today’s behaviour, never to a silent wrong route.

The single-LLM alternative is tracked as the north star, not committed: Latent Agents (ACL 2026) shows a model can internalise a multi-agent pipeline at 93% fewer tokens on a narrow distribution, and SWE-smith/SWE-RL prove 32–70B agents train to 40%+ SWE-bench Verified — but Qwen3-Coder’s Agent RL consumed 20,000 parallel environments, which is vendor scale, not lab scale. The honest 2026 position: the unified model is what the receipt flywheel is FOR; it becomes a build decision only after Stages 1–3 ship and their kill criteria survive.

The read → search → analyze → write context pipeline

As agent operations move from read and search through analyze into write, context clarity per token is the multiplier on every stage. Where we already match or beat SOTA: structured multi-source retrieval with per-item provenance and signed receipts; loud classified errors and the verify ladder; the splice-first preflight; pre-registration and falsification discipline (experimental-framework v0.3.0); and the corpus itself. The gaps, named at the seam in our own code:

No token-budgeted structural skeleton in the search envelope. Seam: ozzydev-native-search-mcp fusion output — add a structural_skeleton field alongside items.
aider repo map (personalized PageRank over tree-sitter symbol graphs, fitted to a 1024-token budget by binary search) + GitHub Accordion ADR-0016 deterministic skeletons (~1/5 tokens, reversible). Measured target: ≥50% dispatch-prompt token reduction at unchanged verify-pass.
Classifier is rules-only; the LLM stage refuses loudly. Seam: ozzydev-native-search-mcp src/classifier.ts + search_router_hints.
MTRouter (ACL 2026, measured): learned turn-level routing with history–model joint embeddings → ScienceWorld 48.4 → 53.8 average score, total cost −58.7%. Our (state, sub-queries, expert-set, outcome) tuple is already logged.
Tool results are monolithic in the next-turn window. Seam: ADR-009 run_receipt_payloads sidecar — the natural JIT handle store, currently unused by callers.
Anthropic code-execution-with-MCP: 150k → 2k tokens (98.7% reduction) by fetching payloads at the use-site; agentic input:output is ~239:1, so cache/retrieval shape dominates spend.
No cache-shape linter for our own dispatch prompts. Seam: bin/ozzydev-mcp-call.mjs dispatch envelope + wave prompts under _WORKSPACE-DOCS.
Don’t Break the Cache (arXiv 2601.06007, measured): cost ↓41–80%, TTFT ↓13–31% from cache discipline; system-prompt-only caching beats full-context caching; head-mutation is the structural killer.
Verify rung-3 is binary property checks. Seam: ozzydev-native-write-mcp src/verify.ts runLadder — same path that drives ADR-013 Phase-5 bandit rewards.
A continuous LLM-scored rung between rung-3 and rung-4 feeds a richer bandit reward than clamp01(w_v·verifyPass − …); harness_run_rewards.reward_shape already anticipates new members. Deterministic where it works; augmented only in the ambiguous middle.

Two external results bound the design. Progressive disclosure works at exactly one level (arXiv 2607.17598: a second routing level never helps and sometimes breaks) — so symbols come to the write stage as ONE skeleton-shaped disclosure step, not a cascade. And pruning beats accumulation (arXiv 2606.10209, measured: prune-and-summarize 91.6% task success vs 71% for full history at one-third the tokens) — the receipt sidecar as JIT handles is how our pipeline prunes without amnesia.

Operator decisions locked 2026-08-01

Resolved under the open-question protocol (AGENTS §4): every option presented with analysis, one recommended, operator chose. These four govern everything on this page.

D1 — Where the paper lands, given harness-router-hardening owns nexartis-ozzydev. Choice: Console research page + flag the workstream.
Additive new route = near-zero merge risk; research log is the canonical home (AGENTS §5). The harness handoff doc carries the scope-line note; commit mechanics follow the one-open-PR-branch protocol with the owning workstream.
D2 — Which reinvented power-tool primitive builds first. Choice: Structural merge (mergiraf) as routed verb + git merge driver.
Direct painkiller for parallel-workstream merges; S–M effort on a battle-tested 25-language engine; compounds with receipts and the verify ladder. Sam-style algebra and wiggle follow.
D3 — Training program shape. Choice: Staged, router first (Stage 0 data/eval gates Stage 1).
Cheapest start (~$50–$500 GPU), highest cascade leverage (FrugalGPT/RouteLLM evidence), and the receipt flywheel already flows. Apply model and verifier follow with pre-set kill criteria; vendor fast-apply stays the fallback throughout.
D4 — Rubric evolution vs single LLM. Choice: Learned estimator OVER the D8 rubric; single LLM as north star only.
The rubric stays the action space and splice stays primary (77.4% at $0/0ms, measured); the learned layer predicts cost/quality/latency per adapter as cascade tier 2 (MTRouter: −58.7% cost, +5.4 pts, measured). A unified model is not within small-lab reach in 2026 — revisit after Stages 1–3.

Evidence gaps — the next experiments

Each runs under the experimental-framework discipline: pre-registration before the first metered run, a stated falsification criterion, n derived from power analysis, and not_observable returned rather than a fabricated zero.

Structural-merge arm. mergiraf verb vs line-merge on a corpus of real parallel-workstream conflicts (this workspace’s own merge history). Pre-registered, falsification stated, n derived from power analysis per experimental-framework v0.3.0. Success metric: false-conflict rate ↓, resolution receipt coverage 100%.
Receipt-derived eval set + oracle_patch capture. Stage 0 prerequisite for every training stage: add oracle_patch = git diff(before, after) at receipt time (one command, cheap); weekly rebuild of the held-out eval; label 5–10k receipts. Kill: cannot reach 5k clean labels.
Structural skeleton in the search envelope. Add token-budgeted structural_skeleton to SearchResponse.items (PageRank over the codesearch/serena symbol graph + deterministic elision). Target: median dispatch-prompt tokens −50% at unchanged verify-pass rate.
Router-distillation bakeoff. Once ≥5k labelled receipts: DeBERTa-v3-base head vs Qwen3-0.6B causal vs the deterministic rubric baseline. Kill: learned head below 95% of deterministic accuracy. Preregistered before the first metered training run.
Wiggle hunk-rescue rung. Measure wiggle’s rescue rate on the splice-residual corpus (the 7 r5b failures + the Osmosis 5/7 set). If it lifts deterministic resolution above ~85% at $0, it earns a rung between splice and the vendor arm.

How this paper stays current

Living document. Internal numbers quote persisted artifacts (r5/r5b results files, fixtures v1.4.0, Phase-2 calibration lock 4f3cce5) — when they are re-measured this page is corrected, not annotated. External claims carry their measured/claimed marking inline; vendor numbers are re-verified quarterly against the fast-apply and routing sources. Experiment results keyed to paper_slug = 'edit-power-tools'; the version bumps on every material change.