agentxchain 2.152.0 → 2.154.0

package/bin/agentxchain.js

@@ -73,6 +73,7 @@ import { injectCommand } from '../src/commands/inject.js';
 import { escalateCommand } from '../src/commands/escalate.js';
 import { acceptTurnCommand } from '../src/commands/accept-turn.js';
 import { checkpointTurnCommand } from '../src/commands/checkpoint-turn.js';
+import { reconcileStateCommand } from '../src/commands/reconcile-state.js';
 import { rejectTurnCommand } from '../src/commands/reject-turn.js';
 import { reissueTurnCommand } from '../src/commands/reissue-turn.js';
 import { proposalListCommand, proposalDiffCommand, proposalApplyCommand, proposalRejectCommand } from '../src/commands/proposal.js';
@@ -701,6 +702,12 @@ program
   .option('--turn <id>', 'Checkpoint a specific accepted turn from history')
   .action(checkpointTurnCommand);
 
+program
+  .command('reconcile-state')
+  .description('Reconcile safe operator commits into governed run state')
+  .option('--accept-operator-head', 'Accept safe fast-forward operator commits as the new governed baseline')
+  .action(reconcileStateCommand);
+
 program
   .command('reject-turn')
   .description('Reject the current governed turn result and retry or escalate')
@@ -753,6 +760,11 @@ 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('--reconcile-operator-commits <mode>', 'Continuous reconcile posture for operator commits: manual, auto_safe_only, or disabled (default: config or manual; auto_safe_only under full-auto approval policy)')
   .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.152.0",
+  "version": "2.154.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/reconcile-state.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { loadProjectContext } from '../lib/config.js';
+import { reconcileOperatorHead } from '../lib/operator-commit-reconcile.js';
+
+export async function reconcileStateCommand(opts = {}) {
+  const context = loadProjectContext();
+  if (!context) {
+    console.log(chalk.red('No agentxchain.json found. Run `agentxchain init` first.'));
+    process.exit(1);
+  }
+
+  const { root, config } = context;
+  if (config.protocol_mode !== 'governed') {
+    console.log(chalk.red('The reconcile-state command is only available for governed projects.'));
+    process.exit(1);
+  }
+
+  if (!opts.acceptOperatorHead) {
+    console.log(chalk.red('No reconciliation action selected.'));
+    console.log(chalk.dim('Run `agentxchain reconcile-state --accept-operator-head` to accept safe operator commits on top of the last checkpoint.'));
+    process.exit(1);
+  }
+
+  const result = reconcileOperatorHead(root);
+  if (!result.ok) {
+    console.log(chalk.red(`Reconcile refused (${result.error_class || 'unknown'}).`));
+    console.log(chalk.red(result.error || 'Unable to reconcile operator commits.'));
+    if (result.offending_path) {
+      console.log(chalk.dim(`Offending path: ${result.offending_path}`));
+    }
+    if (result.offending_commit) {
+      console.log(chalk.dim(`Offending commit: ${result.offending_commit}`));
+    }
+    console.log(chalk.dim('Manual recovery: inspect the commit range, restore governed state artifacts if needed, then restart from an explicit checkpoint.'));
+    process.exit(1);
+  }
+
+  if (result.no_op) {
+    console.log(chalk.green(`State already reconciled at ${result.accepted_head.slice(0, 8)}.`));
+    return;
+  }
+
+  console.log(chalk.green(`Reconciled ${result.accepted_commits.length} operator commit(s).`));
+  console.log(chalk.dim(`Previous baseline: ${result.previous_baseline}`));
+  console.log(chalk.dim(`Accepted HEAD:      ${result.accepted_head}`));
+  if (result.paths_touched.length > 0) {
+    console.log(chalk.dim(`Paths touched:      ${result.paths_touched.join(', ')}`));
+  }
+}

package/src/lib/continuity-status.js

@@ -129,8 +129,15 @@ export function getContinuityStatus(root, state) {
     && checkpoint.run_id !== state.run_id
   );
 
-  const action = deriveRecommendedContinuityAction(state);
   const drift = deriveCheckpointDrift(root, checkpoint, staleCheckpoint);
+  const action = drift.drift_detected === true
+    ? {
+        recommended_command: 'agentxchain reconcile-state --accept-operator-head',
+        recommended_reason: 'operator_commit_drift',
+        recommended_detail: 'accept safe fast-forward operator commits as the new baseline',
+        restart_recommended: false,
+      }
+    : deriveRecommendedContinuityAction(state);
 
   return {
     checkpoint,

package/src/lib/continuous-run.js

@@ -25,6 +25,16 @@ 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 { reconcileOperatorHead } from './operator-commit-reconcile.js';
+import { getContinuityStatus } from './continuity-status.js';
 import {
   archiveStaleIntentsForRun,
   formatLegacyIntentMigrationNotice,
@@ -127,6 +137,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
 // ---------------------------------------------------------------------------
@@ -155,6 +337,99 @@ export function findNextQueuedIntent(root, options = {}) {
   return findNextDispatchableIntent(root, { run_id: options.run_id || null });
 }
 
+/**
+ * BUG-62 slice 2: when `run_loop.continuous.reconcile_operator_commits` is
+ * `auto_safe_only`, the continuous loop consults the session-checkpoint /
+ * governed-state baseline vs current git HEAD before dispatch. If operator
+ * commits landed on top of the baseline and the Turn 184 safety primitive
+ * accepts them, the baseline is auto-rolled forward so the next dispatch
+ * proceeds without manual `agentxchain reconcile-state` intervention. If the
+ * safety primitive refuses the commits (governed-state edits or history
+ * rewrite), the continuous loop pauses with the refusal class mirrored into
+ * `blocked_reason.recovery.detail`, preserving the manual primitive as the
+ * operator's single audited safety function per the BUG-62 spec.
+ */
+export function maybeAutoReconcileOperatorCommits(context, session, contOpts, log = console.log) {
+  const mode = contOpts.reconcileOperatorCommits || 'manual';
+  if (mode !== 'auto_safe_only') {
+    return null;
+  }
+  const { root } = context;
+  const state = loadProjectState(root, context.config);
+  const continuity = getContinuityStatus(root, state);
+  if (!continuity || continuity.drift_detected !== true) {
+    return null;
+  }
+
+  const result = reconcileOperatorHead(root, { safetyMode: 'auto_safe_only' });
+  if (result.ok) {
+    if (result.no_op) {
+      return null;
+    }
+    const acceptedCount = result.accepted_commits?.length || 0;
+    log(
+      `Operator-commit auto-reconcile accepted ${acceptedCount} commit${acceptedCount === 1 ? '' : 's'} `
+      + `(${result.previous_baseline.slice(0, 8)} -> ${result.accepted_head.slice(0, 8)}).`
+    );
+    return null;
+  }
+
+  const errorClass = result.error_class || 'reconcile_refused';
+  const detailLines = [
+    `Operator-commit auto-reconcile refused (${errorClass}).`,
+    result.error || 'Unsafe operator commits detected; manual recovery required.',
+    'Run: agentxchain reconcile-state --accept-operator-head once the unsafe changes are resolved, or revert them.',
+  ];
+  const detail = detailLines.join(' ');
+
+  if (state) {
+    const nextState = {
+      ...state,
+      status: 'blocked',
+      blocked_on: state.blocked_on || 'operator_commit_reconcile_refused',
+      blocked_reason: {
+        ...(state.blocked_reason || {}),
+        category: 'operator_commit_reconcile_refused',
+        error_class: errorClass,
+        recovery: {
+          ...((state.blocked_reason || {}).recovery || {}),
+          recovery_action: 'agentxchain reconcile-state --accept-operator-head',
+          detail,
+        },
+      },
+    };
+    safeWriteJson(join(root, '.agentxchain', 'state.json'), nextState);
+  }
+
+  emitRunEvent(root, 'operator_commit_reconcile_refused', {
+    run_id: state?.run_id || session.current_run_id || null,
+    phase: state?.phase || state?.current_phase || null,
+    status: 'blocked',
+    payload: {
+      error_class: errorClass,
+      message: result.error || null,
+      previous_baseline: result.previous_baseline || null,
+      current_head: result.current_head || null,
+      offending_commit: result.offending_commit || null,
+      offending_path: result.offending_path || null,
+      safety_mode: 'auto_safe_only',
+    },
+  });
+
+  session.status = 'paused';
+  writeContinuousSession(root, session);
+  log(detail);
+  return {
+    ok: true,
+    status: 'blocked',
+    action: 'operator_commit_reconcile_refused',
+    run_id: session.current_run_id,
+    recovery_action: 'agentxchain reconcile-state --accept-operator-head',
+    blocked_category: 'operator_commit_reconcile_refused',
+    error_class: errorClass,
+  };
+}
+
 function reconcileContinuousStartupState(context, session, contOpts, log) {
   const { root, config } = context;
   const governedState = loadProjectState(root, config);
@@ -301,6 +576,25 @@ 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 fullAuto = Boolean((opts.continuous ?? configCont.enabled ?? false) && isFullAutoApprovalPolicy(config));
+  const fullAutoGhostDefault = fullAuto;
+  const resolvedGhostEnabled = opts.autoRetryOnGhost
+    ?? (explicitConfigGhostEnabled ? configGhostRetry.enabled : fullAutoGhostDefault);
+
+  const validReconcileModes = new Set(['manual', 'auto_safe_only', 'disabled']);
+  const configuredReconcile = typeof configCont.reconcile_operator_commits === 'string'
+    && validReconcileModes.has(configCont.reconcile_operator_commits)
+    ? configCont.reconcile_operator_commits
+    : null;
+  const cliReconcile = typeof opts.reconcileOperatorCommits === 'string'
+    && validReconcileModes.has(opts.reconcileOperatorCommits)
+    ? opts.reconcileOperatorCommits
+    : null;
+  const reconcileOperatorCommits = cliReconcile
+    ?? configuredReconcile
+    ?? (fullAuto ? 'auto_safe_only' : 'manual');
 
   return {
     enabled: opts.continuous ?? configCont.enabled ?? false,
@@ -313,9 +607,26 @@ 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,
+    },
+    reconcileOperatorCommits,
   };
 }
 
+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
 // ---------------------------------------------------------------------------
@@ -363,6 +674,9 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
 
   reconcileContinuousStartupState(context, session, contOpts, log);
 
+  const reconcileBlock = maybeAutoReconcileOperatorCommits(context, session, contOpts, log);
+  if (reconcileBlock) return reconcileBlock;
+
   // Paused-session guard: if session is paused (blocked run awaiting unblock),
   // check governed state before attempting to advance. Without this guard, the
   // loop would try to startIntent() on a blocked project, hit the blocked-state
@@ -370,6 +684,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 +722,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 +737,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 +754,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 +950,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 +973,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),
     };
   }