agentxchain 2.135.1 → 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')

package/package.json

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

package/src/commands/resume.js

@@ -144,6 +144,9 @@ export async function resumeCommand(opts) {
         process.exit(1);
       }
       state = reactivated.state;
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
 
       // Write dispatch bundle for the existing turn
       const bundleResult = writeDispatchBundle(root, state, config);
@@ -204,6 +207,9 @@ export async function resumeCommand(opts) {
       process.exit(1);
     }
     state = reactivated.state;
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
 
     const bundleResult = writeDispatchBundle(root, state, config, { turnId: retainedTurn.turn_id });
     if (!bundleResult.ok) {
@@ -233,6 +239,9 @@ export async function resumeCommand(opts) {
     }
     state = initResult.state;
     console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+    if (initResult.migration_notice) {
+      console.log(chalk.yellow(initResult.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -244,6 +253,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -255,6 +267,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // Print run-context header before dispatch

package/src/commands/step.js

@@ -260,6 +260,9 @@ export async function stepCommand(opts) {
           process.exit(1);
         }
         state = reactivated.state;
+        if (reactivated.migration_notice) {
+          console.log(chalk.yellow(reactivated.migration_notice));
+        }
         skipAssignment = true;
 
         // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
@@ -285,6 +288,9 @@ export async function stepCommand(opts) {
       }
       state = initResult.state;
       console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+      if (initResult.migration_notice) {
+        console.log(chalk.yellow(initResult.migration_notice));
+      }
     }
 
     // paused → resume
@@ -296,6 +302,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     if (!skipAssignment && state.status === 'paused' && state.run_id) {
@@ -306,6 +315,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     // Assign the turn

package/src/lib/connector-validate.js

@@ -106,6 +106,12 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
   const tempBase = mkdtempSync(join(tmpdir(), 'axc-connector-validate-'));
   const scratchRoot = join(tempBase, 'workspace');
   const warnings = [...roleSelection.warnings];
+
+  // Surface capability declaration warnings for self-declared connectors
+  const { getCapabilityDeclarationWarnings } = await import('./runtime-capabilities.js');
+  const capWarnings = getCapabilityDeclarationWarnings(runtime);
+  warnings.push(...capWarnings);
+
   let keepArtifacts = options.keepArtifacts === true;
   let dispatch = null;
   let validation = null;

package/src/lib/continuous-run.js

@@ -24,6 +24,11 @@ import {
 } from './intake.js';
 import { loadProjectState } from './config.js';
 import { safeWriteJson } from './safe-write.js';
+import { emitRunEvent } from './run-events.js';
+import {
+  archiveStaleIntentsForRun,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 
@@ -56,7 +61,7 @@ export function removeContinuousSession(root) {
   }
 }
 
-function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd) {
+function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd, currentRunId = null) {
   return {
     session_id: `cont-${randomUUID().slice(0, 8)}`,
     started_at: new Date().toISOString(),
@@ -65,12 +70,13 @@ function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd) {
     max_runs: maxRuns,
     idle_cycles: 0,
     max_idle_cycles: maxIdleCycles,
-    current_run_id: null,
+    current_run_id: currentRunId,
     current_vision_objective: null,
     status: 'running',
     per_session_max_usd: perSessionMaxUsd || null,
     cumulative_spent_usd: 0,
     budget_exhausted: false,
+    startup_reconciled_run_id: null,
   };
 }
 
@@ -133,8 +139,46 @@ function buildContinuousProvenance(intentId, options = {}) {
   };
 }
 
-export function findNextQueuedIntent(root) {
-  return findNextDispatchableIntent(root);
+export function findNextQueuedIntent(root, options = {}) {
+  return findNextDispatchableIntent(root, { run_id: options.run_id || null });
+}
+
+function reconcileContinuousStartupState(context, session, contOpts, log) {
+  const { root, config } = context;
+  const governedState = loadProjectState(root, config);
+  const scopedRunId = session.current_run_id || contOpts.continueFrom || governedState?.run_id || null;
+
+  let sessionChanged = false;
+  if (scopedRunId && session.current_run_id !== scopedRunId) {
+    session.current_run_id = scopedRunId;
+    sessionChanged = true;
+  }
+
+  if (scopedRunId && session.startup_reconciled_run_id !== scopedRunId) {
+    const startupIntents = archiveStaleIntentsForRun(root, scopedRunId, {
+      protocolVersion: governedState?.protocol_version || config?.schema_version || '2.x',
+    });
+    if (startupIntents.archived_migration_intent_ids?.length > 0) {
+      emitRunEvent(root, 'intents_migrated', {
+        run_id: scopedRunId,
+        phase: governedState?.phase || null,
+        status: governedState?.status || 'active',
+        payload: {
+          archived_count: startupIntents.archived_migration_intent_ids.length,
+          archived_intent_ids: startupIntents.archived_migration_intent_ids,
+          reason: 'pre-BUG-34 intents with approved_run_id: null archived during continuous startup',
+        },
+      });
+      const migrationNotice = formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids);
+      if (migrationNotice) log(migrationNotice);
+    }
+    session.startup_reconciled_run_id = scopedRunId;
+    sessionChanged = true;
+  }
+
+  if (sessionChanged) {
+    writeContinuousSession(root, session);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -232,6 +276,7 @@ export function resolveContinuousOptions(opts, config) {
 
   return {
     enabled: opts.continuous ?? configCont.enabled ?? false,
+    continueFrom: opts.continueFrom ?? null,
     visionPath: opts.vision ?? configCont.vision_path ?? '.planning/VISION.md',
     maxRuns: opts.maxRuns ?? configCont.max_runs ?? 100,
     pollSeconds: opts.pollSeconds ?? configCont.poll_seconds ?? 30,
@@ -288,6 +333,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: true, status: 'completed', action: 'session_budget_exhausted', stop_reason: 'session_budget' };
   }
 
+  reconcileContinuousStartupState(context, session, contOpts, log);
+
   // Paused-session guard: if session is paused (blocked run awaiting unblock),
   // check governed state before attempting to advance. Without this guard, the
   // loop would try to startIntent() on a blocked project, hit the blocked-state
@@ -540,7 +587,15 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
     return { exitCode: 1, session: null };
   }
 
-  const session = createSession(contOpts.visionPath, contOpts.maxRuns, contOpts.maxIdleCycles, contOpts.perSessionMaxUsd);
+  const startupState = loadProjectState(root, context.config);
+  const initialRunId = contOpts.continueFrom || startupState?.run_id || null;
+  const session = createSession(
+    contOpts.visionPath,
+    contOpts.maxRuns,
+    contOpts.maxIdleCycles,
+    contOpts.perSessionMaxUsd,
+    initialRunId,
+  );
   writeContinuousSession(root, session);
 
   // SIGINT handler

package/src/lib/dispatch-bundle.js

@@ -389,6 +389,20 @@ function renderPrompt(role, roleId, turn, state, config, root) {
       }
       lines.push('');
     }
+    if (turn.conflict_context.forward_revision_files?.length) {
+      lines.push('Forward-revision files already safe to carry forward:');
+      for (const file of turn.conflict_context.forward_revision_files) {
+        lines.push(`- \`${file}\``);
+      }
+      if (turn.conflict_context.forward_revision_turns_since?.length) {
+        lines.push('');
+        lines.push('Forward-revision turns since assignment:');
+        for (const acceptedTurn of turn.conflict_context.forward_revision_turns_since) {
+          lines.push(`- \`${acceptedTurn.turn_id}\` (${acceptedTurn.role}) touched: ${acceptedTurn.files_changed.join(', ') || '(none)'}`);
+        }
+      }
+      lines.push('');
+    }
     if (turn.conflict_context.non_conflicting_files_preserved?.length) {
       lines.push('Non-conflicting files to preserve from your prior attempt:');
       for (const file of turn.conflict_context.non_conflicting_files_preserved) {

package/src/lib/governed-state.js

@@ -46,6 +46,10 @@ import { emitRunEvent } from './run-events.js';
 import { writeSessionCheckpoint } from './session-checkpoint.js';
 import { recordRunHistory } from './run-history.js';
 import { buildDefaultRunProvenance } from './run-provenance.js';
+import {
+  archiveStaleIntentsForRun,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 import {
   ensureHumanEscalation,
   findCurrentHumanEscalation,
@@ -1243,6 +1247,13 @@ function buildConflictContext(turn) {
         files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
       }))
     : [];
+  const forwardRevisionTurnsSince = Array.isArray(conflictError.forward_revision_turns)
+    ? conflictError.forward_revision_turns.map((entry) => ({
+        turn_id: entry.turn_id,
+        role: entry.role,
+        files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
+      }))
+    : [];
 
   return {
     prior_attempt_turn_id: turn.turn_id,
@@ -1250,6 +1261,8 @@ function buildConflictContext(turn) {
     conflict_type: conflictError.type || 'file_conflict',
     conflicting_files: Array.isArray(conflictError.conflicting_files) ? conflictError.conflicting_files : [],
     accepted_turns_since: acceptedTurnsSince,
+    forward_revision_files: Array.isArray(conflictError.forward_revision_files) ? conflictError.forward_revision_files : [],
+    forward_revision_turns_since: forwardRevisionTurnsSince,
     non_conflicting_files_preserved: Array.isArray(conflictError.non_conflicting_files)
       ? conflictError.non_conflicting_files
       : [],
@@ -2067,6 +2080,25 @@ export function reactivateGovernedRun(root, state, details = {}) {
 
   writeState(root, nextState);
 
+  const startupIntents = nextState.run_id
+    ? archiveStaleIntentsForRun(root, nextState.run_id, {
+      protocolVersion: nextState.protocol_version || state.protocol_version || '2.x',
+    })
+    : { archived_migration_intent_ids: [], migration_notice: null };
+
+  if (startupIntents.archived_migration_intent_ids?.length > 0) {
+    emitRunEvent(root, 'intents_migrated', {
+      run_id: nextState.run_id,
+      phase: nextState.phase,
+      status: nextState.status,
+      payload: {
+        archived_count: startupIntents.archived_migration_intent_ids.length,
+        archived_intent_ids: startupIntents.archived_migration_intent_ids,
+        reason: 'pre-BUG-34 intents with approved_run_id: null archived during run reactivation',
+      },
+    });
+  }
+
   if (humanEscalation) {
     resolveHumanEscalation(root, humanEscalation.escalation_id, {
       resolved_at: now,
@@ -2108,7 +2140,11 @@ export function reactivateGovernedRun(root, state, details = {}) {
     });
   }
 
-  return { ok: true, state: attachLegacyCurrentTurnAlias(nextState) };
+  return {
+    ok: true,
+    state: attachLegacyCurrentTurnAlias(nextState),
+    migration_notice: formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids),
+  };
 }
 
 // ── Core Operations ──────────────────────────────────────────────────────────
@@ -2162,48 +2198,10 @@ 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 */ }
+  const startupIntents = archiveStaleIntentsForRun(root, runId, {
+    protocolVersion: updatedState.protocol_version || '2.x',
+  });
+  const archivedMigrationIntentIds = startupIntents.archived_migration_intent_ids || [];
 
   // BUG-39: emit intents_migrated event when pre-BUG-34 intents were archived
   if (archivedMigrationIntentIds.length > 0) {
@@ -2226,9 +2224,7 @@ export function initializeGovernedRun(root, config, options = {}) {
     payload: { provenance: provenance || {} },
   });
   // 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;
+  const migrationNotice = startupIntents.migration_notice;
 
   return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState), migration_notice: migrationNotice };
 }