agentxchain 2.134.1 → 2.135.1

package/bin/agentxchain.js

@@ -530,6 +530,8 @@ missionPlanCmd
   .option('-m, --mission <mission_id>', 'Explicit mission ID')
   .option('--max-waves <n>', 'Maximum number of dependency waves (default: 10)')
   .option('--continue-on-failure', 'Skip failed workstreams and keep launching ready ones')
+  .option('--auto-retry', 'Coordinator-only: retry one retryable repo-local failure within the same autopilot session')
+  .option('--max-retries <n>', 'Coordinator-only: maximum auto-retries per workstream/repo pair in one autopilot session (default: 1)')
   .option('--cooldown <seconds>', 'Pause between waves in seconds (default: 5)')
   .option('--auto-approve', 'Auto-approve run gates during execution')
   .option('-j, --json', 'Output as JSON')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.134.1",
+  "version": "2.135.1",
   "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/mission.js

@@ -190,6 +190,121 @@ function buildCoordinatorProjectionWarning(message) {
   };
 }
 
+function formatAutoRetryBudgetError(workstreamId, repoId, maxRetries) {
+  return `Auto-retry budget exhausted for ${workstreamId}/${repoId} (max ${maxRetries} per autopilot session).`;
+}
+
+async function executeCoordinatorRetryRun(root, mission, workstreamId, coordinatorConfig, opts = {}) {
+  const retry = retryCoordinatorWorkstream(
+    root,
+    mission,
+    opts.planId,
+    workstreamId,
+    coordinatorConfig,
+    {
+      reason: opts.reason || `mission plan retry ${workstreamId}`,
+    },
+  );
+  if (!retry.ok) {
+    return { ok: false, error: retry.error, plan: opts.plan || null };
+  }
+
+  const executor = opts._executeGovernedRun || executeGovernedRun;
+  const childLog = opts.json ? noop : (opts._log || console.log);
+  const repoContext = loadProjectContext(retry.retryResult.repo_path);
+  if (!repoContext) {
+    return {
+      ok: false,
+      error: `Cannot load project context for retried repo at ${retry.retryResult.repo_path}.`,
+      plan: retry.plan,
+      retryResult: retry.retryResult,
+      launchRecord: retry.launchRecord,
+    };
+  }
+
+  const runOpts = {
+    autoApprove: !!opts.autoApprove,
+    log: childLog,
+    provenance: {
+      trigger: opts.trigger || 'manual',
+      created_by: 'operator',
+      trigger_reason: opts.triggerReasonPrefix
+        ? `${opts.triggerReasonPrefix} repo:${retry.retryResult.repo_id}`
+        : `mission:${mission.mission_id} workstream:${workstreamId} coordinator-retry:${retry.retryResult.repo_id}`,
+    },
+  };
+
+  const retryWarnings = [];
+  let execution;
+  try {
+    execution = await executor(repoContext, runOpts);
+  } catch (error) {
+    const syncedRetryFailure = synchronizeCoordinatorPlanState(root, mission, retry.plan);
+    return {
+      ok: false,
+      error: `Coordinator retry execution failed: ${error.message}`,
+      plan: syncedRetryFailure.ok ? syncedRetryFailure.plan : retry.plan,
+      retryResult: retry.retryResult,
+      launchRecord: retry.launchRecord,
+      warnings: retryWarnings,
+      reconciliation_required: false,
+      exit_code: 1,
+    };
+  }
+
+  if ((execution?.exitCode ?? 0) === 0) {
+    const projection = projectAcceptedCoordinatorTurn(
+      mission.coordinator.workspace_path,
+      coordinatorConfig,
+      retry.retryResult.repo_id,
+      retry.retryResult.reissued_turn_id,
+      workstreamId,
+      loadCoordinatorState(mission.coordinator.workspace_path),
+    );
+    if (!projection.ok) {
+      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: coordinatorConfig?.workstreams?.[workstreamId]?.phase || null,
+        status: 'active',
+        payload: {
+          workstream_id: workstreamId,
+          repo_id: retry.retryResult.repo_id,
+          reissued_turn_id: retry.retryResult.reissued_turn_id,
+          warning_code: warning.code,
+          warning_message: warning.message,
+        },
+      });
+    }
+  }
+
+  const syncedRetry = synchronizeCoordinatorPlanState(root, mission, retry.plan);
+  const retriedPlan = syncedRetry.ok ? syncedRetry.plan : retry.plan;
+  const retriedWorkstream = retriedPlan.workstreams.find((ws) => ws.workstream_id === workstreamId);
+  const retriedLaunchRecord = retriedPlan.launch_records.find(
+    (record) => record.workstream_id === workstreamId && record.dispatch_mode === 'coordinator',
+  ) || retry.launchRecord;
+  const retryCount = retriedLaunchRecord?.repo_dispatches?.filter(
+    (dispatch) => dispatch.repo_id === retry.retryResult.repo_id && dispatch.is_retry,
+  ).length || 0;
+
+  const success = (execution?.exitCode ?? 0) === 0;
+  return {
+    ok: success,
+    error: success ? null : `Coordinator retry execution ended with exit code ${execution?.exitCode ?? 1}.`,
+    plan: retriedPlan,
+    workstream: retriedWorkstream,
+    launchRecord: retriedLaunchRecord,
+    retryResult: retry.retryResult,
+    warnings: retryWarnings,
+    reconciliation_required: retryWarnings.length > 0,
+    exit_code: execution?.exitCode ?? 0,
+    retry_count: retryCount,
+  };
+}
+
 export async function missionListCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
   if (!root) {
@@ -608,100 +723,28 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
     }
 
     if (opts.retry) {
-      const retry = retryCoordinatorWorkstream(
+      const retryExecution = await executeCoordinatorRetryRun(
         root,
         mission,
-        plan.plan_id,
         opts.workstream,
         coordinatorConfigResult.config,
         {
+          ...opts,
+          planId: plan.plan_id,
+          plan,
           reason: `mission plan retry ${opts.workstream}`,
-        },
-      );
-      if (!retry.ok) {
-        console.error(chalk.red(retry.error));
-        process.exit(1);
-      }
-
-      const executor = opts._executeGovernedRun || executeGovernedRun;
-      const childLog = opts.json ? noop : (opts._log || console.log);
-      const repoContext = loadProjectContext(retry.retryResult.repo_path);
-      if (!repoContext) {
-        console.error(chalk.red(`Cannot load project context for retried repo at ${retry.retryResult.repo_path}.`));
-        process.exit(1);
-      }
-
-      const runOpts = {
-        autoApprove: !!opts.autoApprove,
-        log: childLog,
-        provenance: {
           trigger: 'manual',
-          created_by: 'operator',
-          trigger_reason: `mission:${mission.mission_id} workstream:${opts.workstream} coordinator-retry:${retry.retryResult.repo_id}`,
+          triggerReasonPrefix: `mission:${mission.mission_id} workstream:${opts.workstream} coordinator-retry`,
         },
-      };
-
-      let execution;
-      const retryWarnings = [];
-      try {
-        execution = await executor(repoContext, runOpts);
-      } catch (error) {
-        const syncedRetryFailure = synchronizeCoordinatorPlanState(root, mission, retry.plan);
-        console.error(chalk.red(`Coordinator retry execution failed: ${error.message}`));
-        if (opts.json) {
-          console.log(JSON.stringify({
-            dispatch_mode: 'coordinator',
-            retry: true,
-            mission_id: mission.mission_id,
-            plan_id: retry.plan.plan_id,
-            workstream_id: opts.workstream,
-            repo_id: retry.retryResult.repo_id,
-            retried_repo_turn_id: retry.retryResult.failed_turn_id,
-            repo_turn_id: retry.retryResult.reissued_turn_id,
-            workstream_status: syncedRetryFailure.ok
-              ? syncedRetryFailure.plan.workstreams.find((ws) => ws.workstream_id === opts.workstream)?.launch_status || 'needs_attention'
-              : 'needs_attention',
-            launch_record: retry.launchRecord,
-            error: error.message,
-          }, null, 2));
-        }
+      );
+      if (!retryExecution.retryResult) {
+        console.error(chalk.red(retryExecution.error));
         process.exit(1);
       }
 
-      if ((execution?.exitCode ?? 0) === 0) {
-        const projection = projectAcceptedCoordinatorTurn(
-          mission.coordinator.workspace_path,
-          coordinatorConfigResult.config,
-          retry.retryResult.repo_id,
-          retry.retryResult.reissued_turn_id,
-          opts.workstream,
-          loadCoordinatorState(mission.coordinator.workspace_path),
-        );
-        if (!projection.ok) {
-          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,
-            },
-          });
-        }
-      }
-
-      const syncedRetry = synchronizeCoordinatorPlanState(root, mission, retry.plan);
-      const retriedPlan = syncedRetry.ok ? syncedRetry.plan : retry.plan;
-      const retriedWorkstream = retriedPlan.workstreams.find((ws) => ws.workstream_id === opts.workstream);
-      const retriedLaunchRecord = retriedPlan.launch_records.find(
-        (record) => record.workstream_id === opts.workstream && record.dispatch_mode === 'coordinator',
-      ) || retry.launchRecord;
+      const retriedPlan = retryExecution.plan;
+      const retriedWorkstream = retryExecution.workstream;
+      const retriedLaunchRecord = retryExecution.launchRecord;
 
       if (opts.json) {
         console.log(JSON.stringify({
@@ -711,41 +754,41 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
           plan_id: retriedPlan.plan_id,
           workstream_id: opts.workstream,
           super_run_id: mission.coordinator.super_run_id,
-          repo_id: retry.retryResult.repo_id,
-          retried_repo_turn_id: retry.retryResult.failed_turn_id,
-          repo_turn_id: retry.retryResult.reissued_turn_id,
-          role: retry.retryResult.role,
-          bundle_path: retry.retryResult.bundle_path,
-          context_ref: retry.retryResult.context_ref,
+          repo_id: retryExecution.retryResult.repo_id,
+          retried_repo_turn_id: retryExecution.retryResult.failed_turn_id,
+          repo_turn_id: retryExecution.retryResult.reissued_turn_id,
+          role: retryExecution.retryResult.role,
+          bundle_path: retryExecution.retryResult.bundle_path,
+          context_ref: retryExecution.retryResult.context_ref,
           workstream_status: retriedWorkstream?.launch_status || 'launched',
           launch_record: retriedLaunchRecord,
-          exit_code: execution?.exitCode ?? 0,
-          warnings: retryWarnings,
-          reconciliation_required: retryWarnings.length > 0,
+          exit_code: retryExecution.exit_code ?? 0,
+          warnings: retryExecution.warnings || [],
+          reconciliation_required: retryExecution.reconciliation_required || false,
         }, null, 2));
-        if ((execution?.exitCode ?? 0) !== 0) {
-          process.exit(execution.exitCode);
+        if (!retryExecution.ok) {
+          process.exit(retryExecution.exit_code || 1);
         }
         return;
       }
 
-      console.log(chalk.green(`Retried coordinator workstream ${chalk.bold(opts.workstream)} in ${chalk.bold(retry.retryResult.repo_id)}`));
+      console.log(chalk.green(`Retried coordinator workstream ${chalk.bold(opts.workstream)} in ${chalk.bold(retryExecution.retryResult.repo_id)}`));
       console.log('');
       console.log(chalk.dim(`  Mission:      ${mission.mission_id}`));
       console.log(chalk.dim(`  Plan:         ${retriedPlan.plan_id}`));
       console.log(chalk.dim(`  Super Run:    ${mission.coordinator.super_run_id}`));
-      console.log(chalk.dim(`  Repo:         ${retry.retryResult.repo_id}`));
-      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(`  Repo:         ${retryExecution.retryResult.repo_id}`));
+      console.log(chalk.dim(`  Old Turn:     ${retryExecution.retryResult.failed_turn_id}`));
+      console.log(chalk.dim(`  New Turn:     ${retryExecution.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}`));
+      if ((retryExecution.warnings || []).length > 0) {
+        console.log(chalk.yellow(`  Warning:      ${retryExecution.warnings[0].message}`));
       }
       console.log('');
       renderPlan(retriedPlan);
-      if ((execution?.exitCode ?? 0) !== 0) {
-        console.error(chalk.red(`Coordinator retry execution ended with exit code ${execution.exitCode}.`));
-        process.exit(execution.exitCode);
+      if (!retryExecution.ok) {
+        console.error(chalk.red(retryExecution.error));
+        process.exit(retryExecution.exit_code || 1);
       }
       return;
     }
@@ -1119,6 +1162,11 @@ export async function missionPlanAutopilotCommand(planTarget, opts) {
     process.exit(1);
   }
 
+  if (opts.autoRetry && !mission.coordinator) {
+    console.error(chalk.red('--auto-retry is only supported for coordinator-bound missions.'));
+    process.exit(1);
+  }
+
   if (mission.coordinator) {
     return coordinatorAutopilot(planTarget, opts, context, mission);
   }
@@ -1766,14 +1814,25 @@ async function coordinatorAutopilot(planTarget, opts, context, mission) {
 
   const maxWaves = Math.max(1, parseInt(opts.maxWaves, 10) || 10);
   const cooldownSeconds = Math.max(0, parseInt(opts.cooldown, 10) || 5);
+  const autoRetryEnabled = !!opts.autoRetry;
+  const parsedMaxRetries = Number.parseInt(opts.maxRetries, 10);
+  const maxRetries = autoRetryEnabled
+    ? (Number.isFinite(parsedMaxRetries) ? parsedMaxRetries : 1)
+    : 0;
+  if (autoRetryEnabled && maxRetries < 1) {
+    console.error(chalk.red('--max-retries must be >= 1 when --auto-retry is set.'));
+    process.exit(1);
+  }
   const sleep = opts._sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
 
   const waves = [];
   let totalLaunched = 0;
   let totalCompleted = 0;
   let totalFailed = 0;
+  let totalRetries = 0;
   let terminalReason = null;
   let interrupted = false;
+  const retryCounts = new Map();
 
   const onSigint = () => { interrupted = true; };
   process.on('SIGINT', onSigint);
@@ -1848,6 +1907,92 @@ async function coordinatorAutopilot(planTarget, opts, context, mission) {
         totalLaunched++;
 
         if (result.status === 'needs_attention') {
+          if (autoRetryEnabled && result.repo_id) {
+            const retryKey = `${ws.workstream_id}:${result.repo_id}`;
+            const usedRetries = retryCounts.get(retryKey) || 0;
+
+            if (usedRetries < maxRetries) {
+              retryCounts.set(retryKey, usedRetries + 1);
+
+              const retryExecution = await executeCoordinatorRetryRun(
+                root,
+                mission,
+                ws.workstream_id,
+                coord.config,
+                {
+                  ...opts,
+                  planId: plan.plan_id,
+                  plan,
+                  trigger: 'autopilot',
+                  triggerReasonPrefix: `mission:${mission.mission_id} workstream:${ws.workstream_id} autopilot:wave-${waveNum} auto-retry`,
+                  reason: `mission autopilot auto-retry ${ws.workstream_id}/${result.repo_id}`,
+                },
+              );
+
+              if (retryExecution.plan) {
+                plan = retryExecution.plan;
+              }
+              if (retryExecution.retryResult) {
+                totalRetries++;
+              }
+
+              if (retryExecution.ok) {
+                totalCompleted++;
+                waveResults.push({
+                  workstream_id: ws.workstream_id,
+                  status: 'dispatched',
+                  repo_id: retryExecution.retryResult.repo_id,
+                  turn_id: retryExecution.retryResult.reissued_turn_id,
+                  retried: true,
+                  retry_count: retryExecution.retry_count,
+                  retried_repo_turn_id: retryExecution.retryResult.failed_turn_id,
+                  warnings: retryExecution.warnings || [],
+                  reconciliation_required: retryExecution.reconciliation_required || false,
+                });
+                if (!opts.json) {
+                  console.log(chalk.green(`→ ${retryExecution.retryResult.repo_id} retried ✓`));
+                }
+                continue;
+              }
+
+              waveHadFailure = true;
+              totalFailed++;
+              waveResults.push({
+                workstream_id: ws.workstream_id,
+                status: 'needs_attention',
+                repo_id: retryExecution.retryResult?.repo_id || result.repo_id,
+                turn_id: retryExecution.retryResult?.reissued_turn_id || result.turn_id,
+                retried: Boolean(retryExecution.retryResult),
+                retry_count: retryExecution.retry_count || usedRetries + 1,
+                retried_repo_turn_id: retryExecution.retryResult?.failed_turn_id || result.turn_id,
+                error: retryExecution.error,
+                warnings: retryExecution.warnings || [],
+                reconciliation_required: retryExecution.reconciliation_required || false,
+              });
+              if (!opts.json) {
+                console.log(chalk.red(`→ ${result.repo_id} auto-retry failed ✗ (${retryExecution.error})`));
+              }
+              continue;
+            }
+
+            waveHadFailure = true;
+            totalFailed++;
+            const budgetError = formatAutoRetryBudgetError(ws.workstream_id, result.repo_id, maxRetries);
+            waveResults.push({
+              workstream_id: ws.workstream_id,
+              status: 'needs_attention',
+              repo_id: result.repo_id,
+              turn_id: result.turn_id,
+              retry_budget_exhausted: true,
+              retry_count: usedRetries,
+              error: budgetError,
+            });
+            if (!opts.json) {
+              console.log(chalk.red(`→ ${result.repo_id} needs_attention ✗ (${budgetError})`));
+            }
+            continue;
+          }
+
           waveHadFailure = true;
           totalFailed++;
           waveResults.push({ workstream_id: ws.workstream_id, status: 'needs_attention', repo_id: result.repo_id, turn_id: result.turn_id });
@@ -1917,6 +2062,7 @@ async function coordinatorAutopilot(planTarget, opts, context, mission) {
       total_launched: totalLaunched,
       completed: totalCompleted,
       failed: totalFailed,
+      total_retries: totalRetries,
       terminal_reason: terminalReason,
     },
   };
@@ -1930,6 +2076,7 @@ async function coordinatorAutopilot(planTarget, opts, context, mission) {
     console.log(`  Launched:   ${totalLaunched}`);
     console.log(`  Completed:  ${totalCompleted}`);
     console.log(`  Failed:     ${totalFailed}`);
+    console.log(`  Retries:    ${totalRetries}`);
     console.log(`  Outcome:    ${formatTerminalReason(terminalReason)}`);
     if (terminalReason === 'plan_completed') {
       console.log(chalk.green('\n  Plan completed successfully.'));

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

@@ -147,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)

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/context-section-parser.js

@@ -10,6 +10,8 @@ const SECTION_DEFINITIONS = [
   { id: 'last_turn_summary', header: null, required: false },
   { id: 'last_turn_decisions', header: null, required: false },
   { id: 'last_turn_objections', header: null, required: false },
+  { id: 'last_turn_files_changed', header: null, required: false },
+  { id: 'last_turn_changed_file_previews', header: null, required: false },
   { id: 'last_turn_verification', header: null, required: false },
   { id: 'decision_history', header: 'Decision History', required: false },
   { id: 'blockers', header: 'Blockers', required: true },
@@ -54,6 +56,8 @@ export function parseContextSections(contextMd) {
       summaryLines,
       decisionsLines,
       objectionsLines,
+      filesChangedLines,
+      changedFilePreviewLines,
       verificationLines,
     } = splitLastAcceptedTurn(lastAcceptedTurnBody);
 
@@ -61,6 +65,8 @@ export function parseContextSections(contextMd) {
     pushSection(parsedSections, 'last_turn_summary', summaryLines);
     pushSection(parsedSections, 'last_turn_decisions', decisionsLines);
     pushSection(parsedSections, 'last_turn_objections', objectionsLines);
+    pushSection(parsedSections, 'last_turn_files_changed', filesChangedLines);
+    pushSection(parsedSections, 'last_turn_changed_file_previews', changedFilePreviewLines);
     pushSection(parsedSections, 'last_turn_verification', verificationLines);
   }
 
@@ -91,6 +97,8 @@ export function renderContextSections(sections) {
     sectionMap.get('last_turn_summary')?.content,
     sectionMap.get('last_turn_decisions')?.content,
     sectionMap.get('last_turn_objections')?.content,
+    sectionMap.get('last_turn_files_changed')?.content,
+    sectionMap.get('last_turn_changed_file_previews')?.content,
     sectionMap.get('last_turn_verification')?.content,
   ]);
 
@@ -157,6 +165,8 @@ function splitLastAcceptedTurn(lines) {
   let summaryLines = [];
   let decisionsLines = [];
   let objectionsLines = [];
+  let filesChangedLines = [];
+  let changedFilePreviewLines = [];
   let verificationLines = [];
 
   let inVerification = false;
@@ -200,6 +210,20 @@ function splitLastAcceptedTurn(lines) {
       continue;
     }
 
+    if (line.startsWith('### Files Changed')) {
+      const { blockLines, nextIndex } = consumeLevel3Block(lines, index);
+      filesChangedLines = blockLines;
+      index = nextIndex - 1;
+      continue;
+    }
+
+    if (line.startsWith('### Changed File Previews')) {
+      const { blockLines, nextIndex } = consumeLevel3Block(lines, index);
+      changedFilePreviewLines = blockLines;
+      index = nextIndex - 1;
+      continue;
+    }
+
     headerLines.push(line);
   }
 
@@ -208,6 +232,8 @@ function splitLastAcceptedTurn(lines) {
     summaryLines: trimBlankLines(summaryLines),
     decisionsLines: trimBlankLines(decisionsLines),
     objectionsLines: trimBlankLines(objectionsLines),
+    filesChangedLines: trimBlankLines(filesChangedLines),
+    changedFilePreviewLines: trimBlankLines(changedFilePreviewLines),
     verificationLines: trimBlankLines(verificationLines),
   };
 }
@@ -232,6 +258,32 @@ function consumeIndentedBlock(lines, startIndex) {
   };
 }
 
+function consumeLevel3Block(lines, startIndex) {
+  const blockLines = [lines[startIndex]];
+  let index = startIndex + 1;
+  let inCodeBlock = false;
+
+  while (index < lines.length) {
+    const line = lines[index];
+
+    if (line.startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+    }
+
+    if (!inCodeBlock && line.startsWith('### ')) {
+      break;
+    }
+
+    blockLines.push(line);
+    index += 1;
+  }
+
+  return {
+    blockLines: trimBlankLines(blockLines),
+    nextIndex: index,
+  };
+}
+
 function pushSection(target, id, lines) {
   const normalizedLines = trimBlankLines(lines || []);
   if (!normalizedLines.length) return;

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/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/gate-evaluator.js

@@ -85,6 +85,15 @@ function addMissingFile(result, filePath) {
   }
 }
 
+function addFailingFile(result, filePath) {
+  if (!filePath) {
+    return;
+  }
+  if (!result.failing_files.includes(filePath)) {
+    result.failing_files.push(filePath);
+  }
+}
+
 function prefixSemanticReason(filePath, reason) {
   if (!reason || reason.includes(filePath)) {
     return reason;
@@ -111,6 +120,7 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
     if (!existsSync(absPath)) {
       if (artifact.required) {
         addMissingFile(result, artifact.path);
+        addFailingFile(result, artifact.path);
         failures.push(`Required file missing: ${artifact.path}`);
       }
       continue;
@@ -119,6 +129,7 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
     if (artifact.useLegacySemantics) {
       const semanticCheck = evaluateWorkflowGateSemantics(root, artifact.path);
       if (semanticCheck && !semanticCheck.ok) {
+        addFailingFile(result, artifact.path);
         failures.push(semanticCheck.reason);
       }
     }
@@ -130,12 +141,14 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
         semantics_config: semantic.semantics_config,
       });
       if (semanticCheck && !semanticCheck.ok) {
+        addFailingFile(result, artifact.path);
         failures.push(prefixSemanticReason(artifact.path, semanticCheck.reason));
       }
     }
 
     // Charter enforcement: verify owning role participated in this phase
     if (artifact.owned_by && !hasRoleParticipationInPhase(state, phase, artifact.owned_by)) {
+      addFailingFile(result, artifact.path);
       failures.push(
         `"${artifact.path}" requires participation from role "${artifact.owned_by}" in phase "${phase}", but no accepted turn from that role was found`,
       );
@@ -161,11 +174,12 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
  * @property {boolean} blocked_by_human_approval - gate passed structurally but needs human sign-off
  * @property {string[]} reasons - human-readable failure reasons
  * @property {string[]} missing_files - files required by gate but not found
+ * @property {string[]} failing_files - files tied to gate failures
  * @property {boolean} missing_verification - verification required but not passed
  * @property {string|null} next_phase - the target phase if transition was requested and gate passed
  * @property {string|null} transition_request - the raw phase_transition_request value
  * @property {'no_request'|'unknown_phase'|'gate_failed'|'advance'|'awaiting_human_approval'|'no_gate'} action
- */
+*/
 export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
   const currentPhase = state.phase;
   const transitionRequest = acceptedTurn.phase_transition_request || null;
@@ -176,6 +190,7 @@ export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
     blocked_by_human_approval: false,
     reasons: [],
     missing_files: [],
+    failing_files: [],
     missing_verification: false,
     next_phase: null,
     transition_request: transitionRequest,
@@ -303,6 +318,7 @@ export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
  * @property {boolean} blocked_by_human_approval - gate passed structurally but needs human sign-off
  * @property {string[]} reasons - human-readable failure reasons
  * @property {string[]} missing_files - files required by gate but not found
+ * @property {string[]} failing_files - files tied to gate failures
  * @property {boolean} missing_verification - verification required but not passed
  * @property {'no_request'|'not_final_phase'|'gate_failed'|'complete'|'awaiting_human_approval'} action
  */
@@ -313,6 +329,7 @@ export function evaluateRunCompletion({ state, config, acceptedTurn, root }) {
     blocked_by_human_approval: false,
     reasons: [],
     missing_files: [],
+    failing_files: [],
     missing_verification: false,
     action: 'no_request',
   };

package/src/lib/governed-state.js

@@ -2049,6 +2049,7 @@ export function reactivateGovernedRun(root, state, details = {}) {
 
   const now = new Date().toISOString();
   const wasEscalation = state.status === 'blocked' && typeof state.blocked_on === 'string' && state.blocked_on.startsWith('escalation:');
+  const wasNonProgress = state.blocked_on === 'non_progress';
   const humanEscalation = findCurrentHumanEscalation(root, state);
   const nextState = {
     ...state,
@@ -2058,6 +2059,12 @@ export function reactivateGovernedRun(root, state, details = {}) {
     escalation: null,
   };
 
+  // BUG-38: reset non-progress tracking when acknowledging non-progress block
+  if (wasNonProgress || details.acknowledge_non_progress) {
+    nextState.non_progress_signature = null;
+    nextState.non_progress_count = 0;
+  }
+
   writeState(root, nextState);
 
   if (humanEscalation) {
@@ -2154,13 +2161,76 @@ export function initializeGovernedRun(root, config, options = {}) {
   };
 
   writeState(root, updatedState);
+
+  // BUG-34 + BUG-39: retroactive migration — archive stale intents from prior runs.
+  // Intents with an approved_run_id from a DIFFERENT run are archived (BUG-34).
+  // BUG-39: Intents with approved_run_id: null are pre-BUG-34 legacy files that
+  // must be archived with status "archived_migration", NOT adopted into the current
+  // run. Silently adopting them caused continuous mode to pick up stale intents.
+  const archivedMigrationIntentIds = [];
+  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;
+
+          const prevStatus = intent.status;
+          if (intent.approved_run_id && intent.approved_run_id !== runId) {
+            // Intent from a different run — archive it (BUG-34)
+            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: prevStatus, to: 'suppressed', at: intNow, reason: intent.archived_reason });
+          } else if (!intent.approved_run_id) {
+            // BUG-39: pre-BUG-34 legacy intent with no run binding — archive it
+            // with explicit migration reason. Do NOT adopt into current run.
+            intent.status = 'archived_migration';
+            intent.updated_at = intNow;
+            intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during v${updatedState.protocol_version || '2.x'} migration on run ${runId}`;
+            if (!intent.history) intent.history = [];
+            intent.history.push({ from: prevStatus, to: 'archived_migration', at: intNow, reason: intent.archived_reason });
+            if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
+          }
+          safeWriteJson(ip, intent);
+        } catch { /* non-fatal per-intent */ }
+      }
+    }
+  } catch { /* non-fatal — intent migration is best-effort */ }
+
+  // BUG-39: emit intents_migrated event when pre-BUG-34 intents were archived
+  if (archivedMigrationIntentIds.length > 0) {
+    emitRunEvent(root, 'intents_migrated', {
+      run_id: runId,
+      phase: updatedState.phase,
+      status: 'active',
+      payload: {
+        archived_count: archivedMigrationIntentIds.length,
+        archived_intent_ids: archivedMigrationIntentIds,
+        reason: 'pre-BUG-34 intents with approved_run_id: null archived during run initialization',
+      },
+    });
+  }
+
   emitRunEvent(root, 'run_started', {
     run_id: runId,
     phase: updatedState.phase,
     status: 'active',
     payload: { provenance: provenance || {} },
   });
-  return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState) };
+  // BUG-39: return migration notice so callers can display it
+  const migrationNotice = archivedMigrationIntentIds.length > 0
+    ? `Archived ${archivedMigrationIntentIds.length} pre-BUG-34 intent(s). Review: agentxchain intake status --archived.`
+    : null;
+
+  return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState), migration_notice: migrationNotice };
 }
 
 /**
@@ -3107,6 +3177,58 @@ 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';
+      const uniqueFailingFiles = [...new Set(
+        (preGateResult.failing_files || preGateResult.missing_files || [])
+          .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';
@@ -4107,6 +4229,118 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // ── BUG-38: Non-progress convergence guard ─────────────────────────────
+  // Track whether consecutive accepted turns leave the same gate failure
+  // intact without modifying the gated files. When the count reaches the
+  // configurable threshold, block the run to prevent infinite loops.
+  // Proactively evaluates the current phase exit gate on every accepted turn
+  // — not just when a transition is requested — to detect stalled patterns.
+  if (updatedState.status === 'active') {
+    const declaredFiles = new Set((turnResult.files_changed || []).map(f => f.replace(/^\.\//, '')));
+    const npThreshold = config.run_loop?.non_progress_threshold ?? 3;
+
+    // Proactively evaluate the exit gate for the current phase.
+    // evaluatePhaseExit requires a phase_transition_request, so we synthesize
+    // one pointing to the next phase from routing for probing purposes.
+    let proactiveGateFailure = null;
+    try {
+      const currentRouting = config.routing?.[updatedState.phase];
+      if (currentRouting?.exit_gate) {
+        // Find the next phase to use as synthetic transition target
+        const phases = config.phases || [];
+        const currentIdx = phases.findIndex(p => p.id === updatedState.phase);
+        const nextPhaseId = currentIdx >= 0 && currentIdx < phases.length - 1
+          ? phases[currentIdx + 1].id
+          : (currentRouting.allowed_next_roles ? Object.keys(config.routing).find(k => k !== updatedState.phase) : null);
+
+        if (nextPhaseId) {
+          const probeTurn = { ...turnResult, phase_transition_request: nextPhaseId };
+          const probeResult = evaluatePhaseExit({
+            state: updatedState,
+            config,
+            acceptedTurn: probeTurn,
+            root,
+          });
+          if (probeResult.action === 'gate_failed') {
+            proactiveGateFailure = probeResult;
+          }
+        }
+      }
+    } catch { /* non-fatal — probe is advisory */ }
+
+    // Fall back to last_gate_failure if proactive evaluation didn't find one
+    const effectiveGateFailure = proactiveGateFailure || updatedState.last_gate_failure;
+
+    if (effectiveGateFailure && (effectiveGateFailure.gate_id || effectiveGateFailure.gate_type)) {
+      const gateId = effectiveGateFailure.gate_id || effectiveGateFailure.gate_type || 'unknown';
+      // Compute gate failure signature: gate_id + sorted failing files + sorted reasons
+      const failingFiles = [...(effectiveGateFailure.missing_files || effectiveGateFailure.failing_files || [])].sort();
+      const reasons = [...(effectiveGateFailure.reasons || [])].sort();
+      const signature = `${gateId}::${failingFiles.join(',')}::${reasons.join(',')}`;
+
+      // Check if any of the gated files were modified by this turn
+      const gatedFilesModified = failingFiles.some(f => declaredFiles.has(f.replace(/^\.\//, '')));
+
+      const prevSignature = state.non_progress_signature || null;
+      const prevCount = state.non_progress_count || 0;
+
+      if (signature === prevSignature && !gatedFilesModified) {
+        // Same gate failure, gated files untouched — increment counter
+        const newCount = prevCount + 1;
+        updatedState.non_progress_signature = signature;
+        updatedState.non_progress_count = newCount;
+
+        if (newCount >= npThreshold) {
+          // Threshold reached — block the run
+          updatedState.status = 'blocked';
+          updatedState.blocked_on = 'non_progress';
+          updatedState.blocked_reason = buildBlockedReason({
+            category: 'non_progress',
+            recovery: {
+              typed_reason: `Non-progress detected: ${newCount} accepted turns have not reduced gate failure "${gateId}".`,
+              recovery_action: 'agentxchain resume --acknowledge-non-progress',
+              detail: `Gate "${gateId}" has been failing on ${failingFiles.join(', ')} for ${newCount} consecutive turns. The gated file(s) were never modified.`,
+            },
+            turnId: currentTurn.turn_id,
+            blockedAt: now,
+          });
+
+          ledgerEntries.push({
+            type: 'non_progress_block',
+            gate_id: gateId,
+            consecutive_turns: newCount,
+            threshold: npThreshold,
+            failing_files: failingFiles,
+            signature,
+            timestamp: now,
+          });
+
+          emitRunEvent(root, 'run_stalled', {
+            run_id: updatedState.run_id,
+            phase: updatedState.phase,
+            status: 'blocked',
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            payload: {
+              consecutive_non_progress_turns: newCount,
+              threshold: npThreshold,
+              gate_id: gateId,
+              failing_files: failingFiles,
+              signature,
+            },
+          });
+        }
+      } else {
+        // Gate failure changed or gated files were modified — reset counter
+        updatedState.non_progress_signature = signature;
+        updatedState.non_progress_count = 1;
+      }
+    } else {
+      // No gate failure — reset non-progress tracking
+      updatedState.non_progress_signature = null;
+      updatedState.non_progress_count = 0;
+    }
+  }
+
   // ── Transaction journal: prepare before committing writes ──────────────
   const transactionId = generateId('txn');
   const journal = {

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,64 @@ 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) {
+      // BUG-39: pre-BUG-34 legacy intent with no run binding — archive it
+      // with explicit migration reason. Do NOT adopt into current run.
+      const prevStatus = intent.status;
+      intent.status = 'archived_migration';
+      intent.updated_at = now;
+      intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during migration on run ${newRunId}`;
+      if (!intent.history) intent.history = [];
+      intent.history.push({ from: prevStatus, to: 'archived_migration', at: now, reason: intent.archived_reason });
+      safeWriteJson(intentPath, intent);
+      archived++;
+    }
+  }
+
+  return { archived, adopted };
+}
+
 /**
  * Unified intent consumption entry point (BUG-16).
  * Both manual (resume/step --resume) and continuous/scheduler paths should call
@@ -584,7 +673,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 +821,29 @@ 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/39: stamp the current run_id on approval so the intent is scoped
+  // to the run that approved it. When approval happens before any governed
+  // run exists, mark the intent as cross_run_durable so the next run init
+  // preserves this freshly approved work instead of archiving it as legacy
+  // migration debt.
+  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;
+        } else {
+          intent.cross_run_durable = true;
+        }
+      } catch {
+        // non-fatal — stamp is best-effort during approval
+      }
+    } else {
+      intent.cross_run_durable = true;
+    }
+  }
+
   intent.status = 'approved';
   intent.approved_by = approver;
   intent.updated_at = now;

package/src/lib/normalized-config.js

@@ -1178,6 +1178,11 @@ export function normalizeV4(raw) {
       state: '.agentxchain/state.json',
       log: null,
     },
+    // Passthrough fields — these are runtime behavior overrides that don't
+    // need normalization but must survive the config pipeline.
+    ...(raw.gate_semantic_coverage_mode ? { gate_semantic_coverage_mode: raw.gate_semantic_coverage_mode } : {}),
+    ...(raw.intent_coverage_mode ? { intent_coverage_mode: raw.intent_coverage_mode } : {}),
+    ...(raw.run_loop ? { run_loop: raw.run_loop } : {}),
     compat: {
       next_owner_source: 'state-json',
       lock_based_coordination: false,