agentxchain 2.108.0 → 2.110.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

@@ -29,8 +29,8 @@ const VIEWS = {
   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,7 @@ 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',
 };
 
@@ -79,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,
@@ -146,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,
@@ -274,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;
@@ -291,7 +328,9 @@ function connect() {
     statusLabel.textContent = 'Connected';
     reconnectDelay = 1000;
     liveObserverState.connected = true;
-    loadView(currentView());
+    void pollDashboard().finally(() => {
+      loadView(currentView());
+    });
   };
 
   ws.onmessage = (event) => {
@@ -501,5 +540,6 @@ function fallbackSelect(el) {
 
 Promise.all([pickInitialView(), loadSession()]).finally(() => {
   updateNav();
+  startDashboardPolling();
   connect();
 });

package/dashboard/components/blocked.js

@@ -92,6 +92,56 @@ 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'
+        ? (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>
+        <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 +149,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 +219,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,58 @@ 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'
+          ? (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>`;
+    }
+  }
+
+  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 +330,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 +378,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/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.108.0",
+  "version": "2.110.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/approve-completion.js

@@ -37,11 +37,31 @@ 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) {
+        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)}`);
+        }
+      }
+    } 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 +69,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 +101,24 @@ function printGateHookFailure(result, gateType, gateInfo) {
   }
   console.log('');
 }
+
+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'));
+  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:')}     ${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

@@ -36,11 +36,31 @@ 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) {
+        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)}`);
+        }
+      }
+    } 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 +68,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 +106,28 @@ function printGateHookFailure(result, gateType, gateInfo) {
   }
   console.log('');
 }
+
+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`));
+  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:')}     ${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/status.js

@@ -14,9 +14,11 @@ import { getConnectorHealth } from '../lib/connector-health.js';
 import { readRepoDecisions, summarizeRepoDecisions } from '../lib/repo-decisions.js';
 import { deriveWorkflowKitArtifacts } from '../lib/workflow-kit-artifacts.js';
 import { evaluateTimeouts } from '../lib/timeout-evaluator.js';
+import { evaluateApprovalSlaReminders } from '../lib/notification-runner.js';
 import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { readRecentRunEventSummary } from '../lib/recent-event-summary.js';
 import { deriveConflictedTurnResolutionActions } from '../lib/conflict-actions.js';
+import { summarizeLatestGateActionAttempt } from '../lib/gate-actions.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
 
 export async function statusCommand(opts) {
@@ -125,6 +127,14 @@ function renderGovernedStatus(context, opts) {
   const repoDecisionSummary = summarizeRepoDecisions(readRepoDecisions(root), config);
 
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
+  const gateActionAttempt = state?.pending_phase_transition
+    ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)
+    : state?.pending_run_completion
+      ? summarizeLatestGateActionAttempt(root, 'run_completion', state.pending_run_completion.gate)
+      : null;
+
+  // Fire approval SLA reminders as a side effect (webhook-only, no CLI output)
+  evaluateApprovalSlaReminders(root, config, state);
 
   if (opts.json) {
     const dashPid = getDashboardPid(root);
@@ -152,6 +162,7 @@ function renderGovernedStatus(context, opts) {
       next_actions: nextActions,
       connector_health: connectorHealth,
       recent_event_summary: recentEventSummary,
+      gate_action_attempt: gateActionAttempt,
       workflow_kit_artifacts: workflowKitArtifacts,
       dashboard_session: dashboardSessionObj,
     }, null, 2));
@@ -197,6 +208,7 @@ function renderGovernedStatus(context, opts) {
   const activeTurnCount = getActiveTurnCount(state);
   const activeTurns = getActiveTurns(state);
   const singleActiveTurn = getActiveTurn(state);
+  const approvalPending = Boolean(state?.pending_phase_transition || state?.pending_run_completion);
   if (activeTurnCount > 1) {
     console.log(`  ${chalk.dim('Turns:')}    ${activeTurnCount} active`);
     for (const turn of Object.values(activeTurns)) {
@@ -249,8 +261,14 @@ function renderGovernedStatus(context, opts) {
     if (singleActiveTurn.status === 'conflicted' && singleActiveTurn.conflict_state) {
       const cs = singleActiveTurn.conflict_state;
       const files = cs.conflict_error?.conflicting_files || [];
+      const count = cs.detection_count || 1;
       const [reassignAction, mergeAction] = deriveConflictedTurnResolutionActions(singleActiveTurn.turn_id);
-      console.log(`  ${chalk.dim('Conflict:')} ${chalk.red(`${files.length} file(s) conflicting`)} — detection #${cs.detection_count || 1}`);
+      console.log(`  ${chalk.dim('Conflict:')} ${chalk.red(`${files.length} file(s) conflicting`)} — detection #${count}`);
+      if (cs.conflict_error?.overlap_ratio != null) {
+        console.log(`  ${chalk.dim('Overlap:')}  ${(cs.conflict_error.overlap_ratio * 100).toFixed(0)}%`);
+      }
+      const suggestion = cs.conflict_error?.suggested_resolution || 'reject_and_reassign';
+      console.log(`  ${chalk.dim('Suggest:')}  ${suggestion}`);
       console.log(`  ${chalk.dim('Resolve:')}  ${chalk.cyan(reassignAction.command)}`);
       console.log(`  ${chalk.dim('     or:')}  ${chalk.cyan(mergeAction.command)}`);
     }
@@ -321,12 +339,33 @@ function renderGovernedStatus(context, opts) {
     const pt = state.pending_phase_transition;
     console.log(`  ${chalk.dim('Pending:')}  ${formatGovernedPhase(pt.from)} → ${formatGovernedPhase(pt.to)}`);
     console.log(`  ${chalk.dim('Gate:')}     ${pt.gate} (requires human approval)`);
+    if (pt.requested_at) {
+      console.log(`  ${chalk.dim('Requested:')} ${pt.requested_at} (${timeSince(pt.requested_at)} ago)`);
+    }
   }
 
   if (state?.pending_run_completion) {
     const pc = state.pending_run_completion;
     console.log(`  ${chalk.dim('Pending:')}  ${chalk.bold('Run Completion')}`);
     console.log(`  ${chalk.dim('Gate:')}     ${pc.gate} (requires human approval)`);
+    if (pc.requested_at) {
+      console.log(`  ${chalk.dim('Requested:')} ${pc.requested_at} (${timeSince(pc.requested_at)} ago)`);
+    }
+  }
+
+  if (gateActionAttempt) {
+    console.log(`  ${chalk.dim('Gate actions:')} ${gateActionAttempt.status} at ${gateActionAttempt.attempted_at || 'unknown time'}`);
+    for (const action of gateActionAttempt.actions) {
+      const label = action.action_label || action.command || `action ${action.action_index || '?'}`;
+      const outcome = action.status === 'failed'
+        ? (action.timed_out ? chalk.red(`timed out after ${action.timeout_ms}ms`) : chalk.red('failed'))
+        : chalk.green('succeeded');
+      const exit = action.timed_out ? '' : (action.exit_code == null ? '' : ` (exit ${action.exit_code})`);
+      console.log(`    ${action.action_index || '?'}. ${label} — ${outcome}${exit}`);
+      if (action.status === 'failed' && action.stderr_tail) {
+        console.log(`      ${chalk.dim(action.stderr_tail)}`);
+      }
+    }
   }
 
   if (state?.status === 'completed') {
@@ -368,14 +407,20 @@ function renderGovernedStatus(context, opts) {
 
   renderWorkflowKitArtifactsSection(workflowKitArtifacts);
 
-  if (config.timeouts && state?.status === 'active') {
-    const activeTurn = getActiveTurn(state);
+  if (config.timeouts && (state?.status === 'active' || approvalPending)) {
+    const activeTurn = state?.status === 'active' ? getActiveTurn(state) : null;
     const turnResult = activeTurn ? { role: activeTurn.assigned_role } : undefined;
     const timeoutEval = evaluateTimeouts({ config, state, turn: activeTurn, turnResult, now: new Date().toISOString() });
     const allItems = [...timeoutEval.exceeded, ...timeoutEval.warnings];
-    if (allItems.length > 0) {
+    if (allItems.length > 0 || approvalPending) {
       console.log('');
       console.log(`  ${chalk.dim('Timeouts:')}`);
+      if (approvalPending) {
+        console.log(`    ${chalk.yellow('◷')} approval wait does not mutate timeout state; phase/run clocks keep ticking until the next accepted turn`);
+      }
+      if (approvalPending && allItems.length === 0) {
+        console.log(`    ${chalk.dim('No current phase/run timeout pressure.')}`);
+      }
       for (const item of allItems) {
         const isExceeded = timeoutEval.exceeded.includes(item);
         const elapsed = item.elapsed_minutes != null ? `${item.elapsed_minutes}m` : '?';
@@ -637,6 +682,7 @@ function formatRunStatus(status) {
 
 function timeSince(iso) {
   const ms = Date.now() - new Date(iso).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return '0s';
   const sec = Math.floor(ms / 1000);
   if (sec < 60) return `${sec}s`;
   const min = Math.floor(sec / 60);

package/src/commands/step.js

@@ -67,6 +67,7 @@ import { runHooks } from '../lib/hook-runner.js';
 import { finalizeDispatchManifest, verifyDispatchManifest } from '../lib/dispatch-manifest.js';
 import { resolveGovernedRole } from '../lib/role-resolution.js';
 import { shouldSuggestManualQaFallback } from '../lib/manual-qa-fallback.js';
+import { evaluateApprovalSlaReminders } from '../lib/notification-runner.js';
 
 export async function stepCommand(opts) {
   const context = loadProjectContext();
@@ -169,6 +170,7 @@ export async function stepCommand(opts) {
 
   if (!skipAssignment) {
     if (state.pending_phase_transition || state.pending_run_completion) {
+      evaluateApprovalSlaReminders(root, config, state);
       printRecoverySummary(state, 'This run is awaiting approval.', config);
       process.exit(1);
     }