agentxchain 2.135.0 → 2.136.0

package/bin/agentxchain.js

@@ -123,7 +123,7 @@ import { historyCommand } from '../src/commands/history.js';
 import { decisionsCommand } from '../src/commands/decisions.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { eventsCommand } from '../src/commands/events.js';
-import { connectorCheckCommand, connectorValidateCommand } from '../src/commands/connector.js';
+import { connectorCapabilitiesCommand, connectorCheckCommand, connectorValidateCommand } from '../src/commands/connector.js';
 import { scheduleDaemonCommand, scheduleListCommand, scheduleRunDueCommand, scheduleStatusCommand } from '../src/commands/schedule.js';
 import { chainLatestCommand, chainListCommand, chainShowCommand } from '../src/commands/chain.js';
 import { missionAttachChainCommand, missionBindCoordinatorCommand, missionListCommand, missionPlanApproveCommand, missionPlanAutopilotCommand, missionPlanCommand, missionPlanLaunchCommand, missionPlanListCommand, missionPlanShowCommand, missionShowCommand, missionStartCommand } from '../src/commands/mission.js';
@@ -299,6 +299,13 @@ connectorCmd
   .option('--timeout <ms>', 'Per-probe timeout in milliseconds', '8000')
   .action(connectorCheckCommand);
 
+connectorCmd
+  .command('capabilities [runtime_id]')
+  .description('Show merged capability contract for a runtime or all runtimes (machine-readable handshake)')
+  .option('-j, --json', 'Output as JSON')
+  .option('--all', 'Show capabilities for all configured runtimes')
+  .action(connectorCapabilitiesCommand);
+
 connectorCmd
   .command('validate <runtime_id>')
   .description('Dispatch one synthetic governed turn through a runtime and validate the staged turn result')
@@ -530,6 +537,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.136.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {
@@ -10,7 +10,9 @@
     ".": "./bin/agentxchain.js",
     "./adapter-interface": "./src/lib/adapter-interface.js",
     "./runner-interface": "./src/lib/runner-interface.js",
-    "./run-loop": "./src/lib/run-loop.js"
+    "./run-loop": "./src/lib/run-loop.js",
+    "./schemas/agentxchain-config": "./src/lib/schemas/agentxchain-config.schema.json",
+    "./schemas/connector-capabilities-output": "./src/lib/schemas/connector-capabilities-output.schema.json"
   },
   "files": [
     "bin/",

package/scripts/release-preflight.sh

@@ -154,6 +154,8 @@ if [[ "$PUBLISH_GATE" -eq 1 ]]; then
     test/release-identity-hardening.test.js
     test/normalized-config.test.js
     test/conformance.test.js
+    test/beta-scenario-emission-guard.test.js
+    test/claim-reality-preflight.test.js
     test/beta-tester-scenarios/*.test.js
   )
   GATE_TEST_ARGS=()

package/src/commands/connector.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { loadProjectContext } from '../lib/config.js';
 import { DEFAULT_VALIDATE_TIMEOUT_MS, validateConfiguredConnector } from '../lib/connector-validate.js';
 import { DEFAULT_TIMEOUT_MS, probeConfiguredConnectors } from '../lib/connector-probe.js';
+import { getRuntimeCapabilityContract, getRoleRuntimeCapabilityContract, getCapabilityDeclarationWarnings } from '../lib/runtime-capabilities.js';
 
 function printJson(result, exitCode) {
   console.log(JSON.stringify(result, null, 2));
@@ -192,6 +193,141 @@ function printValidateText(result, exitCode) {
   process.exit(exitCode);
 }
 
+function buildCapabilityReport(runtimeId, runtime, roles) {
+  const mergedContract = getRuntimeCapabilityContract(runtime);
+  const declaredCapabilities = (runtime.capabilities && typeof runtime.capabilities === 'object' && !Array.isArray(runtime.capabilities))
+    ? { ...runtime.capabilities }
+    : {};
+  const declarationWarnings = getCapabilityDeclarationWarnings(runtime);
+
+  const roleBindings = [];
+  for (const [roleId, role] of Object.entries(roles)) {
+    const boundRuntime = role.runtime_id || role.runtime;
+    if (boundRuntime !== runtimeId) continue;
+    const roleContract = getRoleRuntimeCapabilityContract(roleId, role, runtime);
+    roleBindings.push({
+      role_id: roleContract.role_id,
+      role_write_authority: roleContract.role_write_authority,
+      effective_write_path: roleContract.effective_write_path,
+      workflow_artifact_ownership: roleContract.workflow_artifact_ownership,
+      notes: roleContract.notes,
+    });
+  }
+
+  return {
+    runtime_id: runtimeId,
+    runtime_type: runtime.type || 'unknown',
+    declared_capabilities: declaredCapabilities,
+    merged_contract: mergedContract,
+    declaration_warnings: declarationWarnings,
+    role_bindings: roleBindings,
+  };
+}
+
+function printCapabilitiesText(report) {
+  console.log('');
+  console.log(chalk.bold(`  ${report.runtime_id}`) + chalk.dim(` (${report.runtime_type})`));
+  console.log(chalk.dim('  ' + '-'.repeat(44)));
+
+  const c = report.merged_contract;
+  console.log(`  ${chalk.dim('Transport:')}         ${c.transport}`);
+  console.log(`  ${chalk.dim('Write files:')}       ${c.can_write_files}`);
+  console.log(`  ${chalk.dim('Proposals:')}         ${c.proposal_support}`);
+  console.log(`  ${chalk.dim('Artifact ownership:')} ${c.workflow_artifact_ownership}`);
+  console.log(`  ${chalk.dim('Local binary:')}      ${c.requires_local_binary ? 'yes' : 'no'}`);
+
+  if (Object.keys(report.declared_capabilities).length > 0) {
+    console.log('');
+    console.log(`  ${chalk.dim('Declared overrides:')}`);
+    for (const [k, v] of Object.entries(report.declared_capabilities)) {
+      console.log(`    ${k}: ${v}`);
+    }
+  }
+
+  if (report.declaration_warnings.length > 0) {
+    console.log('');
+    for (const w of report.declaration_warnings) {
+      console.log(`  ${chalk.yellow('!')} ${w}`);
+    }
+  }
+
+  if (report.role_bindings.length > 0) {
+    console.log('');
+    console.log(`  ${chalk.dim('Role bindings:')}`);
+    for (const rb of report.role_bindings) {
+      const badge = rb.effective_write_path.startsWith('invalid') ? chalk.red('INVALID') : chalk.green('OK');
+      console.log(`    ${badge}  ${rb.role_id} (${rb.role_write_authority}) -> ${rb.effective_write_path}`);
+      for (const note of rb.notes) {
+        console.log(`         ${chalk.dim(note)}`);
+      }
+    }
+  }
+}
+
+export async function connectorCapabilitiesCommand(runtimeId, options = {}) {
+  const context = loadProjectContext();
+  if (!context) {
+    const payload = { error: 'No governed agentxchain.json found.' };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red('No governed agentxchain.json found. Run this inside a governed project.'));
+    process.exit(2);
+  }
+
+  const config = context.config;
+  const runtimes = config.runtimes || {};
+  const roles = config.roles || {};
+
+  if (options.all) {
+    const reports = [];
+    for (const [id, runtime] of Object.entries(runtimes)) {
+      reports.push(buildCapabilityReport(id, runtime, roles));
+    }
+    const payload = { runtimes: reports };
+    if (options.json) { printJson(payload, 0); return; }
+
+    console.log('');
+    console.log(chalk.bold('  AgentXchain Connector Capabilities'));
+    console.log(chalk.dim('  ' + '='.repeat(44)));
+    if (reports.length === 0) {
+      console.log('  No runtimes configured.');
+    } else {
+      for (const r of reports) { printCapabilitiesText(r); }
+    }
+    console.log('');
+    process.exit(0);
+  }
+
+  if (!runtimeId) {
+    const payload = { error: 'Runtime ID required. Use --all to list all runtimes.', available_runtimes: Object.keys(runtimes) };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red('Runtime ID required. Use --all to list all runtimes.'));
+    if (Object.keys(runtimes).length > 0) {
+      console.error(chalk.dim(`Available: ${Object.keys(runtimes).join(', ')}`));
+    }
+    process.exit(2);
+  }
+
+  if (!runtimes[runtimeId]) {
+    const payload = { error: `Runtime "${runtimeId}" not found.`, available_runtimes: Object.keys(runtimes) };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red(`Runtime "${runtimeId}" not found.`));
+    if (Object.keys(runtimes).length > 0) {
+      console.error(chalk.dim(`Available: ${Object.keys(runtimes).join(', ')}`));
+    }
+    process.exit(2);
+  }
+
+  const report = buildCapabilityReport(runtimeId, runtimes[runtimeId], roles);
+  if (options.json) { printJson(report, 0); return; }
+
+  console.log('');
+  console.log(chalk.bold('  AgentXchain Connector Capabilities'));
+  console.log(chalk.dim('  ' + '='.repeat(44)));
+  printCapabilitiesText(report);
+  console.log('');
+  process.exit(0);
+}
+
 export async function connectorValidateCommand(runtimeId, options = {}) {
   const context = loadProjectContext();
   if (!context) {

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

@@ -326,6 +326,9 @@ export async function restartCommand(opts) {
       console.log(chalk.red(`Failed to reactivate run: ${reactivated.error}`));
       process.exit(1);
     }
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // Determine role from option or routing