agentxchain 2.134.0 → 2.135.0

package/package.json

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

package/src/commands/doctor.js

@@ -61,6 +61,7 @@ export async function doctorCommand(opts = {}) {
 function governedDoctor(root, rawConfig, opts) {
   const checks = [];
   const cliVersionHealth = getCliVersionHealth();
+  let stateRunId = null;
 
   checks.push(buildCliVersionCheck(cliVersionHealth));
 
@@ -109,6 +110,7 @@ function governedDoctor(root, rawConfig, opts) {
   if (existsSync(statePath)) {
     try {
       const stateData = JSON.parse(readFileSync(statePath, 'utf8'));
+      stateRunId = stateData.run_id || null;
       if (stateData.schema_version) {
         checks.push({ id: 'state_health', name: 'State health', level: 'pass', detail: `schema_version: ${stateData.schema_version}, status: ${stateData.status || 'unknown'}` });
       } else {
@@ -354,7 +356,7 @@ function governedDoctor(root, rawConfig, opts) {
 
   // 11. Pending intake intents (BUG-15 — informational)
   {
-    const pendingIntents = findPendingApprovedIntents(root);
+    const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId });
     if (pendingIntents.length > 0) {
       const summary = pendingIntents.map(pi => `[${pi.priority}] ${pi.intent_id}`).join(', ');
       checks.push({

package/src/commands/events.js

@@ -88,7 +88,10 @@ function printEvent(evt) {
   const coordinatorRetryDetail = evt.event_type === 'coordinator_retry' && evt.payload
     ? ` — ws ${evt.payload.workstream_id || '?'} repo ${evt.payload.repo_id || '?'} (retry of ${evt.payload.failed_turn_id || '?'})`
     : '';
-  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${intentInfo}${conflictDetail}${conflictResolvedDetail}${rejectionDetail}${acceptanceFailedDetail}${phaseTransitionDetail}${gateFailedDetail}${humanEscalationDetail}${coordinatorRetryDetail}`);
+  const projectionWarningDetail = evt.event_type === 'coordinator_retry_projection_warning' && evt.payload
+    ? ` — ws ${evt.payload.workstream_id || '?'} repo ${evt.payload.repo_id || '?'} (reconciliation required)`
+    : '';
+  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${intentInfo}${conflictDetail}${conflictResolvedDetail}${rejectionDetail}${acceptanceFailedDetail}${phaseTransitionDetail}${gateFailedDetail}${humanEscalationDetail}${coordinatorRetryDetail}${projectionWarningDetail}`);
 }
 
 function formatConflictDetail(evt) {
@@ -150,6 +153,7 @@ function colorEventType(type) {
     gate_failed: chalk.red,
     budget_exceeded_warn: chalk.yellowBright,
     coordinator_retry: chalk.cyan.bold,
+    coordinator_retry_projection_warning: chalk.yellow.bold,
     turn_checkpointed: chalk.green,
     dispatch_progress: chalk.blue.dim,
   };

package/src/commands/mission.js

@@ -38,6 +38,7 @@ import { executeGovernedRun } from './run.js';
 import { dispatchCoordinatorTurn, selectAssignmentForWorkstream } from '../lib/coordinator-dispatch.js';
 import { loadCoordinatorState } from '../lib/coordinator-state.js';
 import { projectRepoAcceptance } from '../lib/coordinator-acceptance.js';
+import { emitRunEvent } from '../lib/run-events.js';
 
 export async function missionStartCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
@@ -182,6 +183,13 @@ function projectAcceptedCoordinatorTurn(workspacePath, coordinatorConfig, repoId
   );
 }
 
+function buildCoordinatorProjectionWarning(message) {
+  return {
+    code: 'coordinator_acceptance_projection_incomplete',
+    message,
+  };
+}
+
 export async function missionListCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
   if (!root) {
@@ -634,6 +642,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       };
 
       let execution;
+      const retryWarnings = [];
       try {
         execution = await executor(repoContext, runOpts);
       } catch (error) {
@@ -669,7 +678,21 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
           loadCoordinatorState(mission.coordinator.workspace_path),
         );
         if (!projection.ok) {
-          console.error(chalk.yellow(`Coordinator retry projection warning: ${projection.error}`));
+          const warning = buildCoordinatorProjectionWarning(projection.error);
+          retryWarnings.push(warning);
+          console.error(chalk.yellow(`Coordinator retry projection warning: ${warning.message}`));
+          emitRunEvent(mission.coordinator.workspace_path, 'coordinator_retry_projection_warning', {
+            run_id: mission.coordinator.super_run_id,
+            phase: coordinatorConfigResult.config?.workstreams?.[opts.workstream]?.phase || null,
+            status: 'active',
+            payload: {
+              workstream_id: opts.workstream,
+              repo_id: retry.retryResult.repo_id,
+              reissued_turn_id: retry.retryResult.reissued_turn_id,
+              warning_code: warning.code,
+              warning_message: warning.message,
+            },
+          });
         }
       }
 
@@ -697,6 +720,8 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
           workstream_status: retriedWorkstream?.launch_status || 'launched',
           launch_record: retriedLaunchRecord,
           exit_code: execution?.exitCode ?? 0,
+          warnings: retryWarnings,
+          reconciliation_required: retryWarnings.length > 0,
         }, null, 2));
         if ((execution?.exitCode ?? 0) !== 0) {
           process.exit(execution.exitCode);
@@ -713,6 +738,9 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       console.log(chalk.dim(`  Old Turn:     ${retry.retryResult.failed_turn_id}`));
       console.log(chalk.dim(`  New Turn:     ${retry.retryResult.reissued_turn_id}`));
       console.log(chalk.dim(`  Workstream:   ${retriedWorkstream?.launch_status || 'launched'}`));
+      if (retryWarnings.length > 0) {
+        console.log(chalk.yellow(`  Warning:      ${retryWarnings[0].message}`));
+      }
       console.log('');
       renderPlan(retriedPlan);
       if ((execution?.exitCode ?? 0) !== 0) {

package/src/commands/restart.js

@@ -342,7 +342,7 @@ export async function restartCommand(opts) {
   if (activeTurnCount === 0) {
     // 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 });
+    const consumed = consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null });
     let assignedState;
     let turnId;
     let assignedRole = roleId;

package/src/commands/resume.js

@@ -267,7 +267,9 @@ export async function resumeCommand(opts) {
   }
 
   const shouldBindIntent = opts.intent !== false;
-  const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+  const consumed = shouldBindIntent
+    ? consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null })
+    : { ok: false };
   if (consumed.ok) {
     state = loadProjectState(root, config);
     if (!state) {

package/src/commands/status.js

@@ -24,6 +24,7 @@ import { getDashboardPid, getDashboardSession } from './dashboard.js';
 import { readPreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
+import { readCoordinatorWarnings } from '../lib/coordinator-warnings.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -111,10 +112,22 @@ function loadStatusContext(dir = process.cwd()) {
     return null;
   }
 
+  const fallbackConfig = {
+    ...rawConfig,
+    files: {
+      talk: rawConfig.files?.talk || 'TALK.md',
+      history: rawConfig.files?.history || '.agentxchain/history.jsonl',
+      state: rawConfig.files?.state || '.agentxchain/state.json',
+      log: Object.prototype.hasOwnProperty.call(rawConfig.files || {}, 'log')
+        ? rawConfig.files.log
+        : null,
+    },
+  };
+
   return {
     root,
     rawConfig,
-    config: rawConfig,
+    config: fallbackConfig,
     version: 4,
   };
 }
@@ -122,6 +135,7 @@ function loadStatusContext(dir = process.cwd()) {
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
   const state = loadProjectState(root, config);
+  const stateRunId = state?.run_id || readRawStateRunId(root, config);
   const continuity = getContinuityStatus(root, state);
   const connectorHealth = getConnectorHealth(root, config, state);
   const recovery = deriveRecoveryDescriptor(state, config);
@@ -133,7 +147,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 pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId || null });
   const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
     ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)
@@ -147,6 +161,9 @@ function renderGovernedStatus(context, opts) {
   const activeTurns = getActiveTurns(state);
   const dispatchProgress = filterDispatchProgressForActiveTurns(readAllDispatchProgress(root), activeTurns);
 
+  // Coordinator warning surfacing — DEC-COORD-RETRY-PROJECTION-EVENT-001
+  const coordinatorWarnings = readCoordinatorWarnings(root, { runId: stateRunId || null });
+
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -183,6 +200,7 @@ function renderGovernedStatus(context, opts) {
       dashboard_session: dashboardSessionObj,
       binding_drift: detectActiveTurnBindingDrift(state, config),
       bundle_integrity: detectStateBundleDesync(root, state),
+      coordinator_warnings: coordinatorWarnings,
     }, null, 2));
     return;
   }
@@ -284,6 +302,7 @@ function renderGovernedStatus(context, opts) {
   renderContinuityStatus(continuity, state);
   renderConnectorHealthStatus(connectorHealth);
   renderRecentEventSummary(recentEventSummary);
+  renderCoordinatorWarnings(coordinatorWarnings);
 
   // BUG-18: State/bundle integrity check
   const desync = detectStateBundleDesync(root, state);
@@ -908,3 +927,37 @@ function formatUsd(value) {
   if (typeof value !== 'number' || Number.isNaN(value)) return '0.00';
   return value.toFixed(2);
 }
+
+/**
+ * Read coordinator retry projection warnings from the event log.
+ * Returns a structured summary for both JSON and CLI output.
+ */
+function renderCoordinatorWarnings(warnings) {
+  if (!warnings || warnings.count === 0) return;
+  console.log(chalk.yellow.bold(`  ⚠ Coordinator reconciliation required (${warnings.count} projection warning${warnings.count !== 1 ? 's' : ''})`));
+  for (const w of warnings.warnings) {
+    const wsLabel = w.workstream_id ? `ws:${w.workstream_id}` : '';
+    const repoLabel = w.repo_id ? `repo:${w.repo_id}` : '';
+    const parts = [wsLabel, repoLabel].filter(Boolean).join(' ');
+    console.log(`    ${chalk.yellow('●')} ${parts} — ${w.warning_code}`);
+  }
+  console.log(chalk.dim('  Run `agentxchain mission plan show latest --json` to force plan sync and verify.'));
+  console.log('');
+}
+
+function readRawStateRunId(root, config) {
+  const relPath = config?.files?.state || '.agentxchain/state.json';
+  const filePath = join(root, relPath);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    return typeof parsed?.run_id === 'string' && parsed.run_id.trim().length > 0
+      ? parsed.run_id.trim()
+      : null;
+  } catch {
+    return null;
+  }
+}

package/src/commands/step.js

@@ -316,7 +316,9 @@ export async function stepCommand(opts) {
       }
 
       const shouldBindIntent = opts.intent !== false;
-      const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+      const consumed = shouldBindIntent
+        ? consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null })
+        : { ok: false };
       if (consumed.ok) {
         state = loadProjectState(root, config);
         if (!state) {

package/src/lib/continuous-run.js

@@ -350,8 +350,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: false, status: 'failed', action: 'vision_missing', stop_reason: `VISION.md not found at ${absVisionPath}` };
   }
 
-  // Step 1: Check intake queue for pending work
-  const queued = findNextDispatchableIntent(root);
+  // Step 1: Check intake queue for pending work (BUG-34: scope to current run)
+  const queued = findNextDispatchableIntent(root, { run_id: session.current_run_id });
   let targetIntentId = null;
   let visionObjective = null;
 

package/src/lib/coordinator-warnings.js

@@ -0,0 +1,31 @@
+import { readRunEvents } from './run-events.js';
+
+function normalizeCoordinatorWarning(event) {
+  return {
+    event_id: event.event_id,
+    timestamp: event.timestamp,
+    run_id: event.run_id || null,
+    workstream_id: event.payload?.workstream_id || null,
+    repo_id: event.payload?.repo_id || null,
+    reissued_turn_id: event.payload?.reissued_turn_id || null,
+    warning_code: event.payload?.warning_code || 'coordinator_acceptance_projection_incomplete',
+    warning_message: event.payload?.warning_message || null,
+  };
+}
+
+export function readCoordinatorWarnings(root, { runId = null } = {}) {
+  const events = readRunEvents(root, { type: 'coordinator_retry_projection_warning' });
+  const filtered = runId
+    ? events.filter((event) => event.run_id === runId)
+    : events;
+
+  if (filtered.length === 0) {
+    return { count: 0, reconciliation_required: false, warnings: [] };
+  }
+
+  return {
+    count: filtered.length,
+    reconciliation_required: true,
+    warnings: filtered.map(normalizeCoordinatorWarning),
+  };
+}

package/src/lib/dashboard/plan-reader.js

@@ -7,6 +7,8 @@
 
 import { buildPlanProgressSummary, loadAllPlans } from '../mission-plans.js';
 import { loadAllMissionArtifacts } from '../missions.js';
+import { loadCoordinatorState } from '../coordinator-state.js';
+import { readCoordinatorWarnings } from '../coordinator-warnings.js';
 
 /**
  * Build a dashboard-ready plan snapshot across all missions.
@@ -49,12 +51,19 @@ export function readPlanSnapshot(workspacePath, { limit, missionId } = {}) {
     latestSummary = buildPlanSummary(latest);
   }
 
+  // Surface coordinator projection warnings for dashboard consumers
+  const coordinatorState = loadCoordinatorState(workspacePath);
+  const coordinatorWarnings = readCoordinatorWarnings(workspacePath, {
+    runId: coordinatorState?.super_run_id || null,
+  });
+
   return {
     ok: true,
     status: 200,
     body: {
       latest: latestSummary,
       plans: plans.map(buildPlanSummary),
+      coordinator_warnings: coordinatorWarnings,
     },
   };
 }

package/src/lib/dispatch-bundle.js

@@ -332,25 +332,8 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('');
   }
 
-  if (turn.intake_context) {
-    lines.push('### Active Injected Intent — respond to this as your primary charter');
-    lines.push('');
-    if (turn.intake_context.charter) {
-      lines.push(turn.intake_context.charter);
-      lines.push('');
-    }
-    if (Array.isArray(turn.intake_context.acceptance_contract) && turn.intake_context.acceptance_contract.length > 0) {
-      lines.push('Acceptance contract:');
-      turn.intake_context.acceptance_contract.forEach((requirement, index) => {
-        lines.push(`${index + 1}. ${requirement}`);
-      });
-      lines.push('');
-    }
-    lines.push('You must explicitly address every acceptance item in your turn summary, artifacts, or verification evidence. Do not treat this as background context.');
-    lines.push('');
-  }
-
-  // Retry context
+  // BUG-35: retry context must appear BEFORE the injected intent so the agent
+  // sees the blocker (gate failure) first and the repair guidance (intent) second.
   if (turn.attempt > 1 && turn.last_rejection) {
     lines.push('## Previous Attempt Failed');
     lines.push('');
@@ -369,6 +352,24 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('');
   }
 
+  if (turn.intake_context) {
+    lines.push('### Active Injected Intent — respond to this as your primary charter');
+    lines.push('');
+    if (turn.intake_context.charter) {
+      lines.push(turn.intake_context.charter);
+      lines.push('');
+    }
+    if (Array.isArray(turn.intake_context.acceptance_contract) && turn.intake_context.acceptance_contract.length > 0) {
+      lines.push('Acceptance contract:');
+      turn.intake_context.acceptance_contract.forEach((requirement, index) => {
+        lines.push(`${index + 1}. ${requirement}`);
+      });
+      lines.push('');
+    }
+    lines.push('You must explicitly address every acceptance item in your turn summary, artifacts, or verification evidence. Do not treat this as background context.');
+    lines.push('');
+  }
+
   if (turn.conflict_context) {
     lines.push('## File Conflict - Retry Required');
     lines.push('');

package/src/lib/governed-state.js

@@ -2154,6 +2154,42 @@ export function initializeGovernedRun(root, config, options = {}) {
   };
 
   writeState(root, updatedState);
+
+  // BUG-34: retroactive migration — archive stale intents from prior runs.
+  // Intents with an approved_run_id from a DIFFERENT run are archived.
+  // Intents with no approved_run_id are adopted into the current run
+  // (they were created while the project was idle or pre-run).
+  try {
+    const intentsDir = join(root, '.agentxchain', 'intake', 'intents');
+    if (existsSync(intentsDir)) {
+      const DISPATCHABLE = new Set(['planned', 'approved']);
+      const intNow = new Date().toISOString();
+      for (const f of readdirSync(intentsDir).filter(x => x.endsWith('.json') && !x.startsWith('.tmp-'))) {
+        const ip = join(intentsDir, f);
+        try {
+          const intent = JSON.parse(readFileSync(ip, 'utf8'));
+          if (!intent || !DISPATCHABLE.has(intent.status)) continue;
+          if (intent.cross_run_durable === true) continue;
+          if (intent.approved_run_id === runId) continue;
+
+          if (intent.approved_run_id && intent.approved_run_id !== runId) {
+            // Intent from a different run — archive it
+            intent.status = 'suppressed';
+            intent.updated_at = intNow;
+            intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${runId} initialization`;
+            if (!intent.history) intent.history = [];
+            intent.history.push({ from: 'approved', to: 'suppressed', at: intNow, reason: intent.archived_reason });
+          } else if (!intent.approved_run_id) {
+            // Legacy intent with no run binding — adopt into current run
+            intent.approved_run_id = runId;
+            intent.updated_at = intNow;
+          }
+          safeWriteJson(ip, intent);
+        } catch { /* non-fatal per-intent */ }
+      }
+    }
+  } catch { /* non-fatal — intent migration is best-effort */ }
+
   emitRunEvent(root, 'run_started', {
     run_id: runId,
     phase: updatedState.phase,
@@ -3107,6 +3143,70 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // ── Gate semantic coverage validation (BUG-36) ────────────────────────────
+  // When a turn proposes a phase transition, pre-evaluate the gate. If the gate
+  // would fail AND the failing files are not in files_changed, reject the turn
+  // early — the agent didn't do the work required for the transition.
+  if (turnResult.phase_transition_request) {
+    const preGateResult = evaluatePhaseExit({
+      state,
+      config,
+      acceptedTurn: turnResult,
+      root,
+    });
+
+    if (preGateResult.action === 'gate_failed') {
+      // Gate is failing. Check if any of the failing reasons reference files
+      // that this turn didn't modify.
+      const declaredFiles = new Set((turnResult.files_changed || []).map(f => f.replace(/^\.\//, '')));
+      const exitGateId = preGateResult.gate_id || 'unknown_gate';
+
+      // Extract file paths from gate failure reasons and missing_files
+      const failingFiles = [
+        ...(preGateResult.missing_files || []),
+      ];
+
+      // Also extract file paths from failure reasons (e.g., ".planning/IMPLEMENTATION_NOTES.md: ...")
+      for (const reason of (preGateResult.reasons || [])) {
+        const fileMatch = reason.match(/(?:Required file missing|file): ([^\s,]+)/);
+        if (fileMatch) failingFiles.push(fileMatch[1]);
+        // Also catch paths at the start of semantic failure messages
+        const semanticMatch = reason.match(/^([^\s:]+\.md):/);
+        if (semanticMatch) failingFiles.push(semanticMatch[1]);
+      }
+
+      const uniqueFailingFiles = [...new Set(failingFiles.map(f => f.replace(/^\.\//, '')))];
+      const uncoveredFiles = uniqueFailingFiles.filter(f => !declaredFiles.has(f));
+
+      const gateSemanticMode = config.gate_semantic_coverage_mode || 'strict';
+      if (uncoveredFiles.length > 0 && gateSemanticMode === 'strict') {
+        const coverageError = `Gate "${exitGateId}" is failing on ${uncoveredFiles.join(', ')}. Your turn did not modify ${uncoveredFiles.length === 1 ? 'that file' : 'those files'}. Either edit the file(s) to satisfy the gate, or remove the phase transition request.`;
+        transitionToFailedAcceptance(root, state, currentTurn, coverageError, {
+          error_code: 'gate_semantic_coverage',
+          stage: 'gate_semantic_coverage',
+          extra: {
+            gate_id: exitGateId,
+            uncovered_files: uncoveredFiles,
+            declared_files: [...declaredFiles],
+            gate_reasons: preGateResult.reasons,
+          },
+        });
+        return {
+          ok: false,
+          error: coverageError,
+          validation: {
+            ...validation,
+            ok: false,
+            stage: 'gate_semantic_coverage',
+            error_class: 'gate_coverage_error',
+            errors: uncoveredFiles.map(f => `Gate "${exitGateId}" is failing on "${f}". Your turn did not modify that file.`),
+            warnings: [],
+          },
+        };
+      }
+    }
+  }
+
   const observedArtifact = buildObservedArtifact(observation, baseline);
   const normalizedVerification = normalizeVerification(turnResult.verification, runtimeType);
   const artifactType = turnResult.artifact?.type || 'review';

package/src/lib/intake.js

@@ -504,15 +504,35 @@ export function intakeStatus(root, intentId) {
   return { ok: true, summary, exitCode: 0 };
 }
 
-export function findNextDispatchableIntent(root) {
+export function findNextDispatchableIntent(root, options = {}) {
   const dirs = intakeDirs(root);
   if (!existsSync(dirs.intents)) {
     return { ok: false, error: 'no intents directory' };
   }
 
-  const intents = readJsonDir(dirs.intents)
+  const scopeRunId = options.run_id || null;
+
+  let intents = readJsonDir(dirs.intents)
     .filter((intent) => intent && DISPATCHABLE_STATUSES.has(intent.status));
 
+  // BUG-34: when run_id scoping is active, filter out intents that belong to
+  // a different run. An intent belongs to the current run if:
+  //   (a) it has approved_run_id matching the current run, OR
+  //   (b) it has no approved_run_id AND is marked cross_run_durable, OR
+  //   (c) it was injected in the current run (approved_run_id matches)
+  // Legacy intents (no approved_run_id, no cross_run_durable) are excluded
+  // because they are stale leftovers from prior runs.
+  if (scopeRunId) {
+    intents = intents.filter((intent) => {
+      if (intent.approved_run_id === scopeRunId) return true;
+      if (intent.cross_run_durable === true) return true;
+      // Legacy intent with no run binding — stale, skip it
+      if (!intent.approved_run_id) return false;
+      // Intent bound to a different run — stale, skip it
+      return false;
+    });
+  }
+
   if (intents.length === 0) {
     return { ok: false, error: 'no dispatchable intents' };
   }
@@ -550,12 +570,23 @@ export function findNextDispatchableIntent(root) {
  * Return all approved-but-unconsumed intents sorted by priority (BUG-15).
  * Used by `status` to surface the pending intent queue.
  */
-export function findPendingApprovedIntents(root) {
+export function findPendingApprovedIntents(root, options = {}) {
   const dirs = intakeDirs(root);
   if (!existsSync(dirs.intents)) return [];
 
+  const scopeRunId = options.run_id || null;
+
   return readJsonDir(dirs.intents)
-    .filter((intent) => intent && intent.status === 'approved')
+    .filter((intent) => {
+      if (!intent || intent.status !== 'approved') return false;
+      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent
+      if (scopeRunId) {
+        if (intent.approved_run_id === scopeRunId) return true;
+        if (intent.cross_run_durable === true) return true;
+        return false;
+      }
+      return true;
+    })
     .sort((a, b) => {
       const aPriority = PRIORITY_RANK[a.priority] ?? Number.MAX_SAFE_INTEGER;
       const bPriority = PRIORITY_RANK[b.priority] ?? Number.MAX_SAFE_INTEGER;
@@ -574,6 +605,59 @@ export function findPendingApprovedIntents(root) {
     }));
 }
 
+/**
+ * BUG-34: Archive stale intents from prior runs.
+ * Called during run initialization to prevent cross-run intent leakage.
+ * Transitions approved/planned intents that don't belong to the new run into
+ * 'suppressed' status with an archival reason.
+ *
+ * @param {string} root
+ * @param {string} newRunId - the run_id of the newly initialized run
+ * @returns {{ archived: number }}
+ */
+export function archiveStaleIntents(root, newRunId) {
+  const dirs = intakeDirs(root);
+  if (!existsSync(dirs.intents)) return { archived: 0, adopted: 0 };
+
+  const now = nowISO();
+  let archived = 0;
+  let adopted = 0;
+
+  const files = readdirSync(dirs.intents).filter(f => f.endsWith('.json') && !f.startsWith('.tmp-'));
+  for (const file of files) {
+    const intentPath = join(dirs.intents, file);
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    if (!intent || !DISPATCHABLE_STATUSES.has(intent.status)) continue;
+    if (intent.cross_run_durable === true) continue;
+    if (intent.approved_run_id === newRunId) continue;
+
+    if (intent.approved_run_id && intent.approved_run_id !== newRunId) {
+      // Intent from a different run — archive it
+      intent.status = 'suppressed';
+      intent.updated_at = now;
+      intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${newRunId} initialization`;
+      if (!intent.history) intent.history = [];
+      intent.history.push({ from: 'approved', to: 'suppressed', at: now, reason: intent.archived_reason });
+      safeWriteJson(intentPath, intent);
+      archived++;
+    } else if (!intent.approved_run_id) {
+      // Legacy intent with no run binding — adopt into current run
+      intent.approved_run_id = newRunId;
+      intent.updated_at = now;
+      safeWriteJson(intentPath, intent);
+      adopted++;
+    }
+  }
+
+  return { archived, adopted };
+}
+
 /**
  * Unified intent consumption entry point (BUG-16).
  * Both manual (resume/step --resume) and continuous/scheduler paths should call
@@ -584,7 +668,22 @@ export function findPendingApprovedIntents(root) {
  * @returns {{ ok: boolean, intentId?: string, intent?: object, error?: string }}
  */
 export function consumeNextApprovedIntent(root, options = {}) {
-  const queued = findNextDispatchableIntent(root);
+  let runId = options.run_id || null;
+  if (!runId) {
+    try {
+      const context = loadProjectContext(root);
+      const state = context ? loadProjectState(root, context.config) : null;
+      runId = state?.run_id || null;
+    } catch {
+      runId = null;
+    }
+  }
+
+  if (runId && options.auto_archive_stale !== false) {
+    archiveStaleIntents(root, runId);
+  }
+
+  const queued = findNextDispatchableIntent(root, { run_id: runId });
   if (!queued.ok) {
     return { ok: false, error: queued.error || 'no dispatchable intents' };
   }
@@ -717,6 +816,23 @@ export function approveIntent(root, intentId, options = {}) {
   const reason = options.reason || (previousStatus === 'blocked' ? 're-approved after block resolution' : 'approved for planning');
   const now = nowISO();
 
+  // BUG-34: stamp the current run_id on approval so the intent is scoped to
+  // the run that approved it. Intents without approved_run_id are treated as
+  // legacy/unbound and filtered out by run-scoped queries.
+  if (!intent.approved_run_id) {
+    const statePath = join(root, '.agentxchain', 'state.json');
+    if (existsSync(statePath)) {
+      try {
+        const state = JSON.parse(readFileSync(statePath, 'utf8'));
+        if (state.run_id) {
+          intent.approved_run_id = state.run_id;
+        }
+      } catch {
+        // non-fatal — stamp is best-effort during approval
+      }
+    }
+  }
+
   intent.status = 'approved';
   intent.approved_by = approver;
   intent.updated_at = now;

package/src/lib/recent-event-summary.js

@@ -47,6 +47,11 @@ function describeEvent(eventType, entry) {
       const retryRepo = trimToNull(entry.payload?.repo_id);
       return `${prefix}${eventType}${wsId ? ` ${wsId}` : ''}${retryRepo ? ` (${retryRepo})` : ''}`;
     }
+    case 'coordinator_retry_projection_warning': {
+      const wsIdWarn = trimToNull(entry.payload?.workstream_id);
+      const warnRepo = trimToNull(entry.payload?.repo_id);
+      return `${prefix}${eventType}${wsIdWarn ? ` ${wsIdWarn}` : ''}${warnRepo ? ` (${warnRepo})` : ''} — reconciliation required`;
+    }
     case 'turn_checkpointed':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;
     case 'dispatch_progress':

package/src/lib/run-events.js

@@ -23,6 +23,7 @@ export const VALID_RUN_EVENTS = [
   'turn_reissued',
   'turn_checkpointed',
   'coordinator_retry',
+  'coordinator_retry_projection_warning',
   'run_blocked',
   'run_completed',
   'escalation_raised',