agentxchain 2.109.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/blocked.js

@@ -120,8 +120,10 @@ function renderGateActionFailure(gateActions, state) {
     html += `<div class="annotation-list">`;
     for (const action of actions) {
       const label = action.action_label || action.command || `action ${action.action_index || '?'}`;
-      const outcome = action.status === 'failed' ? '❌ failed' : '✅ succeeded';
-      const exitStr = action.exit_code != null ? ` (exit ${action.exit_code})` : '';
+      const outcome = action.status === 'failed'
+        ? (action.timed_out ? `⏱ timed out after ${action.timeout_ms}ms` : '❌ failed')
+        : '✅ succeeded';
+      const exitStr = action.timed_out ? '' : (action.exit_code != null ? ` (exit ${action.exit_code})` : '');
       html += `<div class="annotation-card">
         <span class="mono">${esc(String(action.action_index || '?'))}.</span>
         <span>${esc(label)}</span>

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/gate.js

@@ -240,9 +240,12 @@ function renderGateActionsSection(gateActions) {
       html += `<ul>`;
       for (const a of attempt.actions) {
         const aLabel = a.action_label || a.command || `action ${a.action_index || '?'}`;
-        const outcome = a.status === 'failed' ? '❌' : '✅';
-        const exitStr = a.exit_code != null ? ` (exit ${a.exit_code})` : '';
-        html += `<li>${outcome} ${esc(aLabel)}${esc(exitStr)}</li>`;
+        const outcome = a.status === 'failed'
+          ? (a.timed_out ? '⏱' : '❌')
+          : '✅';
+        const timeoutStr = a.timed_out ? ` timed out after ${a.timeout_ms}ms` : '';
+        const exitStr = a.timed_out ? '' : (a.exit_code != null ? ` (exit ${a.exit_code})` : '');
+        html += `<li>${outcome} ${esc(aLabel)}${esc(exitStr)}${esc(timeoutStr)}</li>`;
       }
       html += `</ul>`;
     }

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

package/src/commands/approve-completion.js

@@ -44,7 +44,8 @@ export async function approveCompletionCommand(opts) {
     if (result.gate_actions?.length > 0) {
       console.log(`  ${chalk.dim('Gate actions:')} ${result.gate_actions.length}`);
       for (const action of result.gate_actions) {
-        console.log(`    ${action.index}. ${action.label || action.run}`);
+        const timeoutHint = action.timeout_ms && action.timeout_ms !== 900_000 ? chalk.dim(` [timeout: ${action.timeout_ms}ms]`) : '';
+        console.log(`    ${action.index}. ${action.label || action.run}${timeoutHint}`);
         if (action.label) {
           console.log(`       ${chalk.dim(action.run)}`);
         }
@@ -103,6 +104,10 @@ function printGateHookFailure(result, gateType, gateInfo) {
 
 function printGateActionFailure(result, gateInfo) {
   const failure = result.gateActionRun?.failed_action;
+  const exitLabel = failure?.timed_out
+    ? `timeout after ${failure.timeout_ms}ms`
+    : failure?.exit_code ?? failure?.signal ?? 'unknown';
+  const stderrOrError = failure?.stderr_tail || failure?.spawn_error || null;
 
   console.log('');
   console.log(chalk.yellow('  Run Completion Blocked By Gate Action'));
@@ -110,9 +115,9 @@ function printGateActionFailure(result, gateInfo) {
   console.log('');
   console.log(`  ${chalk.dim('Gate:')}     ${gateInfo.gate}`);
   console.log(`  ${chalk.dim('Action:')}   ${failure?.action_label || failure?.command || '(unknown)'}`);
-  console.log(`  ${chalk.dim('Exit:')}     ${failure?.exit_code ?? failure?.signal ?? 'unknown'}`);
-  if (failure?.stderr_tail) {
-    console.log(`  ${chalk.dim('stderr:')}   ${failure.stderr_tail}`);
+  console.log(`  ${chalk.dim('Exit:')}     ${exitLabel}`);
+  if (stderrOrError) {
+    console.log(`  ${chalk.dim('stderr:')}   ${stderrOrError}`);
   }
   console.log(`  ${chalk.dim('Retry:')}    agentxchain approve-completion`);
   console.log('');

package/src/commands/approve-transition.js

@@ -43,7 +43,8 @@ export async function approveTransitionCommand(opts) {
     if (result.gate_actions?.length > 0) {
       console.log(`  ${chalk.dim('Gate actions:')} ${result.gate_actions.length}`);
       for (const action of result.gate_actions) {
-        console.log(`    ${action.index}. ${action.label || action.run}`);
+        const timeoutHint = action.timeout_ms && action.timeout_ms !== 900_000 ? chalk.dim(` [timeout: ${action.timeout_ms}ms]`) : '';
+        console.log(`    ${action.index}. ${action.label || action.run}${timeoutHint}`);
         if (action.label) {
           console.log(`       ${chalk.dim(action.run)}`);
         }
@@ -108,6 +109,10 @@ function printGateHookFailure(result, gateType, gateInfo) {
 
 function printGateActionFailure(result, gateType, gateInfo) {
   const failure = result.gateActionRun?.failed_action;
+  const exitLabel = failure?.timed_out
+    ? `timeout after ${failure.timeout_ms}ms`
+    : failure?.exit_code ?? failure?.signal ?? 'unknown';
+  const stderrOrError = failure?.stderr_tail || failure?.spawn_error || null;
 
   console.log('');
   console.log(chalk.yellow(`  ${gateType === 'phase_transition' ? 'Phase Transition' : 'Run Completion'} Blocked By Gate Action`));
@@ -119,9 +124,9 @@ function printGateActionFailure(result, gateType, gateInfo) {
   }
   console.log(`  ${chalk.dim('Gate:')}     ${gateInfo.gate}`);
   console.log(`  ${chalk.dim('Action:')}   ${failure?.action_label || failure?.command || '(unknown)'}`);
-  console.log(`  ${chalk.dim('Exit:')}     ${failure?.exit_code ?? failure?.signal ?? 'unknown'}`);
-  if (failure?.stderr_tail) {
-    console.log(`  ${chalk.dim('stderr:')}   ${failure.stderr_tail}`);
+  console.log(`  ${chalk.dim('Exit:')}     ${exitLabel}`);
+  if (stderrOrError) {
+    console.log(`  ${chalk.dim('stderr:')}   ${stderrOrError}`);
   }
   console.log(`  ${chalk.dim('Retry:')}    ${gateType === 'phase_transition' ? 'agentxchain approve-transition' : 'agentxchain approve-completion'}`);
   console.log('');

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') {