Stabilization sweep: centralize paths, TB-2 timeout retry, per-persona timeout

Centralize all hardcoded /tmp/dev-loop/ paths into paths.py with
DEVLOOP_TMP_DIR env var override (14 refs across 8 source files,
justfile, and stress-test script). Feed TB-2 spawn timeouts into
the retry loop instead of early-returning — the 303s timeout from
stress tests will now trigger a retry with diagnostic context.
Add per-persona timeout_seconds to agents.yaml (120-600s by type),
threaded through select_persona → spawn_agent in all TB pipelines.
Align stress test subprocess timeout (600→1320s) with pipeline cap.
Close 219 stress test beads issues. 3 new tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: musicofhel

.beads/issues.jsonl

@@ -13,6 +13,7 @@ personas:
     model: sonnet
     max_turns_default: 10
     max_context_pct: 75
+    timeout_seconds: 300
 
   feature:
     labels: [feature]
@@ -24,6 +25,7 @@ personas:
     model: opus
     max_turns_default: 25
     max_context_pct: 75
+    timeout_seconds: 600
 
   refactor:
     labels: [refactor]
@@ -35,6 +37,7 @@ personas:
     model: opus
     max_turns_default: 20
     max_context_pct: 75
+    timeout_seconds: 600
 
   security-fix:
     labels: [security]
@@ -47,6 +50,7 @@ personas:
     model: opus
     max_turns_default: 15
     max_context_pct: 75
+    timeout_seconds: 600
 
   docs:
     labels: [docs]
@@ -57,6 +61,7 @@ personas:
     model: haiku
     max_turns_default: 10
     max_context_pct: 75
+    timeout_seconds: 120
 
   chore:
     labels: [chore]
@@ -67,6 +72,7 @@ personas:
     model: haiku
     max_turns_default: 5
     max_context_pct: 75
+    timeout_seconds: 120
 
   performance:
     labels: [performance, perf]
@@ -77,6 +83,7 @@ personas:
     model: sonnet
     max_turns_default: 15
     max_context_pct: 75
+    timeout_seconds: 300
 
   infrastructure:
     labels: [infrastructure, ci, ci-cd, devops]
@@ -88,6 +95,7 @@ personas:
     model: sonnet
     max_turns_default: 10
     max_context_pct: 75
+    timeout_seconds: 300
 
   test:
     labels: [test, testing]
@@ -99,3 +107,4 @@ personas:
     model: sonnet
     max_turns_default: 15
     max_context_pct: 75
+    timeout_seconds: 300

config/agents.yaml

@@ -232,7 +232,7 @@ emergency-stop:
 recover:
     @echo "=== Recovery scan ==="
     @echo "Checking for orphaned worktrees..."
-    @find /tmp/dev-loop/worktrees -name ".dev-loop-metadata.json" -mmin +60 2>/dev/null || echo "  No worktree directory found"
+    @find "${DEVLOOP_TMP_DIR:-/tmp/dev-loop}"/worktrees -name ".dev-loop-metadata.json" -mmin +60 2>/dev/null || echo "  No worktree directory found"
     @echo "Checking for stuck issues..."
     @br stale --days 1 2>/dev/null || echo "  No stale issues"
     @echo "Run 'just worktree-gc' to clean up orphaned worktrees"
@@ -242,7 +242,7 @@ worktree-gc:
     #!/usr/bin/env bash
     set -euo pipefail
     echo "Scanning for orphaned worktrees..."
-    orphans=$(find /tmp/dev-loop/worktrees -maxdepth 1 -mmin +1440 -type d 2>/dev/null || true)
+    orphans=$(find "${DEVLOOP_TMP_DIR:-/tmp/dev-loop}"/worktrees -maxdepth 1 -mmin +1440 -type d 2>/dev/null || true)
     if [ -z "$orphans" ]; then
         echo "  No orphans found"
         exit 0
@@ -278,7 +278,7 @@ sessions-list *ARGS:
     #!/usr/bin/env bash
     sessions_dir="${HOME}/.local/share/dev-loop/sessions"
     if [ ! -d "$sessions_dir" ]; then
-        sessions_dir="/tmp/dev-loop/sessions"
+        sessions_dir="${DEVLOOP_TMP_DIR:-/tmp/dev-loop}/sessions"
     fi
     if [ ! -d "$sessions_dir" ]; then
         echo "No sessions directory found"

justfile

@@ -22,11 +22,16 @@
 from pathlib import Path
 
 REPO = Path(__file__).parent.parent
+
+# Add project src to path so we can import devloop.paths
+import sys
+sys.path.insert(0, str(REPO / "src"))
+from devloop.paths import RESULTS_DIR, SESSIONS_DIR, WORKTREE_BASE
+
 PROMPT_BENCH = Path.home() / "prompt-bench"
 OOTESTPROJECT1 = Path.home() / "OOTestProject1"
-RESULTS_BASE = Path("/tmp/dev-loop/stress-test")
-WORKTREE_BASE = Path("/tmp/dev-loop/worktrees")
-SESSION_BASE = Path("/tmp/dev-loop/sessions")
+RESULTS_BASE = RESULTS_DIR
+SESSION_BASE = SESSIONS_DIR
 
 
 def ts() -> str:
@@ -127,7 +132,7 @@ def run_pipeline(func_name: str, *args) -> dict:
     result = subprocess.run(
         ["uv", "run", "python", "-c", code],
         capture_output=True, text=True, check=False,
-        timeout=600, cwd=str(REPO),
+        timeout=1320, cwd=str(REPO),  # 1200s pipeline cap + 120s grace
         env={**os.environ, "CLAUDECODE": ""},  # unset CLAUDECODE
     )
     # Find the JSON line in stdout (skip log noise)

scripts/stress-test.py

@@ -32,6 +32,7 @@ class PersonaConfig(BaseModel):
     model: str
     max_turns_default: int = Field(ge=1)
     max_context_pct: int = Field(ge=1, le=100)
+    timeout_seconds: int = Field(default=300, ge=30)
 
     @field_validator("model")
     @classmethod

src/devloop/config_schemas.py

@@ -22,20 +22,20 @@
 
 from opentelemetry import trace
 
+from devloop.paths import SESSIONS_DIR as _SESSIONS_DIR
+
 logger = logging.getLogger(__name__)
 tracer = trace.get_tracer("feedback.cost_monitor", "0.1.0")
 
 # ---------------------------------------------------------------------------
 # Session-based usage tracking (reads from TB-6 session metadata)
 # ---------------------------------------------------------------------------
 
-_SESSIONS_DIR = Path("/tmp/dev-loop/sessions")
-
 
 def get_usage_summary(hours: int = 24) -> dict:
     """Aggregate usage stats from recent session metadata files.
 
-    Scans /tmp/dev-loop/sessions/*.meta.json for sessions within the
+    Scans ``SESSIONS_DIR/*.meta.json`` for sessions within the
     time window and sums up turn/token counts.
 
     Args:

src/devloop/feedback/cost_monitor.py

@@ -23,11 +23,11 @@
 
 from opentelemetry import trace
 
+from devloop.paths import SESSIONS_DIR as _SESSIONS_DIR
+
 logger = logging.getLogger(__name__)
 tracer = trace.get_tracer("feedback.pattern_detector", "0.1.0")
 
-_SESSIONS_DIR = Path("/tmp/dev-loop/sessions")
-
 # ---------------------------------------------------------------------------
 # Known failure patterns and their suggested fixes
 # ---------------------------------------------------------------------------

src/devloop/feedback/pattern_detector.py

@@ -311,6 +311,7 @@ def retry_agent(
     max_retries: int = 2,
     model: str = "sonnet",
     max_turns: int | None = None,
+    timeout_seconds: float = 300.0,
 ) -> dict:
     """Re-spawn agent with failure context and re-run gates."""
     with tracer.start_as_current_span(
@@ -364,6 +365,7 @@ def retry_agent(
             task_prompt=prompt_text,
             model=model,
             max_turns=max_turns,
+            timeout_seconds=timeout_seconds,
         )
 
         exit_code = agent_result.get("exit_code", -1)

src/devloop/feedback/server.py

@@ -341,6 +341,7 @@ def run_tb1(issue_id: str, repo_path: str) -> dict:
                     model=persona_result.get("model", "sonnet"),
                     allowed_tools=allowed_tools,
                     max_context_pct=max_context_pct,
+                    timeout_seconds=persona_result.get("timeout_seconds", 300),
                 )
 
                 agent_exit = agent_result.get("exit_code", -1)
@@ -431,6 +432,7 @@ def run_tb1(issue_id: str, repo_path: str) -> dict:
                         model=persona_result.get("model", "sonnet"),
                         allowed_tools=allowed_tools,
                         max_context_pct=max_context_pct,
+                        timeout_seconds=persona_result.get("timeout_seconds", 300),
                     )
 
                     agent_exit = agent_result.get("exit_code", -1)

src/devloop/feedback/tb1_golden_path.py

@@ -348,13 +348,26 @@ def run_tb2(
                     task_prompt=task_prompt,
                     model=persona_result.get("model", "sonnet"),
                     allowed_tools=allowed_tools,
+                    timeout_seconds=persona_result.get("timeout_seconds", 300),
                 )
 
                 agent_exit = agent_result.get("exit_code", -1)
                 agent_span.set_attribute("tb2.agent_exit_code", agent_exit)
                 attempt_span_ids.append(_span_id_hex(agent_span))
 
-                if agent_exit != 0:
+                # If the agent timed out, feed the timeout into the retry
+                # loop instead of returning early.  This lets TB-2 retry
+                # after a slow spawn (the 303s timeout seen in stress tests).
+                initial_timed_out = agent_result.get("timed_out", False)
+                if initial_timed_out:
+                    duration = agent_result.get("duration_seconds", 0)
+                    agent_span.set_attribute("tb2.agent_timed_out", True)
+                    agent_span.set_attribute("tb2.agent_duration", duration)
+                    logger.warning(
+                        "TB-2: Initial agent timed out after %.0fs — entering retry loop",
+                        duration,
+                    )
+                elif agent_exit != 0:
                     elapsed = time.monotonic() - pipeline_start
                     return TB2Result(
                         issue_id=issue_id,
@@ -372,59 +385,95 @@ def run_tb2(
                     ).model_dump()
 
             # ----------------------------------------------------------
-            # Phase 8: Run quality gates (or force-fail on first attempt)
+            # Phase 8: Run quality gates (or force-fail, or skip if timed out)
             # ----------------------------------------------------------
-            with tracer_tb2.start_as_current_span(
-                "tb2.phase.gates",
-                attributes={
-                    "tb2.phase": "gates",
-                    "tb2.attempt": 0,
-                    "tb2.force_fail": force_gate_fail,
-                },
-            ) as gates_span:
-                if force_gate_fail:
-                    logger.info("TB-2: FORCED FAILURE on initial gate run")
-                    gate_raw = _make_forced_failure()
-                else:
-                    gate_raw = run_all_gates(
-                        worktree_path=worktree_path,
-                        issue_title=issue_title,
-                        issue_description=issue_description,
-                    )
-
-                try:
-                    gate_suite = GateSuiteResult(**gate_raw)
-                except Exception as exc:
-                    elapsed = time.monotonic() - pipeline_start
-                    error_msg = f"Malformed gate result: {exc}"
-                    return TB2Result(
-                        issue_id=issue_id,
-                        repo_path=repo_path,
-                        success=False,
-                        phase="gates",
-                        worktree_path=worktree_path,
-                        persona=persona_name,
-                        error=error_msg,
-                        duration_seconds=round(elapsed, 2),
-                        trace_id=root_trace_id,
-                        attempt_span_ids=attempt_span_ids,
-                        force_gate_fail_used=force_gate_fail,
-                    ).model_dump()
-
-                gates_span.set_attribute("tb2.gates_passed", gate_suite.overall_passed)
-                if gate_suite.first_failure:
-                    gates_span.set_attribute("tb2.first_failure", gate_suite.first_failure)
-
-                # Record initial attempt
+            gate_suite: GateSuiteResult | None = None
+            gate_raw: dict | None = None
+            gates_span_context = None
+
+            if initial_timed_out:
+                # Agent timed out — no output to gate.  Seed a timeout
+                # failure record and jump straight to the retry loop.
+                duration = agent_result.get("duration_seconds", 0)
+                gate_raw = GateSuiteResult(
+                    overall_passed=False,
+                    first_failure="agent_timeout",
+                    gate_results=[
+                        GateResult(
+                            gate_name="agent_timeout",
+                            passed=False,
+                            findings=[
+                                Finding(
+                                    severity="critical",
+                                    message=f"Agent timed out after {duration:.0f}s (no output to gate)",
+                                ),
+                            ],
+                        ),
+                    ],
+                ).model_dump()
+                gate_suite = GateSuiteResult(**gate_raw)
                 retry_history.append(
                     RetryAttempt(
                         attempt=0,
                         agent_exit_code=agent_exit,
-                        gates_passed=gate_suite.overall_passed,
-                        first_failure=gate_suite.first_failure,
+                        gates_passed=False,
+                        first_failure="agent_timeout",
                         span_id=attempt_span_ids[0] if attempt_span_ids else None,
                     )
                 )
+            else:
+                with tracer_tb2.start_as_current_span(
+                    "tb2.phase.gates",
+                    attributes={
+                        "tb2.phase": "gates",
+                        "tb2.attempt": 0,
+                        "tb2.force_fail": force_gate_fail,
+                    },
+                ) as gates_span:
+                    if force_gate_fail:
+                        logger.info("TB-2: FORCED FAILURE on initial gate run")
+                        gate_raw = _make_forced_failure()
+                    else:
+                        gate_raw = run_all_gates(
+                            worktree_path=worktree_path,
+                            issue_title=issue_title,
+                            issue_description=issue_description,
+                        )
+
+                    try:
+                        gate_suite = GateSuiteResult(**gate_raw)
+                    except Exception as exc:
+                        elapsed = time.monotonic() - pipeline_start
+                        error_msg = f"Malformed gate result: {exc}"
+                        return TB2Result(
+                            issue_id=issue_id,
+                            repo_path=repo_path,
+                            success=False,
+                            phase="gates",
+                            worktree_path=worktree_path,
+                            persona=persona_name,
+                            error=error_msg,
+                            duration_seconds=round(elapsed, 2),
+                            trace_id=root_trace_id,
+                            attempt_span_ids=attempt_span_ids,
+                            force_gate_fail_used=force_gate_fail,
+                        ).model_dump()
+
+                    gates_span.set_attribute("tb2.gates_passed", gate_suite.overall_passed)
+                    if gate_suite.first_failure:
+                        gates_span.set_attribute("tb2.first_failure", gate_suite.first_failure)
+                    gates_span_context = gates_span.get_span_context()
+
+                    # Record initial attempt
+                    retry_history.append(
+                        RetryAttempt(
+                            attempt=0,
+                            agent_exit_code=agent_exit,
+                            gates_passed=gate_suite.overall_passed,
+                            first_failure=gate_suite.first_failure,
+                            span_id=attempt_span_ids[0] if attempt_span_ids else None,
+                        )
+                    )
 
             # ----------------------------------------------------------
             # Phase 9: Gates passed on first try -> success
@@ -485,7 +534,7 @@ def run_tb2(
             # Phase 10: Gates failed -> retry loop with span linking
             # ----------------------------------------------------------
             all_gate_failures: list[dict] = [gate_raw]
-            previous_span_context = gates_span.get_span_context()
+            previous_span_context = gates_span_context
 
             for attempt in range(1, max_retries + 1):
                 retries_used = attempt
@@ -526,6 +575,7 @@ def run_tb2(
                         gate_failures=all_gate_failures,
                         attempt=attempt,
                         max_retries=max_retries,
+                        timeout_seconds=persona_result.get("timeout_seconds", 300),
                     )
 
                     retry_success = retry_raw.get("success", False)