Simplify

Simplify — axis-decomposed compression pass on a diff

A deliberate compress op invoked on a specific change-set. Decompose simplification into three axes that fail independently and so can be reviewed independently: reuse (what already exists), quality (shape of the new code), efficiency (cost of the new code). Three parallel read-only review agents — one per axis — emit findings against the same diff; the orchestrator composes, audits, and applies fixes one rejection-ground class per atomic commit.

The three axes map directly onto ODIN's rejection grounds. Reuse axis primarily detects Graft (new code grafted where a utility already exists). Quality axis primarily detects Excess (unnecessary surface — params, state, comments-of-what) and Sprawl (structure without functional cause — wrappers, ladders, copy-paste variants). Efficiency axis primarily detects Excess (work that need not happen) and Sprawl (structure that bloats hot paths). The op-cell is compress and the patch rule is Minimal Sufficient Change: behavior is preserved, entropy is reduced.

Axis prompts (verbatim, copy-pasteable):

• references/reuse.md — Agent 1 prompt, three rules, Graft focus
• references/quality.md — Agent 2 prompt, eight patterns, Excess + Sprawl
• references/efficiency.md — Agent 3 prompt, seven patterns, Excess + Sprawl
• references/orchestration.md — single-message dispatch recipe, composition, Reviewer audit, fix-sequencing

Mandates, not suggestions

1. The op-cell is compress. Every commit body carries Op: compress. Behavior preservation is a gate, not a guideline.
2. Decompose by axis, never by file. All three agents see the same diff and bring different lenses. Splitting the diff by file across agents defeats the design.
3. The Reviewer audit is the single adjudication authority. Review agents emit findings; the Reviewer validates them; the orchestrator applies the survivors. The orchestrator does not re-litigate findings the Reviewer accepted, and does not rescue findings the Reviewer rejected.
4. Three agents in one tool-call message. Sequential dispatch invalidates the parallel-launch contract.
5. A simplify patch that introduces a new rejection ground is a regression. Post-fix, audit against Excess / Graft / Sprawl per ~/.claude/claude/system-prompt-baseline.md <reject_patches>. Any hit → revert and re-plan.

When to Apply

• The user says "simplify this diff / PR / branch", "tighten up", "compress these changes", or asks for an axis-decomposed pass over a change-set.
• A diff exists and exceeds the trivial threshold (>30 LOC or >2 files) — enough surface area for axis decomposition to pay rent.
• The change just landed and is being compressed before merge.

When NOT to Apply

• Empty diff after all fallbacks — exit 11, pass-through.
• Single file <50 LOC with an obvious shape problem — just edit directly.
• Opportunistic cleanup while touching nearby code — that is cleanup-codebase's territory.
• Public API removal with migration — that is refactor-break-bw-compat's territory.
• Read-only assessment, no fix authorization — use review.
• Fix driven by an external verifier failure or findings file — use fix. simplify is self-sourcing.

Workflow

1. Phase 1 — Detect diff scope. The diff must capture all branch state under review — every commit since the branch diverged from its base, plus staged, plus unstaged. The orchestrator does not guess the base; it resolves an explicit anchor, or errors. Resolve via the first base ref that exists, then run git diff <base> (no ..HEAD, so working-tree changes are included):

   1. git merge-base HEAD origin/main
   2. git merge-base HEAD origin/master
   3. git merge-base HEAD main
   4. git merge-base HEAD master
   5. @{upstream} (the branch's configured upstream tracking ref, full divergence)

   If none of the five resolve, gate the working-tree-only fallback on two ordered checks — first that HEAD exists as a commit at all, then that it has no parent:

   • Check A — git rev-parse --verify HEAD 2>/dev/null. If it fails, HEAD is unborn (fresh git init, no commits yet). Skip git diff entirely and fall through to the user-named-files / no-git-context path below. Do not run git diff HEAD on an unborn HEAD — it errors and would mask the unborn state.
   • Check B — only if Check A succeeded, run git rev-parse --verify HEAD^ 2>/dev/null. If it fails, HEAD is the repo's root commit (real commit, no parent), so there is no committed history that could be silently dropped — the entire scope IS the working tree. Use git diff HEAD. Surface a one-line note: "scope: working-tree only, on root commit".
   • Otherwise — both checks succeeded, so committed history exists but no base ref resolves to anchor it. Error explicitly: print "committed history exists but no base ref resolves (none of origin/main, origin/master, main, master, @{upstream} found); re-invoke with explicit base: simplify against <ref>" and abort. Do not fall back to git diff HEAD — on a local-only main/master/trunk/develop with committed work, that would silently drop the committed work, and the scope contract requires capturing every commit since branch divergence plus staged plus unstaged.

   If there is no git context at all (no .git/), or HEAD is unborn per Check A, fall back to user-named files supplied in the invocation. Empty after all valid resolutions → exit 11. See references/orchestration.md for the exact resolution shell snippet and the explicit-base override syntax.

2. Phase 2 — Dispatch three review agents in one message. Single tool-call message containing three Agent invocations. Each agent receives <axis-prompt from references/> + "\n\n---\n\nDIFF:\n" + <captured diff>. Agents are read-only — no edits, disjoint axes, independence asserted in the spawn message. See references/orchestration.md for the concrete dispatch shape.

3. Phase 3 — Audit, then apply. Wait for all three. Aggregate findings by {axis, file, line, rejection-ground}; dedupe identical cross-axis findings. Dispatch a Reviewer agent to audit the composed list against completeness / consistency / accuracy / scope; the Reviewer's output is the validated survivor set. The orchestrator applies the survivors directly — one rejection-ground class per atomic commit (Op: compress trailer) — and drops non-survivors without comment. No re-adjudication in either direction. Re-run repo-native tests after each commit; on red, auto-revert via git revert HEAD --no-edit.

Constitutional Rules (Non-Negotiable)

1. Op-cell is compress. Behavior preservation is a gate, not a guideline. A test regression between pre- and post-simplify is an automatic git revert HEAD --no-edit. No # type: ignore, no disabling of guards to make tests pass.
2. The Reviewer audit is the single adjudication authority. Review agents emit findings; the Reviewer validates them and returns the survivor set; the orchestrator applies the survivors and drops non-survivors without re-litigation in either direction. Arguing with the Reviewer's survivor set in prose is Excess.
3. Three agents in one tool-call message. The reuse / quality / efficiency agents are independent by construction — same diff, disjoint rejection-ground subsets, read-only. Sequential dispatch is rejected at the validation gate.
4. One rejection-ground class per atomic commit. Excess fixes, Graft fixes, and Sprawl fixes ride in separate commits per ~/.claude/claude/system-prompt-baseline.md <git> charter "one concern per commit" rule. Mixed-class commits trip exit 15.
5. A simplify patch that introduces a new rejection ground is a regression. Post-commit, audit the patch itself against <reject_patches>. Any hit → revert and re-plan. If any rule here conflicts with ~/.claude/claude/system-prompt-baseline.md, the baseline wins.

Validation Gates

Exit Codes

See also

• cleanup-codebase — opportunistic deletion of dead fields / wrappers / configs while touching nearby code. simplify is the deliberate axis-decomposed pass on a specific diff. Cleanup runs inside a file you already had to open; simplify runs over a change-set you intend to compress.
• parallel-launch — general-purpose decomposer for independent concerns. simplify is a specialized invocation of this pattern with a fixed three-axis decomposition (reuse / quality / efficiency). See parallel-launch/references/delegation-scenarios.md for the underlying parallelism rules.
• review — read-only assessment of the active branch; does not edit. simplify also applies the fixes its review agents found.
• fix — polymorphic iterative repair loop driven by an external failure (verifier output, findings file, bug spec). simplify is self-sourcing: it generates its own findings via parallel review agents and consumes them in the same skill invocation.
• refactor-break-bw-compat — public API removal with consumer migration. simplify never breaks public contracts; it is compress-only.