agentxchain 2.145.0 → 2.146.0

package/dashboard/app.js

@@ -15,6 +15,7 @@ import { render as renderCrossRepo } from './components/cross-repo.js';
 import { render as renderDelegations } from './components/delegations.js';
 import { render as renderBlockers } from './components/blockers.js';
 import { render as renderArtifacts } from './components/artifacts.js';
+import { render as renderNotifications } from './components/notifications.js';
 import { render as renderMission } from './components/mission.js';
 import { render as renderChain } from './components/chain.js';
 import { render as renderRunHistory } from './components/run-history.js';
@@ -31,6 +32,7 @@ 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 },
+  notifications: { fetch: ['notifications'], render: renderNotifications },
   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 },
@@ -62,6 +64,7 @@ const API_MAP = {
   coordinatorBlockers: '/api/coordinator/blockers',
   coordinatorRepoStatusRows: '/api/coordinator/repo-status',
   workflowKitArtifacts: '/api/workflow-kit-artifacts',
+  notifications: '/api/notifications',
   missions: '/api/missions',
   plans: '/api/plans',
   chainReports: '/api/chain-reports',

package/dashboard/components/notifications.js

@@ -0,0 +1,127 @@
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function formatResult(entry) {
+  if (entry?.delivered) return badge('delivered', 'var(--green)');
+  if (entry?.timed_out) return badge('timed out', 'var(--yellow)');
+  return badge('failed', 'var(--red)');
+}
+
+function renderWebhookRow(webhook) {
+  return `<tr>
+    <td class="mono">${esc(webhook.name)}</td>
+    <td>${esc(webhook.timeout_ms)}</td>
+    <td>${esc(webhook.event_count)}</td>
+    <td><span class="mono">${esc((webhook.events || []).join(', '))}</span></td>
+  </tr>`;
+}
+
+function renderAuditRow(entry) {
+  const rowStyle = entry?.delivered ? '' : ' style="border-left:3px solid var(--red)"';
+  const statusCode = entry?.status_code == null ? '—' : String(entry.status_code);
+  const duration = entry?.duration_ms == null ? '—' : `${entry.duration_ms}ms`;
+  return `<tr${rowStyle}>
+    <td class="mono">${esc(entry?.emitted_at || '—')}</td>
+    <td><span class="mono">${esc(entry?.event_type || '—')}</span></td>
+    <td class="mono">${esc(entry?.notification_name || '—')}</td>
+    <td>${formatResult(entry)}</td>
+    <td>${esc(statusCode)}</td>
+    <td>${esc(duration)}</td>
+    <td>${esc(entry?.message || '—')}</td>
+  </tr>`;
+}
+
+export function render({ notifications }) {
+  if (!notifications) {
+    return `<div class="placeholder"><h2>Notifications</h2><p>No notification data available.</p></div>`;
+  }
+
+  if (notifications.ok === false) {
+    const hint = notifications.code === 'config_missing'
+      ? ' Run <code>agentxchain init --governed</code> to get started.'
+      : '';
+    return `<div class="placeholder"><h2>Notifications</h2><p>${esc(notifications.error || 'Failed to load notification data.')}${hint}</p></div>`;
+  }
+
+  const recent = Array.isArray(notifications.recent) ? notifications.recent : [];
+  const webhooks = Array.isArray(notifications.webhooks) ? notifications.webhooks : [];
+  const summary = notifications.summary || {};
+
+  if (!notifications.configured && recent.length === 0) {
+    return `<div class="placeholder"><h2>Notifications</h2><p>No <code>notifications.webhooks</code> are configured and no delivery audit entries exist yet.</p></div>`;
+  }
+
+  let html = `<div class="notifications-view"><div class="run-header"><div class="run-meta">`;
+  html += notifications.configured
+    ? badge(`${webhooks.length} webhook${webhooks.length === 1 ? '' : 's'} configured`, 'var(--green)')
+    : badge('not currently configured', 'var(--yellow)');
+  html += badge(`${summary.total_attempts || 0} attempts`, 'var(--accent)');
+  if ((summary.failed || 0) > 0) {
+    html += badge(`${summary.failed} failed`, 'var(--red)');
+  }
+  if ((summary.timed_out || 0) > 0) {
+    html += badge(`${summary.timed_out} timed out`, 'var(--yellow)');
+  }
+  if (notifications.approval_sla?.enabled) {
+    html += badge(`approval SLA: ${(notifications.approval_sla.reminder_after_seconds || []).join(', ')}s`, 'var(--accent)');
+  }
+  html += `</div></div>`;
+
+  if (webhooks.length > 0) {
+    html += `<div class="section"><h3>Notification Targets</h3>
+      <table class="data-table">
+        <thead>
+          <tr>
+            <th>Name</th>
+            <th>Timeout</th>
+            <th>Events</th>
+            <th>Subscribed Event Types</th>
+          </tr>
+        </thead>
+        <tbody>${webhooks.map(renderWebhookRow).join('')}</tbody>
+      </table>
+    </div>`;
+  }
+
+  html += `<div class="section"><h3>Delivery Summary</h3>
+    <p><strong>Delivered:</strong> ${esc(summary.delivered || 0)}<br>
+    <strong>Failed:</strong> ${esc(summary.failed || 0)}<br>
+    <strong>Last emitted:</strong> ${esc(summary.last_emitted_at || '—')}<br>
+    <strong>Last failure:</strong> ${esc(summary.last_failure_at || '—')}</p>
+  </div>`;
+
+  if (recent.length === 0) {
+    html += `<div class="section"><h3>Recent Delivery Attempts</h3><p style="color:var(--text-dim)">No notification deliveries recorded yet.</p></div>`;
+  } else {
+    html += `<div class="section"><h3>Recent Delivery Attempts</h3>
+      <table class="data-table">
+        <thead>
+          <tr>
+            <th>Emitted</th>
+            <th>Event</th>
+            <th>Target</th>
+            <th>Result</th>
+            <th>Status</th>
+            <th>Duration</th>
+            <th>Message</th>
+          </tr>
+        </thead>
+        <tbody>${recent.map(renderAuditRow).join('')}</tbody>
+      </table>
+    </div>`;
+  }
+
+  html += `</div>`;
+  return html;
+}

package/dashboard/index.html

@@ -401,6 +401,7 @@
     <a href="#delegations">Delegations</a>
     <a href="#ledger">Decisions</a>
     <a href="#hooks">Hooks</a>
+    <a href="#notifications">Notifications</a>
     <a href="#blocked">Blocked</a>
     <a href="#gate">Gates</a>
     <a href="#blockers">Blockers</a>

package/package.json

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

package/scripts/release-downstream-truth.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Release downstream truth — run after all downstream surfaces are updated.
-# Verifies: GitHub release exists, Homebrew tap SHA and URL match registry tarball.
+# Verifies: GitHub release is published on the expected tag URL, Homebrew tap SHA and URL match registry tarball.
 # Usage: bash scripts/release-downstream-truth.sh --target-version <semver>
 set -uo pipefail
 
@@ -91,22 +91,30 @@ echo "[1/3] GitHub release"
 if ! command -v gh >/dev/null 2>&1; then
   fail "gh CLI not available — cannot verify GitHub release"
 else
-  GH_FOUND=false
+  GH_READY=false
+  EXPECTED_GH_URL="https://github.com/shivamtiwari93/agentXchain.dev/releases/tag/v${TARGET_VERSION}"
   for attempt in $(seq 1 "$RETRY_ATTEMPTS"); do
     GH_TAG="$(gh release view "v${TARGET_VERSION}" --json tagName -q '.tagName' 2>/dev/null || true)"
-    if [[ "$GH_TAG" == "v${TARGET_VERSION}" ]]; then
-      GH_FOUND=true
+    GH_DRAFT="$(gh release view "v${TARGET_VERSION}" --json isDraft -q '.isDraft' 2>/dev/null || true)"
+    GH_URL="$(gh release view "v${TARGET_VERSION}" --json url -q '.url' 2>/dev/null || true)"
+    GH_PUBLISHED_AT="$(gh release view "v${TARGET_VERSION}" --json publishedAt -q '.publishedAt' 2>/dev/null || true)"
+    if [[ "$GH_TAG" == "v${TARGET_VERSION}" ]] \
+      && [[ "$GH_DRAFT" == "false" ]] \
+      && [[ "$GH_URL" == "$EXPECTED_GH_URL" ]] \
+      && [[ -n "$GH_PUBLISHED_AT" ]] \
+      && [[ "$GH_PUBLISHED_AT" != "null" ]]; then
+      GH_READY=true
       break
     fi
     if [[ "$attempt" -lt "$RETRY_ATTEMPTS" ]]; then
-      echo "  INFO: GitHub release not found (attempt ${attempt}/${RETRY_ATTEMPTS}); retrying in ${RETRY_DELAY_SECONDS}s..."
+      echo "  INFO: GitHub release not ready (attempt ${attempt}/${RETRY_ATTEMPTS}); retrying in ${RETRY_DELAY_SECONDS}s..."
       sleep "$RETRY_DELAY_SECONDS"
     fi
   done
-  if $GH_FOUND; then
-    pass "GitHub release v${TARGET_VERSION} exists"
+  if $GH_READY; then
+    pass "GitHub release v${TARGET_VERSION} is published on the tagged release URL"
   else
-    fail "GitHub release v${TARGET_VERSION} not found after ${RETRY_ATTEMPTS} attempts"
+    fail "GitHub release v${TARGET_VERSION} is not fully published (tag=${GH_TAG:-<missing>} draft=${GH_DRAFT:-<missing>} url=${GH_URL:-<missing>} publishedAt=${GH_PUBLISHED_AT:-<missing>})"
   fi
 fi
 

package/src/commands/init.js

@@ -103,6 +103,68 @@ const DEFAULT_GOVERNED_LOCAL_DEV_RUNTIME = Object.freeze({
   prompt_transport: 'stdin',
 });
 
+const GOVERNED_GITIGNORE_LINES = Object.freeze([
+  '.env',
+  '.agentxchain/staging/',
+  '.agentxchain/dispatch/',
+  '.agentxchain/transactions/',
+  '.agentxchain/state.json',
+  '.agentxchain/session.json',
+  '.agentxchain/history.jsonl',
+  '.agentxchain/decision-ledger.jsonl',
+  '.agentxchain/repo-decisions.jsonl',
+  '.agentxchain/lock.json',
+  '.agentxchain/hook-audit.jsonl',
+  '.agentxchain/hook-annotations.jsonl',
+  '.agentxchain/run-history.jsonl',
+  '.agentxchain/events.jsonl',
+  '.agentxchain/notification-audit.jsonl',
+  '.agentxchain/schedule-state.json',
+  '.agentxchain/schedule-daemon.json',
+  '.agentxchain/continuous-session.json',
+  '.agentxchain/human-escalations.jsonl',
+  '.agentxchain/sla-reminders.json',
+  '.agentxchain/SESSION_RECOVERY.md',
+  '.agentxchain/migration-report.md',
+  '.agentxchain/intake/',
+  '.agentxchain/missions/',
+  '.agentxchain/multirepo/',
+  '.agentxchain/reviews/',
+  '.agentxchain/reports/',
+  '.agentxchain/proposed/',
+  'TALK.md',
+  'HUMAN_TASKS.md',
+]);
+
+const GOVERNED_GITIGNORE_CONTENT = [
+  '# AgentXchain — secrets',
+  '.env',
+  '',
+  '# AgentXchain — transient execution artifacts (never commit)',
+  '.agentxchain/staging/',
+  '.agentxchain/dispatch/',
+  '.agentxchain/transactions/',
+  '',
+  '# AgentXchain — framework-owned state (gitignored by default in fresh scaffolds)',
+  '# These files remain durable on disk and in export/restore, but defaulting them',
+  '# out of raw `git status` reduces operator noise. Existing tracked copies still',
+  '# appear dirty until the repo explicitly untracks them.',
+  ...GOVERNED_GITIGNORE_LINES.slice(4),
+].join('\n') + '\n';
+
+function ensureGitignoreEntries(gitignorePath, content, requiredEntries) {
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, content);
+    return;
+  }
+  const existingIgnore = readFileSync(gitignorePath, 'utf8');
+  const existingLines = new Set(existingIgnore.split(/\r?\n/));
+  const missing = requiredEntries.filter(entry => !existingLines.has(entry));
+  if (missing.length === 0) return;
+  const prefix = existingIgnore.endsWith('\n') || existingIgnore.length === 0 ? '' : '\n';
+  writeFileSync(gitignorePath, existingIgnore + prefix + missing.join('\n') + '\n');
+}
+
 const GOVERNED_RUNTIMES = {
   'manual-pm': { type: 'manual' },
   'manual-dev': { type: 'manual' },
@@ -833,28 +895,10 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
   // TALK.md
   writeFileSync(join(dir, 'TALK.md'), `# ${projectName} — Team Talk File\n\nCanonical human-readable handoff log for all agents.\n\n---\n\n`);
 
-  // .gitignore additions with inline comments so operators know what to commit vs. ignore
+  // .gitignore additions with inline comments so fresh governed repos keep
+  // framework-owned runtime state out of raw git status by default.
   const gitignorePath = join(dir, '.gitignore');
-  const gitignoreContent = [
-    '# AgentXchain — secrets',
-    '.env',
-    '',
-    '# AgentXchain — transient execution artifacts (never commit)',
-    '.agentxchain/staging/',
-    '.agentxchain/dispatch/',
-    '.agentxchain/transactions/',
-  ].join('\n') + '\n';
-  const requiredPaths = ['.env', '.agentxchain/staging/', '.agentxchain/dispatch/', '.agentxchain/transactions/'];
-  if (!existsSync(gitignorePath)) {
-    writeFileSync(gitignorePath, gitignoreContent);
-  } else {
-    const existingIgnore = readFileSync(gitignorePath, 'utf8');
-    const missing = requiredPaths.filter(entry => !existingIgnore.split(/\r?\n/).includes(entry));
-    if (missing.length > 0) {
-      const prefix = existingIgnore.endsWith('\n') ? '' : '\n';
-      writeFileSync(gitignorePath, existingIgnore + prefix + missing.join('\n') + '\n');
-    }
-  }
+  ensureGitignoreEntries(gitignorePath, GOVERNED_GITIGNORE_CONTENT, GOVERNED_GITIGNORE_LINES);
 
   return { config, state, scaffoldWorkflowKitConfig };
 }
@@ -1251,16 +1295,7 @@ export async function initCommand(opts) {
   writeFileSync(join(dir, 'HUMAN_TASKS.md'), '# Human Tasks\n\n(Agents append tasks here when they need human action.)\n');
   const gitignorePath = join(dir, '.gitignore');
   const requiredIgnores = ['.env', '.agentxchain-trigger.json', '.agentxchain-prompts/', '.agentxchain-workspaces/', '.agentxchain-watch.pid', '.agentxchain-autonudge.state'];
-  if (!existsSync(gitignorePath)) {
-    writeFileSync(gitignorePath, requiredIgnores.join('\n') + '\n');
-  } else {
-    const existingIgnore = readFileSync(gitignorePath, 'utf8');
-    const missing = requiredIgnores.filter(entry => !existingIgnore.split(/\r?\n/).includes(entry));
-    if (missing.length > 0) {
-      const prefix = existingIgnore.endsWith('\n') ? '' : '\n';
-      writeFileSync(gitignorePath, existingIgnore + prefix + missing.join('\n') + '\n');
-    }
-  }
+  ensureGitignoreEntries(gitignorePath, requiredIgnores.join('\n') + '\n', requiredIgnores);
 
   // .planning/ structure
   mkdirSync(join(dir, '.planning', 'research'), { recursive: true });

package/src/commands/restart.js

@@ -13,13 +13,16 @@
 import chalk from 'chalk';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
-import { loadProjectContext } from '../lib/config.js';
+import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import {
   assignGovernedTurn,
   getActiveTurns,
   getActiveTurnCount,
   reactivateGovernedRun,
   detectStateBundleDesync,
+  normalizeGovernedStateShape,
+  reconcileApprovalPausesWithConfig,
+  reconcileRecoveryActionsWithConfig,
   STATE_PATH,
   HISTORY_PATH,
   LEDGER_PATH,
@@ -27,7 +30,6 @@ import {
 import { writeDispatchBundle } from '../lib/dispatch-bundle.js';
 import { getDispatchTurnDir } from '../lib/turn-paths.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
-import { loadProjectState } from '../lib/config.js';
 import { deriveRecoveryDescriptor } from '../lib/blocked-state.js';
 import { deriveRecommendedContinuityAction } from '../lib/continuity-status.js';
 import { readSessionCheckpoint, writeSessionCheckpoint, captureBaselineRef, SESSION_PATH } from '../lib/session-checkpoint.js';
@@ -178,7 +180,20 @@ export async function restartCommand(opts) {
     process.exit(1);
   }
 
-  const state = JSON.parse(readFileSync(statePath, 'utf8'));
+  let state;
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
+    const normalized = normalizeGovernedStateShape(parsed);
+    const reconciledApprovals = reconcileApprovalPausesWithConfig(normalized.state, config);
+    const reconciledRecovery = reconcileRecoveryActionsWithConfig(reconciledApprovals.state, config);
+    state = reconciledRecovery.state;
+    if (normalized.changed || reconciledApprovals.changed || reconciledRecovery.changed) {
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+    }
+  } catch {
+    console.log(chalk.red('No valid governed state.json found.'));
+    process.exit(1);
+  }
 
   // Load checkpoint (optional — restart can work without it, just with less context)
   const checkpoint = readSessionCheckpoint(root);

package/src/commands/resume.js

@@ -78,6 +78,10 @@ export async function resumeCommand(opts) {
 
   const staleReconciliation = reconcileStaleTurns(root, state, config);
   state = staleReconciliation.state || state;
+  if (staleReconciliation.ghost_turns.length > 0) {
+    printGhostTurnRecovery(staleReconciliation.ghost_turns);
+    process.exit(1);
+  }
   if (staleReconciliation.stale_turns.length > 0) {
     printStaleTurnRecovery(staleReconciliation.stale_turns);
     process.exit(1);
@@ -359,6 +363,19 @@ export async function resumeCommand(opts) {
   printDispatchSummary(state, config);
 }
 
+function printGhostTurnRecovery(ghostTurns) {
+  console.log(chalk.red.bold('Ghost turn detected — subprocess never started.'));
+  console.log('');
+  for (const ghost of ghostTurns) {
+    const secs = Math.floor(ghost.running_ms / 1000);
+    console.log(`  Turn:    ${ghost.turn_id} (${ghost.role})`);
+    console.log(`  Runtime: ${ghost.runtime_id}`);
+    console.log(`  Age:     ${secs}s with no subprocess output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${ghost.turn_id} --reason ghost`)}`);
+    console.log('');
+  }
+}
+
 function printStaleTurnRecovery(staleTurns) {
   console.log(chalk.red.bold('Stale turn detected.'));
   console.log('');

package/src/commands/status.js

@@ -136,6 +136,10 @@ function loadStatusContext(dir = process.cwd()) {
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
   let state = loadProjectState(root, config);
+  const staleReconciliation = reconcileStaleTurns(root, state, config);
+  state = staleReconciliation.state || state;
+  const staleTurns = staleReconciliation.stale_turns;
+  const ghostTurns = staleReconciliation.ghost_turns || [];
   const stateRunId = state?.run_id || readRawStateRunId(root, config);
   const continuity = getContinuityStatus(root, state);
   const connectorHealth = getConnectorHealth(root, config, state);
@@ -166,11 +170,6 @@ function renderGovernedStatus(context, opts) {
   // Coordinator warning surfacing — DEC-COORD-RETRY-PROJECTION-EVENT-001
   const coordinatorWarnings = readCoordinatorWarnings(root, { runId: stateRunId || null });
 
-  // BUG-47: detect stale running turns and emit turn_stalled events
-  const staleReconciliation = reconcileStaleTurns(root, state, config);
-  state = staleReconciliation.state || state;
-  const staleTurns = staleReconciliation.stale_turns;
-
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -209,6 +208,7 @@ function renderGovernedStatus(context, opts) {
       bundle_integrity: detectStateBundleDesync(root, state),
       coordinator_warnings: coordinatorWarnings,
       stale_turns: staleTurns,
+      ghost_turns: ghostTurns,
     }, null, 2));
     return;
   }
@@ -453,6 +453,19 @@ function renderGovernedStatus(context, opts) {
     }
   }
 
+  // BUG-51: Ghost turn warning (subprocess never started)
+  if (ghostTurns.length > 0) {
+    console.log('');
+    for (const gt of ghostTurns) {
+      const secs = Math.floor(gt.running_ms / 1000);
+      console.log(`  ${chalk.red.bold('⚠ Ghost turn detected — subprocess never started')}`);
+      console.log(`  ${chalk.dim('Turn:')}     ${gt.turn_id} (${gt.role})`);
+      console.log(`  ${chalk.dim('Runtime:')}  ${gt.runtime_id}`);
+      console.log(`  ${chalk.dim('Age:')}      ${secs}s with no subprocess output`);
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(`agentxchain reissue-turn --turn ${gt.turn_id} --reason ghost`)}`);
+    }
+  }
+
   // BUG-47: Stale turn warning
   if (staleTurns.length > 0) {
     console.log('');

package/src/commands/step.js

@@ -97,6 +97,10 @@ export async function stepCommand(opts) {
 
   const staleReconciliation = reconcileStaleTurns(root, state, config);
   state = staleReconciliation.state || state;
+  if (staleReconciliation.ghost_turns.length > 0) {
+    printGhostTurnRecovery(staleReconciliation.ghost_turns);
+    process.exit(1);
+  }
   if (staleReconciliation.stale_turns.length > 0) {
     printStaleTurnRecovery(staleReconciliation.stale_turns);
     process.exit(1);
@@ -909,6 +913,19 @@ export async function stepCommand(opts) {
   }
 }
 
+function printGhostTurnRecovery(ghostTurns) {
+  console.log(chalk.red.bold('Ghost turn detected — subprocess never started.'));
+  console.log('');
+  for (const ghost of ghostTurns) {
+    const secs = Math.floor(ghost.running_ms / 1000);
+    console.log(`  Turn:    ${ghost.turn_id} (${ghost.role})`);
+    console.log(`  Runtime: ${ghost.runtime_id}`);
+    console.log(`  Age:     ${secs}s with no subprocess output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${ghost.turn_id} --reason ghost`)}`);
+    console.log('');
+  }
+}
+
 function printStaleTurnRecovery(staleTurns) {
   console.log(chalk.red.bold('Stale turn detected.'));
   console.log('');

package/src/lib/config.js

@@ -6,6 +6,7 @@ import { safeWriteJson } from './safe-write.js';
 import {
   normalizeGovernedStateShape,
   getActiveTurn,
+  reconcileApprovalPausesWithConfig,
   reconcileBudgetStatusWithConfig,
   reconcileRecoveryActionsWithConfig,
 } from './governed-state.js';
@@ -153,11 +154,13 @@ export function loadProjectState(root, config) {
   if (config?.protocol_mode === 'governed') {
     const normalized = normalizeGovernedStateShape(stateData);
     stateData = normalized.state;
+    const reconciledApprovals = reconcileApprovalPausesWithConfig(stateData, config);
+    stateData = reconciledApprovals.state;
     const reconciledBudget = reconcileBudgetStatusWithConfig(stateData, config);
     stateData = reconciledBudget.state;
     const reconciledRecovery = reconcileRecoveryActionsWithConfig(stateData, config);
     stateData = reconciledRecovery.state;
-    if (normalized.changed || reconciledBudget.changed || reconciledRecovery.changed) {
+    if (normalized.changed || reconciledApprovals.changed || reconciledBudget.changed || reconciledRecovery.changed) {
       safeWriteJson(filePath, stateData);
     }
   }

package/src/lib/dashboard/actions.js

@@ -1,5 +1,5 @@
 import { dirname } from 'path';
-import { loadProjectContext } from '../config.js';
+import { loadProjectContext, loadProjectState } from '../config.js';
 import { approvePhaseTransition, approveRunCompletion } from '../governed-state.js';
 import { deriveGovernedRunNextActions, deriveRecoveryDescriptor } from '../blocked-state.js';
 import {
@@ -205,10 +205,16 @@ function approveCoordinatorGate(workspacePath, state, config) {
 
 export function approvePendingDashboardGate(agentxchainDir) {
   const workspacePath = dirname(agentxchainDir);
-  const repoState = readJsonFile(agentxchainDir, 'state.json');
+  const context = loadProjectContext(workspacePath);
+
+  // Use loadProjectState to get reconciled state — approval-pause repair
+  // may surface a pending_run_completion from an orphaned blocked_on marker,
+  // and we must route on the reconciled truth, not the raw state.json.
+  const repoState = (context?.config?.protocol_mode === 'governed'
+    ? loadProjectState(workspacePath, context.config)
+    : null) || readJsonFile(agentxchainDir, 'state.json');
 
   if (repoState?.pending_phase_transition || repoState?.pending_run_completion) {
-    const context = loadProjectContext(workspacePath);
     return approveRepoGate(workspacePath, context?.config, repoState);
   }
 

package/src/lib/dashboard/bridge-server.js

@@ -23,6 +23,7 @@ import { readCoordinatorRepoStatusRows } from './coordinator-repo-status.js';
 import { readCoordinatorTimeoutStatus } from './coordinator-timeout-status.js';
 import { readAggregatedCoordinatorEvents, watchChildRepoEvents } from './coordinator-event-aggregation.js';
 import { readWorkflowKitArtifacts } from './workflow-kit-artifacts.js';
+import { readNotificationSnapshot } from './notifications-reader.js';
 import { readConnectorHealthSnapshot } from './connectors.js';
 import { readTimeoutStatus } from './timeout-status.js';
 import { queryRunHistory } from '../run-history.js';
@@ -431,6 +432,16 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/notifications') {
+      if (replayMode) {
+        writeJson(res, 200, { ok: true, replay_mode: true, message: 'Notification audit is live-only and not available in replay mode.' });
+        return;
+      }
+      const result = readNotificationSnapshot(workspacePath);
+      writeJson(res, result.status, result.body);
+      return;
+    }
+
     if (pathname === '/api/connectors') {
       const result = readConnectorHealthSnapshot(workspacePath);
       writeJson(res, result.status, result.body);

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

@@ -0,0 +1,91 @@
+import { loadConfig, loadProjectContext } from '../config.js';
+import { readJsonlFile } from './state-reader.js';
+
+function summarizeAuditEntries(entries) {
+  const summary = {
+    total_attempts: entries.length,
+    delivered: 0,
+    failed: 0,
+    timed_out: 0,
+    last_emitted_at: null,
+    last_failure_at: null,
+  };
+
+  for (const entry of entries) {
+    if (entry?.delivered === true) {
+      summary.delivered += 1;
+    } else {
+      summary.failed += 1;
+      if (!summary.last_failure_at || String(entry?.emitted_at || '') > summary.last_failure_at) {
+        summary.last_failure_at = entry?.emitted_at || null;
+      }
+    }
+    if (entry?.timed_out === true) {
+      summary.timed_out += 1;
+    }
+    if (!summary.last_emitted_at || String(entry?.emitted_at || '') > summary.last_emitted_at) {
+      summary.last_emitted_at = entry?.emitted_at || null;
+    }
+  }
+
+  return summary;
+}
+
+function normalizeWebhook(webhook) {
+  return {
+    name: webhook.name,
+    timeout_ms: webhook.timeout_ms,
+    event_count: Array.isArray(webhook.events) ? webhook.events.length : 0,
+    events: Array.isArray(webhook.events) ? webhook.events : [],
+  };
+}
+
+export function readNotificationSnapshot(workspacePath) {
+  const context = loadProjectContext(workspacePath);
+  const governedContext = context?.config ? context : null;
+  const legacyConfigResult = governedContext ? null : loadConfig(workspacePath);
+  if (!governedContext && !legacyConfigResult) {
+    return {
+      ok: false,
+      status: 404,
+      body: {
+        ok: false,
+        code: 'config_missing',
+        error: 'Project config not found. Run `agentxchain init --governed` first.',
+      },
+    };
+  }
+
+  const root = governedContext?.root || legacyConfigResult.root;
+  const config = governedContext?.config || legacyConfigResult.config;
+  const notifications = config?.notifications || {};
+  const webhooks = Array.isArray(notifications.webhooks)
+    ? notifications.webhooks.map(normalizeWebhook)
+    : [];
+  const configured = webhooks.length > 0;
+  const approvalSla = notifications.approval_sla
+    ? {
+      enabled: notifications.approval_sla.enabled !== false,
+      reminder_after_seconds: Array.isArray(notifications.approval_sla.reminder_after_seconds)
+        ? notifications.approval_sla.reminder_after_seconds
+        : [],
+    }
+    : null;
+
+  const auditEntries = (readJsonlFile(`${root}/.agentxchain`, 'notification-audit.jsonl') || [])
+    .slice()
+    .sort((a, b) => String(b?.emitted_at || '').localeCompare(String(a?.emitted_at || '')));
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      ok: true,
+      configured,
+      webhooks,
+      approval_sla: approvalSla,
+      summary: summarizeAuditEntries(auditEntries),
+      recent: auditEntries.slice(0, 10),
+    },
+  };
+}

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

@@ -12,8 +12,9 @@ import {
   deriveGovernedRunNextActions,
   deriveRuntimeBlockedGuidance,
 } from '../blocked-state.js';
-import { loadProjectContext } from '../config.js';
+import { loadProjectContext, loadProjectState } from '../config.js';
 import { getContinuityStatus } from '../continuity-status.js';
+import { reconcileStaleTurns } from '../stale-turn-watchdog.js';
 import { readRepoDecisions, summarizeRepoDecisions } from '../repo-decisions.js';
 import { readAllDispatchProgress } from '../dispatch-progress.js';
 
@@ -136,10 +137,21 @@ function enrichGovernedState(agentxchainDir, state) {
     return state;
   }
 
+  // Use loadProjectState to get reconciled state (approval-pause repair,
+  // budget reconciliation, recovery-action reconciliation applied and
+  // persisted to disk).  Then apply stale-turn reconciliation so recovery
+  // and next-action surfaces reflect the post-watchdog truth — matching
+  // the same ordering used by the CLI `status` command.
+  let reconciledState = loadProjectState(workspacePath, context.config) || state;
+  const staleResult = reconcileStaleTurns(workspacePath, reconciledState, context.config);
+  if (staleResult.changed) {
+    reconciledState = staleResult.state;
+  }
+
   return {
-    ...state,
-    runtime_guidance: deriveRuntimeBlockedGuidance(state, context.config),
-    next_actions: deriveGovernedRunNextActions(state, context.config),
+    ...reconciledState,
+    runtime_guidance: deriveRuntimeBlockedGuidance(reconciledState, context.config),
+    next_actions: deriveGovernedRunNextActions(reconciledState, context.config),
     dispatch_progress: readAllDispatchProgress(workspacePath),
   };
 }

package/src/lib/governed-state.js

@@ -1894,6 +1894,137 @@ export function reconcileRecoveryActionsWithConfig(state, config) {
   return { state: nextState, changed };
 }
 
+function inferApprovalPauseFromState(state, config) {
+  if (!state || typeof state !== 'object' || !config) {
+    return null;
+  }
+
+  if (state.pending_run_completion?.gate) {
+    return {
+      gateType: 'run_completion',
+      gateId: state.pending_run_completion.gate,
+      pendingField: 'pending_run_completion',
+      pendingValue: state.pending_run_completion,
+      typedReason: 'pending_run_completion',
+      recoveryAction: 'agentxchain approve-completion',
+    };
+  }
+
+  if (state.pending_phase_transition?.gate) {
+    return {
+      gateType: 'phase_transition',
+      gateId: state.pending_phase_transition.gate,
+      pendingField: 'pending_phase_transition',
+      pendingValue: state.pending_phase_transition,
+      typedReason: 'pending_phase_transition',
+      recoveryAction: 'agentxchain approve-transition',
+    };
+  }
+
+  // Approval waits are post-turn pause states. If a turn is still retained,
+  // recover the turn first instead of synthesizing a gate wait from stale
+  // blocked_on metadata.
+  if (getActiveTurnCount(state) > 0) {
+    return null;
+  }
+
+  if (typeof state.blocked_on !== 'string' || !state.blocked_on.startsWith('human_approval:')) {
+    return null;
+  }
+
+  const gateId = state.blocked_on.slice('human_approval:'.length) || null;
+  const currentRouting = config.routing?.[state.phase];
+  if (!gateId || !currentRouting?.exit_gate || currentRouting.exit_gate !== gateId) {
+    return null;
+  }
+
+  const requestedByTurn = state.blocked_reason?.turn_id ?? state.last_completed_turn_id ?? null;
+  const nextPhase = getNextPhase(state.phase, config.routing || {});
+
+  if (nextPhase) {
+    return {
+      gateType: 'phase_transition',
+      gateId,
+      pendingField: 'pending_phase_transition',
+      pendingValue: {
+        from: state.phase,
+        to: nextPhase,
+        gate: gateId,
+        requested_by_turn: requestedByTurn,
+      },
+      typedReason: 'pending_phase_transition',
+      recoveryAction: 'agentxchain approve-transition',
+    };
+  }
+
+  return {
+    gateType: 'run_completion',
+    gateId,
+    pendingField: 'pending_run_completion',
+    pendingValue: {
+      gate: gateId,
+      requested_by_turn: requestedByTurn,
+    },
+    typedReason: 'pending_run_completion',
+    recoveryAction: 'agentxchain approve-completion',
+  };
+}
+
+export function reconcileApprovalPausesWithConfig(state, config) {
+  if (!state || typeof state !== 'object' || !config) {
+    return { state, changed: false };
+  }
+
+  const inferred = inferApprovalPauseFromState(state, config);
+  if (!inferred) {
+    return { state, changed: false };
+  }
+
+  let nextState = state;
+  let changed = false;
+
+  if (!state[inferred.pendingField]) {
+    nextState = {
+      ...nextState,
+      [inferred.pendingField]: inferred.pendingValue,
+    };
+    changed = true;
+  }
+
+  if (nextState.status === 'blocked' || nextState.blocked_reason != null) {
+    nextState = {
+      ...nextState,
+      status: 'paused',
+      blocked_reason: null,
+    };
+    changed = true;
+  }
+
+  const recovery = nextState.blocked_reason?.recovery;
+  if (recovery && (
+    recovery.typed_reason !== inferred.typedReason
+    || recovery.recovery_action !== inferred.recoveryAction
+    || recovery.detail !== inferred.gateId
+  )) {
+    nextState = {
+      ...nextState,
+      blocked_reason: {
+        ...nextState.blocked_reason,
+        recovery: {
+          ...recovery,
+          typed_reason: inferred.typedReason,
+          recovery_action: inferred.recoveryAction,
+          turn_retained: false,
+          detail: inferred.gateId,
+        },
+      },
+    };
+    changed = true;
+  }
+
+  return { state: nextState, changed };
+}
+
 function inferBlockedReasonFromState(state) {
   if (!state || typeof state !== 'object') {
     return null;

package/src/lib/recent-event-summary.js

@@ -54,6 +54,7 @@ function describeEvent(eventType, entry) {
     }
     case 'turn_checkpointed':
     case 'turn_stalled':
+    case 'turn_start_failed':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;
     case 'dispatch_progress':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;

package/src/lib/stale-turn-watchdog.js

@@ -1,16 +1,32 @@
 /**
- * Stale Turn Watchdog — BUG-47
+ * Stale Turn Watchdog — BUG-47 + BUG-51
  *
- * Lazy idle-threshold detection: if an active turn has status "running"
- * for >N seconds with no event log activity AND no staged result file,
- * report it as stalled.
+ * Two-tier lazy idle-threshold detection:
+ *
+ * 1. **Fast startup watchdog (BUG-51):** if an active turn has been dispatched
+ *    for >30 seconds with NO dispatch-progress file, NO staged result, and NO
+ *    recent events, it is a "ghost turn" — the subprocess never attached.
+ *    Transitions to `failed_start` immediately.
+ *
+ *    Design note: the watchdog intentionally keys on turn-scoped
+ *    dispatch-progress rather than `stdout.log` existence. Dispatch-progress is
+ *    a framework-authored signal with a stable per-turn contract across runtime
+ *    wiring; `stdout.log` is adapter-authored visibility output and is allowed
+ *    to be best-effort. Using dispatch-progress therefore gives us the same
+ *    operator-facing "no first byte / no worker heartbeat" detection without
+ *    coupling the watchdog to adapter-specific log-attachment details.
+ *
+ * 2. **Stale turn watchdog (BUG-47):** if an active turn has status "running"
+ *    for >N minutes with no event log activity AND no staged result file,
+ *    report it as stalled.
  *
  * Fires on CLI invocations (status, resume, step --resume) rather than
  * requiring a background daemon.
  *
  * Default thresholds:
- *   - local_cli turns: 10 minutes
- *   - api_proxy turns: 5 minutes
+ *   - Startup watchdog: 30 seconds (configurable via run_loop.startup_watchdog_ms)
+ *   - local_cli stale turns: 10 minutes
+ *   - api_proxy stale turns: 5 minutes
  *   - Configurable via run_loop.stale_turn_threshold_ms in agentxchain.json
  */
 
@@ -23,6 +39,7 @@ import { getDispatchProgressRelativePath } from './dispatch-progress.js';
 
 const DEFAULT_LOCAL_CLI_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes
 const DEFAULT_API_PROXY_THRESHOLD_MS = 5 * 60 * 1000;  // 5 minutes
+const DEFAULT_STARTUP_WATCHDOG_MS = 30 * 1000;          // 30 seconds (BUG-51)
 const LEGACY_STAGING_PATH = '.agentxchain/staging/turn-result.json';
 
 /**
@@ -83,6 +100,72 @@ export function detectStaleTurns(root, state, config) {
   return stale;
 }
 
+/**
+ * BUG-51: Detect ghost-dispatched turns — subprocess never started.
+ *
+ * A ghost turn is one that has been in "running" or "retrying" status for
+ * longer than the startup watchdog threshold (default 30s) AND has:
+ *   - no dispatch-progress file (framework-observed proof that no subprocess
+ *     output or heartbeat was attached)
+ *   - no staged result file
+ *   - no recent turn-scoped events (beyond the initial turn_dispatched)
+ *
+ * This is a stricter, faster check than detectStaleTurns (BUG-47).
+ * Ghost turns transition to "failed_start" rather than "stalled".
+ *
+ * @param {string} root - project root directory
+ * @param {object} state - current governed state
+ * @param {object} config - normalized config
+ * @returns {Array<{ turn_id: string, role: string, runtime_id: string, running_ms: number, threshold_ms: number, recommendation: string, failure_type: string }>}
+ */
+export function detectGhostTurns(root, state, config) {
+  const activeTurns = state?.active_turns || {};
+  const ghosts = [];
+  const now = Date.now();
+  const startupThreshold = resolveStartupThreshold(config);
+
+  for (const [turnId, turn] of Object.entries(activeTurns)) {
+    if (turn.status !== 'running' && turn.status !== 'retrying') continue;
+    if (!turn.started_at) continue;
+
+    const startedAt = new Date(turn.started_at).getTime();
+    if (isNaN(startedAt)) continue;
+
+    const runningMs = now - startedAt;
+    if (runningMs < startupThreshold) continue;
+
+    // Ghost detection: NO dispatch-progress file means subprocess never attached
+    const progressPath = join(root, getDispatchProgressRelativePath(turnId));
+    const hasProgress = existsSync(progressPath);
+
+    // If dispatch-progress exists, subprocess started — this is NOT a ghost turn.
+    // The regular stale-turn watchdog (BUG-47) will handle it if it goes silent.
+    if (hasProgress) continue;
+
+    // Also check for staged result (unlikely without progress, but be safe)
+    if (hasTurnScopedStagedResult(root, turnId)) continue;
+
+    // Check for any turn-scoped events beyond the initial dispatch event
+    if (hasRecentTurnEventActivity(root, turnId, startedAt, startupThreshold, now)) continue;
+
+    const runningSeconds = Math.floor(runningMs / 1000);
+    const failureType = 'no_subprocess_output';
+    ghosts.push({
+      turn_id: turnId,
+      role: turn.assigned_role || 'unknown',
+      runtime_id: turn.runtime_id || 'unknown',
+      running_ms: runningMs,
+      threshold_ms: startupThreshold,
+      failure_type: failureType,
+      recommendation: `Turn ${turnId} has been dispatched for ${runningSeconds}s with no subprocess output. `
+        + `The subprocess likely never started. `
+        + `Run \`agentxchain reissue-turn --turn ${turnId} --reason ghost\` to recover.`,
+    });
+  }
+
+  return ghosts;
+}
+
 /**
  * Detect stale turns and emit turn_stalled events for each.
  * Returns the stale turn list for caller display.
@@ -95,18 +178,62 @@ export function detectAndEmitStaleTurns(root, state, config) {
 
 export function reconcileStaleTurns(root, state, config) {
   if (!state || typeof state !== 'object') {
-    return { stale_turns: [], state, changed: false };
+    return { stale_turns: [], ghost_turns: [], state, changed: false };
   }
 
-  const stale = detectStaleTurns(root, state, config);
-  if (stale.length === 0) {
-    return { stale_turns: [], state, changed: false };
+  // BUG-51: Fast startup watchdog — detect ghost turns first (30s threshold)
+  const ghosts = detectGhostTurns(root, state, config);
+
+  // BUG-47: Stale turn watchdog — detect turns that started but went silent (10m threshold)
+  // Exclude turns already caught by ghost detection to avoid double-counting
+  const ghostIds = new Set(ghosts.map(g => g.turn_id));
+  const stale = detectStaleTurns(root, state, config).filter(s => !ghostIds.has(s.turn_id));
+
+  if (ghosts.length === 0 && stale.length === 0) {
+    return { stale_turns: [], ghost_turns: [], state, changed: false };
   }
 
   const nowIso = new Date().toISOString();
   const activeTurns = { ...(state.active_turns || {}) };
+  const budgetReservations = { ...(state.budget_reservations || {}) };
   let changed = false;
 
+  // Process ghost turns (BUG-51) — transition to failed_start
+  for (const entry of ghosts) {
+    const turn = activeTurns[entry.turn_id];
+    if (!turn || (turn.status !== 'running' && turn.status !== 'retrying')) continue;
+
+    activeTurns[entry.turn_id] = {
+      ...turn,
+      status: 'failed_start',
+      failed_start_at: nowIso,
+      failed_start_reason: entry.failure_type,
+      failed_start_previous_status: turn.status,
+      failed_start_threshold_ms: entry.threshold_ms,
+      failed_start_running_ms: entry.running_ms,
+      recovery_command: `agentxchain reissue-turn --turn ${entry.turn_id} --reason ghost`,
+    };
+    changed = true;
+
+    // BUG-51 fix #6: Release budget reservation for ghost turns
+    delete budgetReservations[entry.turn_id];
+
+    emitRunEvent(root, 'turn_start_failed', {
+      run_id: state?.run_id || null,
+      phase: state?.phase || null,
+      status: 'blocked',
+      turn: { turn_id: entry.turn_id, role_id: entry.role },
+      payload: {
+        running_ms: entry.running_ms,
+        threshold_ms: entry.threshold_ms,
+        runtime_id: entry.runtime_id,
+        failure_type: entry.failure_type,
+        recommendation: entry.recommendation,
+      },
+    });
+  }
+
+  // Process stale turns (BUG-47) — transition to stalled
   for (const entry of stale) {
     const turn = activeTurns[entry.turn_id];
     if (!turn || (turn.status !== 'running' && turn.status !== 'retrying')) continue;
@@ -123,6 +250,9 @@ export function reconcileStaleTurns(root, state, config) {
     };
     changed = true;
 
+    // BUG-51 fix #6: Release budget reservation for stale turns too
+    delete budgetReservations[entry.turn_id];
+
     emitRunEvent(root, 'turn_stalled', {
       run_id: state?.run_id || null,
       phase: state?.phase || null,
@@ -138,21 +268,28 @@ export function reconcileStaleTurns(root, state, config) {
   }
 
   if (!changed) {
-    return { stale_turns: stale, state, changed: false };
+    return { stale_turns: stale, ghost_turns: ghosts, state, changed: false };
   }
 
-  const primary = stale[0];
+  const allDetected = [...ghosts, ...stale];
+  const primary = allDetected[0];
+  const category = ghosts.length > 0 ? 'ghost_turn' : 'stale_turn';
+  const blockedOn = allDetected.length === 1
+    ? `turn:${primary.failure_type ? 'failed_start' : 'stalled'}:${primary.turn_id}`
+    : ghosts.length > 0 ? 'turns:failed_start' : 'turns:stalled';
+
   const nextState = {
     ...state,
     status: 'blocked',
     active_turns: activeTurns,
-    blocked_on: stale.length === 1 ? `turn:stalled:${primary.turn_id}` : 'turns:stalled',
+    budget_reservations: budgetReservations,
+    blocked_on: blockedOn,
     blocked_reason: {
-      category: 'stale_turn',
+      category,
       blocked_at: nowIso,
       turn_id: primary.turn_id,
       recovery: {
-        typed_reason: 'stale_turn',
+        typed_reason: category,
         owner: 'human',
         recovery_action: primary.recommendation,
         turn_retained: true,
@@ -168,11 +305,12 @@ export function reconcileStaleTurns(root, state, config) {
     status: 'blocked',
     turn: { turn_id: primary.turn_id, role_id: primary.role },
     payload: {
-      category: 'stale_turn',
+      category,
+      ghost_turn_ids: ghosts.map((entry) => entry.turn_id),
       stalled_turn_ids: stale.map((entry) => entry.turn_id),
     },
   });
-  return { stale_turns: stale, state: nextState, changed: true };
+  return { stale_turns: stale, ghost_turns: ghosts, state: nextState, changed: true };
 }
 
 function resolveThreshold(turn, config) {
@@ -194,13 +332,21 @@ function resolveThreshold(turn, config) {
   return DEFAULT_LOCAL_CLI_THRESHOLD_MS;
 }
 
+function resolveStartupThreshold(config) {
+  const configThreshold = config?.run_loop?.startup_watchdog_ms;
+  if (typeof configThreshold === 'number' && configThreshold > 0) {
+    return configThreshold;
+  }
+  return DEFAULT_STARTUP_WATCHDOG_MS;
+}
+
 function hasRecentTurnEventActivity(root, turnId, startedAt, threshold, now) {
   try {
     const events = readRunEvents(root, { limit: 200 });
     for (let i = events.length - 1; i >= 0; i--) {
       const event = events[i];
       if (event?.turn?.turn_id !== turnId) continue;
-      if (event.event_type === 'turn_stalled') continue;
+      if (event.event_type === 'turn_stalled' || event.event_type === 'turn_start_failed') continue;
       const timestamp = Date.parse(event.timestamp || '');
       if (!Number.isFinite(timestamp)) continue;
       if (timestamp < startedAt) continue;