agentxchain 2.104.0 → 2.105.0

package/dashboard/live-observer.js

@@ -0,0 +1,91 @@
+export const LIVE_OBSERVER_STALE_MS = 15_000;
+
+function formatEventScope(scope) {
+  return scope === 'coordinator' ? 'coordinator' : 'run';
+}
+
+function resolveTimestamp(event) {
+  if (typeof event?.timestamp === 'string' && event.timestamp.trim()) {
+    return event.timestamp;
+  }
+  if (typeof event?.observedAt === 'string' && event.observedAt.trim()) {
+    return `${event.observedAt} (observed)`;
+  }
+  return 'unknown time';
+}
+
+export function buildLiveMeta({
+  connected,
+  lastRefreshAt,
+  lastEvent,
+  scope = 'run',
+  now = Date.now(),
+  staleAfterMs = LIVE_OBSERVER_STALE_MS,
+} = {}) {
+  const refreshMs = typeof lastRefreshAt === 'string' ? new Date(lastRefreshAt).getTime() : Number.NaN;
+  const hasRefresh = Number.isFinite(refreshMs);
+  const scopeLabel = formatEventScope(scope);
+
+  let freshnessState = 'connecting';
+  let freshnessLabel = 'Connecting';
+
+  if (!connected) {
+    freshnessState = 'disconnected';
+    freshnessLabel = 'Disconnected';
+  } else if (hasRefresh) {
+    freshnessState = (now - refreshMs) > staleAfterMs ? 'stale' : 'live';
+    freshnessLabel = freshnessState === 'live' ? 'Live' : 'Stale';
+  }
+
+  const refreshDetail = hasRefresh
+    ? `Updated ${lastRefreshAt}`
+    : connected
+      ? 'Waiting for first dashboard refresh'
+      : 'Waiting for dashboard reconnect';
+
+  const connectionDetail = connected ? 'WebSocket connected' : 'WebSocket disconnected';
+
+  let eventDetail = `No ${scopeLabel} events observed yet`;
+  if (lastEvent) {
+    const repoSuffix = scope === 'coordinator' && lastEvent.repoId ? ` from ${lastEvent.repoId}` : '';
+    eventDetail = `Last ${scopeLabel} event: ${lastEvent.type || 'unknown_event'}${repoSuffix} at ${resolveTimestamp(lastEvent)}`;
+  }
+
+  return {
+    title: scope === 'coordinator' ? 'Live Coordinator Feed' : 'Live Run Feed',
+    freshness_state: freshnessState,
+    freshness_label: freshnessLabel,
+    refresh_detail: refreshDetail,
+    connection_detail: connectionDetail,
+    event_detail: eventDetail,
+  };
+}
+
+export function createLiveEventFromMessage(message, observedAt = new Date().toISOString()) {
+  if (message?.type === 'event') {
+    return {
+      type: message.event?.event_type || 'unknown_event',
+      timestamp: message.event?.timestamp || null,
+      observedAt,
+    };
+  }
+
+  if (message?.type === 'coordinator_event') {
+    return {
+      type: message.event?.event_type || 'unknown_event',
+      timestamp: message.event?.timestamp || null,
+      observedAt,
+      repoId: message.repo_id || message.event?.repo_id || null,
+    };
+  }
+
+  return null;
+}
+
+export function shouldRefreshViewForLiveMessage(viewName, messageType) {
+  if (messageType === 'invalidate') return true;
+  if (messageType === 'coordinator_event') {
+    return viewName === 'cross-repo' || viewName === 'gate';
+  }
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.104.0",
+  "version": "2.105.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/scripts/release-bump.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Release identity creation — replaces raw `npm version <semver>`.
 # Creates version bump commit + annotated tag with fail-closed verification.
-# Usage: bash scripts/release-bump.sh --target-version <semver> [--skip-preflight]
+# Usage: bash scripts/release-bump.sh --target-version <semver> --coauthored-by "Name <email>" [--skip-preflight]
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
@@ -10,10 +10,11 @@ REPO_ROOT="$(cd "${CLI_DIR}/.." && pwd)"
 cd "$CLI_DIR"
 
 TARGET_VERSION=""
+COAUTHORED_BY=""
 SKIP_PREFLIGHT=0
 
 usage() {
-  echo "Usage: bash scripts/release-bump.sh --target-version <semver> [--skip-preflight]" >&2
+  echo "Usage: bash scripts/release-bump.sh --target-version <semver> --coauthored-by \"Name <email>\" [--skip-preflight]" >&2
 }
 
 while [[ $# -gt 0 ]]; do
@@ -32,6 +33,15 @@ while [[ $# -gt 0 ]]; do
       TARGET_VERSION="$2"
       shift 2
       ;;
+    --coauthored-by)
+      if [[ -z "${2:-}" ]]; then
+        echo "Error: --coauthored-by requires a trailer value like \"Name <email>\"" >&2
+        usage
+        exit 1
+      fi
+      COAUTHORED_BY="$2"
+      shift 2
+      ;;
     --skip-preflight)
       SKIP_PREFLIGHT=1
       shift
@@ -49,6 +59,12 @@ if [[ -z "$TARGET_VERSION" ]]; then
   exit 1
 fi
 
+if [[ -z "$COAUTHORED_BY" ]]; then
+  echo "Error: --coauthored-by is required so the release commit carries the mandated trailer" >&2
+  usage
+  exit 1
+fi
+
 echo "AgentXchain Release Identity: ${TARGET_VERSION}"
 echo "============================================="
 
@@ -280,13 +296,20 @@ echo "  OK: version files and allowed release surfaces staged"
 
 # 9. Create release commit
 echo "[9/10] Creating release commit..."
-git commit -m "${TARGET_VERSION}"
+git commit -m "${TARGET_VERSION}
+
+Co-Authored-By: ${COAUTHORED_BY}"
 RELEASE_SHA=$(git rev-parse HEAD)
 COMMIT_MSG=$(git log -1 --format=%s)
 if [[ "$COMMIT_MSG" != "$TARGET_VERSION" ]]; then
   echo "FAIL: commit message is '${COMMIT_MSG}', expected '${TARGET_VERSION}'" >&2
   exit 1
 fi
+COMMIT_BODY=$(git log -1 --format=%B)
+if [[ "$COMMIT_BODY" != *"Co-Authored-By: ${COAUTHORED_BY}"* ]]; then
+  echo "FAIL: release commit body is missing the required Co-Authored-By trailer" >&2
+  exit 1
+fi
 echo "  OK: commit ${RELEASE_SHA:0:7} with message '${TARGET_VERSION}'"
 
 # 9.5. Inline preflight gate — tests, pack, and docs build must pass before tag

package/src/commands/accept-turn.js

@@ -54,7 +54,7 @@ export async function acceptTurnCommand(opts = {}) {
     }
 
     if (result.error_code?.startsWith('hook_') || result.error_code === 'hook_blocked') {
-      const recovery = deriveRecoveryDescriptor(result.state);
+      const recovery = deriveRecoveryDescriptor(result.state, config);
       const activeTurn = result.state?.current_turn;
       const hookName = result.hookResults?.blocker?.hook_name
         || result.hookResults?.results?.find((entry) => entry.hook_name)?.hook_name
@@ -94,7 +94,7 @@ export async function acceptTurnCommand(opts = {}) {
       console.log(`  ${chalk.dim('Overlap:')}  ${(result.conflict.overlap_ratio * 100).toFixed(0)}%`);
       console.log(`  ${chalk.dim('Suggest:')}  ${result.conflict.suggested_resolution}`);
       if (result.state?.status === 'blocked') {
-        const recovery = deriveRecoveryDescriptor(result.state);
+        const recovery = deriveRecoveryDescriptor(result.state, config);
         if (recovery) {
           console.log(`  ${chalk.dim('Action:')}   ${recovery.recovery_action}`);
         }
@@ -177,7 +177,7 @@ export async function acceptTurnCommand(opts = {}) {
   }
   console.log('');
 
-  const recovery = deriveRecoveryDescriptor(result.state);
+  const recovery = deriveRecoveryDescriptor(result.state, config);
   if (recovery) {
     console.log(`  ${chalk.dim('Reason:')}   ${recovery.typed_reason}`);
     console.log(`  ${chalk.dim('Owner:')}    ${recovery.owner}`);

package/src/commands/decisions.js

@@ -7,7 +7,14 @@
 import { resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import chalk from 'chalk';
-import { readRepoDecisions, getActiveRepoDecisions, getRepoDecisionById, resolveDecisionAuthority } from '../lib/repo-decisions.js';
+import {
+  readRepoDecisions,
+  getActiveRepoDecisions,
+  getRepoDecisionById,
+  resolveDecisionAuthority,
+  getDecisionAuthorityMetadata,
+  summarizeRepoDecisions,
+} from '../lib/repo-decisions.js';
 
 /**
  * @param {object} opts - { json?: boolean, all?: boolean, show?: string, dir?: string }
@@ -18,6 +25,7 @@ export async function decisionsCommand(opts) {
     console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
     process.exit(1);
   }
+  const config = loadConfig(root);
 
   // ── Show single decision ───────────────────────────────────────────────
   if (opts.show) {
@@ -26,59 +34,68 @@ export async function decisionsCommand(opts) {
       console.error(chalk.red(`Decision ${opts.show} not found in repo decisions.`));
       process.exit(1);
     }
+    const enriched = enrichDecision(dec, config);
     if (opts.json) {
-      console.log(JSON.stringify(dec, null, 2));
+      console.log(JSON.stringify(enriched, null, 2));
       return;
     }
-    console.log(chalk.bold(`Decision ${dec.id}`));
-    console.log(`  Category:    ${dec.category}`);
-    console.log(`  Statement:   ${dec.statement}`);
-    console.log(`  Rationale:   ${dec.rationale}`);
-    console.log(`  Status:      ${formatStatus(dec.status)}`);
-    console.log(`  Role:        ${dec.role || '—'}`);
-    console.log(`  Phase:       ${dec.phase || '—'}`);
-    console.log(`  Run:         ${(dec.run_id || '—').slice(0, 16)}`);
-    console.log(`  Turn:        ${(dec.turn_id || '—').slice(0, 16)}`);
-    console.log(`  Durability:  ${dec.durability || 'repo'}`);
+    console.log(chalk.bold(`Decision ${enriched.id}`));
+    console.log(`  Category:    ${enriched.category || '—'}`);
+    console.log(`  Statement:   ${enriched.statement || '—'}`);
+    console.log(`  Rationale:   ${enriched.rationale || '—'}`);
+    console.log(`  Status:      ${formatStatus(enriched.status)}`);
+    console.log(`  Binding:     ${formatBindingState(enriched.binding_state)}`);
+    console.log(`  Role:        ${enriched.role || '—'}`);
+    console.log(`  Phase:       ${enriched.phase || '—'}`);
+    console.log(`  Run:         ${(enriched.run_id || '—').slice(0, 16)}`);
+    console.log(`  Turn:        ${(enriched.turn_id || '—').slice(0, 16)}`);
+    console.log(`  Durability:  ${enriched.durability || 'repo'}`);
     // Show decision authority if config has it
-    const config = loadConfig(root);
-    if (config && dec.role) {
-      const auth = resolveDecisionAuthority(dec.role, config);
+    if (config && enriched.role) {
+      const auth = resolveDecisionAuthority(enriched.role, config);
       if (auth !== null && !(typeof auth === 'object' && auth.unknown)) {
-        console.log(`  Authority:   ${auth} (${dec.role})`);
+        console.log(`  Authority:   ${auth} (${enriched.role})`);
       }
     }
-    if (dec.overrides) {
-      console.log(`  Supersedes:  ${chalk.yellow(dec.overrides)}`);
+    if (enriched.overrides) {
+      console.log(`  Supersedes:  ${chalk.yellow(enriched.overrides)}`);
     }
-    console.log(`  Created:     ${dec.created_at || '—'}`);
-    if (dec.overridden_by) {
-      console.log(`  Overridden:  ${chalk.yellow(dec.overridden_by)}`);
+    console.log(`  Created:     ${enriched.created_at || '—'}`);
+    if (enriched.overridden_by) {
+      console.log(`  Overridden:  ${chalk.yellow(enriched.overridden_by)}`);
     }
     return;
   }
 
   // ── List decisions ─────────────────────────────────────────────────────
-  const decisions = opts.all ? readRepoDecisions(root) : getActiveRepoDecisions(root);
+  const allDecisions = readRepoDecisions(root);
+  const decisions = opts.all ? allDecisions : getActiveRepoDecisions(root);
+  const enrichedDecisions = decisions.map((dec) => enrichDecision(dec, config));
 
   if (opts.json) {
-    console.log(JSON.stringify(decisions, null, 2));
+    console.log(JSON.stringify(enrichedDecisions, null, 2));
     return;
   }
 
-  if (decisions.length === 0) {
-    console.log(chalk.dim('No repo-level decisions found.'));
-    if (!opts.all) {
+  if (enrichedDecisions.length === 0) {
+    console.log(chalk.dim(opts.all ? 'No repo-level decisions found.' : 'No active repo decisions found.'));
+    if (!opts.all && allDecisions.length > 0) {
       console.log(chalk.dim('Use --all to include overridden decisions.'));
+      return;
     }
     return;
   }
 
   const label = opts.all ? 'Repo Decisions (all)' : 'Active Repo Decisions';
-  console.log(chalk.bold(`${label}: ${decisions.length}`));
+  const summary = buildDecisionListSummary(summarizeRepoDecisions(allDecisions, config), opts.all);
+  console.log(chalk.bold(`${label}: ${enrichedDecisions.length}`));
+  console.log(chalk.dim(summary.binding_line));
+  if (summary.category_line) console.log(chalk.dim(summary.category_line));
+  if (summary.history_line) console.log(chalk.dim(summary.history_line));
+  if (summary.authority_line) console.log(chalk.dim(summary.authority_line));
   console.log('');
 
-  for (const dec of decisions) {
+  for (const dec of enrichedDecisions) {
     const status = formatStatus(dec.status);
     const runShort = (dec.run_id || '').slice(0, 12);
     const override = dec.overridden_by
@@ -86,8 +103,9 @@ export async function decisionsCommand(opts) {
       : dec.overrides
         ? chalk.dim(` ← supersedes ${dec.overrides}`)
         : '';
+    const authority = formatAuthority(dec);
     console.log(`  ${chalk.cyan(dec.id)}  ${status}  ${chalk.dim(dec.category)}  ${dec.statement}${override}`);
-    console.log(`    ${chalk.dim(`by ${dec.role || '?'} in ${runShort || '?'}`)}`);
+    console.log(`    ${chalk.dim(`by ${dec.role || '?'} in ${runShort || '?'}${authority}`)}`);
   }
 }
 
@@ -97,6 +115,57 @@ function formatStatus(status) {
   return chalk.dim(status || '—');
 }
 
+function enrichDecision(decision, config) {
+  const authority = getDecisionAuthorityMetadata(decision.role, config);
+  return {
+    ...decision,
+    binding_state: decision.status === 'active'
+      ? 'binding'
+      : decision.overridden_by
+        ? 'replaced'
+        : 'historical',
+    authority_level: authority?.level ?? null,
+    authority_source: authority?.source ?? null,
+  };
+}
+
+function buildDecisionListSummary(summary, includeAll) {
+  const categories = summary?.operator_summary?.active_categories || [];
+  const highestAuthority = summary?.operator_summary?.highest_active_authority_level;
+  const highestAuthorityRole = summary?.operator_summary?.highest_active_authority_role;
+  const activeCount = summary?.active_count || 0;
+  const overriddenCount = summary?.overridden_count || 0;
+  return {
+    binding_line: `binding now: ${activeCount} active decision${activeCount === 1 ? '' : 's'}`,
+    category_line: categories.length > 0
+      ? `categories: ${categories.join(', ')}`
+      : null,
+    history_line: overriddenCount > 0
+      ? includeAll
+        ? `history: ${overriddenCount} overridden decision${overriddenCount === 1 ? '' : 's'} recorded`
+        : `history: ${overriddenCount} overridden decision${overriddenCount === 1 ? '' : 's'} hidden (use --all)`
+      : null,
+    authority_line: typeof highestAuthority === 'number'
+      ? `highest active authority: ${highestAuthority} (${highestAuthorityRole || 'unknown'})`
+      : null,
+  };
+}
+
+function formatAuthority(decision) {
+  if (typeof decision.authority_level === 'number') {
+    if (decision.authority_source === 'unknown_role') return ' • authority unknown';
+    return ` • authority ${decision.authority_level}`;
+  }
+  return '';
+}
+
+function formatBindingState(bindingState) {
+  if (bindingState === 'binding') return chalk.green('binding');
+  if (bindingState === 'replaced') return chalk.yellow('replaced');
+  if (bindingState === 'historical') return chalk.dim('historical');
+  return chalk.dim('—');
+}
+
 function findProjectRoot(dir) {
   let current = resolve(dir);
   while (current !== '/') {

package/src/commands/diff.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 
 import { findProjectRoot } from '../lib/config.js';
 import { buildExportDiff, resolveExportArtifact } from '../lib/export-diff.js';
+import { buildExportDiffSummary, buildRunDiffSummary } from '../lib/history-diff-summary.js';
 import { buildRunDiff, resolveRunHistoryReference } from '../lib/run-diff.js';
 
 export async function diffCommand(leftRef, rightRef, opts) {
@@ -28,7 +29,10 @@ export async function diffCommand(leftRef, rightRef, opts) {
     }
 
     if (opts.json) {
-      console.log(JSON.stringify(exportDiff.diff, null, 2));
+      console.log(JSON.stringify({
+        ...exportDiff.diff,
+        summary: buildExportDiffSummary(exportDiff.diff),
+      }, null, 2));
       return;
     }
 
@@ -56,7 +60,10 @@ export async function diffCommand(leftRef, rightRef, opts) {
 
   const diff = buildRunDiff(leftResult.entry, rightResult.entry);
   if (opts.json) {
-    console.log(JSON.stringify(diff, null, 2));
+    console.log(JSON.stringify({
+      ...diff,
+      summary: buildRunDiffSummary(diff),
+    }, null, 2));
     return;
   }
 
@@ -65,12 +72,13 @@ export async function diffCommand(leftRef, rightRef, opts) {
 
 function formatRunDiffText(diff) {
   const lines = [];
+  const summary = buildRunDiffSummary(diff);
   lines.push(chalk.bold('Run Diff'));
   lines.push(`${chalk.dim('Left:')}  ${formatRunHeader(diff.left)}`);
   lines.push(`${chalk.dim('Right:')} ${formatRunHeader(diff.right)}`);
+  appendComparisonSummary(lines, summary);
 
   if (!diff.changed) {
-    lines.push('');
     lines.push(chalk.green('No differences.'));
     return lines.join('\n');
   }
@@ -96,12 +104,13 @@ function formatRunDiffText(diff) {
 
 function formatExportDiffText(diff) {
   const lines = [];
+  const summary = buildExportDiffSummary(diff);
   lines.push(chalk.bold('Export Diff'));
   lines.push(`${chalk.dim('Left:')}  ${formatExportHeader(diff.left_ref, diff.left)}`);
   lines.push(`${chalk.dim('Right:')} ${formatExportHeader(diff.right_ref, diff.right)}`);
+  appendComparisonSummary(lines, summary);
 
   if (!diff.changed) {
-    lines.push('');
     lines.push(chalk.green('No differences.'));
     return lines.join('\n');
   }
@@ -158,6 +167,20 @@ function appendRegressionSection(lines, regressions) {
   }
 }
 
+function appendComparisonSummary(lines, summary) {
+  lines.push('');
+  lines.push(chalk.bold('Comparison Summary'));
+  lines.push(`- Outcome: ${summary.outcome}`);
+  lines.push(`- Risk: ${summary.risk_level}`);
+  if (Array.isArray(summary.highlights) && summary.highlights.length > 0) {
+    lines.push('- Highlights:');
+    for (const item of summary.highlights) {
+      lines.push(`  - ${item}`);
+    }
+  }
+  lines.push('');
+}
+
 function listChangeItems(entry) {
   const items = [];
   if (entry.added.length > 0) {

package/src/commands/doctor.js

@@ -11,6 +11,11 @@ import { loadNormalizedConfig, detectConfigVersion } from '../lib/normalized-con
 import { readDaemonState, evaluateDaemonStatus } from '../lib/run-schedule.js';
 import { getGovernedVersionSurface, formatGovernedVersionLabel } from '../lib/protocol-version.js';
 import { PLUGIN_MANIFEST_FILE } from '../lib/plugins.js';
+import {
+  getRoleRuntimeCapabilityContract,
+  summarizeRoleRuntimeCapability,
+  summarizeRuntimeCapabilityContract,
+} from '../lib/runtime-capabilities.js';
 
 export async function doctorCommand(opts = {}) {
   const root = findProjectRoot(process.cwd());
@@ -76,8 +81,9 @@ function governedDoctor(root, rawConfig, opts) {
   // 3. Runtime reachable — one sub-check per runtime
   // Use normalized runtimes if available, otherwise fall back to raw config
   const runtimes = (normalized && normalized.runtimes) || rawConfig.runtimes || {};
+  const rolesByRuntime = buildRolesByRuntime(normalized?.roles || {});
   for (const [rtId, rt] of Object.entries(runtimes)) {
-    const check = checkRuntimeReachable(rtId, rt);
+    const check = checkRuntimeReachable(rtId, rt, rolesByRuntime[rtId] || []);
     checks.push(check);
   }
   const connectorProbe = getConnectorProbeRecommendation(runtimes);
@@ -290,6 +296,12 @@ function governedDoctor(root, rawConfig, opts) {
             ? chalk.dim('INFO')
             : chalk.red('FAIL');
       console.log(`  ${badge}  ${c.name.padEnd(24)} ${chalk.dim(c.detail)}`);
+      if (c.runtime_contract) {
+        console.log(`        ${chalk.dim(summarizeRuntimeCapabilityContract(c.runtime_contract))}`);
+        if (Array.isArray(c.bound_roles) && c.bound_roles.length > 0) {
+          console.log(`        ${chalk.dim(`roles: ${c.bound_roles.map(summarizeRoleRuntimeCapability).join(' | ')}`)}`);
+        }
+      }
     }
 
     console.log('');
@@ -309,25 +321,45 @@ function governedDoctor(root, rawConfig, opts) {
   process.exit(failCount > 0 ? 1 : 0);
 }
 
-function checkRuntimeReachable(rtId, rt) {
+function buildRolesByRuntime(roles) {
+  const grouped = {};
+  for (const [roleId, role] of Object.entries(roles || {})) {
+    if (!role?.runtime_id) continue;
+    if (!grouped[role.runtime_id]) grouped[role.runtime_id] = [];
+    grouped[role.runtime_id].push([roleId, role]);
+  }
+  return grouped;
+}
+
+function attachRuntimeContract(baseCheck, rtId, rt, boundRoleEntries) {
+  const bound_roles = boundRoleEntries.map(([roleId, role]) => getRoleRuntimeCapabilityContract(roleId, role, rt));
+  return {
+    ...baseCheck,
+    runtime_type: rt?.type || 'unknown',
+    runtime_contract: bound_roles[0]?.runtime_contract || getRoleRuntimeCapabilityContract('__unbound__', { write_authority: 'unknown' }, rt).runtime_contract,
+    bound_roles,
+  };
+}
+
+function checkRuntimeReachable(rtId, rt, boundRoleEntries = []) {
   const base = { id: `runtime_${rtId}`, name: `Runtime: ${rtId}` };
 
   if (!rt || !rt.type) {
-    return { ...base, level: 'warn', detail: 'No runtime type specified' };
+    return attachRuntimeContract({ ...base, level: 'warn', detail: 'No runtime type specified' }, rtId, rt, boundRoleEntries);
   }
 
   switch (rt.type) {
     case 'manual':
-      return { ...base, level: 'pass', detail: 'Manual runtime (no binary needed)' };
+      return attachRuntimeContract({ ...base, level: 'pass', detail: 'Manual runtime (no binary needed)' }, rtId, rt, boundRoleEntries);
 
     case 'local_cli': {
       const cmd = Array.isArray(rt.command) ? rt.command[0] : (typeof rt.command === 'string' ? rt.command.split(/\s+/)[0] : null);
-      if (!cmd) return { ...base, level: 'warn', detail: 'No command configured' };
+      if (!cmd) return attachRuntimeContract({ ...base, level: 'warn', detail: 'No command configured' }, rtId, rt, boundRoleEntries);
       try {
         execSync(`command -v ${cmd}`, { stdio: 'ignore' });
-        return { ...base, level: 'pass', detail: `${cmd} binary found` };
+        return attachRuntimeContract({ ...base, level: 'pass', detail: `${cmd} binary found` }, rtId, rt, boundRoleEntries);
       } catch {
-        return { ...base, level: 'fail', detail: `${cmd} not found in PATH` };
+        return attachRuntimeContract({ ...base, level: 'fail', detail: `${cmd} not found in PATH` }, rtId, rt, boundRoleEntries);
       }
     }
 
@@ -335,34 +367,34 @@ function checkRuntimeReachable(rtId, rt) {
       const envVar = rt.auth_env;
       if (!envVar) {
         // ollama and similar providers may not require auth
-        return { ...base, level: 'pass', detail: `${rt.provider || 'unknown'} provider (no auth required)` };
+        return attachRuntimeContract({ ...base, level: 'pass', detail: `${rt.provider || 'unknown'} provider (no auth required)` }, rtId, rt, boundRoleEntries);
       }
       if (process.env[envVar]) {
-        return { ...base, level: 'pass', detail: `${envVar} is set` };
+        return attachRuntimeContract({ ...base, level: 'pass', detail: `${envVar} is set` }, rtId, rt, boundRoleEntries);
       }
-      return { ...base, level: 'fail', detail: `${envVar} not set` };
+      return attachRuntimeContract({ ...base, level: 'fail', detail: `${envVar} not set` }, rtId, rt, boundRoleEntries);
     }
 
     case 'mcp': {
       const transport = rt.transport || 'stdio';
       if (transport === 'streamable_http') {
-        return { ...base, level: 'warn', detail: 'Remote MCP endpoint (cannot verify at doctor time)' };
+        return attachRuntimeContract({ ...base, level: 'warn', detail: 'Remote MCP endpoint (cannot verify at doctor time)' }, rtId, rt, boundRoleEntries);
       }
       const cmd = Array.isArray(rt.command) ? rt.command[0] : (typeof rt.command === 'string' ? rt.command.split(/\s+/)[0] : null);
-      if (!cmd) return { ...base, level: 'warn', detail: 'No MCP command configured' };
+      if (!cmd) return attachRuntimeContract({ ...base, level: 'warn', detail: 'No MCP command configured' }, rtId, rt, boundRoleEntries);
       try {
         execSync(`command -v ${cmd}`, { stdio: 'ignore' });
-        return { ...base, level: 'pass', detail: `${cmd} binary found` };
+        return attachRuntimeContract({ ...base, level: 'pass', detail: `${cmd} binary found` }, rtId, rt, boundRoleEntries);
       } catch {
-        return { ...base, level: 'fail', detail: `${cmd} not found in PATH` };
+        return attachRuntimeContract({ ...base, level: 'fail', detail: `${cmd} not found in PATH` }, rtId, rt, boundRoleEntries);
       }
     }
 
     case 'remote_agent':
-      return { ...base, level: 'warn', detail: 'Remote agent endpoint (cannot verify at doctor time)' };
+      return attachRuntimeContract({ ...base, level: 'warn', detail: 'Remote agent endpoint (cannot verify at doctor time)' }, rtId, rt, boundRoleEntries);
 
     default:
-      return { ...base, level: 'warn', detail: `Unknown runtime type: ${rt.type}` };
+      return attachRuntimeContract({ ...base, level: 'warn', detail: `Unknown runtime type: ${rt.type}` }, rtId, rt, boundRoleEntries);
   }
 }
 

package/src/commands/history.js

@@ -5,10 +5,11 @@
  */
 
 import { resolve } from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
 import chalk from 'chalk';
 import { queryRunHistory, queryRunLineage, isInheritable } from '../lib/run-history.js';
-import { getRunTriggerLabel, summarizeRunProvenance } from '../lib/run-provenance.js';
+import { buildRunOutcomeSummary } from '../lib/history-diff-summary.js';
+import { getRunTriggerLabel } from '../lib/run-provenance.js';
 
 /**
  * @param {object} opts - { json?: boolean, limit?: number, status?: string, dir?: string }
@@ -67,7 +68,11 @@ export async function historyCommand(opts) {
   });
 
   if (opts.json) {
-    const enriched = entries.map(e => ({ ...e, inheritable: isInheritable(e) }));
+    const enriched = entries.map((e) => ({
+      ...e,
+      inheritable: isInheritable(e),
+      outcome_summary: buildRunOutcomeSummary(e),
+    }));
     console.log(JSON.stringify(enriched, null, 2));
     return;
   }
@@ -85,6 +90,7 @@ export async function historyCommand(opts) {
     pad('#', 4),
     pad('Run ID', 14),
     pad('Status', 11),
+    pad('Outcome', 11),
     pad('Trigger', 14),
     pad('Ctx', 4),
     pad('Phases', 8),
@@ -102,6 +108,7 @@ export async function historyCommand(opts) {
     const idx = String(i + 1);
     const runId = (entry.run_id || '—').slice(0, 12);
     const status = formatStatus(entry.status);
+    const outcome = buildRunOutcomeSummary(entry);
     const trigger = getRunTriggerLabel(entry.provenance);
     const ctx = isInheritable(entry) ? '✓' : '—';
     const phases = String(entry.phases_completed?.length || 0);
@@ -121,6 +128,7 @@ export async function historyCommand(opts) {
       pad(idx, 4),
       pad(runId, 14),
       pad(status, 11),
+      pad(outcome.label, 11),
       pad(trigger, 14),
       pad(ctx, 4),
       pad(phases, 8),
@@ -130,6 +138,10 @@ export async function historyCommand(opts) {
       pad(date, 20),
       pad(headline, 42),
     ].join(' '));
+
+    if (outcome.next_action) {
+      console.log(chalk.dim(`     next: ${truncateLine(outcome.next_action, 148)}`));
+    }
   });
 
   console.log(chalk.dim(`\n${entries.length} run(s) shown`));
@@ -176,3 +188,9 @@ function formatHeadline(headline) {
   if (normalized.length <= 40) return normalized;
   return `${normalized.slice(0, 39)}…`;
 }
+
+function truncateLine(value, max) {
+  if (typeof value !== 'string') return '';
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}…`;
+}