agentxchain 2.107.0 → 2.109.0

package/bin/agentxchain.js

@@ -521,11 +521,13 @@ program
 program
   .command('approve-transition')
   .description('Approve a pending phase transition that requires human sign-off')
+  .option('--dry-run', 'Show configured gate actions without executing approval')
   .action(approveTransitionCommand);
 
 program
   .command('approve-completion')
   .description('Approve a pending run completion that requires human sign-off')
+  .option('--dry-run', 'Show configured gate actions without executing approval')
   .action(approveCompletionCommand);
 
 program

package/dashboard/app.js

@@ -25,12 +25,12 @@ import {
 } from './live-observer.js';
 
 const VIEWS = {
-  timeline: { fetch: ['state', 'continuity', 'history', 'audit', 'annotations', 'connectors', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderTimeline },
+  timeline: { fetch: ['state', 'continuity', 'history', 'events', 'audit', 'annotations', 'connectors', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderTimeline },
   delegations: { fetch: ['state', 'history'], render: renderDelegations },
   ledger: { fetch: ['state', 'ledger', 'coordinatorState', 'coordinatorLedger', 'repoDecisionsSummary'], render: renderLedger },
   hooks: { fetch: ['audit', 'annotations', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderHooks },
-  blocked: { fetch: ['state', 'audit', 'coordinatorState', 'coordinatorAudit', 'coordinatorBlockers', 'coordinatorRepoStatusRows'], render: renderBlocked },
-  gate: { fetch: ['state', 'history', 'coordinatorState', 'coordinatorHistory', 'coordinatorBarriers'], render: renderGate },
+  blocked: { fetch: ['state', 'audit', 'coordinatorState', 'coordinatorAudit', 'coordinatorBlockers', 'coordinatorRepoStatusRows', 'gateActions'], render: renderBlocked },
+  gate: { fetch: ['state', 'history', 'coordinatorState', 'coordinatorHistory', 'coordinatorBarriers', 'gateActions'], render: renderGate },
   initiative: { fetch: ['coordinatorState', 'coordinatorBarriers', 'barrierLedger', 'coordinatorBlockers', 'coordinatorRepoStatusRows'], render: renderInitiative },
   'cross-repo': { fetch: ['coordinatorState', 'coordinatorHistory'], render: renderCrossRepo },
   blockers: { fetch: ['coordinatorBlockers'], render: renderBlockers },
@@ -62,6 +62,8 @@ const API_MAP = {
   runHistory: '/api/run-history',
   timeouts: '/api/timeouts',
   coordinatorTimeouts: '/api/coordinator/timeouts',
+  gateActions: '/api/gate-actions',
+  events: '/api/events?type=turn_conflicted&limit=10',
 };
 
 const viewState = {
@@ -78,11 +80,14 @@ const viewState = {
     hookName: 'all',
   },
 };
+const DASHBOARD_POLL_INTERVAL_MS = 60 * 1000;
 
 let activeViewName = null;
 let activeViewData = null;
 let dashboardSession = null;
 let actionInFlight = false;
+let pollInFlight = false;
+let pollTimer = null;
 const liveObserverState = {
   connected: false,
   lastRefreshAt: null,
@@ -145,7 +150,7 @@ async function pickInitialView() {
 }
 
 function buildRenderData(viewName, data) {
-  const liveMeta = viewName === 'timeline'
+  const liveMeta = (viewName === 'timeline' || viewName === 'timeouts')
     ? buildLiveMeta({
       connected: liveObserverState.connected,
       lastRefreshAt: liveObserverState.lastRefreshAt,
@@ -273,6 +278,39 @@ function rerenderActiveView() {
   renderView(activeViewName, activeViewData);
 }
 
+async function pollDashboard({ refreshView = false } = {}) {
+  if (pollInFlight) return;
+  pollInFlight = true;
+  try {
+    await fetch('/api/poll', { cache: 'no-store' });
+    if (refreshView) {
+      await loadView(currentView());
+    }
+  } catch {
+    // Best-effort heartbeat only
+  } finally {
+    pollInFlight = false;
+  }
+}
+
+function startDashboardPolling() {
+  if (pollTimer) return;
+
+  const tick = () => {
+    if (document.visibilityState === 'hidden') return;
+    if (actionInFlight) return;
+    void pollDashboard({ refreshView: true });
+  };
+
+  pollTimer = setInterval(tick, DASHBOARD_POLL_INTERVAL_MS);
+
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+      void pollDashboard({ refreshView: true });
+    }
+  });
+}
+
 // ── WebSocket connection ──────────────────────────────────────────────────
 
 let ws = null;
@@ -290,7 +328,9 @@ function connect() {
     statusLabel.textContent = 'Connected';
     reconnectDelay = 1000;
     liveObserverState.connected = true;
-    loadView(currentView());
+    void pollDashboard().finally(() => {
+      loadView(currentView());
+    });
   };
 
   ws.onmessage = (event) => {
@@ -500,5 +540,6 @@ function fallbackSelect(el) {
 
 Promise.all([pickInitialView(), loadSession()]).finally(() => {
   updateNav();
+  startDashboardPolling();
   connect();
 });

package/dashboard/components/blocked.js

@@ -92,6 +92,54 @@ function formatCoordinatorRepoCardMeta(row) {
   return parts.join(' | ') || '-';
 }
 
+function getGateActionDryRunCommand(gateActions, state) {
+  const gateType = gateActions?.latest_attempt?.gate_type
+    || (state?.pending_run_completion ? 'run_completion' : null)
+    || (state?.pending_phase_transition ? 'phase_transition' : null);
+
+  return gateType === 'run_completion'
+    ? 'agentxchain approve-completion --dry-run'
+    : 'agentxchain approve-transition --dry-run';
+}
+
+function renderGateActionFailure(gateActions, state) {
+  if (!gateActions?.latest_attempt || gateActions.latest_attempt.status !== 'failed') return '';
+
+  const attempt = gateActions.latest_attempt;
+  const actions = Array.isArray(attempt.actions) ? attempt.actions : [];
+  const dryRunCommand = getGateActionDryRunCommand(gateActions, state);
+
+  let html = `<div class="section"><h3>Gate Action Failure</h3>`;
+  html += `<dl class="detail-list">`;
+  html += `<dt>Attempt</dt><dd class="mono">${esc(attempt.attempt_id || '-')}</dd>`;
+  html += `<dt>Gate</dt><dd class="mono">${esc(attempt.gate_id || '-')}</dd>`;
+  html += `<dt>Attempted At</dt><dd class="mono">${esc(attempt.attempted_at || '-')}</dd>`;
+  html += `</dl>`;
+
+  if (actions.length > 0) {
+    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})` : '';
+      html += `<div class="annotation-card">
+        <span class="mono">${esc(String(action.action_index || '?'))}.</span>
+        <span>${esc(label)}</span>
+        <span>${esc(outcome)}${esc(exitStr)}</span>
+      </div>`;
+      if (action.status === 'failed' && action.stderr_tail) {
+        html += `<pre class="recovery-command mono">${esc(action.stderr_tail)}</pre>`;
+      }
+    }
+    html += `</div>`;
+  }
+
+  html += `<p class="recovery-hint">Re-run with dry-run first:</p>`;
+  html += `<pre class="recovery-command mono" data-copy="${esc(dryRunCommand)}">${esc(dryRunCommand)}</pre>`;
+  html += `</div>`;
+  return html;
+}
+
 export function render({
   state,
   audit = [],
@@ -99,6 +147,7 @@ export function render({
   coordinatorAudit = [],
   coordinatorBlockers = null,
   coordinatorRepoStatusRows = null,
+  gateActions = null,
 }) {
   const activeState = state?.status === 'blocked' ? state : coordinatorState;
   const activeAudit = activeState === state ? audit : coordinatorAudit;
@@ -168,6 +217,12 @@ export function render({
     </div>`;
   }
 
+  // Gate-action failure detail (only for gate_action_failed blocks)
+  const category = String(reason).toLowerCase();
+  if (category.includes('gate_action_failed') && !isCoordinator) {
+    html += renderGateActionFailure(gateActions, activeState);
+  }
+
   if (runtimeGuidance.length > 0) {
     html += `<div class="section"><h3>Runtime Guidance</h3><div class="annotation-list">`;
     for (const entry of runtimeGuidance) {

package/dashboard/components/gate.js

@@ -210,12 +210,55 @@ function aggregateCoordinatorEvidence(entries) {
   return { summaries, decisions, objections: [], risks: [], files };
 }
 
+function renderGateActionsSection(gateActions) {
+  if (!gateActions) return '';
+
+  const configured = Array.isArray(gateActions.configured) ? gateActions.configured : [];
+  const attempt = gateActions.latest_attempt || null;
+
+  if (configured.length === 0 && !attempt) return '';
+
+  let html = `<div class="gate-support"><p><strong>Gate Actions:</strong></p>`;
+
+  if (configured.length > 0) {
+    html += `<ul>`;
+    for (const action of configured) {
+      const label = action.label || action.run || `action ${action.index || '?'}`;
+      html += `<li><div><span class="mono">${esc(String(action.index || '?'))}.</span> ${esc(label)}</div>`;
+      if (action.run) {
+        html += `<div class="mono">${esc(action.run)}</div>`;
+      }
+      html += `</li>`;
+    }
+    html += `</ul>`;
+  }
+
+  if (attempt) {
+    const statusLabel = attempt.status === 'failed' ? '❌ Failed' : '✅ Succeeded';
+    html += `<p><strong>Last Attempt:</strong> ${esc(statusLabel)} at ${esc(attempt.attempted_at || 'unknown')}</p>`;
+    if (Array.isArray(attempt.actions) && attempt.actions.length > 0) {
+      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>`;
+      }
+      html += `</ul>`;
+    }
+  }
+
+  html += `</div>`;
+  return html;
+}
+
 export function render({
   state,
   history = [],
   coordinatorState = null,
   coordinatorHistory = [],
   coordinatorBarriers = {},
+  gateActions = null,
 }) {
   const repoPendingTransition = state?.pending_phase_transition || null;
   const repoPendingCompletion = state?.pending_run_completion || null;
@@ -284,6 +327,9 @@ export function render({
         )).join('')}</ul></div>`;
       }
     }
+    if (!isCoordinator) {
+      html += renderGateActionsSection(gateActions);
+    }
     html += renderApproveControls({
       buttonLabel: isCoordinator ? 'Approve Coordinator Gate' : 'Approve Transition',
       cliCommand: isCoordinator ? 'agentxchain multi approve-gate' : 'agentxchain approve-transition',
@@ -329,6 +375,9 @@ export function render({
     if (evidence.files.length > 0) {
       html += `<div class="gate-support"><p><strong>Files Changed:</strong></p><ul>${evidence.files.map(f => `<li class="mono">${esc(f)}</li>`).join('')}</ul></div>`;
     }
+    if (!isCoordinator) {
+      html += renderGateActionsSection(gateActions);
+    }
     html += renderApproveControls({
       buttonLabel: isCoordinator ? 'Approve Coordinator Gate' : 'Approve Completion',
       cliCommand: isCoordinator ? 'agentxchain multi approve-gate' : 'agentxchain approve-completion',

package/dashboard/components/timeline.js

@@ -90,6 +90,11 @@ function formatTimestamp(iso) {
   }
 }
 
+function formatPercent(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null;
+  return `${Math.round(value * 100)}%`;
+}
+
 function statusBadge(status) {
   const colors = {
     running: 'var(--green)',
@@ -206,6 +211,99 @@ function renderDelegationReview(review) {
   return `<div class="turn-detail"><span class="detail-label">Delegation Review:</span> <span class="mono">${esc(review.parent_turn_id || 'unknown')}</span> with ${esc(resultCount)} result${resultCount === 1 ? '' : 's'}</div>`;
 }
 
+function collectConflictCards(state, events) {
+  const latestByTurn = new Map();
+
+  if (Array.isArray(events)) {
+    for (const event of [...events].reverse()) {
+      if (event?.event_type !== 'turn_conflicted') continue;
+      const turnId = event?.turn?.turn_id;
+      if (!turnId || latestByTurn.has(turnId)) continue;
+      latestByTurn.set(turnId, {
+        turn_id: turnId,
+        role_id: event?.turn?.role_id || 'unknown',
+        detected_at: event?.timestamp || null,
+        state_label: event?.status === 'blocked' ? 'conflict loop blocked run' : 'recent conflict',
+        detection_count: typeof event?.payload?.detection_count === 'number' ? event.payload.detection_count : null,
+        conflicting_files: Array.isArray(event?.payload?.conflicting_files) ? event.payload.conflicting_files : [],
+        accepted_since_turn_ids: Array.isArray(event?.payload?.accepted_since_turn_ids) ? event.payload.accepted_since_turn_ids : [],
+        overlap_ratio: typeof event?.payload?.overlap_ratio === 'number' ? event.payload.overlap_ratio : null,
+      });
+    }
+  }
+
+  const activeTurns = state?.active_turns ? Object.values(state.active_turns) : [];
+  for (const turn of activeTurns) {
+    if (turn?.status !== 'conflicted') continue;
+    if (latestByTurn.has(turn.turn_id)) {
+      const existing = latestByTurn.get(turn.turn_id);
+      latestByTurn.set(turn.turn_id, {
+        ...existing,
+        state_label: state?.blocked_reason?.category === 'conflict_loop' && state?.blocked_on?.includes(turn.turn_id)
+          ? 'conflict loop blocked run'
+          : 'active conflict',
+      });
+      continue;
+    }
+
+    const conflictError = turn?.conflict_state?.conflict_error || {};
+    latestByTurn.set(turn.turn_id, {
+      turn_id: turn.turn_id,
+      role_id: getRole(turn),
+      detected_at: turn?.conflict_state?.detected_at || null,
+      state_label: state?.blocked_reason?.category === 'conflict_loop' && state?.blocked_on?.includes(turn.turn_id)
+        ? 'conflict loop blocked run'
+        : 'active conflict',
+      detection_count: typeof turn?.conflict_state?.detection_count === 'number' ? turn.conflict_state.detection_count : null,
+      conflicting_files: Array.isArray(conflictError.conflicting_files) ? conflictError.conflicting_files : [],
+      accepted_since_turn_ids: Array.isArray(conflictError.accepted_since)
+        ? conflictError.accepted_since.map((entry) => entry?.turn_id).filter(Boolean)
+        : [],
+      overlap_ratio: typeof conflictError.overlap_ratio === 'number' ? conflictError.overlap_ratio : null,
+    });
+  }
+
+  return [...latestByTurn.values()].slice(0, 5);
+}
+
+function renderConflictPanel(state, events) {
+  const conflicts = collectConflictCards(state, events);
+  if (conflicts.length === 0) return '';
+
+  let html = `<div class="section"><h3>Conflicts</h3><div class="turn-list">`;
+  for (const conflict of conflicts) {
+    const detectedAt = formatTimestamp(conflict.detected_at);
+    const overlap = formatPercent(conflict.overlap_ratio);
+    html += `<div class="turn-card">
+      <div class="turn-header">
+        ${roleBadge(conflict.role_id)}
+        <span class="mono">${esc(conflict.turn_id)}</span>
+        ${statusBadge('conflicted')}
+      </div>
+      <div class="turn-detail"><span class="detail-label">Scope:</span> ${esc(conflict.state_label)}</div>`;
+
+    if (detectedAt) {
+      html += `<div class="turn-detail"><span class="detail-label">Detected:</span> ${esc(detectedAt)}</div>`;
+    }
+    if (conflict.conflicting_files.length > 0) {
+      html += `<div class="turn-detail"><span class="detail-label">Files:</span> <span class="mono">${conflict.conflicting_files.map((file) => esc(file)).join(', ')}</span></div>`;
+    }
+    if (conflict.accepted_since_turn_ids.length > 0) {
+      html += `<div class="turn-detail"><span class="detail-label">Accepted since:</span> <span class="mono">${conflict.accepted_since_turn_ids.map((turnId) => esc(turnId)).join(', ')}</span></div>`;
+    }
+    if (overlap) {
+      html += `<div class="turn-detail"><span class="detail-label">Overlap:</span> ${esc(overlap)}</div>`;
+    }
+    if (conflict.detection_count != null) {
+      html += `<div class="turn-detail"><span class="detail-label">Detection count:</span> ${esc(conflict.detection_count)}</div>`;
+    }
+
+    html += `</div>`;
+  }
+  html += `</div></div>`;
+  return html;
+}
+
 function renderContinuityPanel(continuity) {
   if (!continuity) return '';
 
@@ -306,7 +404,7 @@ function renderConnectorHealthPanel(connectorsPayload) {
 
 export { formatDuration, computeElapsed, formatTimestamp };
 
-export function render({ state, continuity, history, annotations, audit, connectors, coordinatorAudit = null, coordinatorAnnotations = null, liveMeta = null }) {
+export function render({ state, continuity, history, events = null, annotations, audit, connectors, coordinatorAudit = null, coordinatorAnnotations = null, liveMeta = null }) {
   if (!state) {
     return `<div class="placeholder"><h2>No Run</h2><p>No governed run found. Start one with <code class="mono">agentxchain init --governed</code></p></div>`;
   }
@@ -330,6 +428,7 @@ export function render({ state, continuity, history, annotations, audit, connect
 
   html += renderContinuityPanel(continuity);
   html += renderConnectorHealthPanel(connectors);
+  html += renderConflictPanel(state, events);
 
   // Active turns
   if (activeTurns.length > 0) {

package/dashboard/components/timeouts.js

@@ -4,9 +4,13 @@
  * Pure render function: takes data from /api/timeouts, returns HTML.
  * All evaluation is server-side. This view renders the snapshot.
  *
+ * Receives liveMeta from the live-observer for websocket freshness display.
+ *
  * See: TIMEOUT_DASHBOARD_SURFACE_SPEC.md
  */
 
+import { renderLiveStatus } from './live-status.js';
+
 function esc(str) {
   if (!str) return '';
   return String(str)
@@ -82,14 +86,22 @@ function renderConfigTable(config) {
 }
 
 function renderLivePressure(live) {
+  const liveContext = live?.context || null;
   const hasExceeded = live.exceeded && live.exceeded.length > 0;
   const hasWarnings = live.warnings && live.warnings.length > 0;
+  const approvalNote = liveContext?.awaiting_approval
+    ? `<p style="color:var(--yellow)">Approval wait does not mutate timeout state, but phase/run clocks continue until the next accepted turn.${liveContext.requested_at ? ` Requested: <code>${esc(liveContext.requested_at)}</code>.` : ''}</p>`
+    : '';
 
   if (!hasExceeded && !hasWarnings) {
-    return `<div class="section"><h3>Live Pressure</h3><p style="color:var(--green)">No timeouts exceeded or approaching limits.</p></div>`;
+    const message = liveContext?.awaiting_approval
+      ? `<p style="color:var(--text-dim)">No current phase/run timeout pressure during this approval wait.</p>`
+      : `<p style="color:var(--green)">No timeouts exceeded or approaching limits.</p>`;
+    return `<div class="section"><h3>Live Pressure</h3>${approvalNote}${message}</div>`;
   }
 
   let html = `<div class="section"><h3>Live Pressure</h3>
+    ${approvalNote}
     <table class="data-table">
       <thead><tr><th>Status</th><th>Scope</th><th>Turn</th><th>Phase</th><th>Elapsed</th><th>Limit</th><th>Exceeded By</th><th>Action</th></tr></thead>
       <tbody>`;
@@ -157,7 +169,7 @@ function renderEvents(events) {
   return html;
 }
 
-export function render({ timeouts }) {
+export function render({ timeouts, liveMeta }) {
   if (!timeouts) {
     return `<div class="placeholder"><h2>Timeouts</h2><p>No timeout data available. Ensure a governed run is active.</p></div>`;
   }
@@ -175,6 +187,9 @@ export function render({ timeouts }) {
 
   let html = `<div class="timeouts-view">`;
 
+  // Freshness banner — timeout data is time-sensitive so operators need visibility
+  html += renderLiveStatus(liveMeta);
+
   // Header
   html += `<div class="run-header"><div class="run-meta">`;
   html += `<span class="phase-label"><strong>Timeouts</strong></span>`;
@@ -190,7 +205,10 @@ export function render({ timeouts }) {
 
   // Live pressure
   if (timeouts.live) {
-    html += renderLivePressure(timeouts.live);
+    html += renderLivePressure({
+      ...timeouts.live,
+      context: timeouts.live_context || null,
+    });
   }
 
   // Persisted events

package/package.json

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

package/src/commands/approve-completion.js

@@ -37,11 +37,30 @@ export async function approveCompletionCommand(opts) {
   console.log(`  ${chalk.dim('Turn:')}   ${pc.requested_by_turn}`);
   console.log('');
 
-  const result = approveRunCompletion(root, config);
+  const result = approveRunCompletion(root, config, { dryRun: opts.dryRun });
+
+  if (result.dry_run) {
+    console.log(chalk.cyan('  Dry Run: gate approval preview only'));
+    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}`);
+        if (action.label) {
+          console.log(`       ${chalk.dim(action.run)}`);
+        }
+      }
+    } else {
+      console.log(`  ${chalk.dim('Gate actions:')} none configured`);
+    }
+    console.log('');
+    return;
+  }
 
   if (!result.ok) {
     if (result.error_code?.startsWith('hook_') || result.error_code === 'hook_blocked') {
       printGateHookFailure(result, 'run_completion', pc);
+    } else if (result.error_code === 'gate_action_failed') {
+      printGateActionFailure(result, pc);
     } else {
       console.log(chalk.red(`  Failed: ${result.error}`));
     }
@@ -49,6 +68,9 @@ export async function approveCompletionCommand(opts) {
   }
 
   console.log(chalk.green('  \u2713 Run completed'));
+  if (result.gateActionRun?.actions?.length > 0) {
+    console.log(`  ${chalk.dim('Gate actions:')} ${result.gateActionRun.actions.length} completed`);
+  }
   console.log(chalk.dim(`  Completed at: ${result.state.completed_at}`));
   console.log('');
 }
@@ -78,3 +100,20 @@ function printGateHookFailure(result, gateType, gateInfo) {
   }
   console.log('');
 }
+
+function printGateActionFailure(result, gateInfo) {
+  const failure = result.gateActionRun?.failed_action;
+
+  console.log('');
+  console.log(chalk.yellow('  Run Completion Blocked By Gate Action'));
+  console.log(chalk.dim('  ' + '-'.repeat(44)));
+  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('Retry:')}    agentxchain approve-completion`);
+  console.log('');
+}

package/src/commands/approve-transition.js

@@ -36,11 +36,30 @@ export async function approveTransitionCommand(opts) {
   console.log(`  ${chalk.dim('Turn:')}  ${pt.requested_by_turn}`);
   console.log('');
 
-  const result = approvePhaseTransition(root, config);
+  const result = approvePhaseTransition(root, config, { dryRun: opts.dryRun });
+
+  if (result.dry_run) {
+    console.log(chalk.cyan('  Dry Run: gate approval preview only'));
+    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}`);
+        if (action.label) {
+          console.log(`       ${chalk.dim(action.run)}`);
+        }
+      }
+    } else {
+      console.log(`  ${chalk.dim('Gate actions:')} none configured`);
+    }
+    console.log('');
+    return;
+  }
 
   if (!result.ok) {
     if (result.error_code?.startsWith('hook_') || result.error_code === 'hook_blocked') {
       printGateHookFailure(result, 'phase_transition', pt);
+    } else if (result.error_code === 'gate_action_failed') {
+      printGateActionFailure(result, 'phase_transition', pt);
     } else {
       console.log(chalk.red(`  Failed: ${result.error}`));
     }
@@ -48,6 +67,9 @@ export async function approveTransitionCommand(opts) {
   }
 
   console.log(chalk.green(`  ✓ Phase advanced: ${pt.from} → ${pt.to}`));
+  if (result.gateActionRun?.actions?.length > 0) {
+    console.log(`  ${chalk.dim('Gate actions:')} ${result.gateActionRun.actions.length} completed`);
+  }
   console.log(chalk.dim(`  Run status: ${result.state.status}`));
   console.log('');
   console.log(chalk.dim(`  Next: agentxchain step  (to run the first turn in ${pt.to} phase)`));
@@ -83,3 +105,24 @@ function printGateHookFailure(result, gateType, gateInfo) {
   }
   console.log('');
 }
+
+function printGateActionFailure(result, gateType, gateInfo) {
+  const failure = result.gateActionRun?.failed_action;
+
+  console.log('');
+  console.log(chalk.yellow(`  ${gateType === 'phase_transition' ? 'Phase Transition' : 'Run Completion'} Blocked By Gate Action`));
+  console.log(chalk.dim('  ' + '-'.repeat(44)));
+  console.log('');
+  if (gateType === 'phase_transition') {
+    console.log(`  ${chalk.dim('From:')}     ${gateInfo.from}`);
+    console.log(`  ${chalk.dim('To:')}       ${gateInfo.to}`);
+  }
+  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('Retry:')}    ${gateType === 'phase_transition' ? 'agentxchain approve-transition' : 'agentxchain approve-completion'}`);
+  console.log('');
+}

package/src/commands/events.js

@@ -61,6 +61,9 @@ function printEvent(evt) {
   const runId = evt.run_id ? evt.run_id.slice(0, 12) : '—';
   const phase = evt.phase || '—';
   const turnInfo = evt.turn?.role_id ? ` [${evt.turn.role_id}]` : '';
+  const conflictDetail = evt.event_type === 'turn_conflicted'
+    ? ` — ${formatConflictDetail(evt)}`
+    : '';
   const rejectionDetail = evt.event_type === 'turn_rejected' && evt.payload?.reason
     ? ` — ${evt.payload.reason}${evt.payload.failed_stage ? ` (${evt.payload.failed_stage})` : ''}`
     : '';
@@ -70,7 +73,34 @@ function printEvent(evt) {
   const gateFailedDetail = evt.event_type === 'gate_failed' && evt.payload?.from_phase
     ? ` ${evt.payload.from_phase} → ${evt.payload.to_phase || '?'}${evt.payload.reasons?.length ? ` — ${evt.payload.reasons[0]}` : ''}${evt.payload.gate_id ? ` (${evt.payload.gate_id})` : ''}`
     : '';
-  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}`);
+  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${conflictDetail}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}`);
+}
+
+function formatConflictDetail(evt) {
+  const payload = evt.payload || {};
+  const fileSummary = summarizeList(payload.conflicting_files, 3) || 'unknown files';
+  const overlapRatio = typeof payload.overlap_ratio === 'number'
+    ? `${Math.round(payload.overlap_ratio * 100)}% overlap`
+    : null;
+  const detectionCount = Number.isInteger(payload.detection_count)
+    ? `detection ${payload.detection_count}`
+    : null;
+  const turnSummary = summarizeList(payload.accepted_since_turn_ids, 2);
+  const parts = [fileSummary, overlapRatio, detectionCount];
+  if (turnSummary) {
+    parts.push(`accepted since ${turnSummary}`);
+  }
+  if (evt.status === 'blocked') {
+    parts.push('run blocked');
+  }
+  return parts.filter(Boolean).join(' | ');
+}
+
+function summarizeList(items, limit) {
+  if (!Array.isArray(items) || items.length === 0) return '';
+  const shown = items.slice(0, limit).join(', ');
+  if (items.length <= limit) return shown;
+  return `${shown} +${items.length - limit} more`;
 }
 
 function colorEventType(type) {
@@ -81,12 +111,14 @@ function colorEventType(type) {
     turn_dispatched: chalk.blue,
     turn_accepted: chalk.green,
     turn_rejected: chalk.yellow,
+    turn_conflicted: chalk.redBright,
     phase_entered: chalk.magenta,
     escalation_raised: chalk.red.bold,
     escalation_resolved: chalk.green,
     gate_pending: chalk.yellow,
     gate_approved: chalk.green,
     gate_failed: chalk.red,
+    budget_exceeded_warn: chalk.yellowBright,
   };
   const colorFn = colors[type] || chalk.white;
   return colorFn(pad(type, 22));