agentxchain 2.151.0 → 2.153.0

package/bin/agentxchain.js

@@ -753,6 +753,10 @@ program
   .option('--triage-approval <mode>', 'Triage policy for vision-derived intents: auto or human (default: config or auto)')
   .option('--max-idle-cycles <n>', 'Stop after N consecutive idle cycles with no derivable work (default: 3)', parseInt)
   .option('--session-budget <usd>', 'Cumulative session-level budget cap in USD for continuous mode', parseFloat)
+  .option('--auto-retry-on-ghost', 'Enable bounded automatic retry for continuous-mode startup ghost turns')
+  .option('--no-auto-retry-on-ghost', 'Disable bounded automatic retry for continuous-mode startup ghost turns')
+  .option('--auto-retry-on-ghost-max-retries <n>', 'Maximum startup ghost retries per continuous run (default: config or 3)', parseInt)
+  .option('--auto-retry-on-ghost-cooldown-seconds <n>', 'Seconds to wait between startup ghost retries (default: config or 5)', parseInt)
   .option('--auto-checkpoint', 'Auto-commit accepted writable turns after acceptance')
   .option('--no-auto-checkpoint', 'Disable automatic checkpointing after accepted writable turns')
   .action(runCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.151.0",
+  "version": "2.153.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/resume.js

@@ -94,6 +94,7 @@ export async function resumeCommand(opts) {
   const activeTurns = getActiveTurns(state);
   const resumeVia = opts?._via || 'resume';
   const turnResumeVia = opts?._via || 'resume --turn';
+  let skipRetainedRedispatch = false;
 
   if (state.status === 'active' && activeCount > 0) {
     if (activeCount === 1) {
@@ -142,7 +143,53 @@ export async function resumeCommand(opts) {
   // patched defensively) once the schema citation + migration citation are
   // documented in code and the coverage matrix.
 
-  if (state.status === 'blocked' && activeCount > 0) {
+  if (state.status === 'blocked' && activeCount > 0 && resumeVia === 'operator_unblock') {
+    const reactivated = reactivateGovernedRun(root, state, { via: resumeVia, notificationConfig: config });
+    if (!reactivated.ok) {
+      console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));
+      process.exit(1);
+    }
+    state = reactivated.state;
+    console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
+    if (reactivated.phantom_notice) {
+      console.log(chalk.yellow(reactivated.phantom_notice));
+    }
+
+    const phaseReconciliation = reconcilePhaseAdvanceBeforeDispatch(root, config, state, {
+      allow_active_turn_cleanup: true,
+      allow_standing_gate: true,
+    });
+    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}`));
+      skipRetainedRedispatch = true;
+    } else {
+      markRunBlocked(root, {
+        category: 'needs_human',
+        blockedOn: state.blocked_on || 'human:unblock_reconcile_failed',
+        recovery: {
+          typed_reason: 'needs_human',
+          owner: 'human',
+          recovery_action: 'agentxchain approve-transition or agentxchain gate show <gate>',
+          turn_retained: true,
+          detail: 'Operator unblock resolved the escalation, but no phase transition could be materialized from the current gate state.',
+        },
+        turnId: opts.turn || null,
+        notificationConfig: config,
+      });
+      console.log(chalk.red('Unblock did not materialize a phase transition; leaving the run blocked for manual recovery.'));
+      process.exit(1);
+    }
+  }
+
+  if (state.status === 'blocked' && activeCount > 0 && !skipRetainedRedispatch) {
     let retainedTurn = null;
     if (opts.turn) {
       retainedTurn = activeTurns[opts.turn];

package/src/lib/continuous-run.js

@@ -25,6 +25,14 @@ import {
 import { loadProjectState } from './config.js';
 import { safeWriteJson } from './safe-write.js';
 import { emitRunEvent } from './run-events.js';
+import { reissueTurn } from './governed-state.js';
+import {
+  applyGhostRetryAttempt,
+  applyGhostRetryExhaustion,
+  buildGhostRetryDiagnosticBundle,
+  buildGhostRetryExhaustionMirror,
+  classifyGhostRetryDecision,
+} from './ghost-retry.js';
 import {
   archiveStaleIntentsForRun,
   formatLegacyIntentMigrationNotice,
@@ -127,6 +135,178 @@ function getBlockedCategory(state) {
   return state?.blocked_reason?.category || null;
 }
 
+function writeGovernedState(root, state) {
+  safeWriteJson(join(root, '.agentxchain', 'state.json'), state);
+}
+
+function clearGhostBlockerAfterReissue(root, state) {
+  const nextState = {
+    ...state,
+    status: 'active',
+    blocked_on: null,
+    blocked_reason: null,
+    escalation: null,
+  };
+  writeGovernedState(root, nextState);
+  return nextState;
+}
+
+async function maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log = console.log) {
+  const { root, config } = context;
+  const decision = classifyGhostRetryDecision({
+    state: blockedState,
+    session,
+    autoRetryOnGhost: contOpts.autoRetryOnGhost,
+    runId: session.current_run_id || blockedState?.run_id || null,
+  });
+
+  if (decision.decision === 'retry') {
+    const oldTurnId = decision.ghost.turn_id;
+    const oldTurn = blockedState?.active_turns?.[oldTurnId] || {};
+    const reissued = reissueTurn(root, config, {
+      turnId: oldTurnId,
+      reason: 'auto_retry_ghost',
+    });
+    if (!reissued.ok) {
+      log(`Ghost auto-retry skipped: ${reissued.error}`);
+      return null;
+    }
+
+    const runId = session.current_run_id || blockedState?.run_id || reissued.state?.run_id || null;
+    const attempt = decision.attempts + 1;
+    const nowIso = new Date().toISOString();
+    const nextState = clearGhostBlockerAfterReissue(root, reissued.state);
+    // Slice 2c: pass runtime/role/timing fields so the fingerprint log can
+    // drive same-signature early-stop detection on subsequent invocations.
+    const oldRuntimeId = oldTurn.runtime_id || reissued.newTurn.runtime_id || null;
+    const oldRoleId = oldTurn.assigned_role || reissued.newTurn.assigned_role || null;
+    const oldRunningMs = oldTurn.failed_start_running_ms ?? null;
+    const oldThresholdMs = oldTurn.failed_start_threshold_ms ?? null;
+    const nextSession = applyGhostRetryAttempt(session, {
+      runId,
+      oldTurnId,
+      newTurnId: reissued.newTurn.turn_id,
+      failureType: decision.ghost.failure_type,
+      maxRetries: decision.maxRetries,
+      nowIso,
+      runtimeId: oldRuntimeId,
+      roleId: oldRoleId,
+      runningMs: oldRunningMs,
+      thresholdMs: oldThresholdMs,
+    });
+    Object.assign(session, nextSession, {
+      status: 'running',
+      current_run_id: runId,
+    });
+    writeContinuousSession(root, session);
+
+    emitRunEvent(root, 'auto_retried_ghost', {
+      run_id: runId,
+      phase: nextState.phase || blockedState?.phase || null,
+      status: 'active',
+      turn: { turn_id: reissued.newTurn.turn_id, role_id: reissued.newTurn.assigned_role },
+      intent_id: oldTurn.intake_context?.intent_id || null,
+      payload: {
+        old_turn_id: oldTurnId,
+        new_turn_id: reissued.newTurn.turn_id,
+        failure_type: decision.ghost.failure_type,
+        attempt,
+        max_retries_per_run: decision.maxRetries,
+        runtime_id: oldTurn.runtime_id || reissued.newTurn.runtime_id || null,
+        running_ms: oldTurn.failed_start_running_ms ?? null,
+        threshold_ms: oldTurn.failed_start_threshold_ms ?? null,
+      },
+    });
+
+    log(`Ghost turn auto-retried (${attempt}/${decision.maxRetries}): ${oldTurnId} -> ${reissued.newTurn.turn_id}`);
+    if ((contOpts.autoRetryOnGhost?.cooldownSeconds ?? 0) > 0) {
+      await new Promise((resolve) => setTimeout(resolve, contOpts.autoRetryOnGhost.cooldownSeconds * 1000));
+    }
+    return {
+      ok: true,
+      status: 'running',
+      action: 'auto_retried_ghost',
+      run_id: runId,
+      old_turn_id: oldTurnId,
+      new_turn_id: reissued.newTurn.turn_id,
+      attempt,
+      max_retries_per_run: decision.maxRetries,
+    };
+  }
+
+  if (decision.decision === 'exhausted') {
+    const runId = session.current_run_id || blockedState?.run_id || null;
+    const oldTurnId = decision.ghost.turn_id;
+    const oldTurn = blockedState?.active_turns?.[oldTurnId] || {};
+    const manualDetail = blockedState?.blocked_reason?.recovery?.detail
+      || blockedState?.blocked_reason?.recovery?.recovery_action
+      || null;
+    // Slice 2c: build the per-attempt diagnostic bundle from the session's
+    // recorded attempts_log. This is the payload the operator needs to
+    // decide their next move (bump retries, change runtime, raise watchdog,
+    // or file a new bug). Also pass signatureRepeat into the mirror so the
+    // status surface distinguishes raw exhaustion from pattern-based early
+    // stop.
+    const diagnosticBundle = buildGhostRetryDiagnosticBundle(session);
+    const signatureRepeat = decision.signatureRepeat || null;
+    const detail = buildGhostRetryExhaustionMirror({
+      attempts: decision.attempts,
+      maxRetries: decision.maxRetries,
+      failureType: decision.ghost.failure_type,
+      manualRecoveryDetail: manualDetail,
+      signatureRepeat,
+    });
+    const nextState = {
+      ...blockedState,
+      blocked_reason: {
+        ...(blockedState.blocked_reason || {}),
+        recovery: {
+          ...(blockedState.blocked_reason?.recovery || {}),
+          detail,
+        },
+      },
+    };
+    writeGovernedState(root, nextState);
+    const nextSession = applyGhostRetryExhaustion(session, {
+      runId,
+      failureType: decision.ghost.failure_type,
+      turnId: oldTurnId,
+      maxRetries: decision.maxRetries,
+      nowIso: new Date().toISOString(),
+    });
+    Object.assign(session, nextSession, { status: 'paused' });
+    writeContinuousSession(root, session);
+
+    emitRunEvent(root, 'ghost_retry_exhausted', {
+      run_id: runId,
+      phase: blockedState?.phase || null,
+      status: 'blocked',
+      turn: { turn_id: oldTurnId, role_id: oldTurn.assigned_role || null },
+      intent_id: oldTurn.intake_context?.intent_id || null,
+      payload: {
+        turn_id: oldTurnId,
+        attempts: decision.attempts,
+        max_retries_per_run: decision.maxRetries,
+        failure_type: decision.ghost.failure_type,
+        runtime_id: oldTurn.runtime_id || null,
+        exhaustion_reason: signatureRepeat ? 'same_signature_repeat' : 'retry_budget_exhausted',
+        signature_repeat: signatureRepeat,
+        diagnostic_bundle: diagnosticBundle,
+        diagnostic_refs: {
+          recovery_action: blockedState?.blocked_reason?.recovery?.recovery_action || null,
+        },
+      },
+    });
+    const tag = signatureRepeat
+      ? `same_signature_repeat [${signatureRepeat.signature}] after ${signatureRepeat.consecutive} attempts`
+      : `${decision.attempts}/${decision.maxRetries}`;
+    log(`Ghost auto-retry exhausted (${tag}) for ${oldTurnId}.`);
+    return null;
+  }
+
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Intake queue check
 // ---------------------------------------------------------------------------
@@ -301,6 +481,11 @@ export function seedFromVision(root, visionPath, options = {}) {
 
 export function resolveContinuousOptions(opts, config) {
   const configCont = config?.run_loop?.continuous || {};
+  const configGhostRetry = configCont.auto_retry_on_ghost || {};
+  const explicitConfigGhostEnabled = Object.prototype.hasOwnProperty.call(configGhostRetry, 'enabled');
+  const fullAutoGhostDefault = Boolean((opts.continuous ?? configCont.enabled ?? false) && isFullAutoApprovalPolicy(config));
+  const resolvedGhostEnabled = opts.autoRetryOnGhost
+    ?? (explicitConfigGhostEnabled ? configGhostRetry.enabled : fullAutoGhostDefault);
 
   return {
     enabled: opts.continuous ?? configCont.enabled ?? false,
@@ -313,9 +498,25 @@ export function resolveContinuousOptions(opts, config) {
     cooldownSeconds: opts.cooldownSeconds ?? configCont.cooldown_seconds ?? 5,
     perSessionMaxUsd: opts.sessionBudget ?? configCont.per_session_max_usd ?? null,
     autoCheckpoint: opts.autoCheckpoint ?? configCont.auto_checkpoint ?? true,
+    autoRetryOnGhost: {
+      enabled: resolvedGhostEnabled ?? false,
+      maxRetriesPerRun: opts.autoRetryOnGhostMaxRetries
+        ?? configGhostRetry.max_retries_per_run
+        ?? 3,
+      cooldownSeconds: opts.autoRetryOnGhostCooldownSeconds
+        ?? configGhostRetry.cooldown_seconds
+        ?? 5,
+    },
   };
 }
 
+export function isFullAutoApprovalPolicy(config) {
+  const policy = config?.approval_policy;
+  if (!policy || typeof policy !== 'object') return false;
+  return policy.phase_transitions?.default === 'auto_approve'
+    && policy.run_completion?.action === 'auto_approve';
+}
+
 // ---------------------------------------------------------------------------
 // Single-step continuous advancement primitive
 // ---------------------------------------------------------------------------
@@ -370,6 +571,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   if (session.status === 'paused') {
     const governedState = loadProjectState(root, context.config);
     if (governedState?.status === 'blocked') {
+      const retried = await maybeAutoRetryGhostBlocker(context, session, contOpts, governedState, log);
+      if (retried) return retried;
       // Still blocked — stay paused, do not attempt new work
       writeContinuousSession(root, session);
       return {
@@ -406,7 +609,10 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     const resumeStopReason = execution.result?.stop_reason;
 
     if (isBlockedContinuousExecution(execution)) {
-      const blockedRecoveryAction = getBlockedRecoveryAction(execution?.result?.state || loadProjectState(root, context.config));
+      const blockedState = execution?.result?.state || loadProjectState(root, context.config);
+      const retried = await maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log);
+      if (retried) return retried;
+      const blockedRecoveryAction = getBlockedRecoveryAction(blockedState);
       session.status = 'paused';
       log(blockedRecoveryAction
         ? `Resumed run blocked again — continuous loop re-paused. Recovery: ${blockedRecoveryAction}`
@@ -418,7 +624,7 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
         action: 'run_blocked',
         run_id: session.current_run_id,
         recovery_action: blockedRecoveryAction,
-        blocked_category: getBlockedCategory(execution?.result?.state || loadProjectState(root, context.config)),
+        blocked_category: getBlockedCategory(blockedState),
       };
     }
 
@@ -435,6 +641,64 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: true, status: 'running', action: 'resumed_after_unblock', run_id: session.current_run_id };
   }
 
+  const activeGovernedState = loadProjectState(root, context.config);
+  if (
+    session.current_run_id
+    && activeGovernedState?.status === 'active'
+    && activeGovernedState.run_id === session.current_run_id
+    && Object.keys(activeGovernedState.active_turns || {}).length > 0
+  ) {
+    log('Continuing active governed run.');
+    let execution;
+    try {
+      execution = await executeGovernedRun(context, {
+        autoApprove: true,
+        autoCheckpoint: contOpts.autoCheckpoint,
+        report: true,
+        log,
+      });
+    } catch (err) {
+      session.status = 'failed';
+      writeContinuousSession(root, session);
+      return { ok: false, status: 'failed', action: 'run_failed', stop_reason: err.message, run_id: session.current_run_id };
+    }
+
+    session.cumulative_spent_usd = (session.cumulative_spent_usd || 0) + getExecutionRunSpentUsd(execution);
+    const resumeStopReason = execution.result?.stop_reason;
+
+    if (isBlockedContinuousExecution(execution)) {
+      const blockedState = execution?.result?.state || loadProjectState(root, context.config);
+      const retried = await maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log);
+      if (retried) return retried;
+      const blockedRecoveryAction = getBlockedRecoveryAction(blockedState);
+      session.status = 'paused';
+      log(blockedRecoveryAction
+        ? `Active run blocked — continuous loop paused. Recovery: ${blockedRecoveryAction}`
+        : 'Active run blocked — continuous loop paused.');
+      writeContinuousSession(root, session);
+      return {
+        ok: true,
+        status: 'blocked',
+        action: 'run_blocked',
+        run_id: session.current_run_id,
+        recovery_action: blockedRecoveryAction,
+        blocked_category: getBlockedCategory(blockedState),
+      };
+    }
+
+    if (execution.exitCode !== 0 || !execution.result) {
+      session.status = 'failed';
+      writeContinuousSession(root, session);
+      return { ok: false, status: 'failed', action: 'run_failed', stop_reason: resumeStopReason || `exit_code_${execution.exitCode}`, run_id: session.current_run_id };
+    }
+
+    session.runs_completed += 1;
+    session.current_run_id = execution.result?.state?.run_id || session.current_run_id;
+    log(`Active run completed (${session.runs_completed}/${contOpts.maxRuns}): ${resumeStopReason || 'completed'}`);
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'running', action: 'continued_active_run', run_id: session.current_run_id };
+  }
+
   // Validate vision file
   if (!existsSync(absVisionPath)) {
     session.status = 'failed';
@@ -573,7 +837,10 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   }
 
   if (isBlockedContinuousExecution(execution)) {
-    const blockedRecoveryAction = getBlockedRecoveryAction(execution?.result?.state || loadProjectState(root, context.config));
+    const blockedState = execution?.result?.state || loadProjectState(root, context.config);
+    const retried = await maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log);
+    if (retried) return retried;
+    const blockedRecoveryAction = getBlockedRecoveryAction(blockedState);
     const resolved = resolveIntent(root, targetIntentId);
     if (!resolved.ok) {
       log(`Continuous resolve error: ${resolved.error}`);
@@ -593,7 +860,7 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
       run_id: session.current_run_id,
       intent_id: targetIntentId,
       recovery_action: blockedRecoveryAction,
-      blocked_category: getBlockedCategory(execution?.result?.state || loadProjectState(root, context.config)),
+      blocked_category: getBlockedCategory(blockedState),
     };
   }
 

package/src/lib/ghost-retry.js

@@ -0,0 +1,447 @@
+/**
+ * ghost-retry.js — Pure decision helper for BUG-61 continuous-mode ghost-turn
+ * auto-recovery.
+ *
+ * This module is deliberately pure (no disk I/O, no subprocess spawn): it takes
+ * the blocked governed state plus the continuous session snapshot and returns a
+ * decision record the continuous loop can act on.
+ *
+ * Slice 2a ships the decision helper + state-shape primitives. Slice 2b wires
+ * it into `advanceContinuousRunOnce()` and covers `reissueTurn()` side-effects
+ * + cooldowns + command-chain beta scenarios.
+ *
+ * Contracts:
+ *   - Retry is eligible ONLY when `blocked_reason.category === "ghost_turn"`
+ *     AND an active turn exists with `status === "failed_start"` AND a typed
+ *     BUG-51 startup failure (`runtime_spawn_failed` or `stdout_attach_failed`).
+ *   - Retry budget is run-scoped: switching `run_id` resets the counter to 0.
+ *   - Staged results on the ghost turn disqualify retry (defer to accept flow).
+ *   - Exhaustion returns `decision: "exhausted"` — the caller is responsible
+ *     for mirroring the outcome into governed state's
+ *     `blocked_reason.recovery.detail` per DEC-BUG61-GHOST-RETRY-STATE-OWNERSHIP-001.
+ */
+
+export const GHOST_FAILURE_TYPES = Object.freeze([
+  'runtime_spawn_failed',
+  'stdout_attach_failed',
+]);
+
+/**
+ * Slice 2c: same-signature early stop threshold.
+ *
+ * When N consecutive recorded attempts share the same fingerprint
+ * `(runtime_id, role_id, failure_type)`, the retry budget is NOT exhausted in
+ * raw count terms but the pattern signals a systematic failure that further
+ * retries will not clear. At that point the loop stops early with
+ * `decision: "exhausted"` and `reason: "same_signature_repeat"`. The threshold
+ * is deliberately low (2) because the BUG-61 contract is "retry transient
+ * ghosts" — a second identical signature is already non-transient evidence.
+ *
+ * Not configurable via `auto_retry_on_ghost` in v1; the value is a framework
+ * invariant. If evidence emerges that 2 is too aggressive, promote to config
+ * through a new DEC rather than silently widening.
+ */
+export const SIGNATURE_REPEAT_THRESHOLD = 2;
+
+/**
+ * Read (or default) the ghost_retry state object from a continuous session.
+ * Returns a plain object; callers should spread/clone before mutating.
+ */
+export function readGhostRetryState(session) {
+  const gr = session?.ghost_retry;
+  if (!gr || typeof gr !== 'object') {
+    return {
+      run_id: null,
+      attempts: 0,
+      max_retries_per_run: null,
+      last_old_turn_id: null,
+      last_new_turn_id: null,
+      last_failure_type: null,
+      last_retried_at: null,
+      exhausted: false,
+      attempts_log: [],
+    };
+  }
+  return {
+    run_id: gr.run_id ?? null,
+    attempts: Number.isInteger(gr.attempts) && gr.attempts >= 0 ? gr.attempts : 0,
+    max_retries_per_run: Number.isInteger(gr.max_retries_per_run) ? gr.max_retries_per_run : null,
+    last_old_turn_id: gr.last_old_turn_id ?? null,
+    last_new_turn_id: gr.last_new_turn_id ?? null,
+    last_failure_type: gr.last_failure_type ?? null,
+    last_retried_at: gr.last_retried_at ?? null,
+    exhausted: Boolean(gr.exhausted),
+    attempts_log: Array.isArray(gr.attempts_log) ? gr.attempts_log : [],
+  };
+}
+
+/**
+ * Reset the ghost_retry counter when the active run_id differs from the last
+ * recorded run_id. Returns the reset state (does not mutate input).
+ */
+export function resetGhostRetryForRun(session, runId) {
+  const current = readGhostRetryState(session);
+  if (current.run_id === runId) return current;
+  return {
+    run_id: runId ?? null,
+    attempts: 0,
+    max_retries_per_run: current.max_retries_per_run,
+    last_old_turn_id: null,
+    last_new_turn_id: null,
+    last_failure_type: null,
+    last_retried_at: null,
+    exhausted: false,
+    attempts_log: [],
+  };
+}
+
+/**
+ * Build the fingerprint string for a recorded attempt. Same shape as the
+ * HUMAN-ROADMAP's "same runtime, same role, same prompt shape" guidance —
+ * we key on (runtime_id, role_id, failure_type). Prompt shape is implicitly
+ * stable across same-turn reissues because `reissueTurn()` re-renders the
+ * same dispatch bundle.
+ *
+ * `null`/missing fields are normalized to `?` so partial records compare
+ * consistently rather than silently matching.
+ */
+export function buildAttemptFingerprint(attempt) {
+  const runtime = attempt?.runtime_id ?? '?';
+  const role = attempt?.role_id ?? '?';
+  const failure = attempt?.failure_type ?? '?';
+  return `${runtime}|${role}|${failure}`;
+}
+
+/**
+ * Classify whether the tail of `attemptsLog` shows `threshold` consecutive
+ * identical fingerprints. Returns:
+ *   - `{ triggered: false, signature: null, consecutive: 0 }` when not hit
+ *   - `{ triggered: true, signature, consecutive }` when hit
+ *
+ * The caller decides what to do with the trigger (slice 2c routes it into
+ * `decision: "exhausted"` with `reason: "same_signature_repeat"`).
+ */
+export function classifySameSignatureExhaustion(attemptsLog, threshold = SIGNATURE_REPEAT_THRESHOLD) {
+  if (!Array.isArray(attemptsLog) || attemptsLog.length < threshold) {
+    return { triggered: false, signature: null, consecutive: 0 };
+  }
+  if (!Number.isInteger(threshold) || threshold < 2) {
+    return { triggered: false, signature: null, consecutive: 0 };
+  }
+  const tail = attemptsLog.slice(-threshold);
+  const signatures = tail.map(buildAttemptFingerprint);
+  const first = signatures[0];
+  if (!first || first === '?|?|?') {
+    return { triggered: false, signature: null, consecutive: 0 };
+  }
+  const allMatch = signatures.every((s) => s === first);
+  if (!allMatch) {
+    return { triggered: false, signature: null, consecutive: 0 };
+  }
+  return { triggered: true, signature: first, consecutive: threshold };
+}
+
+/**
+ * Locate the primary ghost turn from governed state.
+ *
+ * Inputs expected (matches shape written by `stale-turn-watchdog.js`):
+ *   - `state.blocked_reason.category === "ghost_turn"`
+ *   - `state.blocked_reason.turn_id`
+ *   - `state.active_turns[turnId].status === "failed_start"`
+ *   - `state.active_turns[turnId].failed_start_reason` is one of
+ *     GHOST_FAILURE_TYPES
+ *
+ * Returns the turn object + failure type, or null when no eligible turn is
+ * found. Does NOT consult disk.
+ */
+export function findPrimaryGhostTurn(state) {
+  if (!state || typeof state !== 'object') return null;
+  const blockedReason = state.blocked_reason;
+  if (!blockedReason || blockedReason.category !== 'ghost_turn') return null;
+
+  const activeTurns = state.active_turns || {};
+  const hintedTurnId = blockedReason.turn_id;
+  const candidateIds = hintedTurnId && activeTurns[hintedTurnId]
+    ? [hintedTurnId]
+    : Object.keys(activeTurns);
+
+  for (const turnId of candidateIds) {
+    const turn = activeTurns[turnId];
+    if (!turn) continue;
+    if (turn.status !== 'failed_start') continue;
+    const failureType = turn.failed_start_reason;
+    if (!GHOST_FAILURE_TYPES.includes(failureType)) continue;
+    if (hasMeaningfulStagedResult(turn)) continue;
+    return { turn_id: turnId, turn, failure_type: failureType };
+  }
+  return null;
+}
+
+/**
+ * Best-effort detector for a meaningful staged result. If the turn has already
+ * produced a structured result the caller should NOT auto-retry — the accept
+ * pipeline owns that path.
+ */
+function hasMeaningfulStagedResult(turn) {
+  if (!turn) return false;
+  const staged = turn.staged_result ?? turn.result ?? null;
+  if (!staged) return false;
+  if (typeof staged !== 'object') return Boolean(staged);
+  // Ignore purely-null / empty shells the watchdog may leave behind.
+  for (const value of Object.values(staged)) {
+    if (value !== null && value !== undefined && value !== '') return true;
+  }
+  return false;
+}
+
+/**
+ * Classify the retry decision given the current blocked state + session +
+ * resolved options.
+ *
+ * @param {object} params
+ * @param {object} params.state                - governed state (has blocked_reason + active_turns)
+ * @param {object} params.session              - continuous session (source of truth for retry counter)
+ * @param {object} params.autoRetryOnGhost     - resolved continuous options block: { enabled, maxRetriesPerRun, cooldownSeconds }
+ * @param {string|null} [params.runId]         - the run_id the continuous loop believes is active (defaults to state.run_id)
+ * @returns {{
+ *   decision: 'retry' | 'exhausted' | 'skip_non_ghost' | 'missing_active_ghost' | 'disabled' | 'missing_run_id',
+ *   reason: string,
+ *   attempts: number,
+ *   maxRetries: number,
+ *   retryState: object,
+ *   ghost?: { turn_id: string, failure_type: string },
+ *   signatureRepeat?: { signature: string, consecutive: number }
+ * }}
+ *
+ * Exhaustion lanes (added in slice 2c):
+ *   - `reason: "retry budget exhausted (N/N)"` — raw counter cap hit
+ *   - `reason: "same_signature_repeat (<signature>)"` — N consecutive
+ *     identical fingerprints recorded; continuing is unlikely to help. This
+ *     lane can fire BEFORE the raw counter cap — we stop as soon as the
+ *     pattern is visible.
+ */
+export function classifyGhostRetryDecision({ state, session, autoRetryOnGhost, runId } = {}) {
+  const opts = autoRetryOnGhost || {};
+  const enabled = Boolean(opts.enabled);
+  const maxRetries = Number.isInteger(opts.maxRetriesPerRun) && opts.maxRetriesPerRun > 0
+    ? opts.maxRetriesPerRun
+    : 3;
+
+  if (!enabled) {
+    return {
+      decision: 'disabled',
+      reason: 'auto_retry_on_ghost.enabled is false',
+      attempts: 0,
+      maxRetries,
+      retryState: readGhostRetryState(session),
+    };
+  }
+
+  const category = state?.blocked_reason?.category;
+  if (category !== 'ghost_turn') {
+    return {
+      decision: 'skip_non_ghost',
+      reason: `blocked_reason.category=${category ?? 'null'} is not ghost_turn`,
+      attempts: 0,
+      maxRetries,
+      retryState: readGhostRetryState(session),
+    };
+  }
+
+  const ghost = findPrimaryGhostTurn(state);
+  if (!ghost) {
+    return {
+      decision: 'missing_active_ghost',
+      reason: 'blocked_reason names a ghost but no active turn has a typed BUG-51 failed_start',
+      attempts: 0,
+      maxRetries,
+      retryState: readGhostRetryState(session),
+    };
+  }
+
+  const effectiveRunId = runId ?? state?.run_id ?? null;
+  if (!effectiveRunId) {
+    return {
+      decision: 'missing_run_id',
+      reason: 'cannot scope retry counter without a run_id',
+      attempts: 0,
+      maxRetries,
+      retryState: readGhostRetryState(session),
+      ghost: { turn_id: ghost.turn_id, failure_type: ghost.failure_type },
+    };
+  }
+
+  const resetState = resetGhostRetryForRun(session, effectiveRunId);
+  const attempts = resetState.attempts;
+
+  if (attempts >= maxRetries) {
+    return {
+      decision: 'exhausted',
+      reason: `retry budget exhausted (${attempts}/${maxRetries})`,
+      attempts,
+      maxRetries,
+      retryState: { ...resetState, max_retries_per_run: maxRetries, exhausted: true },
+      ghost: { turn_id: ghost.turn_id, failure_type: ghost.failure_type },
+    };
+  }
+
+  // Slice 2c: same-signature early stop. If the recorded attempts log shows
+  // SIGNATURE_REPEAT_THRESHOLD consecutive identical fingerprints, stop early
+  // with a distinct reason so the caller can surface "pattern detected, not
+  // transient" in the exhaustion bundle.
+  const sigCheck = classifySameSignatureExhaustion(resetState.attempts_log, SIGNATURE_REPEAT_THRESHOLD);
+  if (sigCheck.triggered) {
+    return {
+      decision: 'exhausted',
+      reason: `same_signature_repeat (${sigCheck.signature})`,
+      attempts,
+      maxRetries,
+      retryState: { ...resetState, max_retries_per_run: maxRetries, exhausted: true },
+      ghost: { turn_id: ghost.turn_id, failure_type: ghost.failure_type },
+      signatureRepeat: { signature: sigCheck.signature, consecutive: sigCheck.consecutive },
+    };
+  }
+
+  return {
+    decision: 'retry',
+    reason: `retry budget available (${attempts}/${maxRetries})`,
+    attempts,
+    maxRetries,
+    retryState: { ...resetState, max_retries_per_run: maxRetries },
+    ghost: { turn_id: ghost.turn_id, failure_type: ghost.failure_type },
+  };
+}
+
+/**
+ * Apply a successful auto-retry to a session snapshot. Returns a NEW session
+ * object with the ghost_retry counter incremented and last_* fields updated.
+ * Does not write to disk; the caller owns persistence.
+ */
+export function applyGhostRetryAttempt(session, {
+  runId,
+  oldTurnId,
+  newTurnId,
+  failureType,
+  maxRetries,
+  nowIso,
+  runtimeId = null,
+  roleId = null,
+  runningMs = null,
+  thresholdMs = null,
+}) {
+  const base = resetGhostRetryForRun(session, runId);
+  const at = nowIso || new Date().toISOString();
+  // Slice 2c: append a per-attempt fingerprint record. The log is the source
+  // of truth for same-signature early-stop detection and the exhaustion
+  // diagnostic bundle. We cap its size to 10 entries to prevent unbounded
+  // growth on misbehaving projects — the tail is what matters for pattern
+  // detection.
+  const nextEntry = {
+    attempt: base.attempts + 1,
+    old_turn_id: oldTurnId ?? null,
+    new_turn_id: newTurnId ?? null,
+    runtime_id: runtimeId ?? null,
+    role_id: roleId ?? null,
+    failure_type: failureType ?? null,
+    running_ms: runningMs ?? null,
+    threshold_ms: thresholdMs ?? null,
+    retried_at: at,
+  };
+  const attemptsLog = [...base.attempts_log, nextEntry].slice(-10);
+  const ghost_retry = {
+    run_id: runId ?? null,
+    attempts: base.attempts + 1,
+    max_retries_per_run: Number.isInteger(maxRetries) ? maxRetries : base.max_retries_per_run,
+    last_old_turn_id: oldTurnId ?? null,
+    last_new_turn_id: newTurnId ?? null,
+    last_failure_type: failureType ?? null,
+    last_retried_at: at,
+    exhausted: false,
+    attempts_log: attemptsLog,
+  };
+  return { ...(session || {}), ghost_retry };
+}
+
+/**
+ * Apply an exhaustion outcome to a session snapshot. Returns a NEW session
+ * with the counter preserved, `exhausted: true`, and last-failure metadata.
+ */
+export function applyGhostRetryExhaustion(session, { runId, failureType, turnId, maxRetries, nowIso }) {
+  const base = resetGhostRetryForRun(session, runId);
+  const ghost_retry = {
+    run_id: runId ?? null,
+    attempts: base.attempts,
+    max_retries_per_run: Number.isInteger(maxRetries) ? maxRetries : base.max_retries_per_run,
+    last_old_turn_id: turnId ?? base.last_old_turn_id,
+    last_new_turn_id: null,
+    last_failure_type: failureType ?? base.last_failure_type,
+    last_retried_at: nowIso || base.last_retried_at,
+    exhausted: true,
+    // Slice 2c: preserve the per-attempt fingerprint log into the exhausted
+    // state so the operator-facing session.json still has the diagnostic
+    // payload after the loop pauses. Without this, the log would be dropped
+    // exactly when it is most useful.
+    attempts_log: Array.isArray(base.attempts_log) ? base.attempts_log : [],
+  };
+  return { ...(session || {}), ghost_retry };
+}
+
+/**
+ * Build the human-readable mirror string the continuous loop should write
+ * into governed state's `blocked_reason.recovery.detail` at exhaustion time.
+ * Matches the shape `stale-turn-watchdog.js` already uses for that field.
+ *
+ * Slice 2c: accepts optional `signatureRepeat` and adds a brief inline note
+ * so operators see the distinction between raw-budget exhaustion and
+ * pattern-based early stop in the status surface.
+ */
+export function buildGhostRetryExhaustionMirror({
+  attempts,
+  maxRetries,
+  failureType,
+  manualRecoveryDetail,
+  signatureRepeat = null,
+}) {
+  const count = `${attempts}/${maxRetries}`;
+  const ft = failureType || 'ghost_turn';
+  const suffix = manualRecoveryDetail ? ` ${manualRecoveryDetail}` : '';
+  if (signatureRepeat && signatureRepeat.signature) {
+    const sig = signatureRepeat.signature;
+    const consec = signatureRepeat.consecutive || 2;
+    return `Auto-retry stopped early after ${consec} consecutive same-signature attempts [${sig}] (${ft}); last attempt ${count}.${suffix}`;
+  }
+  return `Auto-retry exhausted after ${count} attempts (${ft}).${suffix}`;
+}
+
+/**
+ * Slice 2c: build the per-attempt diagnostic bundle that rides on the
+ * `ghost_retry_exhausted` event payload AND gets surfaced in CLI status so
+ * the operator has enough evidence to decide between (a) bumping
+ * `max_retries_per_run`, (b) changing the runtime, (c) raising
+ * `startup_watchdog_ms`, or (d) filing a new BUG-54-class regression.
+ *
+ * Output shape:
+ *   {
+ *     attempts_log: [...per-attempt records, most recent last...],
+ *     fingerprint_summary: [{ signature, count }, ...] sorted by count desc,
+ *     final_signature: string | null
+ *   }
+ */
+export function buildGhostRetryDiagnosticBundle(sessionOrState) {
+  const state = sessionOrState && typeof sessionOrState === 'object' && sessionOrState.ghost_retry
+    ? readGhostRetryState(sessionOrState)
+    : (Array.isArray(sessionOrState?.attempts_log)
+        ? { attempts_log: sessionOrState.attempts_log }
+        : { attempts_log: [] });
+  const log = Array.isArray(state.attempts_log) ? state.attempts_log : [];
+  const counts = new Map();
+  for (const entry of log) {
+    const sig = buildAttemptFingerprint(entry);
+    counts.set(sig, (counts.get(sig) || 0) + 1);
+  }
+  const fingerprint_summary = Array.from(counts.entries())
+    .map(([signature, count]) => ({ signature, count }))
+    .sort((a, b) => b.count - a.count);
+  const final_signature = log.length > 0 ? buildAttemptFingerprint(log[log.length - 1]) : null;
+  return { attempts_log: log, fingerprint_summary, final_signature };
+}

package/src/lib/governed-state.js

@@ -1514,7 +1514,12 @@ function buildConflictDetail(conflict) {
 }
 
 function hasBlockingActiveTurn(activeTurns) {
-  return Object.values(activeTurns || {}).some((turn) => turn?.status === 'failed' || turn?.status === 'conflicted');
+  return Object.values(activeTurns || {}).some((turn) => [
+    'failed',
+    'conflicted',
+    'failed_start',
+    'stalled',
+  ].includes(turn?.status));
 }
 
 function findHistoryTurnRequest(historyEntries, turnId, kind) {
@@ -1600,6 +1605,95 @@ function resolvePhaseTransitionSource(historyEntries, gateFailure, fallbackTurnI
   return requestedSource;
 }
 
+function buildStandingPhaseTransitionSource(state, config) {
+  const phase = state?.phase;
+  const routing = phase ? config?.routing?.[phase] : null;
+  const gateId = routing?.exit_gate || null;
+  const nextPhase = getNextPhase(phase, config?.routing || {});
+  if (!phase || !gateId || !nextPhase) {
+    return null;
+  }
+  if ((state?.phase_gate_status || {})[gateId] !== 'pending') {
+    return null;
+  }
+  return {
+    turn_id: state?.last_completed_turn_id || state?.blocked_reason?.turn_id || null,
+    run_id: state?.run_id || null,
+    role: null,
+    assigned_role: null,
+    phase,
+    status: 'completed',
+    phase_transition_request: nextPhase,
+    summary: `Synthetic ${gateId} transition source for operator-unblocked standing gate.`,
+    verification: { status: 'pass' },
+  };
+}
+
+function getPhaseRoles(config, phase) {
+  const routing = config?.routing?.[phase] || {};
+  const roles = new Set();
+  if (typeof routing.entry_role === 'string' && routing.entry_role) {
+    roles.add(routing.entry_role);
+  }
+  if (Array.isArray(routing.allowed_next_roles)) {
+    for (const role of routing.allowed_next_roles) {
+      if (typeof role === 'string' && role) roles.add(role);
+    }
+  }
+  return roles;
+}
+
+function cleanupPhaseAdvanceArtifacts(root, state, config, fromPhase) {
+  const phaseRoles = getPhaseRoles(config, fromPhase);
+  const activeTurns = getActiveTurns(state);
+  const removedTurnIds = [];
+  const nextActiveTurns = {};
+  for (const [turnId, turn] of Object.entries(activeTurns)) {
+    const role = turn?.assigned_role || turn?.role_id || turn?.role || null;
+    if (phaseRoles.has(role) && turn?.status !== 'accepted' && turn?.status !== 'completed') {
+      removedTurnIds.push(turnId);
+      continue;
+    }
+    nextActiveTurns[turnId] = turn;
+  }
+
+  const nextReservations = { ...(state?.budget_reservations || {}) };
+  const clearedBudgetTurnIds = [];
+  for (const turnId of removedTurnIds) {
+    if (Object.prototype.hasOwnProperty.call(nextReservations, turnId)) {
+      delete nextReservations[turnId];
+      clearedBudgetTurnIds.push(turnId);
+    }
+  }
+
+  const removedDispatchTurnIds = [];
+  for (const turnId of removedTurnIds) {
+    const dispatchDir = join(root, getDispatchTurnDir(turnId));
+    if (existsSync(dispatchDir)) {
+      try {
+        rmSync(dispatchDir, { recursive: true, force: true });
+        removedDispatchTurnIds.push(turnId);
+      } catch {
+        // Best-effort cleanup; state correctness must not depend on filesystem pruning.
+      }
+    }
+  }
+
+  return {
+    state: {
+      ...state,
+      active_turns: nextActiveTurns,
+      budget_reservations: nextReservations,
+    },
+    payload: {
+      from_phase: fromPhase,
+      removed_turn_ids: removedTurnIds,
+      cleared_budget_turn_ids: clearedBudgetTurnIds,
+      removed_dispatch_turn_ids: removedDispatchTurnIds,
+    },
+  };
+}
+
 function buildBlockedReason({ category, recovery, turnId, blockedAt = new Date().toISOString() }) {
   return {
     category,
@@ -2355,7 +2449,7 @@ export function markRunBlocked(root, details) {
     blockedAt,
   });
 
-  const updatedState = {
+  let updatedState = {
     ...state,
     status: 'blocked',
     blocked_on: details.blockedOn,
@@ -2607,13 +2701,15 @@ export function reactivateGovernedRun(root, state, details = {}) {
   };
 }
 
-export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null) {
+export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null, opts = {}) {
   const currentState = state && typeof state === 'object' ? state : readState(root);
   if (!currentState) {
     return { ok: false, error: 'No governed state.json found' };
   }
 
-  if (currentState.status !== 'active' || getActiveTurnCount(currentState) > 0) {
+  const activeTurnCount = getActiveTurnCount(currentState);
+  const allowActiveTurnCleanup = opts?.allow_active_turn_cleanup === true;
+  if (currentState.status !== 'active' || (activeTurnCount > 0 && !allowActiveTurnCleanup)) {
     return {
       ok: true,
       state: attachLegacyCurrentTurnAlias(currentState),
@@ -2643,12 +2739,15 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
   }
 
   const historyEntries = readJsonlEntries(root, HISTORY_PATH);
-  const phaseSource = resolvePhaseTransitionSource(
+  let phaseSource = resolvePhaseTransitionSource(
     historyEntries,
     gateFailure,
     currentState.last_completed_turn_id || null,
     currentState.queued_phase_transition || null,
   );
+  if (!phaseSource?.phase_transition_request && opts?.allow_standing_gate === true) {
+    phaseSource = buildStandingPhaseTransitionSource(currentState, config);
+  }
   if (!phaseSource?.phase_transition_request) {
     return {
       ok: true,
@@ -2685,7 +2784,7 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
     if (approvalResult.action === 'auto_approve') {
       const now = new Date().toISOString();
       const prevPhase = currentState.phase;
-      const nextState = {
+      let nextState = {
         ...currentState,
         phase: gateResult.next_phase,
         phase_entered_at: now,
@@ -2699,6 +2798,8 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
           [gateResult.gate_id || 'no_gate']: 'passed',
         },
       };
+      const cleanup = cleanupPhaseAdvanceArtifacts(root, nextState, config, prevPhase);
+      nextState = cleanup.state;
       writeState(root, nextState);
       appendJsonl(root, LEDGER_PATH, {
         type: 'approval_policy',
@@ -2738,6 +2839,17 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
           trigger: 'auto_approved',
         },
       });
+      emitRunEvent(root, 'phase_cleanup', {
+        run_id: nextState.run_id,
+        phase: nextState.phase,
+        status: nextState.status,
+        payload: {
+          ...cleanup.payload,
+          to_phase: gateResult.next_phase,
+          gate_id: gateResult.gate_id || null,
+          trigger: 'auto_approved',
+        },
+      });
       return {
         ok: true,
         state: attachLegacyCurrentTurnAlias(nextState),
@@ -2789,7 +2901,7 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
 
   const now = new Date().toISOString();
   const prevPhase = currentState.phase;
-  const nextState = {
+  let nextState = {
     ...currentState,
     phase: gateResult.next_phase,
     phase_entered_at: now,
@@ -2803,6 +2915,8 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
       [gateResult.gate_id || 'no_gate']: 'passed',
     },
   };
+  const cleanup = cleanupPhaseAdvanceArtifacts(root, nextState, config, prevPhase);
+  nextState = cleanup.state;
 
   writeState(root, nextState);
   const retiredIntentIds = retireApprovedPhaseScopedIntents(root, nextState, config, prevPhase, now);
@@ -2832,6 +2946,18 @@ export function reconcilePhaseAdvanceBeforeDispatch(root, config, state = null)
       trigger: 'reconciled_before_dispatch',
     },
   });
+  emitRunEvent(root, 'phase_cleanup', {
+    run_id: nextState.run_id,
+    phase: nextState.phase,
+    status: nextState.status,
+    turn: phaseSource.turn_id ? { turn_id: phaseSource.turn_id, role_id: phaseSource.role || phaseSource.assigned_role || null } : undefined,
+    payload: {
+      ...cleanup.payload,
+      to_phase: gateResult.next_phase,
+      gate_id: gateResult.gate_id || null,
+      trigger: 'reconciled_before_dispatch',
+    },
+  });
 
   return {
     ok: true,
@@ -2876,7 +3002,7 @@ export function initializeGovernedRun(root, config, options = {}) {
   const now = new Date().toISOString();
   const provenance = buildDefaultRunProvenance(options.provenance);
   const repoDecisions = getActiveRepoDecisions(root);
-  const updatedState = {
+  let updatedState = {
     ...state,
     run_id: runId,
     created_at: now,
@@ -4604,7 +4730,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   const remainingReservations = { ...(state.budget_reservations || {}) };
   delete remainingReservations[currentTurn.turn_id];
   const costUsd = turnResult.cost?.usd || 0;
-  const updatedState = {
+  let updatedState = {
     ...state,
     turn_sequence: acceptedSequence,
     last_completed_turn_id: currentTurn.turn_id,
@@ -4946,6 +5072,8 @@ function _acceptGovernedTurnLocked(root, config, opts) {
             [gateResult.gate_id || 'no_gate']: 'passed',
           };
           updatedState.queued_phase_transition = null;
+          const cleanup = cleanupPhaseAdvanceArtifacts(root, updatedState, config, prevPhase);
+          updatedState = cleanup.state;
           const retiredIntentIds = retireApprovedPhaseScopedIntents(root, updatedState, config, prevPhase, now);
           if (retiredIntentIds.length > 0) {
             emitRunEvent(root, 'intent_retired_by_phase_advance', {
@@ -4973,6 +5101,18 @@ function _acceptGovernedTurnLocked(root, config, opts) {
               trigger: 'auto',
             },
           });
+          emitRunEvent(root, 'phase_cleanup', {
+            run_id: updatedState.run_id,
+            phase: updatedState.phase,
+            status: updatedState.status,
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            payload: {
+              ...cleanup.payload,
+              to_phase: gateResult.next_phase,
+              gate_id: gateResult.gate_id || null,
+              trigger: 'auto',
+            },
+          });
         } else if (gateResult.action === 'awaiting_human_approval') {
           // Evaluate approval policy — may auto-approve
           const approvalResult = evaluateApprovalPolicy({
@@ -4992,6 +5132,8 @@ function _acceptGovernedTurnLocked(root, config, opts) {
               [gateResult.gate_id || 'no_gate']: 'passed',
             };
             updatedState.queued_phase_transition = null;
+            const cleanup = cleanupPhaseAdvanceArtifacts(root, updatedState, config, prevPhase);
+            updatedState = cleanup.state;
             ledgerEntries.push({
               type: 'approval_policy',
               gate_type: 'phase_transition',
@@ -5030,6 +5172,18 @@ function _acceptGovernedTurnLocked(root, config, opts) {
                 trigger: 'auto_approved',
               },
             });
+            emitRunEvent(root, 'phase_cleanup', {
+              run_id: updatedState.run_id,
+              phase: updatedState.phase,
+              status: updatedState.status,
+              turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+              payload: {
+                ...cleanup.payload,
+                to_phase: gateResult.next_phase,
+                gate_id: gateResult.gate_id || null,
+                trigger: 'auto_approved',
+              },
+            });
           } else {
             updatedState.status = 'paused';
             updatedState.blocked_on = `human_approval:${gateResult.gate_id}`;
@@ -5975,7 +6129,7 @@ export function approvePhaseTransition(root, config, opts = {}) {
     appendJsonl(root, LEDGER_PATH, entry);
   }
 
-  const updatedState = {
+  let updatedState = {
     ...state,
     phase: transition.to,
     phase_entered_at: new Date().toISOString(),
@@ -5989,6 +6143,8 @@ export function approvePhaseTransition(root, config, opts = {}) {
       [transition.gate]: 'passed',
     },
   };
+  const cleanup = cleanupPhaseAdvanceArtifacts(root, updatedState, config, transition.from);
+  updatedState = cleanup.state;
 
   writeState(root, updatedState);
   clearSlaReminders(root, 'pending_phase_transition');
@@ -6009,6 +6165,17 @@ export function approvePhaseTransition(root, config, opts = {}) {
       trigger: 'human_approved',
     },
   });
+  emitRunEvent(root, 'phase_cleanup', {
+    run_id: updatedState.run_id,
+    phase: updatedState.phase,
+    status: 'active',
+    payload: {
+      ...cleanup.payload,
+      to_phase: transition.to,
+      gate_id: transition.gate || null,
+      trigger: 'human_approved',
+    },
+  });
 
   // Session checkpoint — non-fatal
   writeSessionCheckpoint(root, updatedState, 'phase_approved');

package/src/lib/normalized-config.js

@@ -640,9 +640,38 @@ export function validateRunLoopConfig(runLoop) {
   }
   validateRunLoopPositiveInteger('run_loop.startup_watchdog_ms', runLoop.startup_watchdog_ms, errors);
   validateRunLoopPositiveInteger('run_loop.stale_turn_threshold_ms', runLoop.stale_turn_threshold_ms, errors);
+  if (runLoop.continuous !== undefined && runLoop.continuous !== null) {
+    validateRunLoopContinuousConfig('run_loop.continuous', runLoop.continuous, errors);
+  }
   return errors;
 }
 
+function validateRunLoopContinuousConfig(path, continuous, errors) {
+  if (typeof continuous !== 'object' || Array.isArray(continuous)) {
+    errors.push(`${path} must be an object`);
+    return;
+  }
+  if (continuous.auto_retry_on_ghost !== undefined && continuous.auto_retry_on_ghost !== null) {
+    validateAutoRetryOnGhostConfig(`${path}.auto_retry_on_ghost`, continuous.auto_retry_on_ghost, errors);
+  }
+}
+
+function validateAutoRetryOnGhostConfig(path, value, errors) {
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    errors.push(`${path} must be an object`);
+    return;
+  }
+  if ('enabled' in value && typeof value.enabled !== 'boolean') {
+    errors.push(`${path}.enabled must be a boolean`);
+  }
+  if ('max_retries_per_run' in value) {
+    validatePositiveInteger(`${path}.max_retries_per_run`, value.max_retries_per_run, 'retry count', errors);
+  }
+  if ('cooldown_seconds' in value) {
+    validatePositiveInteger(`${path}.cooldown_seconds`, value.cooldown_seconds, 'seconds', errors);
+  }
+}
+
 function validateRunLoopPositiveInteger(path, value, errors) {
   if (value === undefined || value === null) {
     return;
@@ -656,6 +685,15 @@ function validateRunLoopPositiveInteger(path, value, errors) {
   }
 }
 
+function validatePositiveInteger(path, value, unitLabel, errors) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+    errors.push(`${path} must be a positive integer (${unitLabel})`);
+  }
+}
+
 function validateRuntimePositiveInteger(path, value, errors) {
   if (value === undefined || value === null) {
     return;

package/src/lib/run-events.js

@@ -38,11 +38,14 @@ export const VALID_RUN_EVENTS = [
   'gate_pending',
   'gate_approved',
   'gate_failed',
+  'phase_cleanup',
   'budget_exceeded_warn',
   'human_escalation_raised',
   'human_escalation_resolved',
   'dispatch_progress',
   'session_continuation',
+  'auto_retried_ghost',
+  'ghost_retry_exhausted',
 ];
 
 /**

package/src/lib/schemas/agentxchain-config.schema.json

@@ -104,6 +104,34 @@
           "type": "integer",
           "minimum": 1,
           "description": "Milliseconds to wait before a started turn that previously produced output is treated as stale. Default 600000 for local_cli turns and 300000 for api_proxy turns."
+        },
+        "continuous": {
+          "type": "object",
+          "description": "Continuous-run control knobs.",
+          "properties": {
+            "auto_retry_on_ghost": {
+              "type": "object",
+              "description": "Bounded ghost-turn retry policy for continuous/full-auto sessions.",
+              "properties": {
+                "enabled": {
+                  "type": "boolean",
+                  "description": "Enable bounded automatic reissue for startup ghost turns. Defaults false unless full-auto approval policy posture promotes it."
+                },
+                "max_retries_per_run": {
+                  "type": "integer",
+                  "minimum": 1,
+                  "description": "Maximum ghost retries per run before leaving manual recovery visible. Default 3."
+                },
+                "cooldown_seconds": {
+                  "type": "integer",
+                  "minimum": 1,
+                  "description": "Seconds to wait between automatic ghost retries. Default 5."
+                }
+              },
+              "additionalProperties": true
+            }
+          },
+          "additionalProperties": true
         }
       },
       "additionalProperties": true