etch-loop 0.2.1__tar.gz → 0.3.1__tar.gz

{etch_loop-0.2.1 → etch_loop-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etch-loop
-Version: 0.2.1
+Version: 0.3.1
 Summary: Run Claude Code in a fix-break loop until your codebase is clean
 License: MIT
 Requires-Python: >=3.11

{etch_loop-0.2.1 → etch_loop-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "etch-loop"
-version = "0.2.1"
+version = "0.3.1"
 requires-python = ">=3.11"
 description = "Run Claude Code in a fix-break loop until your codebase is clean"
 readme = "README.md"

etch_loop-0.3.1/src/etch/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/cli.py

@@ -72,6 +72,12 @@ def run(
         help="Skip git commits after fixer runs.",
         is_flag=True,
     ),
+    no_git: bool = typer.Option(
+        False,
+        "--no-git",
+        help="Disable all git operations (diff checks and commits).",
+        is_flag=True,
+    ),
     dry_run: bool = typer.Option(
         False,
         "--dry-run",
@@ -98,6 +104,7 @@ def run(
             prompt_path=prompt,
             max_iterations=max_iterations,
             no_commit=no_commit,
+            no_git=no_git,
             dry_run=dry_run,
             verbose=verbose,
             focus=focus,

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/display.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import threading
 import time
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable, TypeVar
 
 from rich.columns import Columns
@@ -450,6 +451,43 @@ def run_with_scan(label: str, fn: Callable[[], _T]) -> _T:
     return result[0]
 
 
+def print_summary(stats: dict[str, Any]) -> None:
+    """Standalone summary panel, called after the Live context exits."""
+    reason = stats.get("reason", "done")
+    elapsed = stats.get("elapsed", 0.0)
+    iterations = stats.get("iterations", 0)
+    fixes = stats.get("fixes", 0)
+    issues = stats.get("issues", 0)
+    elapsed_str = _format_elapsed(elapsed)
+
+    if reason == "clear":
+        title = f"[{GREEN}]+ all clear[/{GREEN}]"
+    elif reason == "interrupted":
+        title = f"[{AMBER}]- interrupted[/{AMBER}]"
+    elif reason == "max_iterations":
+        title = f"[{AMBER}]- stopped (max iterations)[/{AMBER}]"
+    elif reason == "no_changes":
+        title = f"[{GREEN}]+ clean — fixer found nothing[/{GREEN}]"
+    else:
+        title = f"[{FG}]done[/{FG}]"
+
+    body = (
+        f"[{DIM}]iterations[/{DIM}] [{FG}]{iterations}[/{FG}]   "
+        f"[{DIM}]fixes[/{DIM}] [{FG}]{fixes}[/{FG}]   "
+        f"[{DIM}]breaker issues[/{DIM}] [{FG}]{issues}[/{FG}]   "
+        f"[{DIM}]{elapsed_str} elapsed[/{DIM}]"
+    )
+
+    _console.print(
+        Panel(
+            body,
+            title=title,
+            border_style=Style(color=BORDER),
+            style=Style(bgcolor=BG),
+        )
+    )
+
+
 def print_dry_run(prompt_text: str) -> None:
     _console.print(
         Panel(
@@ -497,6 +535,14 @@ def print_init_skip(filename: str) -> None:
     )
 
 
+def print_report_saved(path: Path) -> None:
+    try:
+        display_path = path.relative_to(Path.cwd())
+    except ValueError:
+        display_path = path
+    _console.print(f"[{DIM}]-  report -> {display_path}[/{DIM}]")
+
+
 # ── Utilities ─────────────────────────────────────────────────────────────────
 
 

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/git.py

@@ -54,7 +54,7 @@ def has_changes() -> bool:
     return bool(status.stdout.strip())
 
 
-def commit(message: str) -> None:
+def commit(message: str, paths: list[str] | None = None) -> None:
     """Stage all changes and create a commit.
 
     Args:
@@ -66,10 +66,11 @@ def commit(message: str) -> None:
     if not message or not message.strip():
         raise GitError("Commit message must not be empty.")
 
-    # Stage all changes
+    # Stage all changes (or specific paths)
+    add_cmd = ["git", "add"] + (paths if paths else ["-A"])
     try:
         add_result = subprocess.run(
-            ["git", "add", "-A"],
+            add_cmd,
             capture_output=True,
             text=True,
         )

etch_loop-0.3.1/src/etch/loop.py

@@ -0,0 +1,239 @@
+"""Core fix-break loop logic."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from etch import agent, display, git, prompt, report, signals
+from etch.agent import AgentError
+from etch.git import GitError
+from etch.prompt import PromptError, load_scan
+
+
+def run(
+    prompt_path: str | Path,
+    max_iterations: int = 20,
+    no_commit: bool = False,
+    no_git: bool = False,
+    dry_run: bool = False,
+    verbose: bool = False,
+    focus: str | None = None,
+) -> None:
+    """Run the scan-fix-break loop."""
+    prompt_path = Path(prompt_path)
+
+    # ── Load prompts ──────────────────────────────────────────────────────────
+    try:
+        prompt_text = prompt.load(prompt_path)
+    except PromptError as exc:
+        display.print_error(str(exc))
+        return
+
+    if focus:
+        prompt_text += f"\n\n## User focus\n\nConcentrate specifically on: {focus}\n"
+
+    if dry_run:
+        display.print_dry_run(prompt_text)
+        return
+
+    try:
+        scan_text = prompt.load_scan(prompt_path)
+    except PromptError as exc:
+        display.print_error(str(exc))
+        return
+
+    try:
+        break_text = prompt.load_break(prompt_path)
+    except PromptError as exc:
+        display.print_error(str(exc))
+        return
+
+    if focus:
+        scan_text += f"\n\n## User focus\n\nConcentrate on: {focus}\n"
+        break_text += f"\n\n## User focus\n\nConcentrate your adversarial review on: {focus}\n"
+
+    start_time = time.monotonic()
+    stats: dict = {
+        "iterations": 0,
+        "fixes": 0,
+        "issues": 0,
+        "reason": "done",
+        "elapsed": 0.0,
+    }
+    last_breaker_signal: str | None = None
+    last_breaker_output: str | None = None
+    iteration_log: list[dict] = []
+
+    with display.EtchDisplay(target=str(prompt_path.parent)) as disp:
+        for iteration in range(1, max_iterations + 1):
+            stats["iterations"] = iteration
+            disp.start_iteration(iteration)
+            iter_entry: dict = {"n": iteration}
+
+            # ── Scanner phase ─────────────────────────────────────────────────
+            disp.start_phase("scanner")
+            scanner_start = time.monotonic()
+            try:
+                scanner_output = agent.run(scan_text, verbose=verbose)
+            except AgentError as exc:
+                disp.finish_phase("scanner", status="error", detail=str(exc),
+                                  duration=time.monotonic() - scanner_start, success=False)
+                stats["reason"] = "agent_error"
+                iteration_log.append(iter_entry)
+                break
+
+            scanner_duration = time.monotonic() - scanner_start
+            scanner_signal = signals.parse(scanner_output)
+            scanner_detail = (
+                signals.extract_summary(scanner_output)
+                or signals.extract_finding(scanner_output)
+            )
+
+            if scanner_signal == "clear":
+                disp.finish_phase("scanner", status="all clear",
+                                  detail=scanner_detail or "nothing to fix",
+                                  duration=scanner_duration, success=True)
+                iter_entry["scanner"] = {"status": "all clear", "detail": scanner_detail}
+                stats["reason"] = "no_changes"
+                iteration_log.append(iter_entry)
+                break
+
+            disp.finish_phase("scanner", status="issues found",
+                              detail=scanner_detail or "issues found",
+                              duration=scanner_duration, success=False)
+            iter_entry["scanner"] = {"status": "issues found", "detail": scanner_detail}
+
+            # ── Build fixer prompt ────────────────────────────────────────────
+            fixer_prompt = prompt_text
+            fixer_prompt += (
+                f"\n\n## Scanner findings\n\n{scanner_output.strip()}\n\n"
+                f"Fix these specific issues.\n"
+            )
+            if last_breaker_output:
+                fixer_prompt += (
+                    f"\n\n## Breaker findings from previous iteration\n\n"
+                    f"{last_breaker_output.strip()}\n\n"
+                    f"Also address these if not already covered above.\n"
+                )
+
+            # ── Fixer phase ───────────────────────────────────────────────────
+            disp.start_phase("fixer")
+            fixer_start = time.monotonic()
+            try:
+                _fixer_output = agent.run(fixer_prompt, verbose=verbose)
+            except AgentError as exc:
+                disp.finish_phase("fixer", status="error", detail=str(exc),
+                                  duration=time.monotonic() - fixer_start, success=False)
+                stats["reason"] = "agent_error"
+                iteration_log.append(iter_entry)
+                break
+
+            fixer_duration = time.monotonic() - fixer_start
+
+            # ── Check for changes (skipped when no_git) ───────────────────────
+            if not no_git:
+                try:
+                    changed = git.has_changes()
+                except GitError as exc:
+                    disp.finish_phase("fixer", status="error", detail=str(exc),
+                                      duration=fixer_duration, success=False)
+                    stats["reason"] = "git_error"
+                    iteration_log.append(iter_entry)
+                    break
+
+                if not changed:
+                    disp.finish_phase("fixer", status="no changes", detail="nothing to fix",
+                                      duration=fixer_duration, success=True)
+                    iter_entry["fixer"] = {"status": "no changes", "detail": "nothing to fix"}
+                    if last_breaker_signal != "issues":
+                        stats["reason"] = "no_changes"
+                        iteration_log.append(iter_entry)
+                        break
+                    iteration_log.append(iter_entry)
+                    # Fall through to breaker
+
+            # ── Commit ────────────────────────────────────────────────────────
+            fixer_summary = (
+                signals.extract_summary(_fixer_output)
+                or signals.extract_commit_message(_fixer_output, fallback="")
+            )
+            commit_msg = signals.extract_commit_message(
+                _fixer_output, fallback=f"fix(edge): iteration {iteration}"
+            )
+            if not no_git and not no_commit:
+                try:
+                    git.commit(commit_msg)
+                except GitError as exc:
+                    disp.finish_phase("fixer", status="commit error", detail=str(exc),
+                                      duration=fixer_duration, success=False)
+                    stats["reason"] = "git_error"
+                    iteration_log.append(iter_entry)
+                    break
+
+            disp.record_fix()
+            stats["fixes"] += 1
+            status_label = "changed" if (no_git or no_commit) else "committed"
+            fixer_detail = fixer_summary or commit_msg
+            disp.finish_phase("fixer", status=status_label, detail=fixer_detail,
+                              duration=fixer_duration, success=True)
+            iter_entry["fixer"] = {"status": status_label, "detail": fixer_detail}
+
+            # ── Breaker phase ─────────────────────────────────────────────────
+            disp.start_phase("breaker")
+            breaker_start = time.monotonic()
+            try:
+                breaker_output = agent.run(break_text, verbose=verbose)
+            except AgentError as exc:
+                disp.finish_phase("breaker", status="error", detail=str(exc),
+                                  duration=time.monotonic() - breaker_start, success=False)
+                stats["reason"] = "agent_error"
+                iteration_log.append(iter_entry)
+                break
+
+            breaker_duration = time.monotonic() - breaker_start
+            signal = signals.parse(breaker_output)
+            last_breaker_signal = signal
+            last_breaker_output = breaker_output if signal == "issues" else None
+            breaker_detail = (
+                signals.extract_summary(breaker_output)
+                or signals.extract_finding(breaker_output)
+            )
+
+            if signal == "clear":
+                disp.finish_phase("breaker", status="all clear",
+                                  detail=breaker_detail or "no issues found",
+                                  duration=breaker_duration, success=True)
+                iter_entry["breaker"] = {"status": "all clear", "detail": breaker_detail}
+                stats["reason"] = "clear"
+                iteration_log.append(iter_entry)
+                break
+            else:
+                disp.record_issue()
+                stats["issues"] += 1
+                disp.finish_phase("breaker", status="issues",
+                                  detail=breaker_detail or "issues found",
+                                  duration=breaker_duration, success=False)
+                iter_entry["breaker"] = {"status": "issues", "detail": breaker_detail}
+                stats["reason"] = "issues"
+                iteration_log.append(iter_entry)
+
+        else:
+            stats["reason"] = "max_iterations"
+
+        stats["elapsed"] = time.monotonic() - start_time
+
+    # Live panel is fully closed before printing anything below
+    display.print_summary(stats)
+
+    # ── Write report ──────────────────────────────────────────────────────────
+    try:
+        report_path = report.write(stats, iteration_log, output_dir=prompt_path.parent)
+        if not no_git and not no_commit and stats["fixes"] > 0:
+            try:
+                git.commit(f"etch: add run report {report_path.name}", paths=[str(report_path)])
+            except GitError:
+                pass  # report write is best-effort
+        display.print_report_saved(report_path)
+    except Exception:
+        pass  # report is best-effort, never fail the run over it

etch_loop-0.3.1/src/etch/report.py

@@ -0,0 +1,89 @@
+"""Run report generation."""
+
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+from typing import Any
+
+
+def write(
+    stats: dict[str, Any],
+    iterations: list[dict],
+    output_dir: Path | None = None,
+) -> Path:
+    """Write a markdown report for a completed etch run.
+
+    Args:
+        stats:      Final stats dict from the loop.
+        iterations: List of per-iteration dicts with scanner/fixer/breaker findings.
+        output_dir: Directory to write the report. Defaults to cwd.
+
+    Returns:
+        Path to the written report file.
+    """
+    output_dir = output_dir or Path.cwd()
+    reports_dir = output_dir / "etch-reports"
+    reports_dir.mkdir(exist_ok=True)
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M")
+    path = reports_dir / f"etch-report-{timestamp}.md"
+
+    lines: list[str] = []
+    lines.append(f"# etch run — {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}\n")
+
+    reason = stats.get("reason", "done")
+    elapsed = _fmt_elapsed(stats.get("elapsed", 0.0))
+    lines.append(f"**outcome:** {_reason_label(reason)}  ")
+    lines.append(f"**iterations:** {stats.get('iterations', 0)}  ")
+    lines.append(f"**fixes:** {stats.get('fixes', 0)}  ")
+    lines.append(f"**breaker issues:** {stats.get('issues', 0)}  ")
+    lines.append(f"**elapsed:** {elapsed}\n")
+
+    for entry in iterations:
+        n = entry.get("n", "?")
+        lines.append(f"---\n\n## iteration {n}\n")
+
+        scanner = entry.get("scanner")
+        if scanner:
+            status = scanner.get("status", "")
+            detail = scanner.get("detail", "")
+            lines.append(f"**scanner** — {status}")
+            if detail:
+                lines.append(f"\n> {detail}\n")
+
+        fixer = entry.get("fixer")
+        if fixer:
+            status = fixer.get("status", "")
+            detail = fixer.get("detail", "")
+            lines.append(f"**fixer** — {status}")
+            if detail:
+                lines.append(f"\n> {detail}\n")
+
+        breaker = entry.get("breaker")
+        if breaker:
+            status = breaker.get("status", "")
+            detail = breaker.get("detail", "")
+            lines.append(f"**breaker** — {status}")
+            if detail:
+                lines.append(f"\n> {detail}\n")
+
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return path
+
+
+def _reason_label(reason: str) -> str:
+    return {
+        "clear": "all clear",
+        "no_changes": "clean — nothing to fix",
+        "max_iterations": "stopped — max iterations reached",
+        "interrupted": "interrupted",
+        "agent_error": "stopped — agent error",
+        "git_error": "stopped — git error",
+    }.get(reason, reason)
+
+
+def _fmt_elapsed(seconds: float) -> str:
+    seconds = max(0.0, seconds)
+    mins = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{mins}m {secs}s" if mins else f"{secs}s"

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/signals.py

@@ -66,6 +66,8 @@ def extract_commit_message(output: str, fallback: str) -> str:
             continue
         # Trim to a reasonable length and strip trailing punctuation
         msg = stripped[:72].rstrip(".,;:")
+        if not msg:
+            continue
         if not msg.lower().startswith("fix"):
             msg = f"fix(edge): {msg[0].lower()}{msg[1:]}"
         return msg
@@ -73,6 +75,23 @@ def extract_commit_message(output: str, fallback: str) -> str:
     return fallback
 
 
+def extract_summary(output: str) -> str:
+    """Extract the ETCH_SUMMARY line written by an agent.
+
+    Agents are prompted to write a line like:
+        ETCH_SUMMARY: fixed 3 null-guard issues in auth.py
+
+    Returns the summary text, or empty string if not found.
+    """
+    if not isinstance(output, str):
+        return ""
+    for line in output.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("ETCH_SUMMARY:"):
+            return stripped[len("ETCH_SUMMARY:"):].strip()
+    return ""
+
+
 def extract_finding(output: str) -> str:
     """Extract first meaningful line before the signal token.
 

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/templates/BREAK.md

@@ -19,7 +19,10 @@ Be adversarial — think like someone actively trying to make this code fail.
 
 1. DO NOT edit any files — read only
 2. Report your findings clearly, one per line
-3. End your output with EXACTLY one of these tokens on its own line:
+3. Before the signal token, write one line starting with `ETCH_SUMMARY:` summarising what you found:
+   - `ETCH_SUMMARY: 2 issues — unguarded empty list in sorter.py:14, exception swallowed in loader.py:67`
+   - `ETCH_SUMMARY: no issues found — code looks solid`
+4. End your output with EXACTLY one of these tokens on its own line:
    - `ETCH_ISSUES_FOUND` — if you found anything worth fixing
    - `ETCH_ALL_CLEAR` — if the code looks solid
 

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/templates/ETCH.md

@@ -23,7 +23,11 @@ Scan the codebase for:
 
 Focus on: [edit this to narrow your scope, e.g. "src/auth/", "the payment module"]
 
-## Commit format
+## Output format
+
+After making your changes, write one line at the end of your output:
+  ETCH_SUMMARY: <concise summary, e.g. "fixed 3 issues — added null guards in auth.py, guarded empty input in parser.py">
+  ETCH_SUMMARY: no changes — nothing to fix
 
 The harness commits automatically. Each commit will be:
   fix(edge): <short description of what was fixed>

{etch_loop-0.2.1 → etch_loop-0.3.1}/src/etch/templates/SCAN.md

@@ -23,7 +23,10 @@ For each issue, include the file path, line number (if known), and a one-line de
 5. List each confirmed issue on its own line, e.g.:
    - src/auth.py:42 — crashes with empty token string (no guard)
    - src/api.js:108 — unhandled promise rejection will silently fail
-6. End your output with EXACTLY one of these tokens on its own line:
+6. Before the signal token, write one line starting with `ETCH_SUMMARY:` summarising what you found in plain English:
+   - `ETCH_SUMMARY: found 3 issues — null dereference in auth.py:42, off-by-one in parser.py:88, unhandled OSError in git.py:31`
+   - `ETCH_SUMMARY: no confirmed bugs found`
+7. End your output with EXACTLY one of these tokens on its own line:
    - `ETCH_ISSUES_FOUND` — if you found confirmed bugs worth fixing
    - `ETCH_ALL_CLEAR` — if the code looks solid or you found nothing certain
 

etch_loop-0.2.1/src/etch/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.1"

etch_loop-0.2.1/src/etch/loop.py

@@ -1,261 +0,0 @@
-"""Core fix-break loop logic."""
-
-from __future__ import annotations
-
-import time
-from pathlib import Path
-
-from etch import agent, display, git, prompt, signals
-from etch.agent import AgentError
-from etch.git import GitError
-from etch.prompt import PromptError, load_scan
-
-
-def run(
-    prompt_path: str | Path,
-    max_iterations: int = 20,
-    no_commit: bool = False,
-    dry_run: bool = False,
-    verbose: bool = False,
-    focus: str | None = None,
-) -> None:
-    """Run the fix-break loop.
-
-    Args:
-        prompt_path:    Path to ETCH.md (fixer prompt).
-        max_iterations: Maximum number of fix-break cycles to run.
-        no_commit:      If True, skip git commits after fixer runs.
-        dry_run:        If True, print the prompt and exit without running.
-        verbose:        If True, stream agent output to the terminal.
-    """
-    prompt_path = Path(prompt_path)
-
-    # ── Load fixer prompt ──────────────────────────────────────────────────────
-    try:
-        prompt_text = prompt.load(prompt_path)
-    except PromptError as exc:
-        display.print_error(str(exc))
-        return
-
-    if focus:
-        prompt_text += f"\n\n## User focus\n\nConcentrate specifically on: {focus}\n"
-
-    # ── Dry run ───────────────────────────────────────────────────────────────
-    if dry_run:
-        display.print_dry_run(prompt_text)
-        return
-
-    # ── Load scanner + breaker prompts early to fail fast ────────────────────
-    try:
-        scan_text = prompt.load_scan(prompt_path)
-    except PromptError as exc:
-        display.print_error(str(exc))
-        return
-
-    try:
-        break_text = prompt.load_break(prompt_path)
-    except PromptError as exc:
-        display.print_error(str(exc))
-        return
-
-    if focus:
-        scan_text += f"\n\n## User focus\n\nConcentrate on: {focus}\n"
-        break_text += f"\n\n## User focus\n\nConcentrate your adversarial review on: {focus}\n"
-
-    start_time = time.monotonic()
-    stats: dict = {
-        "iterations": 0,
-        "fixes": 0,
-        "issues": 0,
-        "reason": "done",
-        "elapsed": 0.0,
-    }
-    last_breaker_signal: str | None = None  # None = breaker hasn't run yet
-    last_breaker_output: str | None = None
-
-    with display.EtchDisplay(target=str(prompt_path.parent)) as disp:
-        for iteration in range(1, max_iterations + 1):
-            stats["iterations"] = iteration
-            disp.start_iteration(iteration)
-
-            # ── Scanner phase ─────────────────────────────────────────────────
-            disp.start_phase("scanner")
-            scanner_start = time.monotonic()
-            try:
-                scanner_output = agent.run(scan_text, verbose=verbose)
-            except AgentError as exc:
-                disp.finish_phase(
-                    "scanner",
-                    status="error",
-                    detail=str(exc),
-                    duration=time.monotonic() - scanner_start,
-                    success=False,
-                )
-                stats["reason"] = "agent_error"
-                break
-
-            scanner_duration = time.monotonic() - scanner_start
-            scanner_signal = signals.parse(scanner_output)
-            scanner_finding = signals.extract_finding(scanner_output)
-
-            if scanner_signal == "clear":
-                disp.finish_phase(
-                    "scanner",
-                    status="all clear",
-                    detail=scanner_finding or "nothing to fix",
-                    duration=scanner_duration,
-                    success=True,
-                )
-                stats["reason"] = "no_changes"
-                break
-
-            disp.finish_phase(
-                "scanner",
-                status="issues found",
-                detail=scanner_finding or "issues found",
-                duration=scanner_duration,
-                success=False,
-            )
-
-            # ── Build fixer prompt with scanner + breaker findings ─────────────
-            fixer_prompt = prompt_text
-            fixer_prompt += (
-                f"\n\n## Scanner findings\n\n"
-                f"{scanner_output.strip()}\n\n"
-                f"Fix these specific issues.\n"
-            )
-            if last_breaker_output:
-                fixer_prompt += (
-                    f"\n\n## Breaker findings from previous iteration\n\n"
-                    f"{last_breaker_output.strip()}\n\n"
-                    f"Also address these if not already covered above.\n"
-                )
-
-            # ── Fixer phase ───────────────────────────────────────────────────
-            disp.start_phase("fixer")
-            fixer_start = time.monotonic()
-            try:
-                _fixer_output = agent.run(fixer_prompt, verbose=verbose)
-            except AgentError as exc:
-                disp.finish_phase(
-                    "fixer",
-                    status="error",
-                    detail=str(exc),
-                    duration=time.monotonic() - fixer_start,
-                    success=False,
-                )
-                stats["reason"] = "agent_error"
-                break
-
-            fixer_duration = time.monotonic() - fixer_start
-
-            # ── Check for changes ─────────────────────────────────────────────
-            try:
-                changed = git.has_changes()
-            except GitError as exc:
-                disp.finish_phase(
-                    "fixer",
-                    status="error",
-                    detail=str(exc),
-                    duration=fixer_duration,
-                    success=False,
-                )
-                stats["reason"] = "git_error"
-                break
-
-            if not changed:
-                disp.finish_phase(
-                    "fixer",
-                    status="no changes",
-                    detail="nothing to fix",
-                    duration=fixer_duration,
-                    success=True,
-                )
-                # If the breaker has never run (first iteration with no diff),
-                # stop immediately — nothing was ever changed, nothing to challenge.
-                # If the breaker previously found issues, run it once more to
-                # confirm whether those issues are still present or now resolved.
-                if last_breaker_signal != "issues":
-                    stats["reason"] = "no_changes"
-                    break
-                # Fall through to run the breaker one final time
-
-            # ── Commit ────────────────────────────────────────────────────────
-            commit_msg = signals.extract_commit_message(
-                _fixer_output, fallback=f"fix(edge): iteration {iteration}"
-            )
-            if not no_commit:
-                try:
-                    git.commit(commit_msg)
-                except GitError as exc:
-                    disp.finish_phase(
-                        "fixer",
-                        status="commit error",
-                        detail=str(exc),
-                        duration=fixer_duration,
-                        success=False,
-                    )
-                    stats["reason"] = "git_error"
-                    break
-
-            disp.record_fix()
-            stats["fixes"] += 1
-            disp.finish_phase(
-                "fixer",
-                status="committed" if not no_commit else "changed",
-                detail=commit_msg,
-                duration=fixer_duration,
-                success=True,
-            )
-
-            # ── Breaker phase ─────────────────────────────────────────────────
-            disp.start_phase("breaker")
-            breaker_start = time.monotonic()
-            try:
-                breaker_output = agent.run(break_text, verbose=verbose)
-            except AgentError as exc:
-                disp.finish_phase(
-                    "breaker",
-                    status="error",
-                    detail=str(exc),
-                    duration=time.monotonic() - breaker_start,
-                    success=False,
-                )
-                stats["reason"] = "agent_error"
-                break
-
-            breaker_duration = time.monotonic() - breaker_start
-            signal = signals.parse(breaker_output)
-            last_breaker_signal = signal
-            last_breaker_output = breaker_output if signal == "issues" else None
-            finding = signals.extract_finding(breaker_output)
-
-            if signal == "clear":
-                disp.finish_phase(
-                    "breaker",
-                    status="all clear",
-                    detail=finding or "no issues found",
-                    duration=breaker_duration,
-                    success=True,
-                )
-                stats["reason"] = "clear"
-                break
-            else:
-                disp.record_issue()
-                stats["issues"] += 1
-                disp.finish_phase(
-                    "breaker",
-                    status="issues",
-                    detail=finding or "issues found",
-                    duration=breaker_duration,
-                    success=False,
-                )
-                stats["reason"] = "issues"
-                # Continue to next iteration
-
-        else:
-            # Loop exhausted without break
-            stats["reason"] = "max_iterations"
-
-        stats["elapsed"] = time.monotonic() - start_time
-        disp.print_summary(stats)