agentxchain 2.145.0 → 2.147.0

package/src/commands/resume.js

@@ -8,8 +8,8 @@
  *   - resolves target role from routing or --role override
  *   - if idle + no run_id → initializeGovernedRun() + assign
  *   - if paused + run_id exists → resume same run + assign
- *   - if paused + current_turn with failed status → re-dispatch same turn
- *   - if active + current_turn exists → reject (no double assignment)
+ *   - if blocked + retained active turn with failed status → re-dispatch same turn
+ *   - if active + an active turn already exists → reject (no double assignment)
  *   - materializes a turn-scoped dispatch bundle under .agentxchain/dispatch/turns/<turn_id>/
  *   - exits without waiting for turn completion
  */
@@ -26,6 +26,8 @@ import {
   getActiveTurns,
   getActiveTurnCount,
   reactivateGovernedRun,
+  reconcilePhaseAdvanceBeforeDispatch,
+  transitionActiveTurnLifecycle,
   STATE_PATH,
 } from '../lib/governed-state.js';
 import { writeDispatchBundle, getDispatchTurnDir, getTurnStagingResultPath } from '../lib/dispatch-bundle.js';
@@ -78,6 +80,10 @@ export async function resumeCommand(opts) {
 
   const staleReconciliation = reconcileStaleTurns(root, state, config);
   state = staleReconciliation.state || state;
+  if (staleReconciliation.ghost_turns.length > 0) {
+    printGhostTurnRecovery(staleReconciliation.ghost_turns);
+    process.exit(1);
+  }
   if (staleReconciliation.stale_turns.length > 0) {
     printStaleTurnRecovery(staleReconciliation.stale_turns);
     process.exit(1);
@@ -116,70 +122,25 @@ export async function resumeCommand(opts) {
     process.exit(1);
   }
 
-  // §47: paused + retained turn with failed/retrying status → re-dispatch same turn
-  if (state.status === 'paused' && activeCount > 0) {
-    // Resolve which turn to re-dispatch
-    let retainedTurn = null;
-    if (opts.turn) {
-      retainedTurn = activeTurns[opts.turn];
-      if (!retainedTurn) {
-        console.log(chalk.red(`No active turn found for --turn ${opts.turn}`));
-        process.exit(1);
-      }
-    } else if (activeCount > 1) {
-      console.log(chalk.red('Multiple retained turns exist. Use --turn <id> to specify which to re-dispatch.'));
-      for (const turn of Object.values(activeTurns)) {
-        console.log(`  ${chalk.yellow('●')} ${turn.turn_id} — ${chalk.bold(turn.assigned_role)} (${turn.status})`);
-      }
-      console.log('');
-      console.log(chalk.dim('Example: agentxchain resume --turn <turn_id>'));
-      process.exit(1);
-    } else {
-      retainedTurn = Object.values(activeTurns)[0];
-    }
-
-    const turnStatus = retainedTurn.status;
-    if (turnStatus === 'failed' || turnStatus === 'retrying') {
-      printResumeRunContext({ root, state, config });
-      console.log(chalk.yellow(`Re-dispatching failed turn: ${retainedTurn.turn_id}`));
-      console.log(`  Role:    ${retainedTurn.assigned_role}`);
-      console.log(`  Attempt: ${retainedTurn.attempt}`);
-      console.log('');
-
-      const reactivated = reactivateGovernedRun(root, state, { via: turnResumeVia, notificationConfig: config });
-      if (!reactivated.ok) {
-        console.log(chalk.red(`Failed to reactivate run: ${reactivated.error}`));
-        process.exit(1);
-      }
-      state = reactivated.state;
-      if (reactivated.migration_notice) {
-        console.log(chalk.yellow(reactivated.migration_notice));
-      }
-      if (reactivated.phantom_notice) {
-        console.log(chalk.yellow(reactivated.phantom_notice));
-      }
-
-      // Write dispatch bundle for the existing turn
-      const bundleResult = writeDispatchBundle(root, state, config);
-      if (!bundleResult.ok) {
-        console.log(chalk.red(`Failed to write dispatch bundle: ${bundleResult.error}`));
-        process.exit(1);
-      }
-      printDispatchBundleWarnings(bundleResult);
-
-      // after_dispatch hooks with bundle-core tamper protection
-      const hooksConfig = config.hooks || {};
-      if (hooksConfig.after_dispatch?.length > 0) {
-        const afterDispatchResult = runAfterDispatchHooks(root, hooksConfig, state, retainedTurn);
-        if (!afterDispatchResult.ok) {
-          process.exit(1);
-        }
-      }
-
-      printDispatchSummary(state, config, retainedTurn);
-      return;
-    }
-  }
+  // Removed (Turn 25): the §47 `paused + retained turn → re-dispatch failed/retrying`
+  // branch is provably unreachable under the current schema and migration contract:
+  //
+  //   1. `cli/src/lib/schema.js:184` rejects `status: 'paused'` unless
+  //      `pending_phase_transition` or `pending_run_completion` is set.
+  //   2. The guard above (line 119) short-circuits with `printRecoverySummary`
+  //      whenever either pending field is set — so any schema-valid paused state
+  //      exits before reaching this point.
+  //   3. Legacy on-disk shapes that pre-date the schema constraint (paused +
+  //      `blocked_on: 'human:...'` / `blocked_on: 'escalation:...'` with no
+  //      pending approval) are auto-migrated to `status: 'blocked'` by
+  //      `normalizeStateForRead` in `governed-state.js:2191-2204` before
+  //      `loadProjectState` returns.
+  //
+  // The reachable retained-turn re-dispatch path is the `blocked + activeCount > 0`
+  // branch immediately below, which legacy paused-pause shapes are migrated into.
+  // Per `DEC-UNREACHABLE-BRANCH-COVERAGE-001`, dead branches are removed (not
+  // patched defensively) once the schema citation + migration citation are
+  // documented in code and the coverage matrix.
 
   if (state.status === 'blocked' && activeCount > 0) {
     let retainedTurn = null;
@@ -240,6 +201,21 @@ export async function resumeCommand(opts) {
       }
     }
 
+    // BUG-51 follow-up: see comment in paused/failed retained-turn branch.
+    // The blocked re-dispatch path has the same watchdog/manifest invariant.
+    const manifestResult = finalizeDispatchManifest(root, retainedTurn.turn_id, {
+      run_id: state.run_id,
+      role: retainedTurn.assigned_role,
+    });
+    if (!manifestResult.ok) {
+      console.log(chalk.red(`Failed to finalize dispatch manifest: ${manifestResult.error}`));
+      process.exit(1);
+    }
+    const dispatched = transitionActiveTurnLifecycle(root, retainedTurn.turn_id, 'dispatched');
+    if (dispatched.ok) {
+      state = dispatched.state;
+    }
+
     printDispatchSummary(state, config, retainedTurn);
     return;
   }
@@ -295,6 +271,24 @@ export async function resumeCommand(opts) {
     }
   }
 
+  const phaseReconciliation = reconcilePhaseAdvanceBeforeDispatch(root, config, state);
+  if (!phaseReconciliation.ok && !phaseReconciliation.state) {
+    console.log(chalk.red(`Failed to reconcile phase gate before dispatch: ${phaseReconciliation.error}`));
+    process.exit(1);
+  }
+  state = phaseReconciliation.state || state;
+  if (phaseReconciliation.advanced) {
+    console.log(chalk.green(`Advanced phase before dispatch: ${phaseReconciliation.from_phase} → ${phaseReconciliation.to_phase}`));
+  }
+  if (state.pending_phase_transition || state.pending_run_completion) {
+    printRecoverySummary(state, 'This run is awaiting approval.', config);
+    process.exit(1);
+  }
+  if (state.status === 'blocked') {
+    printRecoverySummary(state, 'This run is blocked.', config);
+    process.exit(1);
+  }
+
   // Print run-context header before dispatch
   printResumeRunContext({ root, state, config });
 
@@ -356,9 +350,27 @@ export async function resumeCommand(opts) {
     process.exit(1);
   }
 
+  const dispatched = transitionActiveTurnLifecycle(root, turn.turn_id, 'dispatched');
+  if (dispatched.ok) {
+    state = dispatched.state;
+  }
+
   printDispatchSummary(state, config);
 }
 
+function printGhostTurnRecovery(ghostTurns) {
+  console.log(chalk.red.bold('Ghost turn detected — subprocess never started.'));
+  console.log('');
+  for (const ghost of ghostTurns) {
+    const secs = Math.floor(ghost.running_ms / 1000);
+    console.log(`  Turn:    ${ghost.turn_id} (${ghost.role})`);
+    console.log(`  Runtime: ${ghost.runtime_id}`);
+    console.log(`  Age:     ${secs}s with no subprocess output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${ghost.turn_id} --reason ghost`)}`);
+    console.log('');
+  }
+}
+
 function printStaleTurnRecovery(staleTurns) {
   console.log(chalk.red.bold('Stale turn detected.'));
   console.log('');

package/src/commands/run.js

@@ -18,6 +18,7 @@ import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import { runLoop } from '../lib/run-loop.js';
+import { transitionActiveTurnLifecycle } from '../lib/runner-interface.js';
 import { buildRunExport } from '../lib/export.js';
 import { buildGovernanceReport, formatGovernanceReportMarkdown } from '../lib/report.js';
 import { validateParentRun } from '../lib/run-history.js';
@@ -49,6 +50,8 @@ import { resolveContinuousOptions, executeContinuousRun } from '../lib/continuou
 import { createDispatchProgressTracker } from '../lib/dispatch-progress.js';
 import { emitRunEvent } from '../lib/run-events.js';
 import { checkpointAcceptedTurn } from '../lib/turn-checkpoint.js';
+import { failTurnStartup } from '../lib/stale-turn-watchdog.js';
+import { hasMinimumTurnResultShape } from '../lib/turn-result-shape.js';
 
 export async function runCommand(opts) {
   const context = loadProjectContext();
@@ -314,20 +317,49 @@ export async function executeGovernedRun(context, opts = {}) {
       if (!manifestResult.ok) {
         return { accept: false, reason: `dispatch manifest failed: ${manifestResult.error}` };
       }
+      transitionActiveTurnLifecycle(projectRoot, turn.turn_id, 'dispatched');
 
       // ── Route to adapter ──────────────────────────────────────────────
       const tracker = createDispatchProgressTracker(projectRoot, turn, {
         adapter_type: runtimeType,
       });
+      let startupStarted = false;
+      let runningMarked = false;
+
+      const ensureStartingState = (pid = null, at = new Date().toISOString()) => {
+        if (startupStarted) return;
+        startupStarted = true;
+        transitionActiveTurnLifecycle(projectRoot, turn.turn_id, 'starting', { pid, at });
+        tracker.start();
+        if (pid != null) {
+          tracker.setPid(pid);
+        }
+        emitRunEvent(projectRoot, 'dispatch_progress', {
+          run_id: state.run_id,
+          phase: state.phase,
+          status: state.status,
+          turn: { turn_id: turn.turn_id, assigned_role: roleId },
+          payload: { milestone: 'started', output_lines: 0, elapsed_seconds: 0, silent_seconds: 0 },
+        });
+      };
+
+      const ensureRunningState = (stream = 'stdout', at = new Date().toISOString()) => {
+        if (runningMarked) return;
+        runningMarked = true;
+        transitionActiveTurnLifecycle(projectRoot, turn.turn_id, 'running', { stream, at });
+      };
 
       const adapterOpts = {
         signal: combineAbortSignals(controller.signal, ctx.dispatchAbortSignal),
         onStatus: (msg) => log(chalk.dim(`  ${msg}`)),
         verifyManifest: true,
         turnId: turn.turn_id,
+        onSpawnAttached: ({ pid, at }) => ensureStartingState(pid, at),
+        onFirstOutput: ({ at, stream }) => ensureRunningState(stream, at),
       };
 
       const recordOutputActivity = (stream, text) => {
+        ensureRunningState(stream);
         const lines = text.split('\n').length - 1 || 1;
         const wasSilent = tracker.onOutput(stream, lines);
         if (wasSilent) {
@@ -368,23 +400,17 @@ export async function executeGovernedRun(context, opts = {}) {
 
       let adapterResult;
 
-      // Emit dispatch_progress started event and begin tracking
-      tracker.start();
-      emitRunEvent(projectRoot, 'dispatch_progress', {
-        run_id: state.run_id,
-        phase: state.phase,
-        status: state.status,
-        turn: { turn_id: turn.turn_id, assigned_role: roleId },
-        payload: { milestone: 'started', output_lines: 0, elapsed_seconds: 0, silent_seconds: 0 },
-      });
-
       try {
         if (runtimeType === 'api_proxy') {
+          ensureStartingState(null);
+          ensureRunningState('request');
           log(chalk.dim(`  Dispatching to API proxy: ${runtime?.provider || '?'} / ${runtime?.model || '?'}`));
           tracker.requestStarted();
           adapterResult = await dispatchApiProxy(projectRoot, state, cfg, adapterOpts);
           if (adapterResult.ok) tracker.responseReceived();
         } else if (runtimeType === 'mcp') {
+          ensureStartingState(null);
+          ensureRunningState('request');
           const transport = resolveMcpTransport(runtime);
           log(chalk.dim(`  Dispatching to MCP ${transport}: ${describeMcpRuntimeTarget(runtime)}`));
           tracker.requestStarted();
@@ -395,6 +421,8 @@ export async function executeGovernedRun(context, opts = {}) {
           log(chalk.dim(`  Dispatching to local CLI: ${runtime?.command || '(default)'}  transport: ${transport}`));
           adapterResult = await dispatchLocalCli(projectRoot, state, cfg, adapterOpts);
         } else if (runtimeType === 'remote_agent') {
+          ensureStartingState(null);
+          ensureRunningState('request');
           log(chalk.dim(`  Dispatching to remote agent: ${describeRemoteAgentTarget(runtime)}`));
           tracker.requestStarted();
           adapterResult = await dispatchRemoteAgent(projectRoot, state, cfg, adapterOpts);
@@ -413,6 +441,10 @@ export async function executeGovernedRun(context, opts = {}) {
         throw err;
       }
 
+      if (adapterResult.ok && runtimeType === 'local_cli' && !runningMarked) {
+        ensureRunningState('staged_result', adapterResult.firstOutputAt || new Date().toISOString());
+      }
+
       // Emit completion/failure progress event and clean up tracker
       const progressState = tracker.getState();
       const elapsedSec = Math.round((Date.now() - new Date(progressState.started_at)) / 1000);
@@ -439,6 +471,19 @@ export async function executeGovernedRun(context, opts = {}) {
         return { accept: false, reason: 'dispatch timed out' };
       }
 
+      if (adapterResult.startupFailure) {
+        const freshState = loadProjectState(projectRoot, cfg) || state;
+        failTurnStartup(projectRoot, freshState, cfg, turn.turn_id, {
+          failure_type: adapterResult.startupFailureType || 'no_subprocess_output',
+          threshold_ms: cfg?.run_loop?.startup_watchdog_ms ?? 30_000,
+          running_ms: freshState?.active_turns?.[turn.turn_id]?.started_at
+            ? Math.max(0, Date.now() - new Date(freshState.active_turns[turn.turn_id].started_at).getTime())
+            : 0,
+          recommendation: `Turn ${turn.turn_id} failed to start within the startup watchdog window. Run \`agentxchain reissue-turn --turn ${turn.turn_id} --reason ghost\` to recover.`,
+        });
+        return { accept: false, blocked: true, reason: adapterResult.error || 'turn startup failed' };
+      }
+
       // Adapter failure
       if (!adapterResult.ok) {
         if (shouldSuggestManualQaFallback({
@@ -472,6 +517,18 @@ export async function executeGovernedRun(context, opts = {}) {
         return { accept: false, reason: `failed to parse staged result: ${err.message}` };
       }
 
+      // Per DEC-MINIMUM-TURN-RESULT-SHAPE-001: the staged-result read shortcut
+      // must refuse payloads that lack the minimum governed envelope. Adapter
+      // pre-stage guards already reject these, but this is the final boundary
+      // before acceptance projection — fail closed on tampered or legacy
+      // adapter output rather than trust upstream.
+      if (!hasMinimumTurnResultShape(turnResult)) {
+        return {
+          accept: false,
+          reason: 'staged result missing minimum governed envelope (schema_version + identity + lifecycle fields)',
+        };
+      }
+
       return { accept: true, turnResult };
     },
 

package/src/commands/schedule.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { loadProjectContext } from '../lib/config.js';
+import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import {
   SCHEDULE_STATE_PATH,
   DAEMON_STATE_PATH,
@@ -97,19 +97,37 @@ function buildScheduleProvenance(entry) {
   };
 }
 
-function buildScheduleExecutionResult(entryId, execution, fallbackState, action = 'ran') {
-  const state = execution.result?.state || fallbackState || null;
+export function buildScheduleExecutionResult(entryId, execution, fallbackState, action = 'ran') {
+  const state = fallbackState || execution.result?.state || null;
+  const blockedReason = state?.blocked_reason || null;
+  const recoveryAction = blockedReason?.recovery?.recovery_action || null;
+  const blockedCategory = blockedReason?.category || null;
   return {
     id: entryId,
     action,
     run_id: state?.run_id || null,
     stop_reason: execution.result?.stop_reason || null,
     exit_code: execution.exitCode,
+    recovery_action: recoveryAction,
+    blocked_category: blockedCategory,
   };
 }
 
+function resolveScheduleExecutionState(root, config, execution, fallbackState) {
+  const executionState = execution.result?.state || null;
+  const liveState = loadProjectState(root, config);
+
+  if (execution.result?.stop_reason === 'blocked' || execution.result?.stop_reason === 'reject_exhausted') {
+    if (liveState?.status === 'blocked' && liveState?.blocked_reason) {
+      return liveState;
+    }
+  }
+
+  return executionState || liveState || fallbackState || null;
+}
+
 function recordScheduleExecution(context, entryId, execution, fallbackState, nowIso, action = 'ran') {
-  const state = execution.result?.state || fallbackState || null;
+  const state = resolveScheduleExecutionState(context.root, context.config, execution, fallbackState);
   const runId = state?.run_id || null;
   const startedAt = state?.created_at || nowIso;
 
@@ -197,7 +215,7 @@ async function continueActiveScheduledRun(context, opts = {}) {
   }
 
   const blocked = execution.result?.stop_reason === 'blocked';
-  const action = blocked && opts.tolerateBlockedRun ? 'blocked' : 'continued';
+  const action = blocked ? 'blocked' : 'continued';
   const result = recordScheduleExecution(context, scheduleId, execution, state, opts.at || new Date().toISOString(), action);
 
   if (execution.exitCode !== 0 && !(opts.tolerateBlockedRun && blocked)) {
@@ -312,7 +330,7 @@ async function runDueSchedules(context, opts = {}) {
       execution,
       execution.result?.state || null,
       nowIso,
-      blocked && opts.tolerateBlockedRun ? 'blocked' : 'ran',
+      blocked ? 'blocked' : 'ran',
     ));
 
     if (execution.exitCode !== 0) {
@@ -489,6 +507,8 @@ async function advanceScheduleContinuousSession(context, entry, opts = {}) {
     run_id: step.run_id || null,
     intent_id: step.intent_id || null,
     runs_completed: session.runs_completed,
+    recovery_action: step.recovery_action || null,
+    blocked_category: step.blocked_category || null,
   };
 }
 
@@ -536,7 +556,12 @@ export async function scheduleRunDueCommand(opts) {
       } else if (entry.action === 'preemption_failed') {
         console.log(chalk.red(`Schedule preemption failed: ${entry.id} (${entry.error || 'unknown error'})`));
       } else if (entry.action === 'blocked') {
-        console.log(chalk.yellow(`Schedule waiting on unblock: ${entry.id}`));
+        if (entry.recovery_action) {
+          const categorySuffix = entry.blocked_category ? ` (${entry.blocked_category})` : '';
+          console.log(chalk.yellow(`Schedule blocked: ${entry.id}${categorySuffix}. Recovery: ${entry.recovery_action}`));
+        } else {
+          console.log(chalk.yellow(`Schedule waiting on unblock: ${entry.id}`));
+        }
       } else if (entry.action === 'skipped') {
         console.log(chalk.yellow(`Schedule skipped: ${entry.id} (${entry.reason})`));
       } else if (entry.action === 'not_due') {
@@ -709,6 +734,8 @@ export async function scheduleDaemonCommand(opts) {
         runs_completed: contResult.runs_completed ?? null,
       };
       if (contResult.reason) contResultEntry.reason = contResult.reason;
+      if (contResult.recovery_action) contResultEntry.recovery_action = contResult.recovery_action;
+      if (contResult.blocked_category) contResultEntry.blocked_category = contResult.blocked_category;
 
       result = {
         ok: contResult.ok !== false && nonContResult.ok,

package/src/commands/status.js

@@ -136,6 +136,10 @@ function loadStatusContext(dir = process.cwd()) {
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
   let state = loadProjectState(root, config);
+  const staleReconciliation = reconcileStaleTurns(root, state, config);
+  state = staleReconciliation.state || state;
+  const staleTurns = staleReconciliation.stale_turns;
+  const ghostTurns = staleReconciliation.ghost_turns || [];
   const stateRunId = state?.run_id || readRawStateRunId(root, config);
   const continuity = getContinuityStatus(root, state);
   const connectorHealth = getConnectorHealth(root, config, state);
@@ -166,11 +170,6 @@ function renderGovernedStatus(context, opts) {
   // Coordinator warning surfacing — DEC-COORD-RETRY-PROJECTION-EVENT-001
   const coordinatorWarnings = readCoordinatorWarnings(root, { runId: stateRunId || null });
 
-  // BUG-47: detect stale running turns and emit turn_stalled events
-  const staleReconciliation = reconcileStaleTurns(root, state, config);
-  state = staleReconciliation.state || state;
-  const staleTurns = staleReconciliation.stale_turns;
-
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -209,6 +208,7 @@ function renderGovernedStatus(context, opts) {
       bundle_integrity: detectStateBundleDesync(root, state),
       coordinator_warnings: coordinatorWarnings,
       stale_turns: staleTurns,
+      ghost_turns: ghostTurns,
     }, null, 2));
     return;
   }
@@ -382,6 +382,16 @@ function renderGovernedStatus(context, opts) {
         console.log(`      ${chalk.dim('Recover:')} ${chalk.cyan(`agentxchain reject-turn --turn ${turn.turn_id}`)} — reject and retry`);
         console.log(`      ${chalk.dim('     or:')} ${chalk.cyan(`agentxchain accept-turn --turn ${turn.turn_id}`)} — re-attempt acceptance`);
       }
+      if (turn.status === 'failed_start') {
+        console.log(`      ${chalk.dim('Reason:')}  ${turn.failed_start_reason || 'no_subprocess_output'}`);
+        const recover = turn.recovery_command || `agentxchain reissue-turn --turn ${turn.turn_id} --reason ghost`;
+        console.log(`      ${chalk.dim('Recover:')} ${chalk.cyan(recover)}`);
+      }
+      if (turn.status === 'stalled') {
+        console.log(`      ${chalk.dim('Reason:')}  ${turn.stalled_reason || 'no_output_within_threshold'}`);
+        const recover = turn.recovery_command || `agentxchain reissue-turn --turn ${turn.turn_id} --reason stale`;
+        console.log(`      ${chalk.dim('Recover:')} ${chalk.cyan(recover)}`);
+      }
     }
   } else if (singleActiveTurn) {
     console.log(`  ${chalk.dim('Turn:')}     ${singleActiveTurn.turn_id}`);
@@ -432,6 +442,16 @@ function renderGovernedStatus(context, opts) {
       console.log(`  ${chalk.dim('Resolve:')}  ${chalk.cyan(reassignAction.command)}`);
       console.log(`  ${chalk.dim('     or:')}  ${chalk.cyan(mergeAction.command)}`);
     }
+    if (singleActiveTurn.status === 'failed_start') {
+      console.log(`  ${chalk.dim('Reason:')}   ${singleActiveTurn.failed_start_reason || 'no_subprocess_output'}`);
+      const recover = singleActiveTurn.recovery_command || `agentxchain reissue-turn --turn ${singleActiveTurn.turn_id} --reason ghost`;
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(recover)}`);
+    }
+    if (singleActiveTurn.status === 'stalled') {
+      console.log(`  ${chalk.dim('Reason:')}   ${singleActiveTurn.stalled_reason || 'no_output_within_threshold'}`);
+      const recover = singleActiveTurn.recovery_command || `agentxchain reissue-turn --turn ${singleActiveTurn.turn_id} --reason stale`;
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(recover)}`);
+    }
   } else {
     console.log(`  ${chalk.dim('Turn:')}     ${chalk.yellow('No active turn')}`);
   }
@@ -453,6 +473,19 @@ function renderGovernedStatus(context, opts) {
     }
   }
 
+  // BUG-51: Ghost turn warning (subprocess never started)
+  if (ghostTurns.length > 0) {
+    console.log('');
+    for (const gt of ghostTurns) {
+      const secs = Math.floor(gt.running_ms / 1000);
+      console.log(`  ${chalk.red.bold('⚠ Ghost turn detected — subprocess never started')}`);
+      console.log(`  ${chalk.dim('Turn:')}     ${gt.turn_id} (${gt.role})`);
+      console.log(`  ${chalk.dim('Runtime:')}  ${gt.runtime_id}`);
+      console.log(`  ${chalk.dim('Age:')}      ${secs}s with no subprocess output`);
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(`agentxchain reissue-turn --turn ${gt.turn_id} --reason ghost`)}`);
+    }
+  }
+
   // BUG-47: Stale turn warning
   if (staleTurns.length > 0) {
     console.log('');