agentxchain 2.128.0 → 2.130.0

package/src/commands/reissue-turn.js

@@ -0,0 +1,122 @@
+/**
+ * reissue-turn command — unified turn invalidation + reissue against current state.
+ *
+ * Covers all drift recovery scenarios:
+ *   - Baseline drift (HEAD changed after dispatch)
+ *   - Runtime drift (agentxchain.json rebinding after dispatch)
+ *   - Authority drift (write_authority changed on assigned role)
+ *   - Operator-initiated (explicit redo from current state)
+ *
+ * BUG-7 fix: single command, multiple trigger reasons.
+ */
+
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { loadProjectContext, loadProjectState } from '../lib/config.js';
+import {
+  getActiveTurns,
+  getActiveTurn,
+  reissueTurn,
+} from '../lib/governed-state.js';
+import { writeDispatchBundle } from '../lib/dispatch-bundle.js';
+
+export async function reissueTurnCommand(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 reissue-turn command is only available for governed projects.'));
+    process.exit(1);
+  }
+
+  let state = loadProjectState(root, config);
+  if (!state) {
+    console.log(chalk.red('No governed state.json found.'));
+    process.exit(1);
+  }
+
+  // Resolve target turn
+  const activeTurns = getActiveTurns(state);
+  const activeCount = Object.keys(activeTurns).length;
+
+  if (activeCount === 0) {
+    console.log(chalk.red('No active turns to reissue.'));
+    process.exit(1);
+  }
+
+  let targetTurn;
+  if (opts.turn) {
+    targetTurn = activeTurns[opts.turn];
+    if (!targetTurn) {
+      console.log(chalk.red(`No active turn found for --turn ${opts.turn}`));
+      process.exit(1);
+    }
+  } else if (activeCount === 1) {
+    targetTurn = Object.values(activeTurns)[0];
+  } else {
+    console.log(chalk.red('Multiple active turns exist. Use --turn <id> to specify which to reissue.'));
+    for (const turn of Object.values(activeTurns)) {
+      console.log(`  ${chalk.yellow('●')} ${turn.turn_id} — ${chalk.bold(turn.assigned_role)} (${turn.status})`);
+    }
+    process.exit(1);
+  }
+
+  const reason = opts.reason || 'operator-initiated reissue';
+
+  console.log(chalk.cyan(`Reissuing turn: ${targetTurn.turn_id} (${targetTurn.assigned_role})`));
+  console.log(chalk.dim(`Reason: ${reason}`));
+
+  const result = reissueTurn(root, config, {
+    turnId: targetTurn.turn_id,
+    reason,
+  });
+
+  if (!result.ok) {
+    console.log(chalk.red(`Failed to reissue turn: ${result.error}`));
+    process.exit(1);
+  }
+
+  // Write dispatch bundle for the reissued turn
+  const bundleResult = writeDispatchBundle(root, result.state, config, {
+    turnId: result.newTurn.turn_id,
+  });
+
+  if (!bundleResult.ok) {
+    console.log(chalk.red(`Turn reissued but dispatch bundle failed: ${bundleResult.error}`));
+    process.exit(1);
+  }
+
+  // Print summary
+  console.log('');
+  console.log(chalk.green('  Turn Reissued'));
+  console.log(chalk.dim('  ' + '─'.repeat(44)));
+  console.log('');
+  console.log(`  ${chalk.dim('Old turn:')}     ${targetTurn.turn_id}`);
+  console.log(`  ${chalk.dim('New turn:')}     ${result.newTurn.turn_id}`);
+  console.log(`  ${chalk.dim('Role:')}         ${result.newTurn.assigned_role}`);
+  console.log(`  ${chalk.dim('Attempt:')}      ${result.newTurn.attempt}`);
+  console.log(`  ${chalk.dim('Reason:')}       ${reason}`);
+
+  // Show baseline delta
+  if (result.baselineDelta) {
+    const delta = result.baselineDelta;
+    if (delta.head_changed) {
+      console.log(`  ${chalk.dim('HEAD:')}         ${chalk.yellow(delta.old_head?.slice(0, 12) || '?')} → ${chalk.green(delta.new_head?.slice(0, 12) || '?')}`);
+    }
+    if (delta.runtime_changed) {
+      console.log(`  ${chalk.dim('Runtime:')}      ${chalk.yellow(delta.old_runtime || '?')} → ${chalk.green(delta.new_runtime || '?')}`);
+    }
+    if (delta.dirty_files_changed) {
+      console.log(`  ${chalk.dim('Workspace:')}    ${delta.added_dirty_files?.length || 0} new dirty file(s), ${delta.removed_dirty_files?.length || 0} resolved`);
+    }
+  }
+
+  console.log('');
+  console.log(chalk.dim('Run: agentxchain step --resume to dispatch the reissued turn.'));
+}

package/src/commands/reject-turn.js

@@ -107,11 +107,31 @@ function buildRejectionValidation(root, state, config, opts) {
     return resolution;
   }
 
+  // BUG-9 fix: --reassign should work for any rejected turn, not just conflicted ones.
+  // For drift-induced failures with no conflict_state, redirect to reissue-turn.
   if (opts.reassign && !resolution.turn.conflict_state) {
-    return {
-      ok: false,
-      error: '--reassign is only valid for turns with persisted conflict_state.',
-    };
+    // Detect if baseline drift exists
+    const currentHead = (() => {
+      try {
+        return require('child_process').execSync('git rev-parse HEAD', {
+          cwd: root, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+      } catch { return null; }
+    })();
+    const turnHead = resolution.turn.baseline?.head_ref;
+    const hasDrift = currentHead && turnHead && currentHead !== turnHead;
+
+    if (hasDrift) {
+      console.log(chalk.yellow(`Baseline drift detected: HEAD moved from ${turnHead?.slice(0, 12)} to ${currentHead?.slice(0, 12)}.`));
+      console.log(chalk.dim(`Use: agentxchain reissue-turn --turn ${resolution.turn.turn_id} --reason "baseline drift"`));
+      return {
+        ok: false,
+        error: `--reassign detected baseline drift. Use reissue-turn instead for a clean reissue from current HEAD.`,
+      };
+    }
+
+    // No drift, no conflict_state — just do a normal reject + reassign
+    // (treat it as a fresh retry with refreshed baseline, which BUG-8 now handles)
   }
 
   if (resolution.turn.conflict_state) {
@@ -133,8 +153,21 @@ function buildRejectionValidation(root, state, config, opts) {
       [resolution.turn.turn_id]: resolution.turn,
     },
   };
+  const stagingPath = resolveStagingPath(root, resolution.turn.turn_id);
+  // BUG-22: If resolveStagingPath returns null, a stale result from another turn
+  // was detected. Reject with a clear diagnostic instead of consuming it.
+  if (stagingPath === null) {
+    return {
+      ok: true,
+      turn: resolution.turn,
+      validationResult: {
+        errors: [`Stale staging data: .agentxchain/staging/turn-result.json belongs to a different turn. Clean up with: rm .agentxchain/staging/turn-result.json`],
+        failed_stage: 'stale_staging',
+      },
+    };
+  }
   const validation = validateStagedTurnResult(root, projectedState, config, {
-    stagingPath: resolveStagingPath(root, resolution.turn.turn_id),
+    stagingPath,
   });
   if (!validation.ok) {
     return {
@@ -193,8 +226,29 @@ function resolveTargetTurn(state, turnId) {
 }
 
 function resolveStagingPath(root, turnId) {
+  // BUG-22: Prefer turn-scoped staging path. Only fall back to legacy global
+  // staging if the global result's turn_id matches the active turn.
   const turnScopedPath = getTurnStagingResultPath(turnId);
-  return existsSync(join(root, turnScopedPath)) ? turnScopedPath : '.agentxchain/staging/turn-result.json';
+  if (existsSync(join(root, turnScopedPath))) {
+    return turnScopedPath;
+  }
+
+  const legacyPath = '.agentxchain/staging/turn-result.json';
+  const legacyAbs = join(root, legacyPath);
+  if (existsSync(legacyAbs)) {
+    try {
+      const raw = JSON.parse(require('fs').readFileSync(legacyAbs, 'utf8'));
+      if (raw.turn_id && raw.turn_id !== turnId) {
+        // Stale result from a different turn — do not consume
+        return null;
+      }
+    } catch {
+      // Parse error — let the validator handle it
+    }
+    return legacyPath;
+  }
+
+  return legacyPath; // File doesn't exist — validator will report "not found"
 }
 
 function printDispatchBundleWarnings(bundleResult) {

package/src/commands/restart.js

@@ -19,10 +19,15 @@ import {
   getActiveTurns,
   getActiveTurnCount,
   reactivateGovernedRun,
+  detectStateBundleDesync,
   STATE_PATH,
   HISTORY_PATH,
   LEDGER_PATH,
 } from '../lib/governed-state.js';
+import { writeDispatchBundle } from '../lib/dispatch-bundle.js';
+import { getDispatchTurnDir } from '../lib/turn-paths.js';
+import { consumeNextApprovedIntent } from '../lib/intake.js';
+import { loadProjectState } from '../lib/config.js';
 import { deriveRecoveryDescriptor } from '../lib/blocked-state.js';
 import { deriveRecommendedContinuityAction } from '../lib/continuity-status.js';
 import { readSessionCheckpoint, writeSessionCheckpoint, captureBaselineRef, SESSION_PATH } from '../lib/session-checkpoint.js';
@@ -213,6 +218,25 @@ export async function restartCommand(opts) {
     process.exit(1);
   }
 
+  // ── BUG-18: State/bundle integrity check ─────────────────────────────────
+  const desync = detectStateBundleDesync(root, state);
+  if (!desync.ok) {
+    console.log(chalk.red('State/bundle integrity failure detected:'));
+    for (const entry of desync.desynced) {
+      console.log(chalk.red(`  Active turn ${entry.turn_id} (${entry.role}) has no dispatch bundle at ${entry.expected_path}`));
+    }
+    console.log('');
+    console.log(chalk.dim('This is a ghost turn — state references an active turn but the dispatch files are missing.'));
+    console.log(chalk.dim('Recovery options:'));
+    for (const entry of desync.desynced) {
+      console.log(`  ${chalk.cyan(`agentxchain reissue-turn --turn ${entry.turn_id} --reason "missing dispatch bundle"`)}`);
+    }
+    console.log(`  ${chalk.cyan('agentxchain reject-turn --reason "ghost turn — missing dispatch bundle"')}`);
+    console.log('');
+    console.log(chalk.dim('Run `agentxchain doctor` for a full diagnostic.'));
+    process.exit(1);
+  }
+
   // ── Repo-drift detection ────────────────────────────────────────────────
   const driftWarnings = [];
   if (checkpoint?.baseline_ref) {
@@ -265,10 +289,17 @@ export async function restartCommand(opts) {
     console.log(chalk.yellow(`Warning: ${activeTurnCount} turn(s) were assigned but never completed: ${turnIds.join(', ')}`));
     console.log(chalk.dim('These turns will be available for the next agent to complete.'));
 
-    // Fail closed if retained turn + irreconcilable drift
+    // Fail closed if retained turn + irreconcilable drift — BUG-10 fix: surface actionable recovery
     if (driftWarnings.length > 0) {
       console.log(chalk.yellow('Active turns exist with repo drift since checkpoint. Reconnecting with warnings.'));
-      console.log(chalk.dim('Inspect the drift before continuing work on the retained turns.'));
+      console.log('');
+      console.log(chalk.dim('Recovery options:'));
+      for (const turnId of turnIds) {
+        const turn = activeTurns[turnId];
+        console.log(`  ${chalk.cyan(`agentxchain reissue-turn --turn ${turnId} --reason "baseline drift"`)}  — reissue ${turn.assigned_role} from current HEAD`);
+      }
+      console.log(`  ${chalk.cyan('agentxchain reject-turn --reason "baseline drift"')}  — reject and retry with refreshed baseline`);
+      console.log(`  ${chalk.dim('Continue as-is if the drift does not affect the retained turns.')}`);
     }
   }
 
@@ -309,21 +340,61 @@ export async function restartCommand(opts) {
 
   // Assign next turn if no active turn exists
   if (activeTurnCount === 0) {
-    const assignment = assignGovernedTurn(root, config, roleId);
-    if (!assignment.ok) {
-      console.log(chalk.red(`Failed to assign turn: ${assignment.error}`));
-      process.exit(1);
+    // BUG-21 fix: consume approved intents (same as resume path) so intent_id
+    // propagates into turn metadata and all lifecycle events.
+    const consumed = consumeNextApprovedIntent(root, { role: roleId });
+    let assignedState;
+    let turnId;
+    let assignedRole = roleId;
+
+    if (consumed.ok) {
+      // Intake path handled the turn assignment with intakeContext
+      assignedState = loadProjectState(root, config);
+      if (!assignedState) {
+        console.log(chalk.red('Failed to reload governed state after intake binding.'));
+        process.exit(1);
+      }
+      turnId = consumed.turn_id;
+      assignedRole = consumed.role || roleId;
+      console.log(chalk.green(`Bound approved intent to next turn: ${consumed.intentId}`));
+    } else {
+      // No approved intents — plain assignment
+      const assignment = assignGovernedTurn(root, config, roleId);
+      if (!assignment.ok) {
+        console.log(chalk.red(`Failed to assign turn: ${assignment.error}`));
+        process.exit(1);
+      }
+      for (const warning of assignment.warnings || []) {
+        console.log(chalk.yellow(`Warning: ${warning}`));
+      }
+      assignedState = assignment.state;
+      turnId = assignment.turn?.turn_id || assignment.turn?.id;
+      assignedRole = assignment.turn?.assigned_role || roleId;
     }
-    for (const warning of assignment.warnings || []) {
-      console.log(chalk.yellow(`Warning: ${warning}`));
+
+    // BUG-17 fix: write dispatch bundle AFTER state assignment succeeds.
+    // The bundle must exist on disk before we report success, otherwise the
+    // operator sees a "ghost turn" in state with no dispatch directory.
+    if (turnId) {
+      const bundleResult = writeDispatchBundle(root, assignedState, config, { turnId });
+      if (!bundleResult.ok) {
+        console.log(chalk.red(`Turn assigned but dispatch bundle write failed: ${bundleResult.error}`));
+        console.log(chalk.dim('The turn is assigned in state but has no dispatch context.'));
+        console.log(chalk.dim('Run `agentxchain reissue-turn` to reissue with a fresh bundle.'));
+        process.exit(1);
+      }
+      for (const bw of bundleResult.warnings || []) {
+        console.log(chalk.yellow(`Dispatch bundle warning: ${bw}`));
+      }
     }
 
     // assignGovernedTurn already writes a checkpoint at turn_assigned
 
     console.log(chalk.green(`✓ Restarted run ${state.run_id}`));
     console.log(chalk.dim(`  Phase: ${phase}`));
-    console.log(chalk.dim(`  Turn: ${assignment.turn?.id || 'assigned'}`));
-    console.log(chalk.dim(`  Role: ${assignment.turn?.role || roleId || 'routing default'}`));
+    console.log(chalk.dim(`  Turn: ${turnId || 'assigned'}`));
+    console.log(chalk.dim(`  Role: ${assignedRole || 'routing default'}`));
+    console.log(chalk.dim(`  Dispatch: ${getDispatchTurnDir(turnId || 'unknown')}/`));
     if (checkpoint) {
       console.log(chalk.dim(`  Last checkpoint: ${checkpoint.checkpoint_reason} at ${checkpoint.last_checkpoint_at}`));
     }

package/src/commands/resume.js

@@ -39,6 +39,7 @@ import {
 import { deriveRecoveryDescriptor } from '../lib/blocked-state.js';
 import { runHooks } from '../lib/hook-runner.js';
 import { summarizeRunProvenance } from '../lib/run-provenance.js';
+import { consumeNextApprovedIntent } from '../lib/intake.js';
 
 export async function resumeCommand(opts) {
   const context = loadProjectContext();
@@ -265,17 +266,27 @@ export async function resumeCommand(opts) {
     process.exit(1);
   }
 
-  // Assign the turn
-  const assignResult = assignGovernedTurn(root, config, roleId);
-  if (!assignResult.ok) {
-    if (assignResult.error_code?.startsWith('hook_') || assignResult.error_code === 'hook_blocked') {
-      printAssignmentHookFailure(assignResult, roleId, config);
+  const shouldBindIntent = opts.intent !== false;
+  const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+  if (consumed.ok) {
+    state = loadProjectState(root, config);
+    if (!state) {
+      console.log(chalk.red('Failed to reload governed state after intake binding.'));
+      process.exit(1);
     }
-    console.log(chalk.red(`Failed to assign turn: ${assignResult.error}`));
-    process.exit(1);
+    console.log(chalk.green(`Bound approved intent to next turn: ${consumed.intentId}`));
+  } else {
+    const assignResult = assignGovernedTurn(root, config, roleId);
+    if (!assignResult.ok) {
+      if (assignResult.error_code?.startsWith('hook_') || assignResult.error_code === 'hook_blocked') {
+        printAssignmentHookFailure(assignResult, roleId, config);
+      }
+      console.log(chalk.red(`Failed to assign turn: ${assignResult.error}`));
+      process.exit(1);
+    }
+    printAssignmentWarnings(assignResult);
+    state = assignResult.state;
   }
-  printAssignmentWarnings(assignResult);
-  state = assignResult.state;
 
   // Write dispatch bundle
   const bundleResult = writeDispatchBundle(root, state, config);

package/src/commands/run.js

@@ -48,6 +48,7 @@ import { resolveChainOptions, executeChainedRun } from '../lib/run-chain.js';
 import { resolveContinuousOptions, executeContinuousRun } from '../lib/continuous-run.js';
 import { createDispatchProgressTracker } from '../lib/dispatch-progress.js';
 import { emitRunEvent } from '../lib/run-events.js';
+import { checkpointAcceptedTurn } from '../lib/turn-checkpoint.js';
 
 export async function runCommand(opts) {
   const context = loadProjectContext();
@@ -148,6 +149,7 @@ export async function executeGovernedRun(context, opts = {}) {
 
   const maxTurns = opts.maxTurns || 50;
   const autoApprove = !!opts.autoApprove;
+  const autoCheckpoint = opts.autoCheckpoint === true;
   const verbose = !!opts.verbose;
   const overrideResolution = opts.role
     ? resolveGovernedRole({ override: opts.role, state: null, config })
@@ -499,6 +501,17 @@ export async function executeGovernedRun(context, opts = {}) {
       return approved;
     },
 
+    async afterAccept({ turn }) {
+      if (!autoCheckpoint) {
+        return { ok: true };
+      }
+      const checkpoint = checkpointAcceptedTurn(root, { turnId: turn.turn_id });
+      if (!checkpoint.ok) {
+        return { ok: false, error: checkpoint.error || `checkpoint failed for ${turn.turn_id}` };
+      }
+      return { ok: true };
+    },
+
     onEvent(event) {
       switch (event.type) {
         case 'turn_assigned':

package/src/commands/status.js

@@ -8,7 +8,7 @@ import {
   deriveRecoveryDescriptor,
   deriveRuntimeBlockedGuidance,
 } from '../lib/blocked-state.js';
-import { getActiveTurn, getActiveTurnCount, getActiveTurns } from '../lib/governed-state.js';
+import { getActiveTurn, getActiveTurnCount, getActiveTurns, detectActiveTurnBindingDrift, detectStateBundleDesync } from '../lib/governed-state.js';
 import { getContinuityStatus } from '../lib/continuity-status.js';
 import { getConnectorHealth } from '../lib/connector-health.js';
 import { readRepoDecisions, summarizeRepoDecisions } from '../lib/repo-decisions.js';
@@ -21,7 +21,7 @@ import { deriveConflictedTurnResolutionActions } from '../lib/conflict-actions.j
 import { summarizeLatestGateActionAttempt } from '../lib/gate-actions.js';
 import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
-import { readPreemptionMarker } from '../lib/intake.js';
+import { readPreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
 
@@ -133,6 +133,7 @@ function renderGovernedStatus(context, opts) {
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
   const humanEscalation = findCurrentHumanEscalation(root, state);
   const preemptionMarker = readPreemptionMarker(root);
+  const pendingIntents = findPendingApprovedIntents(root);
   const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
     ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)
@@ -175,10 +176,13 @@ function renderGovernedStatus(context, opts) {
       dispatch_progress: dispatchProgress,
       human_escalation: humanEscalation,
       preemption_marker: preemptionMarker,
+      pending_intents: pendingIntents,
       continuous_session: continuousSession,
       gate_action_attempt: gateActionAttempt,
       workflow_kit_artifacts: workflowKitArtifacts,
       dashboard_session: dashboardSessionObj,
+      binding_drift: detectActiveTurnBindingDrift(state, config),
+      bundle_integrity: detectStateBundleDesync(root, state),
     }, null, 2));
     return;
   }
@@ -204,6 +208,21 @@ function renderGovernedStatus(context, opts) {
     console.log('');
   }
 
+  // Pending injected intents (BUG-15)
+  if (pendingIntents.length > 0) {
+    console.log(chalk.yellow.bold('  📋 Pending injected intents (will drive next turn):'));
+    for (const pi of pendingIntents) {
+      const priorityColor = pi.priority === 'p0' ? chalk.red.bold : pi.priority === 'p1' ? chalk.yellow.bold : chalk.dim;
+      const charterSnippet = pi.charter
+        ? (pi.charter.length > 60 ? pi.charter.slice(0, 57) + '...' : pi.charter)
+        : '(no charter)';
+      console.log(`    ${priorityColor(`[${pi.priority}]`)} ${chalk.dim(pi.intent_id)} — ${charterSnippet}`);
+      console.log(chalk.dim(`         Acceptance: ${pi.acceptance_count} item${pi.acceptance_count !== 1 ? 's' : ''}`));
+    }
+    console.log(chalk.dim('  ' + '─'.repeat(44)));
+    console.log('');
+  }
+
   // Continuous session banner
   if (continuousSession) {
     console.log(chalk.cyan.bold('  🔄 Continuous Vision-Driven Session'));
@@ -266,18 +285,31 @@ function renderGovernedStatus(context, opts) {
   renderConnectorHealthStatus(connectorHealth);
   renderRecentEventSummary(recentEventSummary);
 
+  // BUG-18: State/bundle integrity check
+  const desync = detectStateBundleDesync(root, state);
+  if (!desync.ok) {
+    console.log(chalk.red.bold('  ⚠ Ghost turn(s) detected — dispatch bundle missing'));
+    for (const entry of desync.desynced) {
+      console.log(chalk.red(`    ${entry.turn_id} (${entry.role}): ${entry.expected_path} not found`));
+    }
+    console.log(chalk.dim('  Run `agentxchain reissue-turn` to recover, or `agentxchain doctor` for diagnostics.'));
+    console.log('');
+  }
+
   const activeTurnCount = getActiveTurnCount(state);
   const singleActiveTurn = getActiveTurn(state);
   const approvalPending = Boolean(state?.pending_phase_transition || state?.pending_run_completion);
   if (activeTurnCount > 1) {
     console.log(`  ${chalk.dim('Turns:')}    ${activeTurnCount} active`);
     for (const turn of Object.values(activeTurns)) {
-      const marker = turn.status === 'conflicted'
+      const marker = (turn.status === 'conflicted' || turn.status === 'failed_acceptance')
         ? chalk.red('✗')
         : chalk.yellow('●');
       const statusLabel = turn.status === 'conflicted'
         ? chalk.red('conflicted')
-        : turn.status;
+        : turn.status === 'failed_acceptance'
+          ? chalk.red('failed_acceptance')
+          : turn.status;
       let elapsedTag = '';
       if (turn.started_at) {
         const elMs = Date.now() - new Date(turn.started_at).getTime();
@@ -318,6 +350,11 @@ function renderGovernedStatus(context, opts) {
         console.log(`      ${chalk.dim('Resolve:')}   ${chalk.cyan(reassignAction.command)}`);
         console.log(`      ${chalk.dim('     or:')}   ${chalk.cyan(mergeAction.command)}`);
       }
+      if (turn.status === 'failed_acceptance') {
+        console.log(`      ${chalk.dim('Reason:')}  ${turn.failure_reason || 'unknown'}`);
+        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`);
+      }
     }
   } else if (singleActiveTurn) {
     console.log(`  ${chalk.dim('Turn:')}     ${singleActiveTurn.turn_id}`);
@@ -372,6 +409,23 @@ function renderGovernedStatus(context, opts) {
     console.log(`  ${chalk.dim('Turn:')}     ${chalk.yellow('No active turn')}`);
   }
 
+  // Runtime/authority binding drift detection (B-7)
+  const bindingDrifts = detectActiveTurnBindingDrift(state, config);
+  if (bindingDrifts.length > 0) {
+    console.log('');
+    console.log(`  ${chalk.red.bold('⚠ Stale binding detected')}`);
+    for (const drift of bindingDrifts) {
+      if (drift.runtime_changed) {
+        console.log(`  ${chalk.dim('Turn:')}     ${drift.turn_id} (${drift.role_id})`);
+        console.log(`  ${chalk.dim('Runtime:')}  ${chalk.yellow(drift.old_runtime)} → ${chalk.green(drift.new_runtime)} (config changed)`);
+      }
+      if (drift.authority_changed) {
+        console.log(`  ${chalk.dim('Authority:')} ${chalk.yellow(drift.old_authority)} → ${chalk.green(drift.new_authority)} (config changed)`);
+      }
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(drift.recovery_command)}`);
+    }
+  }
+
   // Queued phase/completion requests
   if (state?.queued_phase_transition) {
     const qt = state.queued_phase_transition;

package/src/commands/step.js

@@ -35,6 +35,7 @@ import {
   getActiveTurnCount,
   getActiveTurns,
   reactivateGovernedRun,
+  refreshTurnBaselineSnapshot,
   STATE_PATH,
 } from '../lib/governed-state.js';
 import { getMaxConcurrentTurns } from '../lib/normalized-config.js';
@@ -68,6 +69,7 @@ import { finalizeDispatchManifest, verifyDispatchManifest } from '../lib/dispatc
 import { resolveGovernedRole } from '../lib/role-resolution.js';
 import { shouldSuggestManualQaFallback } from '../lib/manual-qa-fallback.js';
 import { evaluateApprovalSlaReminders } from '../lib/notification-runner.js';
+import { consumeNextApprovedIntent } from '../lib/intake.js';
 
 export async function stepCommand(opts) {
   const context = loadProjectContext();
@@ -213,6 +215,17 @@ export async function stepCommand(opts) {
         process.exit(1);
       }
 
+      // If the target turn failed acceptance, print recovery guidance (BUG-3 fix)
+      if (targetTurn.status === 'failed_acceptance') {
+        console.log(chalk.red(`Turn ${targetTurn.turn_id} (${targetTurn.assigned_role}) failed acceptance.`));
+        console.log(chalk.dim(`Reason: ${targetTurn.failure_reason || 'unknown'}`));
+        console.log('');
+        console.log(chalk.dim('Recovery options:'));
+        console.log(`  ${chalk.cyan(`agentxchain reject-turn --turn ${targetTurn.turn_id}`)}  — reject and retry`);
+        console.log(`  ${chalk.cyan(`agentxchain accept-turn --turn ${targetTurn.turn_id}`)}  — re-attempt acceptance after fixing`);
+        process.exit(1);
+      }
+
       console.log(chalk.yellow(`Re-dispatching blocked turn: ${targetTurn.turn_id}`));
       const reactivated = reactivateGovernedRun(root, state, { via: 'step --resume', notificationConfig: config });
       if (!reactivated.ok) {
@@ -222,6 +235,10 @@ export async function stepCommand(opts) {
       state = reactivated.state;
       skipAssignment = true;
 
+      // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
+      refreshTurnBaselineSnapshot(root, targetTurn.turn_id);
+      state = JSON.parse(readFileSync(join(root, '.agentxchain/state.json'), 'utf8'));
+
       const bundleResult = writeDispatchBundle(root, state, config);
       if (!bundleResult.ok) {
         console.log(chalk.red(`Failed to write dispatch bundle: ${bundleResult.error}`));
@@ -245,6 +262,10 @@ export async function stepCommand(opts) {
         state = reactivated.state;
         skipAssignment = true;
 
+        // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
+        refreshTurnBaselineSnapshot(root, pausedTurn.turn_id);
+        state = JSON.parse(readFileSync(join(root, '.agentxchain/state.json'), 'utf8'));
+
         const bundleResult = writeDispatchBundle(root, state, config);
         if (!bundleResult.ok) {
           console.log(chalk.red(`Failed to write dispatch bundle: ${bundleResult.error}`));
@@ -294,16 +315,26 @@ export async function stepCommand(opts) {
         process.exit(1);
       }
 
-      const assignResult = assignGovernedTurn(root, config, roleId);
-      if (!assignResult.ok) {
-        if (assignResult.error_code?.startsWith('hook_') || assignResult.error_code === 'hook_blocked') {
-          printAssignmentHookFailure(assignResult, roleId, config);
+      const shouldBindIntent = opts.intent !== false;
+      const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+      if (consumed.ok) {
+        state = loadProjectState(root, config);
+        if (!state) {
+          console.log(chalk.red('Failed to reload governed state after intake binding.'));
+          process.exit(1);
         }
-        console.log(chalk.red(`Failed to assign turn: ${assignResult.error}`));
-        process.exit(1);
+      } else {
+        const assignResult = assignGovernedTurn(root, config, roleId);
+        if (!assignResult.ok) {
+          if (assignResult.error_code?.startsWith('hook_') || assignResult.error_code === 'hook_blocked') {
+            printAssignmentHookFailure(assignResult, roleId, config);
+          }
+          console.log(chalk.red(`Failed to assign turn: ${assignResult.error}`));
+          process.exit(1);
+        }
+        printAssignmentWarnings(assignResult);
+        state = assignResult.state;
       }
-      printAssignmentWarnings(assignResult);
-      state = assignResult.state;
 
       const bundleResult = writeDispatchBundle(root, state, config);
       if (!bundleResult.ok) {
@@ -587,13 +618,21 @@ export async function stepCommand(opts) {
       console.log(chalk.yellow(`The subprocess must independently read from .agentxchain/dispatch/turns/${turn.turn_id}/PROMPT.md`));
       console.log(chalk.dim('To enable automatic prompt delivery, set prompt_transport to "argv" or "stdin" in the runtime config.'));
     }
+    // BUG-6: always show log file path so operators know where to watch
+    const logPath = `.agentxchain/dispatch/turns/${turn.turn_id}/stdout.log`;
+    console.log(chalk.dim(`Log: ${logPath}`));
+    if (!opts.stream && !opts.verbose) {
+      console.log(chalk.dim(`  Watch live: tail -f ${logPath}`));
+    }
     console.log(chalk.dim('Press Ctrl+C to abort and leave the turn assigned.'));
     console.log('');
 
+    // BUG-6: stream subprocess output by default (--stream or --verbose), suppress with --quiet
+    const shouldStream = opts.stream || opts.verbose || false;
     const cliResult = await dispatchLocalCli(root, state, config, {
       signal: controller.signal,
-      onStdout: opts.verbose ? (text) => process.stdout.write(chalk.dim(text)) : undefined,
-      onStderr: opts.verbose ? (text) => process.stderr.write(chalk.yellow(text)) : undefined,
+      onStdout: shouldStream ? (text) => process.stdout.write(chalk.dim(text)) : undefined,
+      onStderr: shouldStream ? (text) => process.stderr.write(chalk.yellow(text)) : undefined,
       verifyManifest: true,
     });