tlc-claude-code 2.8.0 → 2.9.0

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,6 +158,16 @@ 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:
@@ -173,13 +183,15 @@ After dispatching all tasks, report:
 
 ```
 Dispatched N tasks to orchestrator:
-  ses_abc123  Task 1: Create schema         codex  running
-  ses_def456  Task 2: Add validation         codex  running
+  ses_abc123  Task 1: Create schema         codex  running  monitor=running
+  ses_def456  Task 2: Add validation        codex  running  monitor=running
 
 Run /tlc:status to check progress.
 I'm free — what would you like to work on?
 ```
 
+Include each session's current monitor state in the status display. When available, prefer the same session-status formatting used by orchestration status views so monitor values stay consistent across commands.
+
 **STOP HERE.** Do not write code. Do not execute inline mode. Claude is the PM, not the coder.
 
 ### Step O5: Monitor (When User Asks)

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.0",
   "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,
   };
 }

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

@@ -49,6 +49,7 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [],
       failures: [],
+      actionable: [],
       stillRunning: 0,
     });
     expect(fetch).not.toHaveBeenCalled();
@@ -74,6 +75,7 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [makeSession()],
       failures: [],
+      actionable: [],
       stillRunning: 0,
     });
     expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
@@ -97,6 +99,7 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [],
       failures: [{ ...makeSession(), reason: 'Tests failed' }],
+      actionable: [],
       stillRunning: 0,
     });
     expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
@@ -131,11 +134,70 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [completed],
       failures: [{ ...failed, reason: 'Rejected' }],
+      actionable: [],
       stillRunning: 1,
     });
     expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([running]);
   });
 
+  it.each([
+    ['stuck', { status: 'stuck', actionable: true, suggestedAction: 'retry' }],
+    ['budget_exhausted', { status: 'budget_exhausted', actionable: true, suggestedAction: 'retry' }],
+  ])('reports actionable monitor state %s', async (state, expected) => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const session = makeSession();
+    writeSessionsFile(activeSessionsPath, [session]);
+
+    const fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ status: state }),
+    });
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [],
+      actionable: [{ ...session, ...expected }],
+      stillRunning: 0,
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
+  });
+
+  it.each([
+    ['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'],
+  ])('reports failure monitor state %s', async (state, failureReason) => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const session = makeSession();
+    writeSessionsFile(activeSessionsPath, [session]);
+
+    const fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ status: state }),
+    });
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [{ ...session, status: state, actionable: false, failureReason }],
+      actionable: [],
+      stillRunning: 0,
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
+  });
+
   it('returns an error result when the orchestrator is unreachable', async () => {
     const activeSessionsPath = makeActiveSessionsPath();
     const session = makeSession();
@@ -152,6 +214,7 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [],
       failures: [],
+      actionable: [],
       stillRunning: -1,
       error: 'orchestrator unreachable',
     });
@@ -170,6 +233,7 @@ describe('completion-checker', () => {
     expect(result).toEqual({
       completions: [],
       failures: [],
+      actionable: [],
       stillRunning: 0,
     });
     expect(fs.existsSync(activeSessionsPath)).toBe(false);