etch-loop 0.5.2__tar.gz → 0.5.3__tar.gz

{etch_loop-0.5.2 → etch_loop-0.5.3}/PKG-INFO

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

etch_loop-0.5.3/etch-loop/BREAK.md

@@ -0,0 +1,41 @@
+# BREAK — breaker prompt
+
+You are an adversarial code reviewer. Your job is to find anything that could go wrong.
+
+## Your mission
+
+Scan the entire codebase with fresh eyes. Do not limit yourself to recent changes.
+
+Look for:
+- Edge cases and boundary conditions that are unhandled anywhere in the code
+- Functions that assume valid input without checking
+- Error paths that are silently swallowed or ignored
+- Race conditions, off-by-one errors, null/empty/zero not guarded
+- Anything that would cause unexpected behavior in production
+
+Be adversarial — think like someone actively trying to make this code fail.
+
+## Rules
+
+1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
+2. Report your findings clearly, one per line
+3. Before the signal token, write your summary in this exact format — it appears directly in the terminal:
+   `<etch_summary>2 issues — unguarded empty list in sorter.py:14, exception swallowed in loader.py:67</etch_summary>`
+   `<etch_summary>no issues found — code looks solid</etch_summary>`
+   **IMPORTANT: write `<etch_summary>` ONLY in your text response — never inside any file you read or edit.**
+4. End with EXACTLY one of these on its own line:
+   `ETCH_ISSUES_FOUND`
+   `ETCH_ALL_CLEAR`
+
+## Scope
+
+- `loop.py`: The no_git/no_commit branch logic at line 181 (`if no_git or changed`) can reach the commit block even when `changed` is False if `no_git=True`, silently skipping the `git.has_changes()` call entirely. The `last_breaker_signal` fall-through at line 174 (fixer sees "no changes" but breaker had prior issues) proceeds to breaker without committing — the iteration state machine has several interacting flags that can produce silent no-ops.
+
+- `agent.py`: The `stderr_reader` thread is joined with a 10-second timeout but its aliveness is never checked; a hung stderr drain can silently drop error output. If `process.kill()` is called after the stdout reader times out, `process.wait()` is called but `stderr_reader` may still be running, causing a race on `stderr_lines`.
+
+- `signals.py` / `extract_commit_message`: The heuristic line-picker can return a token string (e.g. `ETCH_ISSUES_FOUND`) as a commit message if the token appears after other text rather than on its own line, since `parse()` requires exact-line match but `extract_commit_message` does not exclude token lines.
+
+- `git.py` / `has_changes`: Exit code 128 (no commits yet) falls through to `git status --porcelain`, which correctly handles new repos, but `git diff --quiet HEAD` on an empty repo also silently ignores any staged changes — newly staged files in a repo with no HEAD commit would still register as changes, so the two-step detection logic is correct but fragile.
+
+- `prompt.py`: `load_break` and `load_scan` deduplicate the cwd candidate only when `path` is already cwd — if `path.parent == cwd`, both the sibling candidate and the cwd fallback point to the same file, causing it to be read twice in the loop (harmless but surprising). More critically, `load_run` returns `None` for an empty `RUN.md` rather than raising, silently skipping the runner phase with no feedback.

etch_loop-0.5.3/etch-loop/ETCH.md

@@ -0,0 +1,40 @@
+# ETCH — fixer prompt
+
+You are a surgical code reviewer focused on edge cases and robustness.
+
+## Your mission
+
+Scan the codebase for:
+- Unhandled edge cases and boundary conditions
+- Missing null/None/empty checks
+- Unhandled exceptions and error paths
+- Off-by-one errors
+- Race conditions or unsafe concurrent access
+- Missing input validation at system boundaries
+
+## Rules
+
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
+1. Fix only what you find — do not refactor, rename, or reorganize
+2. Do not add comments explaining what you fixed
+3. If you find nothing, make no changes
+
+## Scope
+
+- `loop.py`: The no_git/no_commit branch logic at line 181 (`if no_git or changed`) can reach the commit block even when `changed` is False if `no_git=True`, silently skipping the `git.has_changes()` call entirely. The `last_breaker_signal` fall-through at line 174 (fixer sees "no changes" but breaker had prior issues) proceeds to breaker without committing — the iteration state machine has several interacting flags that can produce silent no-ops.
+
+- `agent.py`: The `stderr_reader` thread is joined with a 10-second timeout but its aliveness is never checked; a hung stderr drain can silently drop error output. If `process.kill()` is called after the stdout reader times out, `process.wait()` is called but `stderr_reader` may still be running, causing a race on `stderr_lines`.
+
+- `signals.py` / `extract_commit_message`: The heuristic line-picker can return a token string (e.g. `ETCH_ISSUES_FOUND`) as a commit message if the token appears after other text rather than on its own line, since `parse()` requires exact-line match but `extract_commit_message` does not exclude token lines.
+
+- `git.py` / `has_changes`: Exit code 128 (no commits yet) falls through to `git status --porcelain`, which correctly handles new repos, but `git diff --quiet HEAD` on an empty repo also silently ignores any staged changes — newly staged files in a repo with no HEAD commit would still register as changes, so the two-step detection logic is correct but fragile.
+
+- `prompt.py`: `load_break` and `load_scan` deduplicate the cwd candidate only when `path` is already cwd — if `path.parent == cwd`, both the sibling candidate and the cwd fallback point to the same file, causing it to be read twice in the loop (harmless but surprising). More critically, `load_run` returns `None` for an empty `RUN.md` rather than raising, silently skipping the runner phase with no feedback.
+
+## Terminal output (required)
+
+After making changes (or deciding there is nothing to fix), write your summary in this exact format — it appears in the terminal and is used as the commit message:
+  `<etch_summary>fixed 3 issues — null guard in auth.py, bounds check in parser.py, timeout in agent.py</etch_summary>`
+  `<etch_summary>nothing to fix — all reported issues were already handled</etch_summary>`
+
+**IMPORTANT: write `<etch_summary>` ONLY in your text response — never inside any file you edit or create.**

etch_loop-0.5.3/etch-loop/RUN.md

@@ -0,0 +1,36 @@
+# RUN — test writer and build validator
+
+You are a test engineer. The fixer has just made changes. Your job is to write tests for what was changed, then run the full suite to confirm everything works.
+
+## Your mission
+
+1. **Write or update tests** — look at what the fixer changed and write targeted tests covering:
+   - The specific edge cases that were fixed
+   - Boundary conditions around the changed code
+   - Any regression paths that could break silently
+   Write tests in the project's existing test style and location.
+
+2. **Run the test suite** — run the full build and test commands to confirm everything passes.
+
+## Build and test commands
+
+- `python -m pytest`
+
+## Rules
+
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
+1. You MAY edit test files — that is your job
+2. Do NOT touch production code — only tests
+3. If tests fail because of flawed test logic, fix the test and re-run before reporting
+4. **After tests pass, clean up everything you created during this session:**
+   - Delete every test file you wrote
+   - Delete any `__pycache__` directories inside the test directory
+   - If you created the test directory itself, remove it entirely (e.g. `rm -rf tests/`)
+   - Leave no temporary files or empty directories behind
+5. When done, write your summary in this exact format — it appears directly in the terminal:
+   `<etch_summary>wrote 4 tests, all 51 passed</etch_summary>`
+   `<etch_summary>2 tests failed — TypeError in test_auth.py:38, production bug in token.py:12</etch_summary>`
+   **IMPORTANT: write `<etch_summary>` ONLY in your text response — never inside any file you edit or create.**
+6. End with EXACTLY one of these on its own line:
+   `ETCH_ALL_CLEAR` — if all tests pass
+   `ETCH_ISSUES_FOUND` — if tests reveal a bug in production code

etch_loop-0.5.3/etch-loop/SCAN.md

@@ -0,0 +1,45 @@
+# SCAN — scanner prompt
+
+You are a code analyst. Your job is to find genuine bugs before the fixer runs.
+
+## Your mission
+
+Read the codebase and produce a precise, actionable list of real issues:
+- Unhandled edge cases and boundary conditions
+- Missing null/None/empty checks that will cause crashes or wrong results
+- Unhandled exceptions and error paths
+- Off-by-one errors
+- Race conditions or unsafe concurrent access
+- Missing input validation at system boundaries
+
+For each issue, include the file path, line number (if known), and a one-line description of what will go wrong.
+
+## Rules
+
+1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
+2. Only report issues you are confident are genuine bugs — not observations, not style, not "could be cleaner"
+3. If something is already handled correctly, do NOT report it — even if the handling is unusual
+4. If you are unsure whether something is a bug, leave it out
+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. Before the signal token, write your summary in this exact format — it appears directly in the terminal:
+   `<etch_summary>3 bugs found — null deref in auth.py:42, off-by-one in parser.py:88</etch_summary>`
+   `<etch_summary>no confirmed bugs found</etch_summary>`
+   **IMPORTANT: write `<etch_summary>` ONLY in your text response — never inside any file you read or edit.**
+7. End with EXACTLY one of these on its own line:
+   `ETCH_ISSUES_FOUND`
+   `ETCH_ALL_CLEAR`
+
+## Scope
+
+- `loop.py`: The no_git/no_commit branch logic at line 181 (`if no_git or changed`) can reach the commit block even when `changed` is False if `no_git=True`, silently skipping the `git.has_changes()` call entirely. The `last_breaker_signal` fall-through at line 174 (fixer sees "no changes" but breaker had prior issues) proceeds to breaker without committing — the iteration state machine has several interacting flags that can produce silent no-ops.
+
+- `agent.py`: The `stderr_reader` thread is joined with a 10-second timeout but its aliveness is never checked; a hung stderr drain can silently drop error output. If `process.kill()` is called after the stdout reader times out, `process.wait()` is called but `stderr_reader` may still be running, causing a race on `stderr_lines`.
+
+- `signals.py` / `extract_commit_message`: The heuristic line-picker can return a token string (e.g. `ETCH_ISSUES_FOUND`) as a commit message if the token appears after other text rather than on its own line, since `parse()` requires exact-line match but `extract_commit_message` does not exclude token lines.
+
+- `git.py` / `has_changes`: Exit code 128 (no commits yet) falls through to `git status --porcelain`, which correctly handles new repos, but `git diff --quiet HEAD` on an empty repo also silently ignores any staged changes — newly staged files in a repo with no HEAD commit would still register as changes, so the two-step detection logic is correct but fragile.
+
+- `prompt.py`: `load_break` and `load_scan` deduplicate the cwd candidate only when `path` is already cwd — if `path.parent == cwd`, both the sibling candidate and the cwd fallback point to the same file, causing it to be read twice in the loop (harmless but surprising). More critically, `load_run` returns `None` for an empty `RUN.md` rather than raising, silently skipping the runner phase with no feedback.

{etch_loop-0.5.2 → etch_loop-0.5.3}/pyproject.toml

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

etch_loop-0.5.3/src/etch/__init__.py

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

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/agent.py

@@ -68,10 +68,18 @@ def run(
     if stdin_writer.is_alive():
         process.kill()
         process.wait()
+        try:
+            process.stdin.close()
+        except OSError:
+            pass
         raise AgentError("Timed out writing prompt to claude stdin")
     if stdin_exc:
         process.kill()
         process.wait()
+        try:
+            process.stdin.close()
+        except OSError:
+            pass
         raise AgentError(f"Failed to write prompt to claude stdin: {stdin_exc[0]}") from stdin_exc[0]
 
     output_lines: list[str] = []
@@ -89,7 +97,8 @@ def run(
 
     def read_stderr() -> None:
         for line in process.stderr:
-            stderr_lines.append(line)
+            with lock:
+                stderr_lines.append(line)
 
     reader = threading.Thread(target=read_stdout, daemon=True)
     stderr_reader = threading.Thread(target=read_stderr, daemon=True)
@@ -99,10 +108,12 @@ def run(
     if reader.is_alive():
         process.kill()
         process.wait()
+        stderr_reader.join(timeout=10)
+        if stderr_reader.is_alive():
+            with lock:
+                stderr_lines.append("[stderr reader timed out]")
         raise AgentError("claude subprocess timed out (output reader still running)")
 
-    stderr_reader.join(timeout=10)
-
     try:
         process.wait(timeout=10)
     except subprocess.TimeoutExpired:
@@ -110,7 +121,13 @@ def run(
         process.wait()
         raise AgentError("claude subprocess timed out waiting for exit")
 
-    stderr_output = "".join(stderr_lines).strip()
+    stderr_reader.join(timeout=10)
+    if stderr_reader.is_alive():
+        with lock:
+            stderr_lines.append("[stderr reader timed out]")
+
+    with lock:
+        stderr_output = "".join(stderr_lines).strip()
 
     if process.returncode != 0:
         detail = stderr_output or "(no stderr)"

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/analyze.py

@@ -173,6 +173,7 @@ For each issue, include the file path, line number (if known), and a one-line de
 ## Rules
 
 1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 2. Only report issues you are confident are genuine bugs — not observations, not style, not "could be cleaner"
 3. If something is already handled correctly, do NOT report it — even if the handling is unusual
 4. If you are unsure whether something is a bug, leave it out
@@ -213,6 +214,7 @@ Scan the codebase for:
 
 ## Rules
 
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 1. Fix only what you find — do not refactor, rename, or reorganize
 2. Do not add comments explaining what you fixed
 3. If you find nothing, make no changes
@@ -255,6 +257,7 @@ Be adversarial — think like someone actively trying to make this code fail.
 ## Rules
 
 1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 2. Report your findings clearly, one per line
 3. Before the signal token, write your summary in this exact format — it appears directly in the terminal:
    `<etch_summary>2 issues — unguarded empty list in sorter.py:14, exception swallowed in loader.py:67</etch_summary>`
@@ -300,10 +303,15 @@ You are a test engineer. The fixer has just made changes. Your job is to write t
 
 ## Rules
 
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 1. You MAY edit test files — that is your job
 2. Do NOT touch production code — only tests
 3. If tests fail because of flawed test logic, fix the test and re-run before reporting
-4. **After tests pass, delete every test file you created during this session** — leave no temporary test files behind
+4. **After tests pass, clean up everything you created during this session:**
+   - Delete every test file you wrote
+   - Delete any `__pycache__` directories inside the test directory
+   - If you created the test directory itself, remove it entirely (e.g. `rm -rf tests/`)
+   - Leave no temporary files or empty directories behind
 5. When done, write your summary in this exact format — it appears directly in the terminal:
    `<etch_summary>wrote 4 tests, all 51 passed</etch_summary>`
    `<etch_summary>2 tests failed — TypeError in test_auth.py:38, production bug in token.py:12</etch_summary>`
@@ -324,7 +332,9 @@ def _detect_run_commands(root: Path) -> list[str]:
     if (root / "package.json").exists():
         try:
             pkg = json.loads((root / "package.json").read_text(encoding="utf-8"))
-            scripts = pkg.get("scripts", {})
+            scripts = pkg.get("scripts") or {}
+            if not isinstance(scripts, dict):
+                scripts = {}
             if "build" in scripts:
                 commands.append("npm run build")
             if "test" in scripts:
@@ -379,14 +389,14 @@ def _list_files(root: Path) -> list[str]:
         )
         if result.returncode == 0 and result.stdout.strip():
             return result.stdout.strip().splitlines()
-    except (subprocess.TimeoutExpired, FileNotFoundError):
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         pass
 
     # Fallback: walk filesystem
     files = []
     try:
         for p in root.rglob("*"):
-            if p.is_file() and not any(part in _SKIP_DIRS for part in p.parts):
+            if p.is_file() and not any(part in _SKIP_DIRS for part in p.relative_to(root).parts):
                 try:
                     files.append(str(p.relative_to(root)))
                 except ValueError:

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/display.py

@@ -287,8 +287,10 @@ class EtchDisplay:
         )
 
     def _refresh(self) -> None:
-        if self._live is not None:
-            self._live.update(self._render())
+        rendered = self._render()
+        with self._lock:
+            if self._live is not None:
+                self._live.update(rendered)
 
     # ── Ticker thread ─────────────────────────────────────────────────────────
 
@@ -303,6 +305,9 @@ class EtchDisplay:
         self._ticker_stop.set()
         if self._ticker_thread is not None:
             self._ticker_thread.join(timeout=1.0)
+            if self._ticker_thread.is_alive():
+                with self._lock:
+                    self._live = None
             self._ticker_thread = None
 
     def _ticker_loop(self) -> None:
@@ -401,8 +406,10 @@ class InitDisplay:
         )
 
     def _refresh(self) -> None:
-        if self._live is not None:
-            self._live.update(self._render())
+        rendered = self._render()
+        with self._lock:
+            if self._live is not None:
+                self._live.update(rendered)
 
     def _start_ticker(self) -> None:
         self._ticker_stop.clear()
@@ -413,6 +420,9 @@ class InitDisplay:
         self._ticker_stop.set()
         if self._ticker_thread is not None:
             self._ticker_thread.join(timeout=1.0)
+            if self._ticker_thread.is_alive():
+                with self._lock:
+                    self._live = None
             self._ticker_thread = None
 
     def _ticker_loop(self) -> None:
@@ -478,6 +488,8 @@ def print_summary(stats: dict[str, Any]) -> None:
         title = f"[{RED}]x agent error[/{RED}]"
     elif reason == "git_error":
         title = f"[{RED}]x git error[/{RED}]"
+    elif reason == "stalled":
+        title = f"[{AMBER}]- stalled (fixer found nothing)[/{AMBER}]"
     else:
         title = f"[{FG}]done[/{FG}]"
 

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/git.py

@@ -56,6 +56,28 @@ def has_changes() -> bool:
     return bool(status.stdout.strip())
 
 
+def changed_files(since_commits: int = 1) -> list[str]:
+    """Return files changed in the last N commits.
+
+    Used to focus the breaker on files the fixer actually touched,
+    rather than the entire codebase.
+
+    Returns an empty list if git is unavailable or no commits exist.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", f"HEAD~{since_commits}", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().splitlines()
+    except (OSError, FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+    return []
+
+
 def commit(message: str, paths: list[str] | None = None) -> None:
     """Stage all changes and create a commit.
 
@@ -69,7 +91,7 @@ def commit(message: str, paths: list[str] | None = None) -> None:
         raise GitError("Commit message must not be empty.")
 
     # Stage all changes (or specific paths)
-    add_cmd = ["git", "add"] + (paths if paths is not None else ["--all"])
+    add_cmd = ["git", "add"] + (paths if paths else ["--all"])
     try:
         add_result = subprocess.run(
             add_cmd,

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/loop.py

@@ -157,6 +157,7 @@ def run(
             fixer_duration = time.monotonic() - fixer_start
 
             # ── Check for changes (skipped when no_git) ───────────────────────
+            changed = False
             if not no_git:
                 try:
                     changed = git.has_changes()
@@ -171,11 +172,9 @@ def run(
                     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
-                    # Fall through to breaker
+                    stats["reason"] = "stalled" if last_breaker_signal == "issues" else "no_changes"
+                    iteration_log.append(iter_entry)
+                    break
 
             # ── Commit ────────────────────────────────────────────────────────
             if no_git or changed:
@@ -196,9 +195,10 @@ def run(
                         iteration_log.append(iter_entry)
                         break
 
-                disp.record_fix()
-                stats["fixes"] += 1
-                status_label = "changed" if (no_git or no_commit) else "committed"
+                if changed or (no_git and fixer_summary and not fixer_summary.lower().startswith("nothing")):
+                    disp.record_fix()
+                    stats["fixes"] += 1
+                status_label = "no-git" if no_git else ("changed" if 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)
@@ -207,8 +207,22 @@ def run(
             # ── Breaker phase ─────────────────────────────────────────────────
             disp.start_phase("breaker")
             breaker_start = time.monotonic()
+            # Focus the breaker only on files the fixer actually changed.
+            # This prevents the breaker from finding brand-new issues in
+            # untouched files, which causes the loop to thrash.
+            effective_break_text = break_text
+            if not no_git:
+                recent_files = git.changed_files(since_commits=1)
+                if recent_files:
+                    files_list = "\n".join(f"- {f}" for f in recent_files)
+                    effective_break_text = break_text + (
+                        f"\n\n## Scope for this iteration\n\n"
+                        f"The fixer just changed these files — review ONLY these:\n"
+                        f"{files_list}\n\n"
+                        f"Do not scan files that were not changed.\n"
+                    )
             try:
-                breaker_output = agent.run(break_text, verbose=verbose)
+                breaker_output = agent.run(effective_break_text, verbose=verbose)
             except AgentError as exc:
                 disp.finish_phase("breaker", status="error", detail=str(exc),
                                   duration=time.monotonic() - breaker_start, success=False)
@@ -255,7 +269,7 @@ def run(
             stats["reason"] = "max_iterations"
 
         # ── Runner — final step, only when loop ended cleanly ─────────────────
-        if run_text and stats["reason"] in ("clear", "no_changes"):
+        if run_text and stats["reason"] == "clear":
             disp.start_phase("runner")
             runner_start = time.monotonic()
             try:

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/prompt.py

@@ -25,7 +25,10 @@ def load(path: str | Path) -> str:
     if not p.is_file():
         raise PromptError(f"Prompt path is not a file: {p}")
 
-    content = p.read_text(encoding="utf-8")
+    try:
+        content = p.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        raise PromptError(f"Prompt file not found: {p}")
     if not content.strip():
         raise PromptError(f"Prompt file is empty: {p}")
 
@@ -66,7 +69,10 @@ def load_break(path: str | Path | None = None) -> str:
 
     for candidate in candidates:
         if candidate.exists() and candidate.is_file():
-            content = candidate.read_text(encoding="utf-8")
+            try:
+                content = candidate.read_text(encoding="utf-8")
+            except FileNotFoundError:
+                continue
             if not content.strip():
                 raise PromptError(f"BREAK.md is empty: {candidate}")
             return content
@@ -97,9 +103,12 @@ def load_run(path: str | Path | None = None) -> str | None:
 
     for candidate in candidates:
         if candidate.exists() and candidate.is_file():
-            content = candidate.read_text(encoding="utf-8")
+            try:
+                content = candidate.read_text(encoding="utf-8")
+            except FileNotFoundError:
+                continue
             if not content.strip():
-                return None
+                raise PromptError(f"RUN.md is empty: {candidate}")
             return content
 
     return None  # Optional phase — no error if absent
@@ -126,7 +135,10 @@ def load_scan(path: str | Path | None = None) -> str:
 
     for candidate in candidates:
         if candidate.exists() and candidate.is_file():
-            content = candidate.read_text(encoding="utf-8")
+            try:
+                content = candidate.read_text(encoding="utf-8")
+            except FileNotFoundError:
+                continue
             if not content.strip():
                 raise PromptError(f"SCAN.md is empty: {candidate}")
             return content

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/report.py

@@ -25,7 +25,7 @@ def write(
     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")
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
     path = reports_dir / f"etch-report-{timestamp}.md"
 
     lines: list[str] = []

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/signals.py

@@ -65,6 +65,9 @@ def extract_commit_message(output: str, fallback: str) -> str:
         stripped = line.strip().lstrip("-*•").strip().strip("`").strip()
         if not stripped or len(stripped) < 8:
             continue
+        bare = line.strip().strip("`").strip()
+        if bare == _TOKEN_CLEAR or bare == _TOKEN_ISSUES:
+            break
         if stripped.startswith("#"):
             continue
         if all(c in _PUNCTUATION_ONLY for c in stripped):
@@ -97,7 +100,7 @@ def extract_summary(output: str) -> str:
         return ""
     m = re.search(r"<etch_summary>(.*?)</etch_summary>", output, re.DOTALL)
     if m:
-        return m.group(1).strip()
+        return " ".join(m.group(1).split())
     return ""
 
 
@@ -113,7 +116,7 @@ def extract_finding(output: str) -> str:
     lines_before: list[str] = []
     for line in output.splitlines():
         stripped = line.strip().strip("`").strip()
-        if stripped in (_TOKEN_CLEAR, _TOKEN_ISSUES):
+        if stripped == _TOKEN_CLEAR or stripped == _TOKEN_ISSUES:
             break
         lines_before.append(line)
 

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/templates/BREAK.md

@@ -18,6 +18,7 @@ Be adversarial — think like someone actively trying to make this code fail.
 ## Rules
 
 1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 2. Report your findings clearly, one per line
 3. Before the signal token, write your summary in this exact format — it appears directly in the terminal:
    `<etch_summary>2 issues — unguarded empty list in sorter.py:14, exception swallowed in loader.py:67</etch_summary>`

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/templates/ETCH.md

@@ -14,6 +14,7 @@ Scan the codebase for:
 
 ## Rules
 
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 1. Fix only what you find — do not refactor, rename, or reorganize
 2. Do not add comments explaining what you fixed
 3. If you find nothing, make no changes

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/templates/RUN.md

@@ -18,10 +18,15 @@ You are a test engineer. The fixer has just made changes. Your job is to write t
 
 ## Rules
 
+0. **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 1. You MAY edit test files — that is your job
 2. Do NOT touch production code — only tests
 3. If tests fail because of flawed test logic, fix the test and re-run before reporting
-4. **After tests pass, delete every test file you created during this session** — leave no temporary test files behind
+4. **After tests pass, clean up everything you created during this session:**
+   - Delete every test file you wrote
+   - Delete any `__pycache__` directories inside the test directory
+   - If you created the test directory itself, remove it entirely (e.g. `rm -rf tests/`)
+   - Leave no temporary files or empty directories behind
 5. When done, write your summary in this exact format — it appears directly in the terminal:
    `<etch_summary>wrote 4 tests, all 51 passed</etch_summary>`
    `<etch_summary>2 tests failed — TypeError in test_auth.py:38, production bug in token.py:12</etch_summary>`

{etch_loop-0.5.2 → etch_loop-0.5.3}/src/etch/templates/SCAN.md

@@ -17,6 +17,7 @@ For each issue, include the file path, line number (if known), and a one-line de
 ## Rules
 
 1. DO NOT edit any files — read only
+   **IGNORE the `etch-loop/` directory entirely** — it contains etch tool metadata, not production code
 2. Only report issues you are confident are genuine bugs — not observations, not style, not "could be cleaner"
 3. If something is already handled correctly, do NOT report it — even if the handling is unusual
 4. If you are unsure whether something is a bug, leave it out

{etch_loop-0.5.2 → etch_loop-0.5.3}/uv.lock

@@ -34,7 +34,7 @@ wheels = [
 
 [[package]]
 name = "etch-loop"
-version = "0.4.9"
+version = "0.5.2"
 source = { editable = "." }
 dependencies = [
     { name = "rich" },

etch_loop-0.5.2/src/etch/__init__.py

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