agentxchain 2.144.0 → 2.146.0

package/src/commands/status.js

@@ -21,10 +21,11 @@ import { deriveConflictedTurnResolutionActions } from '../lib/conflict-actions.j
 import { summarizeLatestGateActionAttempt } from '../lib/gate-actions.js';
 import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
-import { readPreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
+import { readPreemptionMarker, validatePreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
 import { readCoordinatorWarnings } from '../lib/coordinator-warnings.js';
+import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -134,7 +135,11 @@ function loadStatusContext(dir = process.cwd()) {
 
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
-  const state = loadProjectState(root, config);
+  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);
@@ -146,7 +151,8 @@ function renderGovernedStatus(context, opts) {
 
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
   const humanEscalation = findCurrentHumanEscalation(root, state);
-  const preemptionMarker = readPreemptionMarker(root);
+  // BUG-48: validate the marker against live intent state; auto-clear stale markers
+  const preemptionMarker = validatePreemptionMarker(root);
   const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId || null });
   const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
@@ -201,6 +207,8 @@ function renderGovernedStatus(context, opts) {
       binding_drift: detectActiveTurnBindingDrift(state, config),
       bundle_integrity: detectStateBundleDesync(root, state),
       coordinator_warnings: coordinatorWarnings,
+      stale_turns: staleTurns,
+      ghost_turns: ghostTurns,
     }, null, 2));
     return;
   }
@@ -445,6 +453,32 @@ 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('');
+    for (const st of staleTurns) {
+      const mins = Math.floor(st.running_ms / 60000);
+      console.log(`  ${chalk.red.bold('⚠ Stale turn detected')}`);
+      console.log(`  ${chalk.dim('Turn:')}     ${st.turn_id} (${st.role})`);
+      console.log(`  ${chalk.dim('Runtime:')}  ${st.runtime_id}`);
+      console.log(`  ${chalk.dim('Running:')}  ${mins}m with no output`);
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(`agentxchain reissue-turn --turn ${st.turn_id} --reason stale`)}`);
+    }
+  }
+
   // Queued phase/completion requests
   if (state?.queued_phase_transition) {
     const qt = state.queued_phase_transition;

package/src/commands/step.js

@@ -70,6 +70,7 @@ import { resolveGovernedRole } from '../lib/role-resolution.js';
 import { shouldSuggestManualQaFallback } from '../lib/manual-qa-fallback.js';
 import { evaluateApprovalSlaReminders } from '../lib/notification-runner.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
+import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
 export async function stepCommand(opts) {
   const context = loadProjectContext();
@@ -94,6 +95,17 @@ export async function stepCommand(opts) {
     process.exit(1);
   }
 
+  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);
+  }
+
   // Completed runs cannot take more turns
   if (state.status === 'completed') {
     console.log(chalk.green.bold('This run is already completed.'));
@@ -901,6 +913,32 @@ 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('');
+  for (const stale of staleTurns) {
+    const mins = Math.floor(stale.running_ms / 60000);
+    console.log(`  Turn:    ${stale.turn_id} (${stale.role})`);
+    console.log(`  Runtime: ${stale.runtime_id}`);
+    console.log(`  Age:     ${mins}m with no output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${stale.turn_id} --reason stale`)}`);
+    console.log('');
+  }
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function loadHookStagedTurn(root, stagingRel) {

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

@@ -91,8 +91,28 @@ const INTAKE_INTENTS_DIR = '.agentxchain/intake/intents';
 const STALE_LOCK_TIMEOUT_MS = 30_000;
 const GOVERNED_SCHEMA_VERSION = '1.1';
 
+const PREEMPTION_MARKER_REL = '.agentxchain/intake/injected-priority.json';
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+/**
+ * BUG-48: clear the preemption marker if it references the given intent.
+ * Inlined here to avoid a circular dependency with intake.js.
+ */
+function clearPreemptionMarkerIfMatchesIntent(root, intentId) {
+  if (!intentId) return;
+  const p = join(root, PREEMPTION_MARKER_REL);
+  if (!existsSync(p)) return;
+  try {
+    const marker = JSON.parse(readFileSync(p, 'utf8'));
+    if (marker && marker.intent_id === intentId) {
+      unlinkSync(p);
+    }
+  } catch {
+    // best-effort
+  }
+}
+
 function generateId(prefix) {
   return `${prefix}_${randomBytes(8).toString('hex')}`;
 }
@@ -240,6 +260,8 @@ function retireApprovedPhaseScopedIntents(root, state, config, exitedPhase, now)
       entered_phase: state?.phase || null,
     });
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-satisfied intent
+    clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
     retired.push(intent.intent_id);
   }
 
@@ -1872,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;
@@ -2355,6 +2508,13 @@ export function initializeGovernedRun(root, config, options = {}) {
     repo_decisions: repoDecisions.length > 0 ? repoDecisions : null,
   };
 
+  if ((provenance?.trigger === 'continuation' || provenance?.trigger === 'recovery') && !updatedState.accepted_integration_ref) {
+    const baseline = captureBaseline(root);
+    if (baseline?.head_ref) {
+      updatedState.accepted_integration_ref = `git:${baseline.head_ref}`;
+    }
+  }
+
   writeState(root, updatedState);
 
   const startupIntents = archiveStaleIntentsForRun(root, runId, {

package/src/lib/intake.js

@@ -412,6 +412,7 @@ export function triageIntent(root, intentId, fields) {
     intent.updated_at = now;
     intent.history.push({ from: 'detected', to: 'suppressed', at: now, reason: fields.reason });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, exitCode: 0 };
   }
 
@@ -428,6 +429,7 @@ export function triageIntent(root, intentId, fields) {
     intent.updated_at = now;
     intent.history.push({ from: 'triaged', to: 'rejected', at: now, reason: fields.reason });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, exitCode: 0 };
   }
 
@@ -839,6 +841,8 @@ export function approveIntent(root, intentId, options = {}) {
     intent.archived_reason = phantomReason;
     intent.history.push({ from: previousStatus, to: 'superseded', at: now, reason: phantomReason, approver });
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-superseded intent
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, superseded: true, exitCode: 0 };
   }
 
@@ -1319,6 +1323,8 @@ export function resolveIntent(root, intentId, opts = {}) {
     mkdirSync(obsDir, { recursive: true });
 
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-completed intent
+    clearPreemptionMarkerForIntent(root, intentId);
     return {
       ok: true,
       intent,
@@ -1765,6 +1771,47 @@ export function clearPreemptionMarker(root) {
   }
 }
 
+/**
+ * BUG-48: Clear the preemption marker if it references a specific intent.
+ * Called when an intent transitions to a non-actionable terminal state so the
+ * marker cannot outlive the intent it points at.
+ */
+export function clearPreemptionMarkerForIntent(root, intentId) {
+  if (!intentId) return;
+  const marker = readPreemptionMarker(root);
+  if (marker && marker.intent_id === intentId) {
+    clearPreemptionMarker(root);
+  }
+}
+
+/**
+ * BUG-48: Validate the preemption marker against the live intent state.
+ * If the marker references an intent whose on-disk status is non-actionable
+ * (superseded, satisfied, completed, rejected, suppressed, failed,
+ * archived_migration), auto-clear the marker and return null.
+ * Otherwise return the marker as-is.
+ */
+const PREEMPTION_ACTIONABLE_STATUSES = new Set(['approved', 'planned']);
+
+export function validatePreemptionMarker(root) {
+  const marker = readPreemptionMarker(root);
+  if (!marker?.intent_id) return marker;
+
+  const loaded = readIntent(root, marker.intent_id);
+  if (!loaded.ok) {
+    // intent file missing — stale marker
+    clearPreemptionMarker(root);
+    return null;
+  }
+
+  if (!PREEMPTION_ACTIONABLE_STATUSES.has(loaded.intent?.status)) {
+    clearPreemptionMarker(root);
+    return null;
+  }
+
+  return marker;
+}
+
 export function consumePreemptionMarker(root, options = {}) {
   const marker = readPreemptionMarker(root);
   if (!marker?.intent_id) {

package/src/lib/intent-startup-migration.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { queryAcceptedTurnHistory } from './accepted-turn-history.js';
@@ -6,6 +6,25 @@ import { safeWriteJson } from './safe-write.js';
 import { VALID_GOVERNED_TEMPLATE_IDS, loadGovernedTemplate } from './governed-templates.js';
 
 const DISPATCHABLE_STATUSES = new Set(['planned', 'approved']);
+const PREEMPTION_MARKER_REL = '.agentxchain/intake/injected-priority.json';
+
+/**
+ * BUG-48: clear preemption marker if it references the given intent.
+ * Inlined to avoid circular dependency with intake.js.
+ */
+function clearPreemptionMarkerIfMatchesIntent(root, intentId) {
+  if (!intentId) return;
+  const p = join(root, PREEMPTION_MARKER_REL);
+  if (!existsSync(p)) return;
+  try {
+    const marker = JSON.parse(readFileSync(p, 'utf8'));
+    if (marker && marker.intent_id === intentId) {
+      unlinkSync(p);
+    }
+  } catch {
+    // best-effort
+  }
+}
 
 function nowISO() {
   return new Date().toISOString();
@@ -127,6 +146,7 @@ export function migratePreBug34Intents(root, runId, options = {}) {
       reason: intent.archived_reason,
     });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
     if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
   }
 
@@ -260,6 +280,8 @@ export function archiveStaleIntentsForRun(root, runId, options = {}) {
         reason: intent.archived_reason,
       });
       safeWriteJson(intentPath, intent);
+      // BUG-48: clear preemption marker if it references this now-superseded intent
+      clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
       phantomSuperseded += 1;
       if (intent.intent_id) phantomSupersededIntentIds.push(intent.intent_id);
       continue;

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

@@ -53,6 +53,8 @@ function describeEvent(eventType, entry) {
       return `${prefix}${eventType}${wsIdWarn ? ` ${wsIdWarn}` : ''}${warnRepo ? ` (${warnRepo})` : ''} — reconciliation required`;
     }
     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/run-events.js

@@ -24,6 +24,7 @@ export const VALID_RUN_EVENTS = [
   'conflict_resolved',
   'acceptance_failed',
   'turn_reissued',
+  'turn_stalled',
   'turn_checkpointed',
   'coordinator_retry',
   'coordinator_retry_projection_warning',