agentxchain 2.110.0 → 2.111.0

package/bin/agentxchain.js

@@ -121,6 +121,7 @@ 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';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -392,6 +393,32 @@ 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);
+
 program
   .command('validate')
   .description('Validate project protocol artifacts')
@@ -516,6 +543,10 @@ 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)
   .action(runCommand);
 
 program

package/dashboard/app.js

@@ -15,6 +15,7 @@ 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 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 +36,7 @@ const VIEWS = {
   'cross-repo': { fetch: ['coordinatorState', 'coordinatorHistory'], render: renderCrossRepo },
   blockers: { fetch: ['coordinatorBlockers'], render: renderBlockers },
   artifacts: { fetch: ['workflowKitArtifacts'], render: renderArtifacts },
+  chain: { fetch: ['chainReports'], render: renderChain },
   'run-history': { fetch: ['runHistory'], render: renderRunHistory },
   timeouts: { fetch: ['timeouts'], render: renderTimeouts },
   'coordinator-timeouts': { fetch: ['coordinatorTimeouts'], render: renderCoordinatorTimeouts },
@@ -58,6 +60,7 @@ const API_MAP = {
   coordinatorBlockers: '/api/coordinator/blockers',
   coordinatorRepoStatusRows: '/api/coordinator/repo-status',
   workflowKitArtifacts: '/api/workflow-kit-artifacts',
+  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/index.html

@@ -405,6 +405,7 @@
     <a href="#gate">Gates</a>
     <a href="#blockers">Blockers</a>
     <a href="#artifacts">Artifacts</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.111.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/chain.js

@@ -0,0 +1,252 @@
+/**
+ * agentxchain chain — operator-facing read surface for chain reports.
+ *
+ * Surfaces chain report metadata so operators can inspect lights-out
+ * run-chaining history without opening raw JSON files.
+ */
+
+import chalk from 'chalk';
+import { findProjectRoot } from '../lib/config.js';
+import {
+  loadAllChainReports,
+  loadChainReport,
+  loadLatestChainReport,
+} from '../lib/chain-reports.js';
+
+/**
+ * agentxchain chain latest — show the most recent chain report.
+ *
+ * @param {object} opts - { json?: boolean, dir?: string }
+ */
+export async function chainLatestCommand(opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  const report = loadLatestChainReport(root);
+  if (!report) {
+    console.log(chalk.dim('No chain reports found.'));
+    console.log(chalk.dim('  Run `agentxchain run --chain` to enable auto-chaining.'));
+    return;
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  renderChainReport(report);
+}
+
+/**
+ * agentxchain chain list — list all chain reports.
+ *
+ * @param {object} opts - { json?: boolean, limit?: number, dir?: string }
+ */
+export async function chainListCommand(opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  const reports = loadAllChainReports(root);
+  const limit = opts.limit ? parseInt(opts.limit, 10) : 20;
+  const limited = reports.slice(0, limit);
+
+  if (opts.json) {
+    console.log(JSON.stringify(limited, null, 2));
+    return;
+  }
+
+  if (limited.length === 0) {
+    console.log(chalk.dim('No chain reports found.'));
+    console.log(chalk.dim('  Run `agentxchain run --chain` to enable auto-chaining.'));
+    return;
+  }
+
+  // Table header
+  const header = [
+    pad('#', 4),
+    pad('Chain ID', 16),
+    pad('Runs', 6),
+    pad('Turns', 7),
+    pad('Terminal Reason', 28),
+    pad('Duration', 12),
+    pad('Started', 22),
+  ].join(' ');
+
+  console.log(chalk.bold(header));
+  console.log(chalk.dim('─'.repeat(header.length)));
+
+  limited.forEach((report, i) => {
+    const idx = String(i + 1);
+    const chainId = report.chain_id || '—';
+    const runs = String(report.runs?.length || 0);
+    const turns = String(report.total_turns || 0);
+    const terminal = formatTerminalReason(report.terminal_reason);
+    const duration = report.total_duration_ms != null
+      ? formatDuration(report.total_duration_ms)
+      : '—';
+    const started = report.started_at
+      ? new Date(report.started_at).toLocaleString()
+      : '—';
+
+    console.log([
+      pad(idx, 4),
+      pad(chainId, 16),
+      pad(runs, 6),
+      pad(turns, 7),
+      pad(terminal, 28),
+      pad(duration, 12),
+      pad(started, 22),
+    ].join(' '));
+  });
+
+  console.log(chalk.dim(`\n${limited.length} chain(s) shown${reports.length > limit ? ` (${reports.length} total)` : ''}`));
+}
+
+/**
+ * agentxchain chain show <chain_id> — show a specific chain report.
+ *
+ * @param {string} chainId
+ * @param {object} opts - { json?: boolean, dir?: string }
+ */
+export async function chainShowCommand(chainId, opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  const report = loadChainReport(root, chainId);
+  if (!report) {
+    console.error(chalk.red(`Chain report not found: ${chainId}`));
+    console.log(chalk.dim('  Use `agentxchain chain list` to see available chain reports.'));
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  renderChainReport(report);
+}
+
+// ── Rendering ─────────────────────────────────────────────────────────────────
+
+function renderChainReport(report) {
+  console.log(chalk.bold(`Chain Report: ${report.chain_id}`));
+  console.log('');
+  console.log(`  Total runs:     ${report.runs?.length || 0}`);
+  console.log(`  Total turns:    ${report.total_turns || 0}`);
+  console.log(`  Duration:       ${formatDuration(report.total_duration_ms || 0)}`);
+  console.log(`  Terminal:       ${formatTerminalReason(report.terminal_reason)}`);
+  console.log(`  Started:        ${report.started_at || '—'}`);
+  console.log(`  Completed:      ${report.completed_at || '—'}`);
+  console.log('');
+
+  if (!report.runs || report.runs.length === 0) {
+    console.log(chalk.dim('  No runs recorded.'));
+    return;
+  }
+
+  // Run table header
+  const runHeader = [
+    pad('#', 4),
+    pad('Run ID', 14),
+    pad('Status', 12),
+    pad('Trigger', 14),
+    pad('Turns', 7),
+    pad('Duration', 12),
+    pad('Parent', 14),
+    pad('Ctx', 40),
+  ].join(' ');
+
+  console.log(chalk.bold('  Runs:'));
+  console.log(`  ${chalk.dim(runHeader)}`);
+  console.log(`  ${chalk.dim('─'.repeat(runHeader.length))}`);
+
+  report.runs.forEach((run, i) => {
+    const idx = String(i + 1);
+    const runId = (run.run_id || '—').slice(0, 12);
+    const status = formatStatus(run.status);
+    const trigger = run.provenance_trigger || '—';
+    const turns = String(run.turns || 0);
+    const duration = run.duration_ms != null ? formatDuration(run.duration_ms) : '—';
+    const parent = run.parent_run_id ? run.parent_run_id.slice(0, 12) : '—';
+    const ctx = formatInheritedContextSummary(run.inherited_context_summary);
+
+    console.log(`  ${[
+      pad(idx, 4),
+      pad(runId, 14),
+      pad(status, 12),
+      pad(trigger, 14),
+      pad(turns, 7),
+      pad(duration, 12),
+      pad(parent, 14),
+      pad(ctx, 40),
+    ].join(' ')}`);
+  });
+}
+
+function formatInheritedContextSummary(summary) {
+  if (!summary) return '—';
+
+  const parts = [];
+  if (summary.parent_roles_used?.length) {
+    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 ? parts.join(', ') : '—';
+}
+
+function formatTerminalReason(reason) {
+  if (!reason) return '—';
+  switch (reason) {
+    case 'chain_limit_reached': return chalk.cyan('chain limit reached');
+    case 'non_chainable_status': return chalk.yellow('non-chainable status');
+    case 'operator_abort': return chalk.red('operator abort');
+    case 'parent_validation_failed': return chalk.red('parent validation failed');
+    case 'completed': return chalk.green('completed');
+    case 'blocked': return chalk.yellow('blocked');
+    default: return reason;
+  }
+}
+
+function formatStatus(status) {
+  if (status === 'completed') return chalk.green('completed');
+  if (status === 'blocked') return chalk.yellow('blocked');
+  if (status === 'failed') return chalk.red('failed');
+  return status || '—';
+}
+
+function formatDuration(ms) {
+  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 pad(str, width) {
+  return String(str).padEnd(width);
+}
+
+// ── Data Loading ──────────────────────────────────────────────────────────────

package/src/commands/diff.js

@@ -215,9 +215,28 @@ function formatValue(value, label = '') {
   if (typeof value === 'boolean') return value ? 'yes' : 'no';
   if (label === 'Cost' || label === 'Budget') return `$${value.toFixed(4)}`;
   if (label === 'Duration') return formatDuration(value);
+  if (label === 'Blocked reason' && value && typeof value === 'object') {
+    return formatBlockedReason(value);
+  }
+  if (typeof value === 'object') return JSON.stringify(value);
   return String(value);
 }
 
+function formatBlockedReason(reason) {
+  const category = reason.category || 'unknown';
+  const gateAction = reason.gate_action;
+  if (category === 'gate_action_failed' && gateAction) {
+    const actionLabel = gateAction.action_label || gateAction.command || 'unknown action';
+    if (gateAction.timed_out) {
+      return `gate_action_failed: ${actionLabel} timed out after ${gateAction.timeout_ms}ms`;
+    }
+    const exit = gateAction.exit_code != null ? ` (exit ${gateAction.exit_code})` : '';
+    return `gate_action_failed: ${actionLabel} failed${exit}`;
+  }
+  const detail = reason.detail || reason.recovery?.detail || '';
+  return detail ? `${category}: ${detail}` : category;
+}
+
 function formatDelta(delta, label) {
   if (delta == null || delta === 0) return '';
   if (label === 'Cost' || label === 'Budget') {

package/src/commands/run.js

@@ -44,6 +44,7 @@ import {
   getDispatchTurnDir,
   getTurnStagingResultPath,
 } from '../lib/turn-paths.js';
+import { resolveChainOptions, executeChainedRun } from '../lib/run-chain.js';
 
 export async function runCommand(opts) {
   const context = loadProjectContext();
@@ -52,6 +53,14 @@ export async function runCommand(opts) {
     process.exit(1);
   }
 
+  const chainOpts = resolveChainOptions(opts, context.config);
+  if (chainOpts.enabled) {
+    console.log(chalk.cyan.bold('agentxchain run --chain'));
+    console.log(chalk.dim(`  Chain mode: enabled (max ${chainOpts.maxChains} continuations, on: ${chainOpts.chainOn.join(',')}, cooldown: ${chainOpts.cooldownSeconds}s)`));
+    const { exitCode } = await executeChainedRun(context, opts, chainOpts, executeGovernedRun);
+    process.exit(exitCode);
+  }
+
   const execution = await executeGovernedRun(context, opts);
   process.exit(execution.exitCode);
 }
@@ -167,8 +176,7 @@ export async function executeGovernedRun(context, opts = {}) {
   let aborted = false;
   let sigintCount = 0;
   const controller = new AbortController();
-
-  process.on('SIGINT', () => {
+  const onSigint = () => {
     sigintCount++;
     if (sigintCount >= 2) {
       process.exit(130);
@@ -176,37 +184,39 @@ export async function executeGovernedRun(context, opts = {}) {
     aborted = true;
     controller.abort();
     log(chalk.yellow('\nSIGINT received — finishing current turn, then stopping.'));
-  });
+  };
+  process.on('SIGINT', onSigint);
 
-  // ── Run header ──────────────────────────────────────────────────────────
-  log(chalk.cyan.bold('agentxchain run'));
-  log(chalk.dim(`  Max turns: ${maxTurns}  Gate mode: ${autoApprove ? 'auto-approve' : 'interactive'}`));
-  if (provenance) {
-    const provenanceSummary = summarizeRunProvenance(provenance);
-    if (provenanceSummary) {
-      log(`  ${chalk.dim('Origin:')}    ${chalk.magenta(provenanceSummary)}`);
+  try {
+    // ── Run header ──────────────────────────────────────────────────────────
+    log(chalk.cyan.bold('agentxchain run'));
+    log(chalk.dim(`  Max turns: ${maxTurns}  Gate mode: ${autoApprove ? 'auto-approve' : 'interactive'}`));
+    if (provenance) {
+      const provenanceSummary = summarizeRunProvenance(provenance);
+      if (provenanceSummary) {
+        log(`  ${chalk.dim('Origin:')}    ${chalk.magenta(provenanceSummary)}`);
+      }
     }
-  }
-  if (inheritedContext) {
-    const ic = inheritedContext;
-    const phasesCount = ic.parent_phases_completed?.length || 0;
-    const decisionsCount = ic.recent_decisions?.length || 0;
-    const turnsCount = ic.recent_accepted_turns?.length || 0;
-    const parts = [];
-    if (phasesCount) parts.push(`${phasesCount} phase${phasesCount !== 1 ? 's' : ''}`);
-    if (decisionsCount) parts.push(`${decisionsCount} decision${decisionsCount !== 1 ? 's' : ''}`);
-    if (turnsCount) parts.push(`${turnsCount} turn${turnsCount !== 1 ? 's' : ''}`);
-    const detail = parts.length ? ` — ${parts.join(', ')}` : '';
-    log(`  ${chalk.dim('Inherits:')} ${chalk.magenta(`parent ${ic.parent_run_id} (${ic.parent_status || 'unknown'})${detail}`)}`);
-  }
-  log('');
+    if (inheritedContext) {
+      const ic = inheritedContext;
+      const phasesCount = ic.parent_phases_completed?.length || 0;
+      const decisionsCount = ic.recent_decisions?.length || 0;
+      const turnsCount = ic.recent_accepted_turns?.length || 0;
+      const parts = [];
+      if (phasesCount) parts.push(`${phasesCount} phase${phasesCount !== 1 ? 's' : ''}`);
+      if (decisionsCount) parts.push(`${decisionsCount} decision${decisionsCount !== 1 ? 's' : ''}`);
+      if (turnsCount) parts.push(`${turnsCount} turn${turnsCount !== 1 ? 's' : ''}`);
+      const detail = parts.length ? ` — ${parts.join(', ')}` : '';
+      log(`  ${chalk.dim('Inherits:')} ${chalk.magenta(`parent ${ic.parent_run_id} (${ic.parent_status || 'unknown'})${detail}`)}`);
+    }
+    log('');
 
-  // ── Track first-call for --role override ────────────────────────────────
-  let firstSelectRole = true;
-  let qaMissingCredentialsFallback = null;
+    // ── Track first-call for --role override ────────────────────────────────
+    let firstSelectRole = true;
+    let qaMissingCredentialsFallback = null;
 
-  // ── Callbacks ───────────────────────────────────────────────────────────
-  const callbacks = {
+    // ── Callbacks ───────────────────────────────────────────────────────────
+    const callbacks = {
     selectRole(state, cfg) {
       if (aborted) return null;
 
@@ -407,84 +417,87 @@ export async function executeGovernedRun(context, opts = {}) {
           break;
       }
     },
-  };
-
-  // ── Execute ─────────────────────────────────────────────────────────────
-  const runLoopOpts = {
-    maxTurns,
-    startNewRunFromCompleted: true,
-    startNewRunFromBlocked: opts.allowBlockedRestart ?? Boolean(provenance),
-  };
-  if (provenance) runLoopOpts.provenance = provenance;
-  if (inheritedContext) runLoopOpts.inheritedContext = inheritedContext;
-  const result = await runLoop(root, config, callbacks, runLoopOpts);
+    };
 
-  // ── Summary ─────────────────────────────────────────────────────────────
-  log('');
-  log(chalk.dim('─── Run Summary ───'));
-  log(`  Status:  ${result.ok ? chalk.green('completed') : chalk.yellow(result.stop_reason)}`);
-  log(`  Turns:   ${result.turns_executed}`);
-  log(`  Gates:   ${result.gates_approved} approved`);
-  log(`  Errors:  ${result.errors.length ? chalk.red(result.errors.length) : 'none'}`);
-
-  if (result.errors.length) {
-    for (const err of result.errors) {
-      log(chalk.red(`    ${err}`));
+    // ── Execute ─────────────────────────────────────────────────────────────
+    const runLoopOpts = {
+      maxTurns,
+      startNewRunFromCompleted: true,
+      startNewRunFromBlocked: opts.allowBlockedRestart ?? Boolean(provenance),
+    };
+    if (provenance) runLoopOpts.provenance = provenance;
+    if (inheritedContext) runLoopOpts.inheritedContext = inheritedContext;
+    const result = await runLoop(root, config, callbacks, runLoopOpts);
+
+    // ── Summary ─────────────────────────────────────────────────────────────
+    log('');
+    log(chalk.dim('─── Run Summary ───'));
+    log(`  Status:  ${result.ok ? chalk.green('completed') : chalk.yellow(result.stop_reason)}`);
+    log(`  Turns:   ${result.turns_executed}`);
+    log(`  Gates:   ${result.gates_approved} approved`);
+    log(`  Errors:  ${result.errors.length ? chalk.red(result.errors.length) : 'none'}`);
+
+    if (result.errors.length) {
+      for (const err of result.errors) {
+        log(chalk.red(`    ${err}`));
+      }
     }
-  }
 
-  if (qaMissingCredentialsFallback) {
-    printManualQaFallback(log);
-  }
+    if (qaMissingCredentialsFallback) {
+      printManualQaFallback(log);
+    }
 
-  // Recovery guidance for blocked/rejected states
-  if (result.state && (result.stop_reason === 'blocked' || result.stop_reason === 'reject_exhausted' || result.stop_reason === 'dispatch_error')) {
-    const recovery = deriveRecoveryDescriptor(result.state, config);
-    if (recovery) {
-      log('');
-      log(chalk.yellow(`  Recovery: ${recovery.typed_reason}`));
-      log(chalk.dim(`  Action:   ${recovery.recovery_action}`));
-      if (recovery.detail) {
-        log(chalk.dim(`  Detail:   ${recovery.detail}`));
+    // Recovery guidance for blocked/rejected states
+    if (result.state && (result.stop_reason === 'blocked' || result.stop_reason === 'reject_exhausted' || result.stop_reason === 'dispatch_error')) {
+      const recovery = deriveRecoveryDescriptor(result.state, config);
+      if (recovery) {
+        log('');
+        log(chalk.yellow(`  Recovery: ${recovery.typed_reason}`));
+        log(chalk.dim(`  Action:   ${recovery.recovery_action}`));
+        if (recovery.detail) {
+          log(chalk.dim(`  Detail:   ${recovery.detail}`));
+        }
       }
     }
-  }
-
-  // ── Auto governance report ──────────────────────────────────────────────
-  if (opts.report !== false && result.state) {
-    try {
-      const reportsDir = join(root, '.agentxchain', 'reports');
-      mkdirSync(reportsDir, { recursive: true });
-
-      const exportResult = buildRunExport(root);
-      if (exportResult.ok) {
-        const runId = result.state.run_id || 'unknown';
-        const exportPath = join(reportsDir, `export-${runId}.json`);
-        writeFileSync(exportPath, JSON.stringify(exportResult.export, null, 2));
-
-        const reportResult = buildGovernanceReport(exportResult.export, { input: exportPath });
-        const reportPath = join(reportsDir, `report-${runId}.md`);
-        writeFileSync(reportPath, formatGovernanceReportMarkdown(reportResult.report));
 
-        log('');
-        log(chalk.dim(`  Governance report: .agentxchain/reports/report-${runId}.md`));
-      } else {
-        log(chalk.dim(`  Governance report skipped: ${exportResult.error}`));
+    // ── Auto governance report ──────────────────────────────────────────────
+    if (opts.report !== false && result.state) {
+      try {
+        const reportsDir = join(root, '.agentxchain', 'reports');
+        mkdirSync(reportsDir, { recursive: true });
+
+        const exportResult = buildRunExport(root);
+        if (exportResult.ok) {
+          const runId = result.state.run_id || 'unknown';
+          const exportPath = join(reportsDir, `export-${runId}.json`);
+          writeFileSync(exportPath, JSON.stringify(exportResult.export, null, 2));
+
+          const reportResult = buildGovernanceReport(exportResult.export, { input: exportPath });
+          const reportPath = join(reportsDir, `report-${runId}.md`);
+          writeFileSync(reportPath, formatGovernanceReportMarkdown(reportResult.report));
+
+          log('');
+          log(chalk.dim(`  Governance report: .agentxchain/reports/report-${runId}.md`));
+        } else {
+          log(chalk.dim(`  Governance report skipped: ${exportResult.error}`));
+        }
+      } catch (err) {
+        log(chalk.dim(`  Governance report failed: ${err.message}`));
       }
-    } catch (err) {
-      log(chalk.dim(`  Governance report failed: ${err.message}`));
     }
-  }
 
-  // ── Exit code ───────────────────────────────────────────────────────────
-  const successReasons = new Set(['completed', 'gate_held', 'caller_stopped', 'max_turns_reached']);
-  return {
-    exitCode: result.ok || successReasons.has(result.stop_reason) ? 0 : 1,
-    result,
-    skipped: false,
-    skipReason: null,
-    provenance: provenance || null,
-  };
+    // ── Exit code ───────────────────────────────────────────────────────────
+    const successReasons = new Set(['completed', 'gate_held', 'caller_stopped', 'max_turns_reached']);
+    return {
+      exitCode: result.ok || successReasons.has(result.stop_reason) ? 0 : 1,
+      result,
+      skipped: false,
+      skipReason: null,
+      provenance: provenance || null,
+    };
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+  }
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────

package/src/lib/chain-reports.js

@@ -0,0 +1,54 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export function getChainReportsDir(root) {
+  return join(root, '.agentxchain', 'reports');
+}
+
+export function loadAllChainReports(root) {
+  const reportsDir = getChainReportsDir(root);
+  if (!existsSync(reportsDir)) return [];
+
+  const files = readdirSync(reportsDir)
+    .filter((file) => file.startsWith('chain-') && file.endsWith('.json'))
+    .sort()
+    .reverse();
+
+  const reports = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(reportsDir, file), 'utf8');
+      reports.push(JSON.parse(content));
+    } catch {
+      // Advisory artifact only. Skip malformed files instead of failing the surface.
+    }
+  }
+
+  reports.sort((a, b) => {
+    const aTime = a.started_at ? new Date(a.started_at).getTime() : 0;
+    const bTime = b.started_at ? new Date(b.started_at).getTime() : 0;
+    return bTime - aTime;
+  });
+
+  return reports;
+}
+
+export function loadLatestChainReport(root) {
+  const reports = loadAllChainReports(root);
+  return reports.length > 0 ? reports[0] : null;
+}
+
+export function loadChainReport(root, chainId) {
+  const reportsDir = getChainReportsDir(root);
+  const exactPath = join(reportsDir, `${chainId}.json`);
+  if (existsSync(exactPath)) {
+    try {
+      return JSON.parse(readFileSync(exactPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  const reports = loadAllChainReports(root);
+  return reports.find((report) => report.chain_id === chainId) || null;
+}

package/src/lib/dashboard/bridge-server.js

@@ -29,6 +29,7 @@ import { queryRunHistory } from '../run-history.js';
 import { loadProjectContext, loadProjectState } from '../config.js';
 import { evaluateApprovalSlaReminders } from '../notification-runner.js';
 import { readGateActionSnapshot } from './gate-action-reader.js';
+import { readChainReportSnapshot } from './chain-report-reader.js';
 
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
@@ -462,6 +463,13 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/chain-reports') {
+      const limit = url.searchParams.get('limit') ? parseInt(url.searchParams.get('limit'), 10) : undefined;
+      const result = readChainReportSnapshot(workspacePath, { limit });
+      writeJson(res, result.status, result.body);
+      return;
+    }
+
     if (pathname === '/api/gate-actions') {
       const result = readGateActionSnapshot(workspacePath);
       writeJson(res, result.status, result.body);

package/src/lib/dashboard/chain-report-reader.js

@@ -0,0 +1,15 @@
+import { loadAllChainReports, loadLatestChainReport } from '../chain-reports.js';
+
+export function readChainReportSnapshot(workspacePath, { limit } = {}) {
+  const reports = loadAllChainReports(workspacePath);
+  const effectiveLimit = Number.isInteger(limit) && limit > 0 ? limit : reports.length;
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      latest: loadLatestChainReport(workspacePath),
+      reports: reports.slice(0, effectiveLimit),
+    },
+  };
+}

package/src/lib/dashboard/state-reader.js

@@ -62,6 +62,7 @@ FILE_TO_RESOURCE[normalizeRelativePath(REPO_DECISIONS_FILE)] = '/api/repo-decisi
 export const WATCH_DIRECTORIES = [
   '',
   MULTIREPO_DIR,
+  'reports',
 ];
 
 export function normalizeRelativePath(filePath) {
@@ -69,7 +70,11 @@ export function normalizeRelativePath(filePath) {
 }
 
 export function resourceForRelativePath(filePath) {
-  return FILE_TO_RESOURCE[normalizeRelativePath(filePath)] || null;
+  const normalized = normalizeRelativePath(filePath);
+  if (normalized.startsWith('reports/chain-') && normalized.endsWith('.json')) {
+    return '/api/chain-reports';
+  }
+  return FILE_TO_RESOURCE[normalized] || null;
 }
 
 /**

package/src/lib/export-diff.js

@@ -216,6 +216,9 @@ function normalizeRunExport(artifact) {
     budget_warn_mode: budgetStatus.warn_mode === true,
     budget_exhausted: budgetStatus.exhausted === true,
     phase_gate_status: normalizeGateStatusMap(phaseGateStatus),
+    blocked_category: state.blocked_reason?.category || null,
+    blocked_gate_action_timed_out: state.blocked_reason?.gate_action?.timed_out === true,
+    blocked_gate_action_timeout_ms: typeof state.blocked_reason?.gate_action?.timeout_ms === 'number' ? state.blocked_reason.gate_action.timeout_ms : null,
     delegation_missing_decisions: normalizeDelegationMissingMap(summary.delegation_summary),
   };
 }
@@ -563,11 +566,17 @@ function detectRunRegressions(left, right) {
     const leftGate = (left.phase_gate_status || {})[gateId] || null;
     const rightGate = (right.phase_gate_status || {})[gateId] || null;
     if (leftGate && rightGate && GATE_PASSED_STATES.has(leftGate) && GATE_FAILED_STATES.has(rightGate)) {
+      let causeDetail = '';
+      if (right.blocked_category === 'gate_action_failed') {
+        causeDetail = right.blocked_gate_action_timed_out
+          ? ` (gate action timed out after ${right.blocked_gate_action_timeout_ms}ms)`
+          : ' (gate action failed)';
+      }
       regressions.push({
         id: `REG-GATE-${String(++counter).padStart(3, '0')}`,
         category: 'gate',
         severity: 'error',
-        message: `Gate "${gateId}" regressed from ${leftGate} to ${rightGate}`,
+        message: `Gate "${gateId}" regressed from ${leftGate} to ${rightGate}${causeDetail}`,
         field: `phase_gate_status.${gateId}`,
         left: leftGate,
         right: rightGate,

package/src/lib/run-chain.js

@@ -0,0 +1,262 @@
+/**
+ * Run Chain — auto-chaining governed runs for lights-out operation.
+ *
+ * When a governed run completes (or reaches another chainable terminal status),
+ * this module automatically starts a new run that inherits context from the
+ * previous one. Removes the manual `--continue-from` step and enables
+ * continuous governed delivery.
+ *
+ * Spec: .planning/RUN_CHAIN_SPEC.md
+ */
+
+import { randomUUID } from 'crypto';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { recordRunHistory, validateParentRun } from './run-history.js';
+
+const DEFAULT_MAX_CHAINS = 5;
+const DEFAULT_CHAIN_ON = ['completed'];
+const DEFAULT_COOLDOWN_SECONDS = 5;
+
+/**
+ * Resolve chain options from CLI flags and config, with CLI flags taking precedence.
+ *
+ * @param {object} opts - CLI options
+ * @param {object} config - agentxchain.json config
+ * @returns {{ enabled: boolean, maxChains: number, chainOn: string[], cooldownSeconds: number }}
+ */
+export function resolveChainOptions(opts, config) {
+  const configChain = config?.run_loop?.chain || {};
+
+  const enabled = opts.chain ?? configChain.enabled ?? false;
+  const maxChains = opts.maxChains ?? configChain.max_chains ?? DEFAULT_MAX_CHAINS;
+  const cooldownSeconds = opts.chainCooldown ?? configChain.cooldown_seconds ?? DEFAULT_COOLDOWN_SECONDS;
+
+  let chainOn;
+  if (opts.chainOn) {
+    chainOn = typeof opts.chainOn === 'string'
+      ? opts.chainOn.split(',').map(s => s.trim()).filter(Boolean)
+      : opts.chainOn;
+  } else if (Array.isArray(configChain.chain_on)) {
+    chainOn = configChain.chain_on;
+  } else {
+    chainOn = DEFAULT_CHAIN_ON;
+  }
+
+  return { enabled, maxChains, chainOn, cooldownSeconds };
+}
+
+/**
+ * Execute a chained sequence of governed runs.
+ *
+ * @param {object} context - { root, config }
+ * @param {object} opts - CLI options (passed to executeGovernedRun)
+ * @param {object} chainOpts - resolved chain options
+ * @param {Function} executeGovernedRun - the run executor function
+ * @param {Function} [log] - logging function
+ * @returns {Promise<{ exitCode: number, chainReport: object }>}
+ */
+export async function executeChainedRun(context, opts, chainOpts, executeGovernedRun, log = console.log) {
+  const chainId = `chain-${randomUUID().slice(0, 8)}`;
+  const chainOnSet = new Set(chainOpts.chainOn);
+  const maxRuns = chainOpts.maxChains + 1; // initial + continuations
+  const startedAt = new Date().toISOString();
+
+  const chainReport = {
+    chain_id: chainId,
+    started_at: startedAt,
+    runs: [],
+    total_turns: 0,
+    total_duration_ms: 0,
+    terminal_reason: null,
+  };
+
+  let previousRunId = null;
+  let lastExitCode = 0;
+  let aborted = false;
+
+  // Capture SIGINT to prevent chaining after current run
+  const onSigint = () => { aborted = true; };
+  process.on('SIGINT', onSigint);
+
+  try {
+    for (let i = 0; i < maxRuns; i++) {
+      const runNumber = i + 1;
+      log('');
+      log(`  \u2500\u2500 Chain run ${runNumber}/${maxRuns} ${'─'.repeat(50)}`);
+
+      // Build continuation options for runs after the first
+      const runOpts = { ...opts };
+      if (previousRunId) {
+        runOpts.continueFrom = previousRunId;
+        runOpts.inheritContext = true;
+      }
+
+      const runStart = Date.now();
+      const execution = await executeGovernedRun(context, runOpts);
+      const runDuration = Date.now() - runStart;
+
+      const runId = execution.result?.state?.run_id || `unknown-${i}`;
+      const stopReason = execution.result?.stop_reason || (execution.result?.ok ? 'completed' : 'unknown');
+      const turnsExecuted = execution.result?.turns_executed || 0;
+
+      chainReport.runs.push(buildRunReportEntry(execution, runDuration, {
+        fallbackRunId: runId,
+        fallbackStatus: stopReason,
+        fallbackTurns: turnsExecuted,
+      }));
+      chainReport.total_turns += turnsExecuted;
+      chainReport.total_duration_ms += runDuration;
+
+      lastExitCode = execution.exitCode;
+      previousRunId = runId;
+
+      // Check abort
+      if (aborted) {
+        chainReport.terminal_reason = 'operator_abort';
+        break;
+      }
+
+      // Check if this is the last possible run
+      if (i === maxRuns - 1) {
+        chainReport.terminal_reason = 'chain_limit_reached';
+        break;
+      }
+
+      // Check if terminal status is chainable
+      if (!chainOnSet.has(stopReason)) {
+        chainReport.terminal_reason = 'non_chainable_status';
+        break;
+      }
+
+      // Validate parent run exists for continuation
+      let validation = validateParentRun(context.root, runId);
+      if (!validation.ok && execution.result?.state && (stopReason === 'completed' || stopReason === 'blocked')) {
+        const repair = recordRunHistory(context.root, execution.result.state, context.config, stopReason);
+        if (repair.ok) {
+          validation = validateParentRun(context.root, runId);
+        }
+      }
+      if (!validation.ok) {
+        log(`  Chain: cannot continue — ${validation.error}`);
+        chainReport.terminal_reason = 'parent_validation_failed';
+        break;
+      }
+
+      // Cooldown
+      const continuationsRemaining = Math.max(0, maxRuns - (runNumber + 1));
+      log('');
+      log(`  Chain: run ${stopReason} \u2192 starting continuation (${continuationsRemaining} remaining)...`);
+      if (chainOpts.cooldownSeconds > 0) {
+        log(`  Waiting ${chainOpts.cooldownSeconds}s...`);
+        await sleep(chainOpts.cooldownSeconds * 1000);
+      }
+
+      // Check abort again after cooldown
+      if (aborted) {
+        chainReport.terminal_reason = 'operator_abort';
+        break;
+      }
+    }
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+  }
+
+  // If terminal_reason not set, derive from last run
+  if (!chainReport.terminal_reason) {
+    const lastRun = chainReport.runs[chainReport.runs.length - 1];
+    chainReport.terminal_reason = lastRun?.status || 'unknown';
+  }
+
+  chainReport.completed_at = new Date().toISOString();
+
+  // Write chain report
+  writeChainReport(context.root, chainReport);
+
+  // Print chain summary
+  printChainSummary(chainReport, log);
+
+  return { exitCode: lastExitCode, chainReport };
+}
+
+/**
+ * Write chain report to .agentxchain/reports/.
+ */
+function writeChainReport(root, report) {
+  try {
+    const reportsDir = join(root, '.agentxchain', 'reports');
+    mkdirSync(reportsDir, { recursive: true });
+    const reportPath = join(reportsDir, `${report.chain_id}.json`);
+    writeFileSync(reportPath, JSON.stringify(report, null, 2));
+  } catch {
+    // Non-fatal — chain report is advisory
+  }
+}
+
+/**
+ * Print chain summary to terminal.
+ */
+function printChainSummary(report, log) {
+  log('');
+  log('  \u2500\u2500\u2500 Chain Summary \u2500\u2500\u2500');
+  log(`  Total runs:   ${report.runs.length}`);
+  log(`  Total turns:  ${report.total_turns}`);
+  log(`  Duration:     ${formatDuration(report.total_duration_ms)}`);
+  log(`  Terminal:     ${report.terminal_reason}`);
+}
+
+/**
+ * Format milliseconds to a human-readable duration.
+ */
+function formatDuration(ms) {
+  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 sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function buildRunReportEntry(execution, runDuration, fallback = {}) {
+  const state = execution?.result?.state || null;
+  const provenance = state?.provenance || null;
+
+  return {
+    run_id: state?.run_id || fallback.fallbackRunId || 'unknown',
+    status: execution?.result?.stop_reason || fallback.fallbackStatus || 'unknown',
+    turns: execution?.result?.turns_executed || fallback.fallbackTurns || 0,
+    duration_ms: runDuration,
+    provenance_trigger: provenance?.trigger || null,
+    parent_run_id: provenance?.parent_run_id || null,
+    inherited_context_summary: summarizeInheritedContext(state?.inherited_context || null),
+  };
+}
+
+function summarizeInheritedContext(inheritedContext) {
+  if (!inheritedContext) return null;
+
+  return {
+    parent_run_id: inheritedContext.parent_run_id || null,
+    parent_status: inheritedContext.parent_status || null,
+    inherited_at: inheritedContext.inherited_at || null,
+    parent_roles_used: Array.isArray(inheritedContext.parent_roles_used)
+      ? inheritedContext.parent_roles_used
+      : [],
+    parent_phases_completed_count: Array.isArray(inheritedContext.parent_phases_completed)
+      ? inheritedContext.parent_phases_completed.length
+      : 0,
+    recent_decisions_count: Array.isArray(inheritedContext.recent_decisions)
+      ? inheritedContext.recent_decisions.length
+      : 0,
+    recent_accepted_turns_count: Array.isArray(inheritedContext.recent_accepted_turns)
+      ? inheritedContext.recent_accepted_turns.length
+      : 0,
+  };
+}