Simplify

---
name: Simplify
description: Bounded simplification pass for a file or hunk that preserves behavior while reducing complexity.
requires:
  bins: []
  env: []
---

# Simplify

Simplify code in a bounded, evidence-driven way: smaller, clearer, and easier
to maintain while preserving behavior unless the user explicitly asks otherwise.

## Use when

- User asks for refactor/cleanup without adding new features.
- A file or hunk looks noisy (duplication, dead code, redundant guards).
- You need clearer names and tighter structure with minimal risk.

## Do not use when

- User is requesting new behavior or a product-level redesign.
- You do not have a concrete target file/hunk.
- The change would require broad API/contract breakage without approval.

## Input contract

- `target` (required): file path or hunk identifier to simplify.
- `scope` (optional): `file` or `hunk` (default `file`).
- `max_passes` (optional): default `2`, clamp to `[1, 4]`.
- `preserve_behavior` (optional): default `true`.
- `focus` (optional): subset of
  `reuse`, `dead_code`, `redundant_guards`, `naming`, `duplication`, `efficiency`.

## Parsing rules (priority order)

1. If structured args are provided, use them directly.
2. Else infer from user language:
   - "this file", explicit path, or pasted diff -> `target`
   - "just this block/hunk" -> `scope=hunk`
   - "two passes/max 3 rounds" -> `max_passes`
   - "don't change behavior" -> `preserve_behavior=true`
   - keywords like "remove dead code", "rename", "dedupe" -> `focus`
3. Defaults:
   - `scope=file`, `max_passes=2`, `preserve_behavior=true`
4. If `target` is still missing, ask for one concrete file or hunk.

## Canonical workflow

1. **Understand baseline**
   - Read the target and identify purpose, invariants, and public interfaces.
2. **Run bounded simplify passes (`1..max_passes`)**
   - Apply only high-signal improvements:
     - remove dead code / unreachable branches
     - collapse redundant guards and repeated conditionals
     - deduplicate copy-paste logic into local helpers where appropriate
     - improve naming for intent clarity
     - replace ad-hoc logic with existing utilities when available
3. **Behavior safety check**
   - If `preserve_behavior=true`, avoid interface/semantic changes.
   - If a behavior change seems necessary, stop and ask for confirmation.
4. **Verification**
   - Run targeted checks (lint/test/build scope relevant to changed files).
5. Stop when:
   - no further meaningful simplification remains (`status=already_simple`), or
   - simplification applied safely (`status=simplified`), or
   - blocked by missing context/approval (`status=needs_user_input`), or
   - pass budget reached (`status=max_passes_reached`).

## Guardrails

- Never run unbounded refactor loops.
- Do not introduce speculative abstractions with no local payoff.
- Do not touch unrelated files "while here".
- Prefer small, reviewable edits over sweeping rewrites.
- Keep comments only for non-obvious WHY; remove narrative noise.

## Output format

Always return:

- `status`: `simplified` | `already_simple` | `needs_user_input` | `max_passes_reached`
- `passes_run`: number of simplify passes executed
- `target`: normalized file/hunk target
- `focus_used`: normalized focus dimensions
- `changes`: concise bullet list of concrete simplifications
- `behavior_safety`: why behavior is preserved (or what approval is needed)
- `verification`: checks run + outcomes
- `next_action`: required unless `status=simplified` or `already_simple`

## Examples

- `target="crates/core/src/agent/mod.rs" max_passes=2 focus="dead_code,redundant_guards"`
- `target="src/main.rs#L120" scope="hunk" preserve_behavior=true`
- `target="diff:latest" focus="reuse,duplication,naming" max_passes=3`