agentxchain 2.128.0 → 2.129.0

package/src/commands/mission.js

@@ -4,6 +4,7 @@ import { resolve } from 'path';
 import { findProjectRoot, loadProjectContext } from '../lib/config.js';
 import {
   attachChainToMission,
+  bindCoordinatorToMission,
   buildMissionListSummary,
   buildMissionSnapshot,
   createMission,
@@ -12,6 +13,8 @@ import {
   loadMissionArtifact,
   loadMissionSnapshot,
 } from '../lib/missions.js';
+import { loadCoordinatorConfig } from '../lib/coordinator-config.js';
+import { initializeCoordinatorRun } from '../lib/coordinator-state.js';
 import {
   approvePlanArtifact,
   createPlanArtifact,
@@ -48,6 +51,22 @@ export async function missionStartCommand(opts) {
     process.exit(1);
   }
 
+  // Multi-repo: validate coordinator config before creating mission (fail-fast)
+  let coordinatorConfig = null;
+  let coordinatorWorkspacePath = null;
+  if (opts.multi) {
+    coordinatorWorkspacePath = resolve(opts.coordinatorWorkspace || opts.coordinatorConfig || root);
+    coordinatorConfig = loadCoordinatorConfig(coordinatorWorkspacePath);
+    if (!coordinatorConfig.ok) {
+      console.error(chalk.red('Coordinator config validation failed:'));
+      console.error(chalk.dim(`  Expected agentxchain-multi.json at: ${coordinatorWorkspacePath}`));
+      for (const err of coordinatorConfig.errors || []) {
+        console.error(chalk.red(`  ${err}`));
+      }
+      process.exit(1);
+    }
+  }
+
   const result = createMission(root, {
     missionId: opts.id,
     title,
@@ -58,6 +77,37 @@ export async function missionStartCommand(opts) {
     process.exit(1);
   }
 
+  // Multi-repo: initialize coordinator and bind to mission
+  if (opts.multi && coordinatorConfig) {
+    const initResult = initializeCoordinatorRun(coordinatorWorkspacePath, coordinatorConfig.config);
+    if (!initResult.ok) {
+      // Atomic rollback: delete the mission artifact
+      const { getMissionsDir } = await import('../lib/missions.js');
+      const { unlinkSync, existsSync: fileExists } = await import('fs');
+      const { join: joinPath } = await import('path');
+      const missionFile = joinPath(getMissionsDir(root), `${result.mission.mission_id}.json`);
+      if (fileExists(missionFile)) {
+        try { unlinkSync(missionFile); } catch { /* best effort */ }
+      }
+      console.error(chalk.red('Coordinator initialization failed:'));
+      for (const err of initResult.errors || []) {
+        console.error(chalk.red(`  ${err}`));
+      }
+      process.exit(1);
+    }
+
+    const bindResult = bindCoordinatorToMission(root, result.mission.mission_id, {
+      super_run_id: initResult.super_run_id,
+      config_path: opts.coordinatorConfig || null,
+      workspace_path: coordinatorWorkspacePath,
+    });
+    if (!bindResult.ok) {
+      console.error(chalk.yellow(`Mission created but coordinator binding failed: ${bindResult.error}`));
+    } else {
+      result.mission = bindResult.mission;
+    }
+  }
+
   const snapshot = buildMissionSnapshot(root, result.mission);
   if (opts.plan) {
     try {
@@ -1288,6 +1338,54 @@ function renderMissionPlanError(error) {
   }
 }
 
+// ── Mission Bind-Coordinator Command ───────────────────────────────────────
+
+export async function missionBindCoordinatorCommand(missionId, opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  const superRunId = String(opts.superRunId || '').trim();
+  const configPath = String(opts.coordinatorConfig || '').trim();
+  if (!superRunId) {
+    console.error(chalk.red('--super-run-id is required.'));
+    process.exit(1);
+  }
+
+  const mission = missionId
+    ? loadMissionArtifact(root, missionId)
+    : loadLatestMissionArtifact(root);
+  if (!mission) {
+    console.error(chalk.red(missionId ? `Mission not found: ${missionId}` : 'No mission found.'));
+    process.exit(1);
+  }
+
+  const workspacePath = resolve(opts.coordinatorWorkspace || root);
+  const result = bindCoordinatorToMission(root, mission.mission_id, {
+    super_run_id: superRunId,
+    config_path: configPath || null,
+    workspace_path: workspacePath,
+  });
+
+  if (!result.ok) {
+    console.error(chalk.red(result.error));
+    process.exit(1);
+  }
+
+  const snapshot = buildMissionSnapshot(root, result.mission);
+  if (opts.json) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+
+  console.log(chalk.green(`Bound coordinator ${superRunId} to ${snapshot.mission_id}`));
+  renderMissionSnapshot(snapshot);
+}
+
+// ── Rendering ──────────────────────────────────────────────────────────────
+
 function renderMissionSnapshot(snapshot) {
   const latestPlan = snapshot.latest_plan || null;
 
@@ -1309,6 +1407,36 @@ function renderMissionSnapshot(snapshot) {
     console.log(`  Missing chains:        ${snapshot.missing_chain_ids.join(', ')}`);
   }
 
+  // Coordinator (multi-repo) section
+  if (snapshot.coordinator_status) {
+    const cs = snapshot.coordinator_status;
+    console.log('');
+    console.log(chalk.bold('  Coordinator (multi-repo):'));
+    if (cs.unreachable) {
+      console.log(`    Super Run:           ${cs.super_run_id || '—'}`);
+      console.log(`    Status:              ${chalk.red('unreachable')}`);
+    } else {
+      console.log(`    Super Run:           ${cs.super_run_id || '—'}`);
+      console.log(`    Status:              ${formatCoordinatorStatus(cs.status)}`);
+      console.log(`    Phase:               ${cs.phase || '—'}`);
+      if (cs.repo_runs && Object.keys(cs.repo_runs).length > 0) {
+        console.log('    Repos:');
+        for (const [repoId, repo] of Object.entries(cs.repo_runs)) {
+          console.log(`      ${pad(repoId, 16)} ${pad(repo.status || '—', 14)} ${pad(repo.phase || '—', 18)} ${repo.run_id || '—'}`);
+        }
+      }
+      if (cs.pending_barriers && cs.pending_barriers.length > 0) {
+        console.log('    Barriers:');
+        for (const barrier of cs.pending_barriers) {
+          console.log(`      ${pad(barrier.id, 28)} ${pad(barrier.type || '—', 24)} ${barrier.status || '—'}`);
+        }
+      }
+      if (cs.blocked_reason) {
+        console.log(`    Blocked:             ${chalk.yellow(cs.blocked_reason)}`);
+      }
+    }
+  }
+
   if (latestPlan) {
     console.log('');
     console.log(chalk.bold('  Latest plan:'));
@@ -1374,6 +1502,20 @@ function formatMissionStatus(status) {
   }
 }
 
+function formatCoordinatorStatus(status) {
+  if (!status) return '—';
+  switch (status) {
+    case 'active':
+      return chalk.green('active');
+    case 'blocked':
+      return chalk.red('blocked');
+    case 'completed':
+      return chalk.cyan('completed');
+    default:
+      return status;
+  }
+}
+
 function formatTimestamp(value) {
   if (!value) return '—';
   try {

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) {

package/src/commands/restart.js

@@ -265,10 +265,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.')}`);
     }
   }
 

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/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 } 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,12 @@ 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),
     }, null, 2));
     return;
   }
@@ -204,6 +207,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'));
@@ -272,12 +290,14 @@ function renderGovernedStatus(context, opts) {
   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 +338,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 +397,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,
     });