agentxchain 2.125.0 → 2.127.0

package/dashboard/components/timeline.js

@@ -95,6 +95,30 @@ function formatPercent(value) {
   return `${Math.round(value * 100)}%`;
 }
 
+function formatDispatchActivity(progress) {
+  if (!progress || typeof progress !== 'object') return null;
+  const lastActivityAt = progress.last_activity_at ? new Date(progress.last_activity_at) : null;
+  const agoSec = lastActivityAt && !Number.isNaN(lastActivityAt.getTime())
+    ? Math.round((Date.now() - lastActivityAt.getTime()) / 1000)
+    : null;
+
+  if (progress.activity_type === 'silent') {
+    const silentSince = progress.silent_since ? new Date(progress.silent_since) : null;
+    const silentSec = silentSince && !Number.isNaN(silentSince.getTime())
+      ? Math.round((Date.now() - silentSince.getTime()) / 1000)
+      : agoSec;
+    return `Silent for ${silentSec ?? 0}s (${progress.output_lines || 0} lines total, last output ${agoSec ?? 0}s ago)`;
+  }
+  if (progress.activity_type === 'request') {
+    return `API request in flight (${agoSec ?? 0}s ago)`;
+  }
+  if (progress.activity_type === 'response') {
+    return 'API response received';
+  }
+  const agoLabel = agoSec != null && agoSec > 0 ? `, last ${agoSec}s ago` : '';
+  return `Producing output (${progress.output_lines || 0} lines${agoLabel})`;
+}
+
 function statusBadge(status) {
   const colors = {
     running: 'var(--green)',
@@ -411,6 +435,9 @@ export function render({ state, continuity, history, events = null, annotations,
 
   const turnCount = Array.isArray(history) ? history.length : 0;
   const activeTurns = state.active_turns ? Object.values(state.active_turns) : [];
+  const dispatchProgress = state.dispatch_progress && typeof state.dispatch_progress === 'object'
+    ? state.dispatch_progress
+    : {};
 
   let html = `<div class="timeline-view">`;
 
@@ -436,6 +463,7 @@ export function render({ state, continuity, history, events = null, annotations,
     for (const turn of activeTurns) {
       const elapsedMs = computeElapsed(turn.started_at);
       const elapsedStr = formatDuration(elapsedMs);
+      const activity = formatDispatchActivity(dispatchProgress[turn.turn_id]);
       html += `<div class="turn-card active">
         <div class="turn-header">
           ${roleBadge(getRole(turn))}
@@ -445,6 +473,7 @@ export function render({ state, continuity, history, events = null, annotations,
         </div>
         ${renderDelegationContext(turn.delegation_context)}
         ${renderDelegationReview(turn.delegation_review)}
+        ${activity ? `<div class="turn-detail"><span class="detail-label">Activity:</span> ${esc(activity)}</div>` : ''}
       </div>`;
     }
     html += `</div></div>`;

package/package.json

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

package/src/commands/run.js

@@ -46,6 +46,8 @@ import {
 } from '../lib/turn-paths.js';
 import { resolveChainOptions, executeChainedRun } from '../lib/run-chain.js';
 import { resolveContinuousOptions, executeContinuousRun } from '../lib/continuous-run.js';
+import { createDispatchProgressTracker } from '../lib/dispatch-progress.js';
+import { emitRunEvent } from '../lib/run-events.js';
 
 export async function runCommand(opts) {
   const context = loadProjectContext();
@@ -299,38 +301,114 @@ export async function executeGovernedRun(context, opts = {}) {
       }
 
       // ── Route to adapter ──────────────────────────────────────────────
+      const tracker = createDispatchProgressTracker(projectRoot, turn, {
+        adapter_type: runtimeType,
+      });
+
       const adapterOpts = {
-        signal: controller.signal,
+        signal: combineAbortSignals(controller.signal, ctx.dispatchAbortSignal),
         onStatus: (msg) => log(chalk.dim(`  ${msg}`)),
         verifyManifest: true,
         turnId: turn.turn_id,
       };
 
+      const recordOutputActivity = (stream, text) => {
+        const lines = text.split('\n').length - 1 || 1;
+        const wasSilent = tracker.onOutput(stream, lines);
+        if (wasSilent) {
+          const progressState = tracker.getState();
+          emitRunEvent(projectRoot, 'dispatch_progress', {
+            run_id: state.run_id,
+            phase: state.phase,
+            status: state.status,
+            turn: { turn_id: turn.turn_id, assigned_role: roleId },
+            payload: {
+              milestone: 'output_resumed',
+              output_lines: progressState.output_lines,
+              elapsed_seconds: Math.round((Date.now() - new Date(progressState.started_at)) / 1000),
+              silent_seconds: 0,
+            },
+          });
+        }
+      };
+
       if (verbose) {
-        adapterOpts.onStdout = (text) => process.stdout.write(chalk.dim(text));
-        adapterOpts.onStderr = (text) => process.stderr.write(chalk.yellow(text));
+        adapterOpts.onStdout = (text) => {
+          process.stdout.write(chalk.dim(text));
+          recordOutputActivity('stdout', text);
+        };
+        adapterOpts.onStderr = (text) => {
+          process.stderr.write(chalk.yellow(text));
+          recordOutputActivity('stderr', text);
+        };
+      } else {
+        // Even in non-verbose mode, track output activity for progress visibility
+        adapterOpts.onStdout = (text) => {
+          recordOutputActivity('stdout', text);
+        };
+        adapterOpts.onStderr = (text) => {
+          recordOutputActivity('stderr', text);
+        };
       }
 
       let adapterResult;
 
-      if (runtimeType === 'api_proxy') {
-        log(chalk.dim(`  Dispatching to API proxy: ${runtime?.provider || '?'} / ${runtime?.model || '?'}`));
-        adapterResult = await dispatchApiProxy(projectRoot, state, cfg, adapterOpts);
-      } else if (runtimeType === 'mcp') {
-        const transport = resolveMcpTransport(runtime);
-        log(chalk.dim(`  Dispatching to MCP ${transport}: ${describeMcpRuntimeTarget(runtime)}`));
-        adapterResult = await dispatchMcp(projectRoot, state, cfg, adapterOpts);
-      } else if (runtimeType === 'local_cli') {
-        const transport = runtime ? resolvePromptTransport(runtime) : 'dispatch_bundle_only';
-        log(chalk.dim(`  Dispatching to local CLI: ${runtime?.command || '(default)'}  transport: ${transport}`));
-        adapterResult = await dispatchLocalCli(projectRoot, state, cfg, adapterOpts);
-      } else if (runtimeType === 'remote_agent') {
-        log(chalk.dim(`  Dispatching to remote agent: ${describeRemoteAgentTarget(runtime)}`));
-        adapterResult = await dispatchRemoteAgent(projectRoot, state, cfg, adapterOpts);
-      } else {
-        return { accept: false, reason: `unknown runtime type "${runtimeType}"` };
+      // Emit dispatch_progress started event and begin tracking
+      tracker.start();
+      emitRunEvent(projectRoot, 'dispatch_progress', {
+        run_id: state.run_id,
+        phase: state.phase,
+        status: state.status,
+        turn: { turn_id: turn.turn_id, assigned_role: roleId },
+        payload: { milestone: 'started', output_lines: 0, elapsed_seconds: 0, silent_seconds: 0 },
+      });
+
+      try {
+        if (runtimeType === 'api_proxy') {
+          log(chalk.dim(`  Dispatching to API proxy: ${runtime?.provider || '?'} / ${runtime?.model || '?'}`));
+          tracker.requestStarted();
+          adapterResult = await dispatchApiProxy(projectRoot, state, cfg, adapterOpts);
+          if (adapterResult.ok) tracker.responseReceived();
+        } else if (runtimeType === 'mcp') {
+          const transport = resolveMcpTransport(runtime);
+          log(chalk.dim(`  Dispatching to MCP ${transport}: ${describeMcpRuntimeTarget(runtime)}`));
+          tracker.requestStarted();
+          adapterResult = await dispatchMcp(projectRoot, state, cfg, adapterOpts);
+          if (adapterResult.ok) tracker.responseReceived();
+        } else if (runtimeType === 'local_cli') {
+          const transport = runtime ? resolvePromptTransport(runtime) : 'dispatch_bundle_only';
+          log(chalk.dim(`  Dispatching to local CLI: ${runtime?.command || '(default)'}  transport: ${transport}`));
+          adapterResult = await dispatchLocalCli(projectRoot, state, cfg, adapterOpts);
+        } else if (runtimeType === 'remote_agent') {
+          log(chalk.dim(`  Dispatching to remote agent: ${describeRemoteAgentTarget(runtime)}`));
+          tracker.requestStarted();
+          adapterResult = await dispatchRemoteAgent(projectRoot, state, cfg, adapterOpts);
+          if (adapterResult.ok) tracker.responseReceived();
+        } else {
+          tracker.fail();
+          return { accept: false, reason: `unknown runtime type "${runtimeType}"` };
+        }
+      } catch (err) {
+        tracker.fail();
+        emitRunEvent(projectRoot, 'dispatch_progress', {
+          run_id: state.run_id, phase: state.phase, status: state.status,
+          turn: { turn_id: turn.turn_id, assigned_role: roleId },
+          payload: { milestone: 'failed', output_lines: tracker.getState().output_lines, elapsed_seconds: Math.round((Date.now() - new Date(tracker.getState().started_at)) / 1000), silent_seconds: 0 },
+        });
+        throw err;
       }
 
+      // Emit completion/failure progress event and clean up tracker
+      const progressState = tracker.getState();
+      const elapsedSec = Math.round((Date.now() - new Date(progressState.started_at)) / 1000);
+      const milestone = adapterResult.ok ? 'completed' : (adapterResult.timedOut ? 'timed_out' : 'failed');
+      if (adapterResult.ok) { tracker.complete(); } else { tracker.fail(); }
+      emitRunEvent(projectRoot, 'dispatch_progress', {
+        run_id: state.run_id, phase: state.phase, status: state.status,
+        turn: { turn_id: turn.turn_id, assigned_role: roleId },
+        payload: { milestone, output_lines: progressState.output_lines, elapsed_seconds: elapsedSec, silent_seconds: progressState.silent_since ? Math.round((Date.now() - new Date(progressState.silent_since)) / 1000) : 0 },
+      });
+
       // Save adapter logs
       if (adapterResult.logs?.length) {
         saveDispatchLogs(projectRoot, turn.turn_id, adapterResult.logs);
@@ -557,3 +635,28 @@ function printManualQaFallback(log = console.log) {
   log(chalk.dim('  - Then recover the retained QA turn with: agentxchain step --resume'));
   log(chalk.dim('  - Guide: https://agentxchain.dev/docs/getting-started'));
 }
+
+function combineAbortSignals(primarySignal, secondarySignal) {
+  if (!secondarySignal) {
+    return primarySignal;
+  }
+  if (!primarySignal) {
+    return secondarySignal;
+  }
+  if (typeof AbortSignal.any === 'function') {
+    return AbortSignal.any([primarySignal, secondarySignal]);
+  }
+
+  const combined = new AbortController();
+  const forward = (signal) => {
+    if (!signal) return;
+    if (signal.aborted) {
+      combined.abort(signal.reason);
+      return;
+    }
+    signal.addEventListener('abort', () => combined.abort(signal.reason), { once: true });
+  };
+  forward(primarySignal);
+  forward(secondarySignal);
+  return combined.signal;
+}

package/src/commands/status.js

@@ -13,7 +13,7 @@ import { getContinuityStatus } from '../lib/continuity-status.js';
 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 { evaluateTimeouts, computeTimeoutBudget } 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';
@@ -23,6 +23,7 @@ import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
 import { readPreemptionMarker } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
+import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -142,6 +143,9 @@ function renderGovernedStatus(context, opts) {
   // Fire approval SLA reminders as a side effect (webhook-only, no CLI output)
   evaluateApprovalSlaReminders(root, config, state);
 
+  const activeTurns = getActiveTurns(state);
+  const dispatchProgress = filterDispatchProgressForActiveTurns(readAllDispatchProgress(root), activeTurns);
+
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -168,6 +172,7 @@ function renderGovernedStatus(context, opts) {
       next_actions: nextActions,
       connector_health: connectorHealth,
       recent_event_summary: recentEventSummary,
+      dispatch_progress: dispatchProgress,
       human_escalation: humanEscalation,
       preemption_marker: preemptionMarker,
       continuous_session: continuousSession,
@@ -262,7 +267,6 @@ function renderGovernedStatus(context, opts) {
   renderRecentEventSummary(recentEventSummary);
 
   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) {
@@ -283,7 +287,23 @@ function renderGovernedStatus(context, opts) {
           elapsedTag = m > 0 ? ` — ${m}m ${s % 60}s` : ` — ${s}s`;
         }
       }
-      console.log(`    ${marker} ${turn.turn_id} — ${chalk.bold(turn.assigned_role)} (${statusLabel}) [attempt ${turn.attempt}]${elapsedTag}`);
+      let budgetTag = '';
+      if (config.timeouts?.per_turn_minutes && turn.started_at) {
+        const tb = computeTimeoutBudget({ config, state, turn, now: new Date() });
+        const tBudget = tb.find((b) => b.scope === 'turn');
+        if (tBudget) {
+          if (tBudget.exceeded) {
+            budgetTag = ` ${chalk.red('[TIMEOUT]')}`;
+          } else {
+            budgetTag = ` ${chalk.dim(`[${tBudget.remaining_minutes}m left]`)}`;
+          }
+        }
+      }
+      console.log(`    ${marker} ${turn.turn_id} — ${chalk.bold(turn.assigned_role)} (${statusLabel}) [attempt ${turn.attempt}]${elapsedTag}${budgetTag}`);
+      const activityLine = formatDispatchActivityLine(dispatchProgress[turn.turn_id]);
+      if (activityLine) {
+        console.log(`      ${chalk.dim('Activity:')} ${activityLine}`);
+      }
       if (turn.status === 'conflicted' && turn.conflict_state) {
         const cs = turn.conflict_state;
         const files = cs.conflict_error?.conflicting_files || [];
@@ -314,6 +334,26 @@ function renderGovernedStatus(context, opts) {
         console.log(`  ${chalk.dim('Elapsed:')}  ${elapsed}`);
       }
     }
+    // Turn-level timeout budget inline with turn info
+    if (config.timeouts?.per_turn_minutes && singleActiveTurn.started_at) {
+      const turnBudgets = computeTimeoutBudget({ config, state, turn: singleActiveTurn, now: new Date() });
+      const turnBudget = turnBudgets.find((b) => b.scope === 'turn');
+      if (turnBudget) {
+        if (turnBudget.exceeded) {
+          console.log(`  ${chalk.dim('Budget:')}   ${chalk.red(`EXCEEDED — was ${turnBudget.limit_minutes}m, over by ${turnBudget.elapsed_minutes - turnBudget.limit_minutes}m`)}`);
+        } else {
+          const remMins = Math.floor(turnBudget.remaining_seconds / 60);
+          const remSecs = turnBudget.remaining_seconds % 60;
+          const remLabel = remMins > 0 ? `${remMins}m ${remSecs}s` : `${remSecs}s`;
+          console.log(`  ${chalk.dim('Budget:')}   ${chalk.green(`${remLabel} remaining`)} of ${turnBudget.limit_minutes}m (deadline ${new Date(turnBudget.deadline_iso).toLocaleTimeString()})`);
+        }
+      }
+    }
+    // Dispatch progress activity line (DEC-DISPATCH-PROGRESS-001)
+    const activityLine = formatDispatchActivityLine(dispatchProgress[singleActiveTurn.turn_id]);
+    if (activityLine) {
+      console.log(`  ${chalk.dim('Activity:')} ${activityLine}`);
+    }
     if (singleActiveTurn.status === 'conflicted' && singleActiveTurn.conflict_state) {
       const cs = singleActiveTurn.conflict_state;
       const files = cs.conflict_error?.conflicting_files || [];
@@ -474,19 +514,22 @@ function renderGovernedStatus(context, opts) {
   renderWorkflowKitArtifactsSection(workflowKitArtifacts);
 
   if (config.timeouts && (state?.status === 'active' || approvalPending)) {
+    const nowDate = new Date();
     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 timeoutEval = evaluateTimeouts({ config, state, turn: activeTurn, turnResult, now: nowDate.toISOString() });
     const allItems = [...timeoutEval.exceeded, ...timeoutEval.warnings];
-    if (allItems.length > 0 || approvalPending) {
+    // Compute full budget for phase/run scopes (turn budget is shown inline with turn info above)
+    const budgets = computeTimeoutBudget({ config, state, turn: activeTurn, now: nowDate })
+      .filter((b) => b.scope !== 'turn'); // turn budget already shown inline
+
+    if (allItems.length > 0 || budgets.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.')}`);
-      }
+      // Show exceeded/warned items
       for (const item of allItems) {
         const isExceeded = timeoutEval.exceeded.includes(item);
         const elapsed = item.elapsed_minutes != null ? `${item.elapsed_minutes}m` : '?';
@@ -495,6 +538,17 @@ function renderGovernedStatus(context, opts) {
         const label = isExceeded ? chalk.red(`EXCEEDED ${item.scope}`) : chalk.yellow(`${item.scope}`);
         console.log(`    ${icon} ${label}: ${elapsed}/${limit} (action: ${item.action || 'n/a'})`);
       }
+      // Show remaining budget for non-exceeded phase/run scopes
+      const exceededScopes = new Set(allItems.map((i) => `${i.scope}:${i.phase || ''}`));
+      for (const b of budgets) {
+        const key = `${b.scope}:${b.phase || ''}`;
+        if (exceededScopes.has(key)) continue; // already shown as exceeded above
+        const scopeLabel = b.scope === 'phase' ? `phase (${b.phase})` : b.scope;
+        console.log(`    ${chalk.green('✓')} ${scopeLabel}: ${b.elapsed_minutes}m/${b.limit_minutes}m — ${chalk.green(`${b.remaining_minutes}m remaining`)}`);
+      }
+      if (approvalPending && allItems.length === 0 && budgets.length === 0) {
+        console.log(`    ${chalk.dim('No current phase/run timeout pressure.')}`);
+      }
     }
   }
 
@@ -702,6 +756,45 @@ function pluralizeRepoDecisionCount(count, singular, plural) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
 
+function filterDispatchProgressForActiveTurns(progressByTurn, activeTurns) {
+  const filtered = {};
+  if (!progressByTurn || typeof progressByTurn !== 'object') {
+    return filtered;
+  }
+  for (const turn of Object.values(activeTurns || {})) {
+    const turnId = turn?.turn_id;
+    if (turnId && progressByTurn[turnId]) {
+      filtered[turnId] = progressByTurn[turnId];
+    }
+  }
+  return filtered;
+}
+
+function formatDispatchActivityLine(progress) {
+  if (!progress || typeof progress !== 'object') return null;
+  const lastAct = progress.last_activity_at ? new Date(progress.last_activity_at) : null;
+  const agoSec = lastAct && !Number.isNaN(lastAct.getTime())
+    ? Math.round((Date.now() - lastAct.getTime()) / 1000)
+    : null;
+
+  if (progress.activity_type === 'silent') {
+    const silentAt = progress.silent_since ? new Date(progress.silent_since) : null;
+    const silentSec = silentAt && !Number.isNaN(silentAt.getTime())
+      ? Math.round((Date.now() - silentAt.getTime()) / 1000)
+      : agoSec;
+    return chalk.yellow(`Silent for ${silentSec}s`) +
+      ` (${progress.output_lines || 0} lines total, last output ${agoSec ?? 0}s ago)`;
+  }
+  if (progress.activity_type === 'request') {
+    return chalk.cyan('API request in flight') + ` (${agoSec ?? 0}s ago)`;
+  }
+  if (progress.activity_type === 'response') {
+    return chalk.green('API response received');
+  }
+  const agoLabel = agoSec != null && agoSec > 0 ? `, last ${agoSec}s ago` : '';
+  return chalk.green('Producing output') + ` (${progress.output_lines || 0} lines${agoLabel})`;
+}
+
 function renderLastGateFailure(failure, config) {
   const entryRole = config?.routing?.[failure.phase]?.entry_role || null;
   const suggestedCommand = entryRole ? `agentxchain step --role ${entryRole}` : 'agentxchain step --role <role>';

package/src/commands/turn.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import chalk from 'chalk';
 import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import { getActiveTurnCount, getActiveTurns } from '../lib/governed-state.js';
+import { computeTimeoutBudget } from '../lib/timeout-evaluator.js';
 import {
   getDispatchAssignmentPath,
   getDispatchContextPath,
@@ -54,11 +55,11 @@ export function turnShowCommand(turnId, opts) {
   }
 
   if (opts.json) {
-    console.log(JSON.stringify(buildTurnPayload(selectedTurnId, turn, state, artifacts, assignment), null, 2));
+    console.log(JSON.stringify(buildTurnPayload(selectedTurnId, turn, state, artifacts, assignment, context.config), null, 2));
     return;
   }
 
-  printTurnSummary(selectedTurnId, turn, state, artifacts, assignment);
+  printTurnSummary(selectedTurnId, turn, state, artifacts, assignment, context.config);
 }
 
 function requireGovernedContext() {
@@ -118,9 +119,9 @@ function buildArtifactIndex(root, turnId) {
   );
 }
 
-function buildTurnPayload(turnId, turn, state, artifacts, assignment) {
+function buildTurnPayload(turnId, turn, state, artifacts, assignment, config) {
   const elapsedMs = getElapsedMs(turn.started_at);
-  return {
+  const payload = {
     turn_id: turnId,
     run_id: state.run_id || assignment?.run_id || null,
     phase: state.phase || assignment?.phase || null,
@@ -140,9 +141,17 @@ function buildTurnPayload(turnId, turn, state, artifacts, assignment) {
       }]),
     ),
   };
+  // Add timeout budget if configured
+  if (config?.timeouts) {
+    const budgets = computeTimeoutBudget({ config, state, turn, now: new Date() });
+    if (budgets.length > 0) {
+      payload.timeout_budget = budgets;
+    }
+  }
+  return payload;
 }
 
-function printTurnSummary(turnId, turn, state, artifacts, assignment) {
+function printTurnSummary(turnId, turn, state, artifacts, assignment, config) {
   const elapsedMs = getElapsedMs(turn.started_at);
   console.log('');
   console.log(chalk.bold(`  Turn: ${chalk.cyan(turnId)}`));
@@ -159,6 +168,21 @@ function printTurnSummary(turnId, turn, state, artifacts, assignment) {
   if (elapsedMs != null) {
     console.log(`  ${chalk.dim('Elapsed:')}  ${formatElapsed(elapsedMs)}`);
   }
+  // Timeout budget per scope
+  if (config?.timeouts) {
+    const budgets = computeTimeoutBudget({ config, state, turn, now: new Date() });
+    for (const b of budgets) {
+      const scopeLabel = b.scope === 'phase' ? `phase (${b.phase})` : b.scope;
+      if (b.exceeded) {
+        console.log(`  ${chalk.dim('Timeout:')}  ${chalk.red(`${scopeLabel} EXCEEDED`)} — was ${b.limit_minutes}m, over by ${b.elapsed_minutes - b.limit_minutes}m`);
+      } else {
+        const remMins = Math.floor(b.remaining_seconds / 60);
+        const remSecs = b.remaining_seconds % 60;
+        const remLabel = remMins > 0 ? `${remMins}m ${remSecs}s` : `${remSecs}s`;
+        console.log(`  ${chalk.dim('Timeout:')}  ${scopeLabel} — ${chalk.green(`${remLabel} remaining`)} of ${b.limit_minutes}m`);
+      }
+    }
+  }
   console.log(`  ${chalk.dim('Dispatch:')} ${getDispatchTurnDir(turnId)}`);
   if (assignment?.staging_result_path) {
     console.log(`  ${chalk.dim('Staging:')}  ${assignment.staging_result_path}`);

package/src/lib/dashboard/state-reader.js

@@ -15,6 +15,7 @@ import {
 import { loadProjectContext } from '../config.js';
 import { getContinuityStatus } from '../continuity-status.js';
 import { readRepoDecisions, summarizeRepoDecisions } from '../repo-decisions.js';
+import { readAllDispatchProgress } from '../dispatch-progress.js';
 
 const STATE_FILE = 'state.json';
 const SESSION_FILE = 'session.json';
@@ -80,6 +81,9 @@ export function normalizeRelativePath(filePath) {
 
 export function resourcesForRelativePath(filePath) {
   const normalized = normalizeRelativePath(filePath);
+  if (/^dispatch-progress-[^/]+\.json$/.test(normalized)) {
+    return ['/api/state'];
+  }
   if (normalized.startsWith('missions/plans/') && normalized.endsWith('.json')) {
     return ['/api/plans', '/api/missions'];
   }
@@ -136,6 +140,7 @@ function enrichGovernedState(agentxchainDir, state) {
     ...state,
     runtime_guidance: deriveRuntimeBlockedGuidance(state, context.config),
     next_actions: deriveGovernedRunNextActions(state, context.config),
+    dispatch_progress: readAllDispatchProgress(workspacePath),
   };
 }
 

package/src/lib/dashboard/timeout-status.js

@@ -9,7 +9,7 @@
 
 import { join } from 'path';
 import { loadProjectContext, loadProjectState } from '../config.js';
-import { evaluateTimeouts } from '../timeout-evaluator.js';
+import { evaluateTimeouts, computeTimeoutBudget } from '../timeout-evaluator.js';
 import { readJsonlFile } from './state-reader.js';
 
 /**
@@ -209,7 +209,15 @@ export function readTimeoutStatus(workspacePath) {
   const configSummary = buildTimeoutConfigSummary(timeouts, config.routing);
 
   // Live timeout evaluation — only meaningful when the run is active
-  const live = evaluateDashboardTimeoutPressure(config, state, new Date());
+  const nowDate = new Date();
+  const live = evaluateDashboardTimeoutPressure(config, state, nowDate);
+
+  // Compute remaining budget for all configured scopes
+  const activeTurnsList = getActiveTurns(state);
+  const primaryTurn = activeTurnsList.length === 1 ? activeTurnsList[0] : null;
+  const budget = (state?.status === 'active' || Boolean(state?.pending_phase_transition || state?.pending_run_completion))
+    ? computeTimeoutBudget({ config, state, turn: primaryTurn, now: nowDate })
+    : [];
 
   // Persisted timeout events from the decision ledger
   const ledger = readJsonlFile(agentxchainDir, 'decision-ledger.jsonl');
@@ -223,6 +231,7 @@ export function readTimeoutStatus(workspacePath) {
         configured: true,
         config: configSummary,
         live,
+        budget,
         live_context: buildLiveContext(state),
         events,
       },

package/src/lib/dispatch-progress.js

@@ -0,0 +1,298 @@
+/**
+ * dispatch-progress.js — Real-time adapter dispatch progress tracking.
+ *
+ * Writes `.agentxchain/dispatch-progress.json` during in-flight adapter
+ * dispatch so operators can distinguish "adapter is working" from "adapter
+ * is hung" via `agentxchain status` and the dashboard file-watcher.
+ *
+ * DEC-DISPATCH-PROGRESS-001: progress writes are best-effort and never
+ * block or delay the governed turn.
+ */
+
+import { writeFileSync, unlinkSync, readFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+
+export const LEGACY_DISPATCH_PROGRESS_PATH = '.agentxchain/dispatch-progress.json';
+export const DISPATCH_PROGRESS_FILE_PREFIX = '.agentxchain/dispatch-progress-';
+
+export function getDispatchProgressRelativePath(turnId) {
+  return `${DISPATCH_PROGRESS_FILE_PREFIX}${turnId}.json`;
+}
+
+function getDispatchProgressFilePath(root, turnId) {
+  return join(root, getDispatchProgressRelativePath(turnId));
+}
+
+function listDispatchProgressFiles(root) {
+  const agentxchainDir = join(root, '.agentxchain');
+  if (!existsSync(agentxchainDir)) return [];
+  try {
+    return readdirSync(agentxchainDir)
+      .filter((entry) => entry.startsWith('dispatch-progress-') && entry.endsWith('.json'))
+      .map((entry) => join(agentxchainDir, entry));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create a dispatch progress tracker for a single turn.
+ *
+ * Usage:
+ *   const tracker = createDispatchProgressTracker(root, turn, runtime);
+ *   tracker.start();
+ *   // ... during dispatch:
+ *   tracker.onOutput('stdout', lineCount);
+ *   tracker.onOutput('stderr', lineCount);
+ *   // ... when done:
+ *   tracker.complete();  // or tracker.fail();
+ *
+ * @param {string} root - project root
+ * @param {object} turn - turn object with turn_id, runtime_id, assigned_role
+ * @param {object} options
+ * @param {string} options.adapter_type - 'local_cli' | 'api_proxy' | 'mcp' | 'remote_agent'
+ * @param {number} [options.pid] - subprocess PID (local_cli only)
+ * @param {number} [options.writeIntervalMs=1000] - min interval between file writes
+ * @param {number} [options.silenceThresholdMs=30000] - silence detection threshold
+ * @returns {DispatchProgressTracker}
+ */
+export function createDispatchProgressTracker(root, turn, options = {}) {
+  const {
+    adapter_type = 'local_cli',
+    pid = null,
+    writeIntervalMs = 1000,
+    silenceThresholdMs = 30000,
+  } = options;
+
+  const filePath = getDispatchProgressFilePath(root, turn.turn_id);
+
+  let state = {
+    turn_id: turn.turn_id,
+    runtime_id: turn.runtime_id || null,
+    adapter_type,
+    started_at: null,
+    last_activity_at: null,
+    activity_type: 'output',
+    activity_summary: 'Dispatch starting',
+    output_lines: 0,
+    stderr_lines: 0,
+    silent_since: null,
+    pid,
+  };
+
+  let lastWriteAt = 0;
+  let silenceTimer = null;
+  let dirty = false;
+
+  function writeProgress() {
+    try {
+      const dir = dirname(filePath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n');
+      lastWriteAt = Date.now();
+      dirty = false;
+    } catch {
+      // Best-effort — never interrupt dispatch.
+    }
+  }
+
+  function maybeWrite() {
+    if (!dirty) return;
+    const now = Date.now();
+    if (now - lastWriteAt >= writeIntervalMs) {
+      writeProgress();
+    }
+  }
+
+  function resetSilenceTimer() {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    silenceTimer = setTimeout(() => {
+      state.activity_type = 'silent';
+      state.silent_since = state.silent_since || new Date().toISOString();
+      state.activity_summary = `No output for ${Math.round(silenceThresholdMs / 1000)}s`;
+      dirty = true;
+      writeProgress();
+    }, silenceThresholdMs);
+  }
+
+  return {
+    /** Start tracking — call once at dispatch start. */
+    start() {
+      const now = new Date().toISOString();
+      state.started_at = now;
+      state.last_activity_at = now;
+      state.activity_type = 'output';
+      state.activity_summary = 'Subprocess started';
+      dirty = true;
+      writeProgress();
+      if (adapter_type === 'local_cli') {
+        resetSilenceTimer();
+      }
+    },
+
+    /** Record output activity from the subprocess. */
+    onOutput(stream, lineCount = 1) {
+      const now = new Date().toISOString();
+      const wasSilent = state.activity_type === 'silent';
+      state.last_activity_at = now;
+      state.activity_type = 'output';
+      state.silent_since = null;
+      if (stream === 'stderr') {
+        state.stderr_lines += lineCount;
+      } else {
+        state.output_lines += lineCount;
+      }
+      state.activity_summary = `Producing output (${state.output_lines} lines)`;
+      dirty = true;
+      maybeWrite();
+      if (adapter_type === 'local_cli') {
+        resetSilenceTimer();
+      }
+      return wasSilent; // caller can use this to emit a "resumed" event
+    },
+
+    /** Mark as API request in flight (api_proxy, mcp, remote_agent). */
+    requestStarted() {
+      state.activity_type = 'request';
+      state.activity_summary = 'API request in flight';
+      state.last_activity_at = new Date().toISOString();
+      dirty = true;
+      writeProgress();
+    },
+
+    /** Mark API response received. */
+    responseReceived() {
+      state.activity_type = 'response';
+      state.activity_summary = 'API response received';
+      state.last_activity_at = new Date().toISOString();
+      dirty = true;
+      writeProgress();
+    },
+
+    /** Update PID after spawn (local_cli). */
+    setPid(newPid) {
+      state.pid = newPid;
+      dirty = true;
+      maybeWrite();
+    },
+
+    /** Get current progress state snapshot. */
+    getState() {
+      return { ...state };
+    },
+
+    /** Clean up — dispatch completed successfully. */
+    complete() {
+      if (silenceTimer) clearTimeout(silenceTimer);
+      deleteProgressFile(root, turn.turn_id);
+    },
+
+    /** Clean up — dispatch failed. */
+    fail() {
+      if (silenceTimer) clearTimeout(silenceTimer);
+      deleteProgressFile(root, turn.turn_id);
+    },
+
+    /** Clean up timers without deleting file (for abort paths). */
+    dispose() {
+      if (silenceTimer) clearTimeout(silenceTimer);
+    },
+  };
+}
+
+/**
+ * Delete the dispatch progress file.
+ * @param {string} root - project root
+ */
+export function deleteProgressFile(root, turnId = null) {
+  try {
+    if (turnId) {
+      const filePath = getDispatchProgressFilePath(root, turnId);
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+      }
+      return;
+    }
+
+    const legacyPath = join(root, LEGACY_DISPATCH_PROGRESS_PATH);
+    if (existsSync(legacyPath)) {
+      unlinkSync(legacyPath);
+    }
+    for (const filePath of listDispatchProgressFiles(root)) {
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+      }
+    }
+  } catch {
+    // Best-effort.
+  }
+}
+
+/**
+ * Read the current dispatch progress file.
+ * Returns null if no file exists or it's malformed.
+ *
+ * @param {string} root - project root
+ * @returns {object|null}
+ */
+export function readDispatchProgress(root, turnId = null) {
+  try {
+    let filePath;
+    if (turnId) {
+      filePath = getDispatchProgressFilePath(root, turnId);
+      if (!existsSync(filePath)) return null;
+    } else {
+      const files = listDispatchProgressFiles(root);
+      if (files.length === 0) {
+        const legacyPath = join(root, LEGACY_DISPATCH_PROGRESS_PATH);
+        if (!existsSync(legacyPath)) return null;
+        filePath = legacyPath;
+      } else if (files.length === 1) {
+        filePath = files[0];
+      } else {
+        return null;
+      }
+    }
+    const raw = readFileSync(filePath, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data.turn_id || !data.started_at) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read all current per-turn dispatch progress files.
+ *
+ * @param {string} root - project root
+ * @returns {Record<string, object>}
+ */
+export function readAllDispatchProgress(root) {
+  const progressByTurn = {};
+
+  for (const filePath of listDispatchProgressFiles(root)) {
+    try {
+      const raw = readFileSync(filePath, 'utf8');
+      const data = JSON.parse(raw);
+      const turnId = typeof data?.turn_id === 'string' && data.turn_id.length > 0
+        ? data.turn_id
+        : basename(filePath).replace(/^dispatch-progress-/, '').replace(/\.json$/, '');
+      if (!turnId || !data?.started_at) continue;
+      progressByTurn[turnId] = data;
+    } catch {
+      // Ignore malformed files.
+    }
+  }
+
+  if (Object.keys(progressByTurn).length === 0) {
+    const legacy = readDispatchProgress(root);
+    if (legacy?.turn_id) {
+      progressByTurn[legacy.turn_id] = legacy;
+    }
+  }
+
+  return progressByTurn;
+}

package/src/lib/repo-observer.js

@@ -24,6 +24,7 @@ import { join } from 'path';
 
 const OPERATIONAL_PATH_PREFIXES = [
   '.agentxchain/dispatch/',
+  '.agentxchain/dispatch-progress-',
   '.agentxchain/staging/',
   '.agentxchain/intake/',
   '.agentxchain/locks/',

package/src/lib/run-events.js

@@ -28,6 +28,7 @@ export const VALID_RUN_EVENTS = [
   'budget_exceeded_warn',
   'human_escalation_raised',
   'human_escalation_resolved',
+  'dispatch_progress',
 ];
 
 /**

package/src/lib/run-loop.js

@@ -12,7 +12,7 @@
  *   - Never calls process dot exit
  *   - No stdout/stderr
  *   - No adapter dispatch (caller provides dispatch callback)
- *   - Imports only from runner-interface.js
+ *   - Governed lifecycle operations import through runner-interface.js
  */
 
 import {
@@ -21,6 +21,7 @@ import {
   assignTurn,
   acceptTurn,
   rejectTurn,
+  markRunBlocked,
   writeDispatchBundle,
   getTurnStagingResultPath,
   approvePhaseGate,
@@ -33,10 +34,11 @@ import {
 } from './runner-interface.js';
 
 import { runAdmissionControl } from './admission-control.js';
-import { mkdirSync, writeFileSync } from 'fs';
+import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { evaluateApprovalSlaReminders } from './notification-runner.js';
 import { readPreemptionMarker } from './intake.js';
+import { buildTimeoutBlockedReason, evaluateTimeouts } from './timeout-evaluator.js';
 
 const DEFAULT_MAX_TURNS = 50;
 
@@ -214,6 +216,7 @@ async function executeSequentialTurn(root, config, state, callbacks, emit, error
 async function executeParallelTurns(root, config, state, maxConcurrent, callbacks, emit, errors) {
   const history = [];
   let acceptedCount = 0;
+  const timedOutDispatches = [];
 
   // ── Collect active turns that need dispatch (retries) ────────────────
   const activeTurns = getActiveTurns(state);
@@ -332,7 +335,7 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
   const dispatchResults = await Promise.allSettled(
     contexts.map(async (ctx) => {
       try {
-        return { ctx, result: await callbacks.dispatch(ctx) };
+        return { ctx, result: await dispatchWithTimeout(ctx, config, callbacks.dispatch) };
       } catch (err) {
         return { ctx, result: { accept: false, reason: `dispatch threw: ${err.message}` } };
       }
@@ -350,6 +353,11 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
     const { turn } = ctx;
     const roleId = turn.assigned_role;
 
+    if (dispatchResult?.timed_out === true) {
+      timedOutDispatches.push({ ctx, dispatchResult });
+      continue;
+    }
+
     if (dispatchResult.accept) {
       const absStaging = join(root, ctx.stagingPath);
       mkdirSync(dirname(absStaging), { recursive: true });
@@ -405,6 +413,13 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
     }
   }
 
+  if (timedOutDispatches.length > 0) {
+    const timedOut = timedOutDispatches[0];
+    const blocked = persistDispatchTimeout(root, config, timedOut.ctx.turn, timedOut.dispatchResult.timeout_result, errors);
+    emit({ type: 'blocked', state: blocked.state, reason: 'timeout:turn' });
+    return { terminal: true, ok: false, stop_reason: 'blocked', history, acceptedCount };
+  }
+
   // ── Stall detection: if no turns were accepted and no new roles were ──
   // ── assignable, terminate to avoid infinite re-dispatch loops. ────────
   if (acceptedCount === 0 && history.length > 0) {
@@ -445,12 +460,18 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
 
   let dispatchResult;
   try {
-    dispatchResult = await callbacks.dispatch(context);
+    dispatchResult = await dispatchWithTimeout(context, config, callbacks.dispatch);
   } catch (err) {
     errors.push(`dispatch threw for ${roleId}: ${err.message}`);
     return { terminal: true, ok: false, stop_reason: 'dispatch_error', history };
   }
 
+  if (dispatchResult?.timed_out === true) {
+    const blocked = persistDispatchTimeout(root, config, turn, dispatchResult.timeout_result, errors);
+    emit({ type: 'blocked', state: blocked.state, reason: 'timeout:turn' });
+    return { terminal: true, ok: false, stop_reason: 'blocked', history };
+  }
+
   if (dispatchResult.accept) {
     const absStaging = join(root, stagingPath);
     mkdirSync(dirname(absStaging), { recursive: true });
@@ -574,3 +595,107 @@ function makeResult(ok, stop_reason, state, turns_executed, turn_history, gates_
 function noop() {}
 
 export { DEFAULT_MAX_TURNS };
+
+function buildTimeoutLedgerEntry(timeoutResult, timestamp, turnId, phase) {
+  return {
+    type: 'timeout',
+    scope: timeoutResult.scope,
+    phase: timeoutResult.phase || phase || null,
+    turn_id: turnId || null,
+    limit_minutes: timeoutResult.limit_minutes,
+    elapsed_minutes: timeoutResult.elapsed_minutes,
+    exceeded_by_minutes: timeoutResult.exceeded_by_minutes,
+    action: timeoutResult.action,
+    timestamp,
+  };
+}
+
+function appendJsonl(root, relPath, value) {
+  appendFileSync(join(root, relPath), `${JSON.stringify(value)}\n`);
+}
+
+function getDispatchTimeoutResult(config, state, turn, now = new Date()) {
+  const evaluation = evaluateTimeouts({ config, state, turn, now });
+  return evaluation.exceeded.find((entry) => entry.scope === 'turn' && entry.action === 'escalate') || null;
+}
+
+async function dispatchWithTimeout(context, config, dispatchFn) {
+  const timeoutResult = getDispatchTimeoutResult(config, context.state, context.turn);
+  if (!timeoutResult) {
+    return await dispatchFn(context);
+  }
+
+  const remainingMs = Math.max(
+    0,
+    timeoutResult.limit_minutes * 60 * 1000
+      - Math.max(0, new Date() - new Date(context.turn.started_at || context.turn.assigned_at || new Date())),
+  );
+  const abortController = new AbortController();
+  if (remainingMs === 0) {
+    abortController.abort(new Error(`Turn timeout exceeded after ${timeoutResult.limit_minutes}m`));
+    return {
+      timed_out: true,
+      timeout_result: timeoutResult,
+    };
+  }
+  const enrichedContext = {
+    ...context,
+    dispatchTimeoutMs: remainingMs,
+    dispatchDeadlineAt: new Date(Date.now() + remainingMs).toISOString(),
+    dispatchAbortSignal: abortController.signal,
+  };
+
+  let timer = null;
+  const dispatchPromise = Promise.resolve(dispatchFn(enrichedContext))
+    .then((result) => ({ kind: 'result', result }))
+    .catch((error) => ({ kind: 'error', error }));
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      abortController.abort(new Error(`Turn timeout exceeded after ${timeoutResult.limit_minutes}m`));
+      resolve({ kind: 'timeout', timeoutResult });
+    }, remainingMs);
+  });
+
+  const winner = await Promise.race([dispatchPromise, timeoutPromise]);
+  clearTimeout(timer);
+
+  if (winner.kind === 'timeout') {
+    return {
+      timed_out: true,
+      timeout_result: winner.timeoutResult,
+    };
+  }
+
+  if (winner.kind === 'error') {
+    throw winner.error;
+  }
+
+  return winner.result;
+}
+
+function persistDispatchTimeout(root, config, turn, timeoutResult, errors) {
+  const blockedAt = new Date().toISOString();
+  const blockedReason = buildTimeoutBlockedReason(timeoutResult, { turnRetained: true });
+  const blocked = markRunBlocked(root, {
+    blockedOn: `timeout:${timeoutResult.scope}`,
+    category: blockedReason.category,
+    recovery: blockedReason.recovery,
+    turnId: turn.turn_id,
+    blockedAt,
+    notificationConfig: config,
+  });
+
+  if (!blocked.ok) {
+    errors.push(`markRunBlocked(timeout): ${blocked.error}`);
+    return { state: loadState(root, config) };
+  }
+
+  try {
+    appendJsonl(root, '.agentxchain/decision-ledger.jsonl', buildTimeoutLedgerEntry(timeoutResult, blockedAt, turn.turn_id, blocked.state?.phase));
+  } catch (err) {
+    errors.push(`timeout ledger append failed: ${err.message}`);
+  }
+
+  errors.push(`dispatch timed out for ${turn.assigned_role} after ${timeoutResult.limit_minutes}m`);
+  return blocked;
+}

package/src/lib/timeout-evaluator.js

@@ -210,6 +210,93 @@ export function validateTimeoutsConfig(timeouts, routing) {
   return { ok: errors.length === 0, errors };
 }
 
+/**
+ * Compute remaining timeout budget for an active turn/phase/run.
+ *
+ * Unlike evaluateTimeouts() which only returns items when exceeded,
+ * this returns budget info for ALL configured timeout scopes regardless
+ * of whether the deadline has passed.
+ *
+ * @param {object} options
+ * @param {object} options.config - Normalized config with optional `timeouts` section
+ * @param {object} options.state - Current governed state
+ * @param {object} [options.turn] - Active turn metadata
+ * @param {Date|string} [options.now] - Override for current time (testing)
+ * @returns {Array<TimeoutBudget>} Array of { scope, limit_minutes, elapsed_minutes, remaining_minutes, deadline_iso, exceeded, action }
+ */
+export function computeTimeoutBudget({ config, state, turn = null, now = new Date() }) {
+  const timeouts = config?.timeouts;
+  if (!timeouts) return [];
+
+  const nowMs = typeof now === 'string' ? new Date(now).getTime() : now.getTime();
+  const budgets = [];
+
+  // Per-turn budget
+  if (timeouts.per_turn_minutes && turn) {
+    const startedAt = turn.started_at || turn.assigned_at;
+    if (startedAt) {
+      const dispatchMs = new Date(startedAt).getTime();
+      const limitMs = timeouts.per_turn_minutes * 60 * 1000;
+      const elapsedMs = nowMs - dispatchMs;
+      const remainingMs = limitMs - elapsedMs;
+      budgets.push({
+        scope: 'turn',
+        limit_minutes: timeouts.per_turn_minutes,
+        elapsed_minutes: Math.round(elapsedMs / 60000),
+        remaining_minutes: Math.max(0, Math.round(remainingMs / 60000)),
+        remaining_seconds: Math.max(0, Math.round(remainingMs / 1000)),
+        deadline_iso: new Date(dispatchMs + limitMs).toISOString(),
+        exceeded: elapsedMs > limitMs,
+        action: resolveAction(timeouts.action, 'turn'),
+      });
+    }
+  }
+
+  // Per-phase budget
+  const phaseLimit = resolvePhaseLimit(timeouts, config.routing, state.phase);
+  const phaseAction = resolvePhaseAction(timeouts, config.routing, state.phase);
+  if (phaseLimit) {
+    const phaseEnteredAt = findPhaseEntryTime(state);
+    if (phaseEnteredAt) {
+      const entryMs = new Date(phaseEnteredAt).getTime();
+      const limitMs = phaseLimit * 60 * 1000;
+      const elapsedMs = nowMs - entryMs;
+      const remainingMs = limitMs - elapsedMs;
+      budgets.push({
+        scope: 'phase',
+        phase: state.phase,
+        limit_minutes: phaseLimit,
+        elapsed_minutes: Math.round(elapsedMs / 60000),
+        remaining_minutes: Math.max(0, Math.round(remainingMs / 60000)),
+        remaining_seconds: Math.max(0, Math.round(remainingMs / 1000)),
+        deadline_iso: new Date(entryMs + limitMs).toISOString(),
+        exceeded: elapsedMs > limitMs,
+        action: phaseAction,
+      });
+    }
+  }
+
+  // Per-run budget
+  if (timeouts.per_run_minutes && state.created_at) {
+    const createMs = new Date(state.created_at).getTime();
+    const limitMs = timeouts.per_run_minutes * 60 * 1000;
+    const elapsedMs = nowMs - createMs;
+    const remainingMs = limitMs - elapsedMs;
+    budgets.push({
+      scope: 'run',
+      limit_minutes: timeouts.per_run_minutes,
+      elapsed_minutes: Math.round(elapsedMs / 60000),
+      remaining_minutes: Math.max(0, Math.round(remainingMs / 60000)),
+      remaining_seconds: Math.max(0, Math.round(remainingMs / 1000)),
+      deadline_iso: new Date(createMs + limitMs).toISOString(),
+      exceeded: elapsedMs > limitMs,
+      action: resolveAction(timeouts.action, 'run'),
+    });
+  }
+
+  return budgets;
+}
+
 /**
  * Build a blocked_reason descriptor for a timeout.
  */