agentxchain 2.110.0 → 2.112.0

package/bin/agentxchain.js

@@ -121,6 +121,8 @@ import { diffCommand } from '../src/commands/diff.js';
 import { eventsCommand } from '../src/commands/events.js';
 import { connectorCheckCommand } 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, missionListCommand, missionShowCommand, missionStartCommand } from '../src/commands/mission.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -392,6 +394,69 @@ program
   .option('-d, --dir <path>', 'Project directory')
   .action(eventsCommand);
 
+const chainCmd = program
+  .command('chain')
+  .description('Inspect run-chaining history and reports');
+
+chainCmd
+  .command('latest')
+  .description('Show the most recent chain report')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(chainLatestCommand);
+
+chainCmd
+  .command('list')
+  .description('List all chain reports')
+  .option('-j, --json', 'Output as JSON')
+  .option('-l, --limit <n>', 'Max chain reports to show (default: 20)')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(chainListCommand);
+
+chainCmd
+  .command('show <chain_id>')
+  .description('Show a specific chain report by ID')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(chainShowCommand);
+
+const missionCmd = program
+  .command('mission')
+  .description('Group chained runs under a single-repo long-horizon mission');
+
+missionCmd
+  .command('start')
+  .description('Create a durable mission artifact for a single repo')
+  .requiredOption('--title <text>', 'Mission title')
+  .requiredOption('--goal <text>', 'Mission goal')
+  .option('--id <mission_id>', 'Override the derived mission ID')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(missionStartCommand);
+
+missionCmd
+  .command('list')
+  .description('List mission artifacts newest first')
+  .option('-l, --limit <n>', 'Max missions to show (default: 20)')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(missionListCommand);
+
+missionCmd
+  .command('show [mission_id]')
+  .description('Show one mission, or the latest mission when no ID is provided')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(missionShowCommand);
+
+missionCmd
+  .command('attach-chain [chain_id]')
+  .description('Attach a chain report to a mission (default: latest chain on latest mission)')
+  .option('-m, --mission <mission_id>', 'Explicit mission ID (defaults to latest mission)')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(missionAttachChainCommand);
+
 program
   .command('validate')
   .description('Validate project protocol artifacts')
@@ -516,6 +581,11 @@ program
   .option('--continue-from <run_id>', 'Continue from a prior terminal run (sets trigger=continuation)')
   .option('--recover-from <run_id>', 'Recover from a prior blocked run (sets trigger=recovery)')
   .option('--inherit-context', 'Inherit read-only summary context from the parent run (requires --continue-from or --recover-from)')
+  .option('--chain', 'Auto-chain runs: when a run completes, start a continuation automatically')
+  .option('--max-chains <n>', 'Maximum continuation runs in chain mode (default: 5)', parseInt)
+  .option('--chain-on <statuses>', 'Comma-separated terminal statuses that trigger chaining (default: completed)')
+  .option('--chain-cooldown <seconds>', 'Seconds to wait between chained runs (default: 5)', parseInt)
+  .option('--mission <mission_id>', 'Bind chained runs to a mission (use "latest" for most recent mission)')
   .action(runCommand);
 
 program

package/dashboard/app.js

@@ -15,6 +15,8 @@ import { render as renderCrossRepo } from './components/cross-repo.js';
 import { render as renderDelegations } from './components/delegations.js';
 import { render as renderBlockers } from './components/blockers.js';
 import { render as renderArtifacts } from './components/artifacts.js';
+import { render as renderMission } from './components/mission.js';
+import { render as renderChain } from './components/chain.js';
 import { render as renderRunHistory } from './components/run-history.js';
 import { render as renderTimeouts } from './components/timeouts.js';
 import { render as renderCoordinatorTimeouts } from './components/coordinator-timeouts.js';
@@ -35,6 +37,8 @@ const VIEWS = {
   'cross-repo': { fetch: ['coordinatorState', 'coordinatorHistory'], render: renderCrossRepo },
   blockers: { fetch: ['coordinatorBlockers'], render: renderBlockers },
   artifacts: { fetch: ['workflowKitArtifacts'], render: renderArtifacts },
+  mission: { fetch: ['missions'], render: renderMission },
+  chain: { fetch: ['chainReports'], render: renderChain },
   'run-history': { fetch: ['runHistory'], render: renderRunHistory },
   timeouts: { fetch: ['timeouts'], render: renderTimeouts },
   'coordinator-timeouts': { fetch: ['coordinatorTimeouts'], render: renderCoordinatorTimeouts },
@@ -58,6 +62,8 @@ const API_MAP = {
   coordinatorBlockers: '/api/coordinator/blockers',
   coordinatorRepoStatusRows: '/api/coordinator/repo-status',
   workflowKitArtifacts: '/api/workflow-kit-artifacts',
+  missions: '/api/missions',
+  chainReports: '/api/chain-reports',
   connectors: '/api/connectors',
   runHistory: '/api/run-history',
   timeouts: '/api/timeouts',

package/dashboard/components/chain.js

@@ -0,0 +1,200 @@
+/**
+ * Chain view — renders run-chaining visibility from /api/chain-reports.
+ *
+ * Pure render function: takes snapshot data from the bridge server and returns
+ * HTML for latest-chain lineage plus recent chain-session history.
+ */
+
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function formatStatus(status) {
+  switch (status) {
+    case 'completed':
+      return badge('completed', 'var(--green)');
+    case 'blocked':
+      return badge('blocked', 'var(--yellow)');
+    case 'failed':
+      return badge('failed', 'var(--red)');
+    default:
+      return badge(status || 'unknown', 'var(--text-dim)');
+  }
+}
+
+function formatTerminalReason(reason) {
+  switch (reason) {
+    case 'chain_limit_reached':
+      return badge('chain limit reached', '#38bdf8');
+    case 'non_chainable_status':
+      return badge('non-chainable status', 'var(--yellow)');
+    case 'operator_abort':
+      return badge('operator abort', 'var(--red)');
+    case 'parent_validation_failed':
+      return badge('parent validation failed', 'var(--red)');
+    default:
+      return badge(reason || 'unknown', 'var(--text-dim)');
+  }
+}
+
+function formatDuration(ms) {
+  if (ms == null) return '—';
+  if (ms < 1000) return `${ms}ms`;
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+function formatDate(iso) {
+  if (!iso) return '—';
+  try {
+    const date = new Date(iso);
+    return date.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
+      + ' ' + date.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+  } catch {
+    return esc(iso);
+  }
+}
+
+function truncateId(value, len = 12) {
+  if (!value) return '—';
+  return value.length > len ? `${value.slice(0, len)}…` : value;
+}
+
+function formatContextSummary(summary) {
+  if (!summary) return '—';
+
+  const parts = [];
+  if (Array.isArray(summary.parent_roles_used) && summary.parent_roles_used.length > 0) {
+    parts.push(`${summary.parent_roles_used.length} roles`);
+  }
+  if (summary.parent_phases_completed_count > 0) {
+    parts.push(`${summary.parent_phases_completed_count} phases`);
+  }
+  if (summary.recent_decisions_count > 0) {
+    parts.push(`${summary.recent_decisions_count} decisions`);
+  }
+  if (summary.recent_accepted_turns_count > 0) {
+    parts.push(`${summary.recent_accepted_turns_count} turns`);
+  }
+
+  return parts.length > 0 ? esc(parts.join(', ')) : '—';
+}
+
+function renderLatestRunsTable(report) {
+  if (!Array.isArray(report?.runs) || report.runs.length === 0) {
+    return `<p class="section-subtitle">No runs recorded for this chain.</p>`;
+  }
+
+  let html = `<div class="section"><h3>Latest Chain Lineage</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Run ID</th>
+          <th>Status</th>
+          <th>Trigger</th>
+          <th>Turns</th>
+          <th>Duration</th>
+          <th>Parent</th>
+          <th>Inherited Context</th>
+        </tr>
+      </thead>
+      <tbody>`;
+
+  report.runs.forEach((run, index) => {
+    html += `<tr>
+      <td style="color:var(--text-dim)">${index + 1}</td>
+      <td class="mono" title="${esc(run.run_id || '')}">${esc(truncateId(run.run_id))}</td>
+      <td>${formatStatus(run.status)}</td>
+      <td>${esc(run.provenance_trigger || '—')}</td>
+      <td>${run.turns ?? '—'}</td>
+      <td>${formatDuration(run.duration_ms)}</td>
+      <td class="mono" title="${esc(run.parent_run_id || '')}">${esc(truncateId(run.parent_run_id))}</td>
+      <td>${formatContextSummary(run.inherited_context_summary)}</td>
+    </tr>`;
+  });
+
+  html += '</tbody></table></div>';
+  return html;
+}
+
+function renderRecentChainsTable(reports) {
+  let html = `<div class="section"><h3>Recent Chain Sessions</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Chain ID</th>
+          <th>Runs</th>
+          <th>Turns</th>
+          <th>Terminal</th>
+          <th>Duration</th>
+          <th>Started</th>
+        </tr>
+      </thead>
+      <tbody>`;
+
+  reports.forEach((report, index) => {
+    html += `<tr>
+      <td style="color:var(--text-dim)">${index + 1}</td>
+      <td class="mono" title="${esc(report.chain_id || '')}">${esc(truncateId(report.chain_id, 14))}</td>
+      <td>${report.runs?.length || 0}</td>
+      <td>${report.total_turns ?? '—'}</td>
+      <td>${formatTerminalReason(report.terminal_reason)}</td>
+      <td>${formatDuration(report.total_duration_ms)}</td>
+      <td>${formatDate(report.started_at)}</td>
+    </tr>`;
+  });
+
+  html += '</tbody></table></div>';
+  return html;
+}
+
+export function render({ chainReports }) {
+  if (!chainReports || typeof chainReports !== 'object') {
+    return `<div class="placeholder"><h2>Chain</h2><p>No chain data available. Run a chained governed session to populate this view.</p></div>`;
+  }
+
+  const reports = Array.isArray(chainReports.reports) ? chainReports.reports : [];
+  const latest = chainReports.latest || reports[0] || null;
+
+  if (!latest || reports.length === 0) {
+    return `<div class="placeholder"><h2>Chain</h2><p>No chain reports found. Run <code>agentxchain run --chain</code> to record automatic continuation lineage.</p></div>`;
+  }
+
+  let html = `<div class="chain-view"><div class="run-header"><div class="run-meta">`;
+  html += `<span class="turn-count">latest chain ${esc(latest.chain_id || '—')}</span>`;
+  html += badge(`${latest.runs?.length || 0} runs`, '#38bdf8');
+  html += badge(`${latest.total_turns || 0} turns`, 'var(--green)');
+  html += formatTerminalReason(latest.terminal_reason);
+  html += `</div></div>`;
+
+  html += `<div class="section"><h3>Latest Chain Summary</h3><dl class="detail-list">`;
+  html += `<dt>Started</dt><dd>${esc(latest.started_at || '—')}</dd>`;
+  html += `<dt>Completed</dt><dd>${esc(latest.completed_at || '—')}</dd>`;
+  html += `<dt>Total Duration</dt><dd>${formatDuration(latest.total_duration_ms)}</dd>`;
+  html += `<dt>Total Turns</dt><dd>${latest.total_turns ?? '—'}</dd>`;
+  html += `<dt>Terminal Reason</dt><dd>${esc(latest.terminal_reason || '—')}</dd>`;
+  html += `</dl></div>`;
+
+  html += renderLatestRunsTable(latest);
+  html += renderRecentChainsTable(reports);
+  html += '</div>';
+  return html;
+}

package/dashboard/components/mission.js

@@ -0,0 +1,177 @@
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function formatMissionStatus(status) {
+  switch (status) {
+    case 'progressing':
+      return badge('progressing', 'var(--green)');
+    case 'planned':
+      return badge('planned', '#38bdf8');
+    case 'needs_attention':
+      return badge('needs attention', 'var(--yellow)');
+    case 'degraded':
+      return badge('degraded', 'var(--red)');
+    default:
+      return badge(status || 'unknown', 'var(--text-dim)');
+  }
+}
+
+function formatTerminalReason(reason) {
+  switch (reason) {
+    case 'chain_limit_reached':
+      return badge('chain limit reached', '#38bdf8');
+    case 'non_chainable_status':
+      return badge('non-chainable status', 'var(--yellow)');
+    case 'operator_abort':
+      return badge('operator abort', 'var(--red)');
+    case 'parent_validation_failed':
+      return badge('parent validation failed', 'var(--red)');
+    case 'completed':
+      return badge('completed', 'var(--green)');
+    default:
+      return badge(reason || 'none', 'var(--text-dim)');
+  }
+}
+
+function formatDate(iso) {
+  if (!iso) return '—';
+  try {
+    const date = new Date(iso);
+    return date.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
+      + ' ' + date.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+  } catch {
+    return esc(iso);
+  }
+}
+
+function truncateId(value, len = 14) {
+  if (!value) return '—';
+  return value.length > len ? `${value.slice(0, len)}…` : value;
+}
+
+function renderAttachedChains(latest) {
+  if (!Array.isArray(latest?.chains) || latest.chains.length === 0) {
+    return `<div class="section"><h3>Attached Chains</h3><p class="section-subtitle">No chain reports are attached to this mission yet.</p></div>`;
+  }
+
+  let html = `<div class="section"><h3>Attached Chains</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Chain ID</th>
+          <th>Runs</th>
+          <th>Turns</th>
+          <th>Terminal</th>
+          <th>Started</th>
+        </tr>
+      </thead>
+      <tbody>`;
+
+  latest.chains.forEach((chain, index) => {
+    html += `<tr>
+      <td style="color:var(--text-dim)">${index + 1}</td>
+      <td class="mono" title="${esc(chain.chain_id || '')}">${esc(truncateId(chain.chain_id))}</td>
+      <td>${chain.runs?.length || 0}</td>
+      <td>${chain.total_turns ?? '—'}</td>
+      <td>${formatTerminalReason(chain.terminal_reason)}</td>
+      <td>${formatDate(chain.started_at)}</td>
+    </tr>`;
+  });
+
+  html += '</tbody></table></div>';
+  return html;
+}
+
+function renderRecentMissions(missions) {
+  let html = `<div class="section"><h3>Recent Missions</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Mission ID</th>
+          <th>Status</th>
+          <th>Chains</th>
+          <th>Runs</th>
+          <th>Turns</th>
+          <th>Repo Decisions</th>
+          <th>Latest Terminal</th>
+          <th>Updated</th>
+          <th>Title</th>
+        </tr>
+      </thead>
+      <tbody>`;
+
+  missions.forEach((mission, index) => {
+    html += `<tr>
+      <td style="color:var(--text-dim)">${index + 1}</td>
+      <td class="mono" title="${esc(mission.mission_id || '')}">${esc(truncateId(mission.mission_id, 18))}</td>
+      <td>${formatMissionStatus(mission.derived_status)}</td>
+      <td>${mission.chain_count ?? 0}</td>
+      <td>${mission.total_runs ?? 0}</td>
+      <td>${mission.total_turns ?? 0}</td>
+      <td>${mission.active_repo_decisions_count ?? 0}</td>
+      <td>${formatTerminalReason(mission.latest_terminal_reason)}</td>
+      <td>${formatDate(mission.updated_at || mission.created_at)}</td>
+      <td>${esc(mission.title || '—')}</td>
+    </tr>`;
+  });
+
+  html += '</tbody></table></div>';
+  return html;
+}
+
+export function render({ missions }) {
+  if (!missions || typeof missions !== 'object') {
+    return `<div class="placeholder"><h2>Mission</h2><p>No mission data available. Create a mission and bind a chain to populate this view.</p></div>`;
+  }
+
+  const missionList = Array.isArray(missions.missions) ? missions.missions : [];
+  const latest = missions.latest || missionList[0] || null;
+
+  if (!latest || missionList.length === 0) {
+    return `<div class="placeholder"><h2>Mission</h2><p>No missions found. Run <code>agentxchain mission start --title "..." --goal "..."</code> and then <code>agentxchain run --chain --mission latest</code> to track long-horizon work here.</p></div>`;
+  }
+
+  const missingChains = Array.isArray(latest.missing_chain_ids) ? latest.missing_chain_ids : [];
+
+  let html = `<div class="mission-view"><div class="run-header"><div class="run-meta">`;
+  html += `<span class="turn-count">latest mission ${esc(latest.mission_id || '—')}</span>`;
+  html += formatMissionStatus(latest.derived_status);
+  html += badge(`${latest.chain_count || 0} chains`, '#38bdf8');
+  html += badge(`${latest.total_turns || 0} turns`, 'var(--green)');
+  html += badge(`${latest.active_repo_decisions_count || 0} repo decisions`, 'var(--yellow)');
+  html += `</div></div>`;
+
+  html += `<div class="section"><h3>Latest Mission Summary</h3><dl class="detail-list">`;
+  html += `<dt>Title</dt><dd>${esc(latest.title || '—')}</dd>`;
+  html += `<dt>Goal</dt><dd>${esc(latest.goal || '—')}</dd>`;
+  html += `<dt>Updated</dt><dd>${esc(latest.updated_at || latest.created_at || '—')}</dd>`;
+  html += `<dt>Latest Chain</dt><dd class="mono">${esc(latest.latest_chain_id || '—')}</dd>`;
+  html += `<dt>Latest Terminal</dt><dd>${esc(latest.latest_terminal_reason || '—')}</dd>`;
+  html += `<dt>Total Runs</dt><dd>${latest.total_runs ?? 0}</dd>`;
+  html += `<dt>Attached Chains</dt><dd>${latest.attached_chain_count ?? 0}</dd>`;
+  html += `<dt>Missing Chains</dt><dd>${missingChains.length}</dd>`;
+  html += `<dt>Active Repo Decisions</dt><dd>${latest.active_repo_decisions_count ?? 0}</dd>`;
+  html += `</dl></div>`;
+
+  if (missingChains.length > 0) {
+    html += `<div class="section"><h3>Missing Chain References</h3><p class="section-subtitle">This mission is degraded until the missing chain reports are restored.</p><p class="mono">${esc(missingChains.join(', '))}</p></div>`;
+  }
+
+  html += renderAttachedChains(latest);
+  html += renderRecentMissions(missionList);
+  html += '</div>';
+  return html;
+}

package/dashboard/index.html

@@ -405,6 +405,8 @@
     <a href="#gate">Gates</a>
     <a href="#blockers">Blockers</a>
     <a href="#artifacts">Artifacts</a>
+    <a href="#mission">Mission</a>
+    <a href="#chain">Chain</a>
     <a href="#run-history">Run History</a>
     <a href="#timeouts">Timeouts</a>
     <a href="#coordinator-timeouts">Coordinator Timeouts</a>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.110.0",
+  "version": "2.112.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "test:node": "node --test test/*.test.js",
     "preflight:release": "bash scripts/release-preflight.sh",
     "preflight:release:strict": "bash scripts/release-preflight.sh --strict",
+    "check:release-alignment": "node scripts/check-release-alignment.mjs",
     "postflight:release": "bash scripts/release-postflight.sh",
     "postflight:downstream": "bash scripts/release-downstream-truth.sh",
     "bump:release": "bash scripts/release-bump.sh",

package/scripts/check-release-alignment.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  RELEASE_ALIGNMENT_SCOPES,
+  validateReleaseAlignment,
+} from '../src/lib/release-alignment.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '..', '..');
+
+function usage() {
+  console.error('Usage: node cli/scripts/check-release-alignment.mjs [--target-version <semver>] [--scope prebump|current] [--json]');
+}
+
+let targetVersion = null;
+let scope = RELEASE_ALIGNMENT_SCOPES.CURRENT;
+let json = false;
+
+for (let index = 2; index < process.argv.length; index += 1) {
+  const arg = process.argv[index];
+  if (arg === '--target-version') {
+    targetVersion = process.argv[index + 1] || null;
+    if (!targetVersion) {
+      console.error('Error: --target-version requires a semver argument');
+      usage();
+      process.exit(1);
+    }
+    index += 1;
+    continue;
+  }
+  if (arg === '--scope') {
+    scope = process.argv[index + 1] || '';
+    if (!Object.values(RELEASE_ALIGNMENT_SCOPES).includes(scope)) {
+      console.error(`Error: invalid --scope "${scope}"`);
+      usage();
+      process.exit(1);
+    }
+    index += 1;
+    continue;
+  }
+  if (arg === '--json') {
+    json = true;
+    continue;
+  }
+  console.error(`Error: unknown argument "${arg}"`);
+  usage();
+  process.exit(1);
+}
+
+const result = validateReleaseAlignment(REPO_ROOT, { targetVersion, scope });
+
+if (json) {
+  console.log(JSON.stringify(result, null, 2));
+} else if (result.ok) {
+  console.log(`Release alignment OK for ${result.targetVersion} (${result.scope}, ${result.checkedSurfaceCount} surfaces).`);
+} else {
+  console.error(`Release alignment FAILED for ${result.targetVersion} (${result.scope}, ${result.errors.length} issue(s)).`);
+  for (const error of result.errors) {
+    console.error(`- [${error.surface_id}] ${error.message}`);
+  }
+}
+
+process.exit(result.ok ? 0 : 1);

package/scripts/release-bump.sh

@@ -143,74 +143,23 @@ if git rev-parse "v${TARGET_VERSION}" >/dev/null 2>&1; then
 fi
 echo "  OK: tag v${TARGET_VERSION} does not exist"
 
-# 4. Pre-bump version-surface alignment guard
-# Ensures all governed version surfaces already reference the target version
+# 4. Pre-bump release-alignment guard
+# Ensures all manual target-version surfaces already reference the target version
 # BEFORE the bump commit is created. This catches stale drift that would
 # otherwise only be discovered after minting local release identities.
 #
 # NOTE: Homebrew mirror formula and README are NOT checked here. They are
-# auto-aligned in step 5 because the registry SHA256 is inherently a
-# post-publish artifact. See DEC-HOMEBREW-SHA-SPLIT-001.
-echo "[4/9] Verifying version-surface alignment for ${TARGET_VERSION}..."
-SURFACE_ERRORS=()
-
-# 4a. CHANGELOG top heading
-CHANGELOG_TOP=$(grep -m1 -E '^## [0-9]+\.[0-9]+\.[0-9]+$' "${REPO_ROOT}/cli/CHANGELOG.md" 2>/dev/null | sed 's/^## //' || true)
-if [[ "$CHANGELOG_TOP" != "$TARGET_VERSION" ]]; then
-  SURFACE_ERRORS+=("CHANGELOG.md top heading is '${CHANGELOG_TOP:-missing}', expected '${TARGET_VERSION}'")
-fi
-
-# 4b. Release notes page exists
-RELEASE_DOC_ID="v${TARGET_VERSION//./-}"
-RELEASE_DOC_PATH="website-v2/docs/releases/${RELEASE_DOC_ID}.mdx"
-if [[ ! -f "${REPO_ROOT}/${RELEASE_DOC_PATH}" ]]; then
-  SURFACE_ERRORS+=("release notes page missing: ${RELEASE_DOC_PATH}")
-fi
-
-# 4c. Docs sidebar auto-generates releases from dirName (release doc existence is sufficient)
-if ! grep -q "dirName.*releases" "${REPO_ROOT}/website-v2/sidebars.ts" 2>/dev/null; then
-  SURFACE_ERRORS+=("sidebars.ts does not auto-generate releases (missing dirName: 'releases')")
-fi
-
-# 4d. Homepage hero badge shows target version
-if ! grep -q "v${TARGET_VERSION}" "${REPO_ROOT}/website-v2/src/pages/index.tsx" 2>/dev/null; then
-  SURFACE_ERRORS+=("homepage index.tsx does not contain 'v${TARGET_VERSION}'")
-fi
-
-# 4e. Conformance capabilities version
-CAPS_VERSION=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('${REPO_ROOT}/.agentxchain-conformance/capabilities.json','utf8')).version)}catch{console.log('missing')}" 2>/dev/null || echo "missing")
-if [[ "$CAPS_VERSION" != "$TARGET_VERSION" ]]; then
-  SURFACE_ERRORS+=("capabilities.json version is '${CAPS_VERSION}', expected '${TARGET_VERSION}'")
-fi
-
-# 4f. Protocol implementor guide example
-if ! grep -q "\"version\": \"${TARGET_VERSION}\"" "${REPO_ROOT}/website-v2/docs/protocol-implementor-guide.mdx" 2>/dev/null; then
-  SURFACE_ERRORS+=("protocol-implementor-guide.mdx does not contain '\"version\": \"${TARGET_VERSION}\"'")
-fi
-
-# 4g. Launch evidence report title
-ESCAPED_VERSION="${TARGET_VERSION//./\\.}"
-if ! grep -qE "^# Launch Evidence Report — AgentXchain v${ESCAPED_VERSION}" "${REPO_ROOT}/.planning/LAUNCH_EVIDENCE_REPORT.md" 2>/dev/null; then
-  SURFACE_ERRORS+=("LAUNCH_EVIDENCE_REPORT.md title does not carry v${TARGET_VERSION}")
-fi
-
-# 4h. llms.txt must list the current release notes route
-CURRENT_RELEASE_ROUTE="/docs/releases/${RELEASE_DOC_ID}"
-if ! grep -q "${CURRENT_RELEASE_ROUTE}" "${REPO_ROOT}/website-v2/static/llms.txt" 2>/dev/null; then
-  SURFACE_ERRORS+=("website-v2/static/llms.txt does not list '${CURRENT_RELEASE_ROUTE}'")
-fi
-
-# 4i. sitemap.xml is now auto-generated by Docusaurus at build time — no static file check needed
-
-if [[ "${#SURFACE_ERRORS[@]}" -gt 0 ]]; then
-  echo "FAIL: ${#SURFACE_ERRORS[@]} version-surface(s) not aligned to ${TARGET_VERSION}:" >&2
-  printf '  - %s\n' "${SURFACE_ERRORS[@]}" >&2
+# auto-aligned in step 6 because the registry tarball URL is deterministic but
+# the registry SHA256 is inherently post-publish truth.
+echo "[4/10] Verifying release alignment for ${TARGET_VERSION}..."
+if node "${CLI_DIR}/scripts/check-release-alignment.mjs" --target-version "${TARGET_VERSION}" --scope prebump; then
+  :
+else
   echo "" >&2
   echo "Fix these surfaces before running release-bump. The bump script refuses to" >&2
   echo "create release identity when governed surfaces are stale." >&2
   exit 1
 fi
-echo "  OK: all 8 governed version surfaces reference ${TARGET_VERSION}"
 
 # 5. Normalize release-note sidebar ordering
 echo "[5/10] Normalizing release-note sidebar positions..."