agentxchain 2.69.0 → 2.71.0

package/package.json

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

package/src/commands/multi.js

@@ -10,6 +10,7 @@
  *   multi resync       — detect divergence and rebuild coordinator state from repo authority
  */
 
+import chalk from 'chalk';
 import { loadCoordinatorConfig } from '../lib/coordinator-config.js';
 import {
   initializeCoordinatorRun,
@@ -105,11 +106,44 @@ export async function multiStatusCommand(options) {
   }
 
   console.log(`Super Run:    ${status.super_run_id}`);
-  console.log(`Status:       ${status.status}`);
+  console.log(`Status:       ${formatCoordinatorStatus(status.status)}`);
   console.log(`Phase:        ${status.phase}`);
 
+  // Elapsed time for active runs
+  if (status.created_at && status.status === 'active') {
+    const elapsedMs = Date.now() - new Date(status.created_at).getTime();
+    if (elapsedMs >= 0) {
+      const secs = Math.floor(elapsedMs / 1000);
+      const mins = Math.floor(secs / 60);
+      const remainSecs = secs % 60;
+      const elapsed = mins > 0 ? `${mins}m ${remainSecs}s` : `${remainSecs}s`;
+      console.log(`Elapsed:      ${elapsed}`);
+    }
+  }
+
+  // Blocked state with reason
+  if (status.status === 'blocked') {
+    const reason = (typeof status.blocked_reason === 'string' && status.blocked_reason.trim())
+      ? status.blocked_reason.trim()
+      : 'unknown reason';
+    console.log(`Blocked:      ${chalk.red.bold('BLOCKED')} — ${reason}`);
+  }
+
+  // Pending gate with phase transition direction
   if (status.pending_gate) {
-    console.log(`Pending Gate: ${status.pending_gate.gate} (${status.pending_gate.gate_type})`);
+    const pg = status.pending_gate;
+    const fromTo = pg.from && pg.to ? ` ${pg.from} → ${pg.to}` : '';
+    console.log(`Pending Gate: ${pg.gate} (${pg.gate_type})${fromTo}`);
+    console.log(`Action:       Run ${chalk.cyan('agentxchain multi approve-gate')} to advance`);
+  }
+
+  // Completed state
+  if (status.status === 'completed') {
+    console.log('');
+    console.log(`  ${chalk.green.bold('✓ Coordinator run completed')}`);
+    if (status.updated_at) {
+      console.log(`  ${chalk.dim('Completed:')} ${status.updated_at}`);
+    }
   }
 
   console.log('');
@@ -119,6 +153,17 @@ export async function multiStatusCommand(options) {
     console.log(`  ${repoId}: ${info.status || 'unknown'}${phase} (run: ${info.run_id})`);
   }
 
+  // Phase gate status
+  const gateEntries = Object.entries(status.phase_gate_status || {});
+  if (gateEntries.length > 0) {
+    console.log('');
+    console.log('Gates:');
+    for (const [gate, gateStatus] of gateEntries) {
+      const icon = gateStatus === 'passed' ? chalk.green('✓') : chalk.dim('○');
+      console.log(`  ${icon} ${gate}: ${gateStatus}`);
+    }
+  }
+
   const barrierEntries = Object.entries(barriers || {});
   if (barrierEntries.length > 0) {
     console.log('');
@@ -129,6 +174,15 @@ export async function multiStatusCommand(options) {
   }
 }
 
+function formatCoordinatorStatus(status) {
+  switch (status) {
+    case 'active': return chalk.green(status);
+    case 'blocked': return chalk.red.bold(status);
+    case 'completed': return chalk.cyan(status);
+    default: return status;
+  }
+}
+
 // ── multi step ─────────────────────────────────────────────────────────────
 
 export async function multiStepCommand(options) {

package/src/lib/coordinator-state.js

@@ -401,6 +401,10 @@ export function getCoordinatorStatus(workspacePath) {
     repo_runs: state.repo_runs,
     pending_barriers: pendingBarriers,
     pending_gate: state.pending_gate ?? null,
+    blocked_reason: state.blocked_reason ?? null,
+    created_at: state.created_at ?? null,
+    updated_at: state.updated_at ?? null,
+    phase_gate_status: state.phase_gate_status ?? null,
   };
 }
 

package/src/lib/report.js

@@ -20,6 +20,76 @@ function summarizeBlockedOn(blockedOn) {
   return 'present';
 }
 
+function renderGovernanceEventDetailText(lines, evt, indent) {
+  switch (evt.type) {
+    case 'policy_escalation':
+      for (const v of evt.violations || []) {
+        lines.push(`${indent}violation: ${v.policy_id || '?'} / ${v.rule || '?'} — ${v.message || 'n/a'}`);
+      }
+      break;
+    case 'conflict_detected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`${indent}files: ${evt.conflicting_files.join(', ')}`);
+      }
+      if (evt.overlap_ratio != null) {
+        lines.push(`${indent}overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
+      }
+      break;
+    case 'conflict_rejected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`${indent}files: ${evt.conflicting_files.join(', ')}`);
+      }
+      break;
+    case 'conflict_resolution_selected':
+      if (evt.resolution_method) {
+        lines.push(`${indent}resolution: ${evt.resolution_method}`);
+      }
+      break;
+    case 'operator_escalated':
+      if (evt.reason) lines.push(`${indent}reason: ${evt.reason}`);
+      if (evt.blocked_on) lines.push(`${indent}blocked_on: ${evt.blocked_on}`);
+      break;
+    case 'escalation_resolved':
+      if (evt.resolved_via) lines.push(`${indent}resolved via: ${evt.resolved_via}`);
+      if (evt.previous_blocked_on) lines.push(`${indent}was blocked on: ${evt.previous_blocked_on}`);
+      break;
+  }
+}
+
+function renderGovernanceEventDetailMarkdown(lines, evt) {
+  switch (evt.type) {
+    case 'policy_escalation':
+      for (const v of evt.violations || []) {
+        lines.push(`  - Violation: \`${v.policy_id || '?'}\` / \`${v.rule || '?'}\` — ${v.message || 'n/a'}`);
+      }
+      break;
+    case 'conflict_detected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`  - Files: ${evt.conflicting_files.map((f) => `\`${f}\``).join(', ')}`);
+      }
+      if (evt.overlap_ratio != null) {
+        lines.push(`  - Overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
+      }
+      break;
+    case 'conflict_rejected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`  - Files: ${evt.conflicting_files.map((f) => `\`${f}\``).join(', ')}`);
+      }
+      break;
+    case 'conflict_resolution_selected':
+      if (evt.resolution_method) lines.push(`  - Resolution: \`${evt.resolution_method}\``);
+      break;
+    case 'operator_escalated':
+      if (evt.reason) lines.push(`  - Reason: ${evt.reason}`);
+      if (evt.blocked_on) lines.push(`  - Blocked on: \`${evt.blocked_on}\``);
+      break;
+    case 'escalation_resolved':
+      if (evt.resolved_via) lines.push(`  - Resolved via: \`${evt.resolved_via}\``);
+      if (evt.previous_blocked_on) lines.push(`  - Was blocked on: \`${evt.previous_blocked_on}\``);
+      break;
+  }
+}
+
 function summarizeBlockedState(run) {
   const blockedReason = run?.blocked_reason;
   if (blockedReason && typeof blockedReason === 'object' && !Array.isArray(blockedReason)) {
@@ -175,6 +245,60 @@ function extractGateFailureDigest(artifact) {
     }));
 }
 
+const GOVERNANCE_EVENT_TYPES = new Set([
+  'policy_escalation',
+  'conflict_detected',
+  'conflict_rejected',
+  'conflict_resolution_selected',
+  'operator_escalated',
+  'escalation_resolved',
+]);
+
+function extractGovernanceEventDigest(artifact, relPath = '.agentxchain/decision-ledger.jsonl') {
+  const data = extractFileData(artifact, relPath);
+  if (!Array.isArray(data) || data.length === 0) return [];
+  return data
+    .filter((d) => typeof d?.decision === 'string' && GOVERNANCE_EVENT_TYPES.has(d.decision))
+    .map((d) => {
+      const base = {
+        type: d.decision,
+        timestamp: d.timestamp || null,
+        turn_id: d.turn_id || null,
+        role: d.role || null,
+        phase: d.phase || null,
+      };
+      switch (d.decision) {
+        case 'policy_escalation':
+          base.violations = Array.isArray(d.violations) ? d.violations.map((v) => ({
+            policy_id: v.policy_id || null,
+            rule: v.rule || null,
+            message: v.message || null,
+          })) : [];
+          break;
+        case 'conflict_detected':
+          base.conflicting_files = Array.isArray(d.conflict?.files) ? d.conflict.files : [];
+          base.overlap_ratio = typeof d.conflict?.overlap_ratio === 'number' ? d.conflict.overlap_ratio : null;
+          break;
+        case 'conflict_rejected':
+          base.conflicting_files = Array.isArray(d.conflict?.files) ? d.conflict.files : [];
+          break;
+        case 'conflict_resolution_selected':
+          base.resolution_method = d.conflict?.resolution || null;
+          break;
+        case 'operator_escalated':
+          base.blocked_on = d.blocked_on || null;
+          base.reason = d.escalation?.reason || null;
+          break;
+        case 'escalation_resolved':
+          base.resolved_via = d.resolved_via || null;
+          base.previous_blocked_on = d.blocked_on || null;
+          break;
+      }
+      return base;
+    })
+    .sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+}
+
 function extractTimeoutEventDigest(artifact, relPath = '.agentxchain/decision-ledger.jsonl') {
   const data = extractFileData(artifact, relPath);
   if (!Array.isArray(data) || data.length === 0) return [];
@@ -658,6 +782,7 @@ function buildRunSubject(artifact) {
   const intakeLinks = extractIntakeLinks(artifact);
   const recoverySummary = extractRecoverySummary(artifact);
   const continuity = extractContinuityMetadata(artifact);
+  const governanceEvents = extractGovernanceEventDigest(artifact);
 
   return {
     kind: 'governed_run',
@@ -689,6 +814,7 @@ function buildRunSubject(artifact) {
       turns,
       decisions,
       approval_policy_events: approvalPolicyEvents,
+      governance_events: governanceEvents,
       gate_failures: gateFailures,
       timeout_events: timeoutEvents,
       hook_summary: hookSummary,
@@ -764,6 +890,7 @@ function buildCoordinatorSubject(artifact) {
       base.turns = extractHistoryTimeline(childExport);
       base.decisions = extractDecisionDigest(childExport);
       base.approval_policy_events = extractApprovalPolicyDigest(childExport);
+      base.governance_events = extractGovernanceEventDigest(childExport);
       base.gate_failures = extractGateFailureDigest(childExport);
       base.timeout_events = extractTimeoutEventDigest(childExport);
       base.hook_summary = extractHookSummary(childExport);
@@ -780,6 +907,7 @@ function buildCoordinatorSubject(artifact) {
   const barrierLedgerTimeline = extractBarrierLedgerTimeline(artifact);
   const decisionDigest = extractCoordinatorDecisionDigest(artifact);
   const coordinatorApprovalPolicyEvents = extractCoordinatorApprovalPolicyDigest(artifact);
+  const coordinatorGovernanceEvents = extractGovernanceEventDigest(artifact, '.agentxchain/multirepo/decision-ledger.jsonl');
   const coordinatorTimeoutEvents = extractTimeoutEventDigest(artifact, '.agentxchain/multirepo/decision-ledger.jsonl');
   const timing = computeCoordinatorTiming(artifact, coordinatorTimeline);
   const blockedReason = normalizeCoordinatorBlockedReason(coordinatorState.blocked_reason);
@@ -824,6 +952,7 @@ function buildCoordinatorSubject(artifact) {
     barrier_ledger_timeline: barrierLedgerTimeline,
     decision_digest: decisionDigest,
     approval_policy_events: coordinatorApprovalPolicyEvents,
+    governance_events: coordinatorGovernanceEvents,
     timeout_events: coordinatorTimeoutEvents,
     recovery_report: extractRecoveryReportSummary(artifact),
     repos,
@@ -1008,6 +1137,14 @@ export function formatGovernanceReportText(report) {
       }
     }
 
+    if (run.governance_events && run.governance_events.length > 0) {
+      lines.push('', 'Governance Events:');
+      for (const evt of run.governance_events) {
+        lines.push(`  - ${evt.type} | ${evt.role || '?'} | ${evt.phase || '?'} | at: ${evt.timestamp || 'n/a'}`);
+        renderGovernanceEventDetailText(lines, evt, '      ');
+      }
+    }
+
     if (run.timeout_events && run.timeout_events.length > 0) {
       lines.push('', 'Timeout Events:');
       for (const evt of run.timeout_events) {
@@ -1082,6 +1219,7 @@ export function formatGovernanceReportText(report) {
     barrier_ledger_timeline,
     decision_digest,
     approval_policy_events,
+    governance_events,
     timeout_events,
     recovery_report,
   } = report.subject;
@@ -1179,6 +1317,14 @@ export function formatGovernanceReportText(report) {
     }
   }
 
+  if (governance_events && governance_events.length > 0) {
+    lines.push('', 'Governance Events:');
+    for (const evt of governance_events) {
+      lines.push(`  - ${evt.type} | ${evt.role || '?'} | ${evt.phase || '?'} | at: ${evt.timestamp || 'n/a'}`);
+      renderGovernanceEventDetailText(lines, evt, '      ');
+    }
+  }
+
   if (timeout_events && timeout_events.length > 0) {
     lines.push('', 'Timeout Events:');
     for (const evt of timeout_events) {
@@ -1254,6 +1400,13 @@ export function formatGovernanceReportText(report) {
           repoLines.push(`    - ${evt.action || 'unknown'}: ${evt.gate_type || 'unknown'} | ${transition} | ${evt.timestamp || 'n/a'}`);
         }
       }
+      if (repo.governance_events && repo.governance_events.length > 0) {
+        repoLines.push('  Governance Events:');
+        for (const evt of repo.governance_events) {
+          repoLines.push(`    - ${evt.type} | ${evt.role || '?'} | ${evt.phase || '?'} | at: ${evt.timestamp || 'n/a'}`);
+          renderGovernanceEventDetailText(repoLines, evt, '        ');
+        }
+      }
       if (repo.timeout_events && repo.timeout_events.length > 0) {
         repoLines.push('  Timeout Events:');
         for (const evt of repo.timeout_events) {
@@ -1417,6 +1570,14 @@ export function formatGovernanceReportMarkdown(report) {
       }
     }
 
+    if (run.governance_events && run.governance_events.length > 0) {
+      lines.push('', '## Governance Events', '');
+      for (const evt of run.governance_events) {
+        lines.push(`- **${evt.type}** (\`${evt.role || '?'}\`, \`${evt.phase || '?'}\` phase) at \`${evt.timestamp || 'n/a'}\``);
+        renderGovernanceEventDetailMarkdown(lines, evt);
+      }
+    }
+
     if (run.timeout_events && run.timeout_events.length > 0) {
       lines.push('', '## Timeout Events', '');
       for (const evt of run.timeout_events) {
@@ -1494,6 +1655,7 @@ export function formatGovernanceReportMarkdown(report) {
     barrier_ledger_timeline,
     decision_digest,
     approval_policy_events,
+    governance_events,
     timeout_events,
     recovery_report: coordRecoveryReport,
   } = report.subject;
@@ -1592,6 +1754,14 @@ export function formatGovernanceReportMarkdown(report) {
     }
   }
 
+  if (governance_events && governance_events.length > 0) {
+    mdLines.push('', '## Governance Events', '');
+    for (const evt of governance_events) {
+      mdLines.push(`- **${evt.type}** (\`${evt.role || '?'}\`, \`${evt.phase || '?'}\` phase) at \`${evt.timestamp || 'n/a'}\``);
+      renderGovernanceEventDetailMarkdown(mdLines, evt);
+    }
+  }
+
   if (timeout_events && timeout_events.length > 0) {
     mdLines.push('', '## Timeout Events', '');
     for (const evt of timeout_events) {
@@ -1670,6 +1840,13 @@ export function formatGovernanceReportMarkdown(report) {
         if (evt.reason) repoLines.push(`  - ${evt.reason}`);
       }
     }
+    if (repo.governance_events && repo.governance_events.length > 0) {
+      repoLines.push('', '#### Governance Events', '');
+      for (const evt of repo.governance_events) {
+        repoLines.push(`- **${evt.type}** (\`${evt.role || '?'}\`, \`${evt.phase || '?'}\` phase) at \`${evt.timestamp || 'n/a'}\``);
+        renderGovernanceEventDetailMarkdown(repoLines, evt);
+      }
+    }
     if (repo.timeout_events && repo.timeout_events.length > 0) {
       repoLines.push('', '#### Timeout Events', '');
       for (const evt of repo.timeout_events) {