agentxchain 2.135.0 → 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.135.0",
+  "version": "2.135.1",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

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/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/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) {
@@ -2155,10 +2162,12 @@ 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).
+  // 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)) {
@@ -2172,17 +2181,23 @@ export function initializeGovernedRun(root, config, options = {}) {
           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
+            // 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: 'approved', to: 'suppressed', at: intNow, reason: intent.archived_reason });
+            intent.history.push({ from: prevStatus, 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;
+            // 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 */ }
@@ -2190,13 +2205,32 @@ export function initializeGovernedRun(root, config, options = {}) {
     }
   } 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 };
 }
 
 /**
@@ -3160,22 +3194,10 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       // 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 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';
@@ -4207,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

@@ -647,11 +647,16 @@ export function archiveStaleIntents(root, newRunId) {
       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;
+      // 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);
-      adopted++;
+      archived++;
     }
   }
 
@@ -816,9 +821,11 @@ 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.
+  // 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)) {
@@ -826,10 +833,14 @@ export function approveIntent(root, intentId, options = {}) {
         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;
     }
   }
 

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,