tlc-claude-code 2.8.0 → 2.9.1

package/.claude/commands/tlc/audit.md

@@ -22,6 +22,18 @@ Run a comprehensive audit of the codebase against TLC coding standards.
 /tlc:audit
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'audit', prompt, project })`
+3. Report to user: "Dispatched audit to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/autofix.md

@@ -145,6 +145,18 @@ The existing autofix instructions below are the Inline Mode instructions and sho
 /tlc:autofix
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'autofix', prompt, project })`
+3. Report to user: "Dispatched autofix to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/build.md

@@ -158,54 +158,101 @@ fs.writeFileSync(path, JSON.stringify(existing, null, 2));
 "
 ```
 
+After dispatching, monitor each session to completion with `completion-checker` and react to the returned monitor state:
+
+- When a session completes, call `skill-dispatcher.captureResult()` to collect its output before merge-back
+- `stuck` -> ask the user: `Session stuck. Retry or cancel?`
+- `budget_exhausted` -> ask the user: `Budget exhausted. Re-dispatch or skip?`
+- `completed` -> proceed with merge-back
+- `crashed` / `errored` -> report the error, skip that task, and continue with remaining tasks
+
+Treat `completion-checker` as the source of truth for whether a session should merge, pause for user input, or be skipped.
+
 ### Step O3-fallback: Direct Dispatch (No Orchestrator)
 
 If orchestrator is down, dispatch directly via tmux on the host:
 
 ```bash
 tmux new-session -d -s <task-id> -c $(pwd)
-tmux send-keys -t <task-id> "/opt/homebrew/bin/codex --full-auto '<prompt>'" Enter
+tmux send-keys -t <task-id> "/opt/homebrew/bin/codex --dangerously-bypass-approvals-and-sandbox '<prompt>'" Enter
 ```
 
-### Step O4: Report and Free
+### Step O4: Report and Monitor
 
-After dispatching all tasks, report:
+After dispatching all tasks, report the initial state:
 
 ```
 Dispatched N tasks to orchestrator:
   ses_abc123  Task 1: Create schema         codex  running
-  ses_def456  Task 2: Add validation         codex  running
+  ses_def456  Task 2: Add validation        codex  running
 
-Run /tlc:status to check progress.
-I'm free — what would you like to work on?
+Monitoring for completion...
 ```
 
-**STOP HERE.** Do not write code. Do not execute inline mode. Claude is the PM, not the coder.
+**Do NOT stop here. Do NOT say "I'm free". Enter the monitoring loop immediately.**
 
-### Step O5: Monitor (When User Asks)
+### Step O5: Auto-Monitor Loop (Mandatory)
 
-When the user asks for status or agents complete, check:
+After dispatching, poll all sessions every 30 seconds until all reach terminal states. This loop runs automatically — do not wait for the user to ask.
 
-```bash
-# Check all sessions
-curl -s http://localhost:3100/sessions | node -e "
-const d=require('fs').readFileSync('/dev/stdin','utf8');
-JSON.parse(d).forEach(s=>console.log(s.id, s.status, s.project));
-"
-
-# Check specific session output (inside container)
-docker exec tlc-agent-runner tmux capture-pane -t <session_id> -p -S -20
+```
+Poll cycle:
+1. For each dispatched session, check: GET /sessions/:id/status (or tmux capture-pane)
+2. Classify each session:
+   - completed → ready for merge-back
+   - stuck → send Enter once, re-check next cycle. After 3 attempts, ask user: "Session stuck. Retry or cancel?"
+   - budget_exhausted → ask user: "Budget exhausted. Re-dispatch or skip?"
+   - crashed / errored → log error, mark task as failed, continue with others
+   - timed_out → log timeout, mark task as failed
+   - running → continue monitoring
+3. When ANY session completes, report immediately: "✅ ses_abc123 Task 1 complete"
+4. When ALL dispatched sessions reach terminal states, exit the loop
 ```
 
-Auto-approve any prompts found in tmux sessions:
+**Use Bash `sleep 30` between poll cycles. Do not use background tasks for this — poll sequentially in the main conversation so results are visible.**
 
-```bash
-docker exec tlc-agent-runner tmux send-keys -t <session_id> Enter
+Surface progress at natural milestones:
+- When a session completes: one-line status update
+- When all sessions in a parallel batch complete: summary + trigger next batch
+- When a session fails: immediate report with error details
+
+### Step O5a: Dispatch Dependent Tasks
+
+When a batch of tasks completes, check the dependency graph for newly unblocked tasks. Dispatch them immediately without asking.
+
+```
+Example:
+  Tasks 1+2 dispatched (parallel, no deps)
+  Task 1 completes → check if any task depends only on Task 1 → dispatch it
+  Task 2 completes → check if remaining tasks are unblocked → dispatch them
+  Tasks 3+4 now unblocked → dispatch immediately
+  ...continue until all tasks dispatched and completed
 ```
 
+### Step O5b: Auto Merge-Back
+
+When all tasks in the phase complete (or all non-failed tasks complete):
+
+1. Pull all commits from container worktrees to the host phase branch
+2. Run the full test suite: `cd server && npx vitest run` (or project's test command)
+3. If tests pass → continue to Step O5c
+4. If tests fail → report failures, attempt auto-fix (one round), re-run tests
+
+### Step O5c: Auto Review + PR
+
+After tests pass:
+
+1. Run auto-review (same checks as Step 10 in Inline Mode)
+2. If review passes → push branch and create PR (ask user before pushing per project rules)
+3. If review fails → fix issues, re-run tests, re-review (max 3 iterations)
+
 ### Step O6: Cleanup
 
-When all tasks complete, remove `.tlc/.build-routing-active` and report results.
+After PR is created (or phase completes):
+- Remove `.tlc/.build-routing-active`
+- Remove `.tlc/.active-sessions.json`
+- Mark completed tasks `[x]` in PLAN.md
+- Report final summary
 
 ## INLINE MODE
 

package/.claude/commands/tlc/cleanup.md

@@ -25,7 +25,19 @@ Automatically fix all coding standards violations. No prompts - just fixes every
 /tlc:cleanup
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'cleanup', prompt, project })`
+3. Report to user: "Dispatched cleanup to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Inject Standards
 

package/.claude/commands/tlc/coverage.md

@@ -138,6 +138,18 @@ The existing coverage instructions below are the Inline Mode instructions and sh
 - When joining a project to understand test gaps
 - After "vibe coding" a feature without tests
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'coverage', prompt, project })`
+3. Report to user: "Dispatched coverage to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/discuss.md

@@ -149,6 +149,18 @@ This command is not a blank-page brainstorming prompt. The agent should do the i
 
 If no phase number, auto-detect current phase from `.planning/ROADMAP.md`.
 
+## Background Dispatch (Research Only)
+
+When the orchestrator is available, dispatch Step 1 (Scan Context) to a background agent for fast research, then continue the interview inline with the results.
+
+1. Check orchestrator health
+2. If available: dispatch a research agent via `skill-dispatcher.dispatch({ skill: 'discuss-research', prompt: 'Scan the codebase for phase context: read ROADMAP, PROJECT.md, relevant code, recent changes. Return structured context as JSON.' })`
+3. When research agent completes, capture result and inject as context for Step 2 (Expand Before Asking)
+4. Steps 2+ (the actual interview) always run inline - they need user interaction
+5. If orchestrator unavailable, run Step 1 inline as before
+
+Override: `--inline` flag forces all steps inline.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/docs.md

@@ -187,7 +187,19 @@ Once set up, GitHub Actions automatically:
 
 2. **You don't need to manually maintain docs.** Just push code.
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'docs', prompt, project })`
+3. Report to user: "Dispatched docs to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Run Setup (Once)
 

package/.claude/commands/tlc/edge-cases.md

@@ -147,7 +147,19 @@ The existing edge-case generation instructions below are the Inline Mode instruc
 
 If no arguments, prompts for target.
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'edge-cases', prompt, project })`
+3. Report to user: "Dispatched edge-cases to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Identify Target
 

package/.claude/commands/tlc/plan.md

@@ -187,6 +187,18 @@ Before reading or writing phase artifacts, normalize the requested phase argumen
 
 When a prefixed ID resolves to another repo, operate in that repo's directory (for example `CORE-3` resolves via the manifest and runs against `../tlc-core`).
 
+## Background Dispatch (Research Only)
+
+When the orchestrator is available, dispatch research (architecture scan, existing patterns, stack analysis) to a background agent before creating the plan inline.
+
+1. Check orchestrator health
+2. If available: dispatch research agent via `skill-dispatcher.dispatch({ skill: 'plan-research', prompt: 'Scan project structure, existing patterns, tech stack, and recent changes. Return structured context for planning.' })`
+3. When research completes, inject results into Step 1 (Load Context)
+4. Steps 2+ (task breakdown, plan creation) always run inline - they need user review
+5. If orchestrator unavailable, run all steps inline as before
+
+Override: `--inline` flag forces all steps inline.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/preflight.md

@@ -15,6 +15,18 @@ It also runs:
 - After any multi-file change
 - Before recommending a commit or push
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'preflight', prompt, project })`
+3. Report to user: "Dispatched preflight to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/refactor.md

@@ -17,6 +17,18 @@ Same fixes as `/tlc:cleanup` but:
 /tlc:refactor
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'refactor', prompt, project })`
+3. Report to user: "Dispatched refactor to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/review-pr.md

@@ -18,7 +18,19 @@ Review a GitHub/GitLab pull request for TLC compliance.
 /tlc:review-pr              # Review current PR (if on PR branch)
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'review-pr', prompt, project })`
+3. Report to user: "Dispatched review-pr to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Fetch PR Information
 

package/.claude/commands/tlc/review.md

@@ -174,6 +174,18 @@ TLC automatically uses ALL providers configured for the `review` capability in `
 /tlc:review --base dev   # Review vs different base branch
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'review', prompt, project })`
+3. Report to user: "Dispatched review to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/security.md

@@ -16,7 +16,19 @@ Run security audit on project dependencies and display vulnerabilities.
 /tlc:security
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'security', prompt, project })`
+3. Report to user: "Dispatched security to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Detect Package Manager
 

package/.claude/commands/tlc/status.md

@@ -19,7 +19,13 @@ If no phase specified, shows overall test status.
    - If no manifest exists, fall back to current-repo-only status
 2. **Detect test framework** (Vitest, Jest, pytest, etc.)
 3. **Run the test suite**
-4. **Report results** with next action
+4. **Check active background agent sessions**
+   - Read `.tlc/.active-sessions.json` when present
+   - Query live session state for each active background session
+   - Use the shared `session-status` display functions for formatting session rows
+   - Show each running background agent with: skill name, elapsed time, session ID, and monitor state
+   - Mark stuck or errored sessions with `[!]`
+5. **Report results** with next action
 
 When workspace mode is active, include a one-line summary such as:
 
@@ -44,9 +50,22 @@ Test Status
 ───────────
 [TLC] 142 tests | [CORE] 38 tests | [SA] 67 tests
 
+Background Agents:
+  [TLC] review     ses_abc123  2m30s  running
+  [TLC] watchci    ses_def456  15m    running
+  [CORE] build     ses_ghi789  5m     stuck [!]
+
 Ready for: /tlc:verify in the active repo
 ```
 
+When active background sessions exist, always include a `Background Agents:` section after the test summary. Prefer session-status formatting helpers so the output stays aligned with other orchestration views.
+
+Alerting rules:
+
+- Show `[!]` for `stuck` sessions
+- Show `[!]` for `errored` sessions
+- Include the monitor state verbatim (`running`, `stuck`, `budget_exhausted`, `crashed`, etc.)
+
 **Some failing:**
 ```
 Test Status

package/.claude/commands/tlc/verify.md

@@ -17,6 +17,18 @@ Verify the phase automatically from its plan acceptance criteria, then leave onl
 
 If no phase number, auto-detect current phase.
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'verify', prompt, project })`
+3. Report to user: "Dispatched verify to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## Process
 
 ### Step 1: Load the Phase Plan

package/.claude/commands/tlc/watchci.md

@@ -19,6 +19,18 @@ This is the "I pushed, now babysit CI for me" command.
 /tlc:watchci 3          # max 3 fix attempts (default: 5)
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'watchci', prompt, project })`
+3. Report to user: "Dispatched watchci to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## Process
 
 ### Step 1: Find the Active Run

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",

package/server/lib/orchestration/completion-checker.js

@@ -1,5 +1,17 @@
 const fs = require('fs/promises');
 
+const ACTIONABLE_MONITOR_STATES = new Map([
+  ['stuck', { suggestedAction: 'retry' }],
+  ['budget_exhausted', { suggestedAction: 'retry' }],
+]);
+
+const FAILURE_MONITOR_STATES = new Map([
+  ['crashed', 'session crashed and needs investigation'],
+  ['errored', 'session errored and needs investigation'],
+  ['loop_detected', 'session entered a loop and needs investigation'],
+  ['timed_out', 'session timed out and needs investigation'],
+]);
+
 async function readActiveSessions(activeSessionsPath) {
   try {
     const raw = await fs.readFile(activeSessionsPath, 'utf8');
@@ -18,6 +30,19 @@ async function writeActiveSessions(activeSessionsPath, sessions) {
   await fs.writeFile(activeSessionsPath, JSON.stringify(sessions, null, 2));
 }
 
+function getNormalizedStatus(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const monitorState = payload.monitorState
+    || payload.monitor?.state
+    || payload.metadata?.monitorState
+    || null;
+
+  return String(monitorState || payload.status || '').trim().toLowerCase() || null;
+}
+
 async function checkCompletions({
   activeSessionsPath,
   orchestratorUrl,
@@ -28,12 +53,14 @@ async function checkCompletions({
     return {
       completions: [],
       failures: [],
+      actionable: [],
       stillRunning: 0,
     };
   }
 
   const completions = [];
   const failures = [];
+  const actionable = [];
   const remainingSessions = [];
 
   let orchestratorReachable = true;
@@ -51,13 +78,14 @@ async function checkCompletions({
       }
 
       const payload = await response.json();
+      const status = getNormalizedStatus(payload);
 
-      if (payload.status === 'completed') {
+      if (status === 'completed') {
         completions.push(session);
         continue;
       }
 
-      if (payload.status === 'failed') {
+      if (status === 'failed') {
         failures.push({
           ...session,
           ...(payload.reason ? { reason: payload.reason } : {}),
@@ -65,6 +93,26 @@ async function checkCompletions({
         continue;
       }
 
+      if (ACTIONABLE_MONITOR_STATES.has(status)) {
+        actionable.push({
+          ...session,
+          status,
+          actionable: true,
+          suggestedAction: ACTIONABLE_MONITOR_STATES.get(status).suggestedAction,
+        });
+        continue;
+      }
+
+      if (FAILURE_MONITOR_STATES.has(status)) {
+        failures.push({
+          ...session,
+          status,
+          actionable: false,
+          failureReason: FAILURE_MONITOR_STATES.get(status),
+        });
+        continue;
+      }
+
       remainingSessions.push(session);
     } catch (error) {
       if (!orchestratorReachable) {
@@ -82,6 +130,7 @@ async function checkCompletions({
     return {
       completions: [],
       failures: [],
+      actionable: [],
       stillRunning: -1,
       error: 'orchestrator unreachable',
     };
@@ -92,6 +141,7 @@ async function checkCompletions({
   return {
     completions,
     failures,
+    actionable,
     stillRunning: remainingSessions.length,
   };
 }