spec-runner 2.4.0__tar.gz → 2.4.1__tar.gz

{spec_runner-2.4.0/src/spec_runner.egg-info → spec_runner-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spec-runner
-Version: 2.4.0
+Version: 2.4.1
 Summary: Task automation from markdown specs via Claude CLI
 Author: Andrei
 License-Expression: MIT

{spec_runner-2.4.0 → spec_runner-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spec-runner"
-version = "2.4.0"
+version = "2.4.1"
 description = "Task automation from markdown specs via Claude CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{spec_runner-2.4.0 → spec_runner-2.4.1}/src/spec_runner/cli.py

@@ -117,6 +117,27 @@ def _print_dry_run(tasks_to_run: list[Task], config: ExecutorConfig, state: Exec
     print(json.dumps({"dry_run": True, "tasks": data}, indent=2))
 
 
+def _acquire_run_lock(config: ExecutorConfig) -> ExecutorLock:
+    """Acquire the exclusive executor lock, or exit(1) if another run holds it."""
+    lock = ExecutorLock(config.state_file.with_suffix(".lock"))
+    if not lock.acquire():
+        held_by = getattr(lock, "_held_by", {})
+        alive = held_by.get("alive", "true")
+        logger.error(
+            "Another executor is already running",
+            lock_file=str(config.state_file.with_suffix(".lock")),
+            held_by_pid=held_by.get("pid", "unknown"),
+            started=held_by.get("started", "unknown"),
+            process_alive=alive,
+        )
+        if alive == "false":
+            logger.error(
+                "Lock holder is dead. Use --force to override, or delete the lock file manually."
+            )
+        sys.exit(1)
+    return lock
+
+
 def cmd_run(args: argparse.Namespace, config: ExecutorConfig) -> None:
     """Execute tasks."""
     # HITL review incompatible with TUI mode
@@ -124,61 +145,52 @@ def cmd_run(args: argparse.Namespace, config: ExecutorConfig) -> None:
         logger.warning("--hitl-review ignored in TUI mode (TUI owns the screen)")
         config.hitl_review = False
 
-    if getattr(args, "tui", False):
-        import threading
-
-        from .logging import setup_logging
-        from .tui import SpecRunnerApp
-
-        # TUI mode: log to file, TUI owns screen
-        log_file = config.logs_dir / f"run-{datetime.now().strftime('%Y%m%d-%H%M%S')}.log"
-        config.logs_dir.mkdir(parents=True, exist_ok=True)
-        setup_logging(level=config.log_level, tui_mode=True, log_file=log_file)
+    # Acquire the exclusive lock unless --force. TUI mode also holds it (one
+    # executor per project) — when held, stale-task recovery can safely reset all
+    # orphaned 'running' tasks; with --force a concurrent runner may exist, so we
+    # fall back to the age-based heuristic.
+    if getattr(args, "force", False):
+        logger.warning("Skipping lock check (--force)")
+        lock = None
+    else:
+        lock = _acquire_run_lock(config)
+    lock_held = lock is not None
 
-        app = SpecRunnerApp(config=config)
+    try:
+        if getattr(args, "tui", False):
+            import threading
 
-        def _start_execution() -> None:
-            t = threading.Thread(target=lambda: _run_tasks(args, config), daemon=True)
-            t.start()
+            from .logging import setup_logging
+            from .tui import SpecRunnerApp
 
-        app.call_later(_start_execution)
-        app.run()
-        return
+            # TUI mode: log to file, TUI owns screen
+            log_file = config.logs_dir / f"run-{datetime.now().strftime('%Y%m%d-%H%M%S')}.log"
+            config.logs_dir.mkdir(parents=True, exist_ok=True)
+            setup_logging(level=config.log_level, tui_mode=True, log_file=log_file)
 
-    if getattr(args, "force", False):
-        logger.warning("Skipping lock check (--force)")
-        _run_tasks(args, config)
-    else:
-        # Acquire lock to prevent concurrent runs
-        lock = ExecutorLock(config.state_file.with_suffix(".lock"))
-        if not lock.acquire():
-            held_by = getattr(lock, "_held_by", {})
-            pid = held_by.get("pid", "unknown")
-            started = held_by.get("started", "unknown")
-            alive = held_by.get("alive", "true")
+            app = SpecRunnerApp(config=config)
 
-            logger.error(
-                "Another executor is already running",
-                lock_file=str(config.state_file.with_suffix(".lock")),
-                held_by_pid=pid,
-                started=started,
-                process_alive=alive,
-            )
-            if alive == "false":
-                logger.error(
-                    "Lock holder is dead. Use --force to override, "
-                    "or delete the lock file manually."
+            def _start_execution() -> None:
+                t = threading.Thread(
+                    target=lambda: _run_tasks(args, config, lock_held=lock_held), daemon=True
                 )
-            sys.exit(1)
+                t.start()
 
-        try:
-            _run_tasks(args, config)
-        finally:
+            app.call_later(_start_execution)
+            app.run()
+        else:
+            _run_tasks(args, config, lock_held=lock_held)
+    finally:
+        if lock is not None:
             lock.release()
 
 
-def _run_tasks(args, config: ExecutorConfig):
-    """Internal task execution logic."""
+def _run_tasks(args, config: ExecutorConfig, *, lock_held: bool = False):
+    """Internal task execution logic.
+
+    lock_held: True when the caller holds the exclusive executor lock, so any
+    orphaned 'running' task can be safely reset regardless of age.
+    """
     # Clear any leftover stop file from previous runs
     clear_stop_file(config)
 
@@ -194,9 +206,17 @@ def _run_tasks(args, config: ExecutorConfig):
             task_filter=getattr(args, "task", None),
         )
 
-        # Recover tasks stuck in 'running' from previous crash
+        # Recover tasks stuck in 'running' from a previous crashed/interrupted run.
+        # When we hold the exclusive lock (lock_held), no other runner exists — any
+        # 'running' task is orphaned and is reset regardless of age (otherwise a
+        # session interruption, e.g. a dropped remote shell, leaves a half-done
+        # task that the next run re-picks first and hangs re-doing it). Without the
+        # lock (--force), a concurrent runner may be active, so fall back to the
+        # age-based heuristic (2x the task timeout).
         stale_timeout = config.task_timeout_minutes * 2
-        recovered = recover_stale_tasks(state, stale_timeout, config.tasks_file)
+        recovered = recover_stale_tasks(
+            state, stale_timeout, config.tasks_file, recover_all=lock_held
+        )
         if recovered:
             logger.warning("Recovered stale tasks", task_ids=recovered)
             tasks = parse_tasks(config.tasks_file)

{spec_runner-2.4.0 → spec_runner-2.4.1}/src/spec_runner/doctor.py

@@ -65,8 +65,10 @@ class DoctorReport:
 
 
 def _not_in_path(error: str) -> bool:
-    e = error.lower()
-    return "no such file" in e or "not found" in e
+    # Match the FileNotFoundError for a missing executable specifically. A broad
+    # "not found" also appears in API/auth errors (e.g. "API Key not found"),
+    # which must not be misreported as command-not-in-PATH.
+    return "no such file or directory" in error.lower()
 
 
 def extract(attempt: TaskAttempt, scratch_root: Path, with_review: bool) -> DoctorReport:

{spec_runner-2.4.0 → spec_runner-2.4.1}/src/spec_runner/review.py

@@ -70,36 +70,44 @@ def build_review_prompt(
         lint_output: Lint check output to include in review context
         previous_error: Error from previous attempt (retry context)
     """
-    # Get changed files from git
-    result = subprocess.run(
-        ["git", "diff", "--name-only", "HEAD~1"],
-        capture_output=True,
-        text=True,
-        cwd=config.project_root,
-    )
-    changed_files = (
-        result.stdout.strip() if result.returncode == 0 else "Unable to get changed files"
-    )
+    # Gather the task diff via `git diff HEAD~1` ONLY when this project does
+    # git-based task isolation (a branch and/or commit per task). When git
+    # automation is off — a subdir of a larger repo, or `--no-branch --no-commit`
+    # — `git diff HEAD~1` runs against the PARENT repo and yields a huge, unrelated
+    # diff that makes the reviewer slow or hang. In that case skip it.
+    if config.create_git_branch or config.auto_commit:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "HEAD~1"],
+            capture_output=True,
+            text=True,
+            cwd=config.project_root,
+        )
+        changed_files = (
+            result.stdout.strip() if result.returncode == 0 else "Unable to get changed files"
+        )
 
-    # Get git diff stat
-    result = subprocess.run(
-        ["git", "diff", "HEAD~1", "--stat"],
-        capture_output=True,
-        text=True,
-        cwd=config.project_root,
-    )
-    git_diff_stat = result.stdout.strip() if result.returncode == 0 else ""
-
-    # Full diff for review context (truncated to 30KB)
-    diff_p_result = subprocess.run(
-        ["git", "diff", "-p", "HEAD~1"],
-        capture_output=True,
-        text=True,
-        cwd=config.project_root,
-    )
-    full_diff = diff_p_result.stdout[:30_000]
-    if len(diff_p_result.stdout) > 30_000:
-        full_diff += "\n... (diff truncated)"
+        result = subprocess.run(
+            ["git", "diff", "HEAD~1", "--stat"],
+            capture_output=True,
+            text=True,
+            cwd=config.project_root,
+        )
+        git_diff_stat = result.stdout.strip() if result.returncode == 0 else ""
+
+        # Full diff for review context (truncated to 30KB)
+        diff_p_result = subprocess.run(
+            ["git", "diff", "-p", "HEAD~1"],
+            capture_output=True,
+            text=True,
+            cwd=config.project_root,
+        )
+        full_diff = diff_p_result.stdout[:30_000]
+        if len(diff_p_result.stdout) > 30_000:
+            full_diff += "\n... (diff truncated)"
+    else:
+        changed_files = "(git diff unavailable: git automation disabled for this project)"
+        git_diff_stat = ""
+        full_diff = ""
 
     # Try to load CLI-specific or custom template
     template = load_prompt_template("review", cli_name=cli_name)

{spec_runner-2.4.0 → spec_runner-2.4.1}/src/spec_runner/state.py

@@ -799,11 +799,15 @@ def recover_stale_tasks(
     state: ExecutorState,
     timeout_minutes: float,
     tasks_file: Path,
+    *,
+    recover_all: bool = False,
 ) -> list[str]:
     """Detect and recover tasks stuck in 'running' status.
 
-    A task is considered stale if it has been 'running' for longer
-    than timeout_minutes (typically 2x the task timeout).
+    A task is considered stale if it has been 'running' for longer than
+    timeout_minutes (typically 2x the task timeout). When ``recover_all`` is True
+    (the caller holds the exclusive executor lock, so any 'running' task is
+    orphaned from a dead run) every running task is recovered regardless of age.
 
     Returns list of recovered task IDs.
     """
@@ -819,7 +823,7 @@ def recover_stale_tasks(
         started = datetime.fromisoformat(ts.started_at)
         elapsed_minutes = (now - started).total_seconds() / 60
 
-        if elapsed_minutes <= timeout_minutes:
+        if not recover_all and elapsed_minutes <= timeout_minutes:
             continue
 
         # Stale task — recover it

{spec_runner-2.4.0 → spec_runner-2.4.1/src/spec_runner.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spec-runner
-Version: 2.4.0
+Version: 2.4.1
 Summary: Task automation from markdown specs via Claude CLI
 Author: Andrei
 License-Expression: MIT

{spec_runner-2.4.0 → spec_runner-2.4.1}/tests/test_doctor.py

@@ -150,6 +150,21 @@ def test_extract_command_not_found(tmp_path):
     assert rep.verdict == "broken"
 
 
+def test_extract_not_found_in_message_is_not_path_error(tmp_path):
+    # An auth/API error whose TEXT contains "not found" (e.g. Google's
+    # "API Key not found") must NOT be misreported as command-not-in-PATH.
+    att = _attempt(
+        success=False,
+        error='{"error": {"message": "API Key not found. Please pass a valid API key."}}',
+        error_kind="auth",
+        claude_output=None,
+    )
+    rep = extract(att, tmp_path, with_review=False)
+    assert rep.checks["invocation"].status == CHECK_FAIL
+    assert "PATH" not in rep.checks["invocation"].detail
+    assert "auth" in rep.checks["invocation"].detail
+
+
 def test_extract_auth_failure_classified(tmp_path):
     att = _attempt(
         success=False,

{spec_runner-2.4.0 → spec_runner-2.4.1}/tests/test_execution.py

@@ -1323,7 +1323,7 @@ class TestCrashRecovery:
         recover_calls = []
         monkeypatch.setattr(
             "spec_runner.cli.recover_stale_tasks",
-            lambda state, timeout_minutes, tasks_file: recover_calls.append(True) or [],
+            lambda state, timeout_minutes, tasks_file, **kw: recover_calls.append(True) or [],
         )
 
         args = type(

{spec_runner-2.4.0 → spec_runner-2.4.1}/tests/test_hooks.py

@@ -361,6 +361,35 @@ class TestBuildReviewPrompt:
                 prompt = build_review_prompt(task, config)
         assert "Constitution" not in prompt
 
+    def test_skips_git_diff_when_git_automation_off(self):
+        # Subdir project / --no-branch --no-commit: `git diff HEAD~1` would hit the
+        # PARENT repo (huge, unrelated diff → reviewer slow/hangs). Skip it.
+        task = _make_task()
+        config = _make_config(create_git_branch=False, auto_commit=False)
+        with (
+            patch("spec_runner.review.subprocess.run") as mock_run,
+            patch("spec_runner.review.load_prompt_template", return_value=None),
+        ):
+            build_review_prompt(task, config)
+        git_diff_calls = [
+            c for c in mock_run.call_args_list if c.args and c.args[0][:2] == ["git", "diff"]
+        ]
+        assert git_diff_calls == []
+
+    def test_runs_git_diff_when_auto_commit_on(self):
+        task = _make_task()
+        config = _make_config(create_git_branch=False, auto_commit=True)
+        with (
+            patch("spec_runner.review.subprocess.run") as mock_run,
+            patch("spec_runner.review.load_prompt_template", return_value=None),
+        ):
+            mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+            build_review_prompt(task, config)
+        git_diff_calls = [
+            c for c in mock_run.call_args_list if c.args and c.args[0][:2] == ["git", "diff"]
+        ]
+        assert git_diff_calls
+
 
 class TestRunCodeReview:
     """Tests for run_code_review returning ReviewVerdict."""

{spec_runner-2.4.0 → spec_runner-2.4.1}/tests/test_state.py

@@ -887,6 +887,25 @@ class TestRecoverStaleTasks:
             recovered = recover_stale_tasks(state, timeout_minutes=60, tasks_file=tasks_file)
             assert recovered == []
 
+    def test_recover_all_resets_orphaned_running_regardless_of_age(self, tmp_path):
+        # Under the exclusive lock any 'running' task is orphaned from a dead run.
+        # recover_all=True must reset even a just-started one (no age check), so an
+        # interrupted session doesn't leave a half-done task the next run re-hangs on.
+        from spec_runner.state import recover_stale_tasks
+
+        config = _make_config(tmp_path)
+        (tmp_path / "spec").mkdir(exist_ok=True)
+        tasks_file = tmp_path / "spec" / "tasks.md"
+        tasks_file.write_text("### TASK-001: thing\nP0 | IN_PROGRESS\n")
+
+        with ExecutorState(config) as state:
+            state.mark_running("TASK-001")
+            # Large timeout would normally NOT recover a fresh task; recover_all overrides.
+            recovered = recover_stale_tasks(
+                state, timeout_minutes=999, tasks_file=tasks_file, recover_all=True
+            )
+            assert recovered == ["TASK-001"]
+
     def test_does_not_recover_completed_tasks(self, tmp_path):
         from spec_runner.state import recover_stale_tasks