agentxchain 2.155.72 → 2.155.73

package/src/lib/continuous-run.js

@@ -47,6 +47,7 @@ import { getDispatchLogPath, getTurnStagingResultPath } from './turn-paths.js';
 import { reconcileOperatorHead } from './operator-commit-reconcile.js';
 import { getContinuityStatus } from './continuity-status.js';
 import { resolveGovernedRole } from './role-resolution.js';
+import { writeSessionCheckpoint } from './session-checkpoint.js';
 import {
   archiveStaleIntentsForRun,
   formatLegacyIntentMigrationNotice,
@@ -63,7 +64,7 @@ import {
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 const PRODUCTIVE_TIMEOUT_RETRY_MAX_PER_RUN = 1;
-const PRODUCTIVE_TIMEOUT_RETRY_DEADLINE_MINUTES = 60;
+const PRODUCTIVE_TIMEOUT_RETRY_DEADLINE_MINUTES = 120;
 const PROVIDER_REQUEST_TIMEOUT_RE = /request timed out|timed out waiting for (?:provider|api)|provider request timed out/i;
 
 function getRoadmapReplenishmentTriageHints(root) {
@@ -636,9 +637,21 @@ function clearGhostBlockerAfterReissue(root, state) {
     escalation: null,
   };
   writeGovernedState(root, nextState);
+  writeSessionCheckpoint(root, nextState, 'blocker_cleared');
   return nextState;
 }
 
+function isGovernedRunStillActiveForSession(root, config, session) {
+  try {
+    const state = loadProjectState(root, config);
+    if (!state || state.status !== 'active') return false;
+    if (session.current_run_id && state.run_id && session.current_run_id !== state.run_id) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Slice 2d (Turn 201): read the per-turn adapter dispatch log and return the
  * most recent stderr excerpt + exit code + signal from `process_exit` or
@@ -1253,7 +1266,7 @@ function reconcileContinuousStartupState(context, session, contOpts, log) {
  * @param {string} root
  * @param {string} visionPath - Absolute path to VISION.md
  * @param {{ triageApproval?: string }} options
- * @returns {{ ok: boolean, intentId?: string, section?: string, goal?: string, error?: string, idle?: boolean }}
+ * @returns {{ ok: boolean, intentId?: string, section?: string, goal?: string, source?: string, error?: string, idle?: boolean }}
  */
 export function seedFromVision(root, visionPath, options = {}) {
   const roadmapResult = deriveRoadmapCandidates(root);
@@ -1402,6 +1415,15 @@ export function seedFromVision(root, visionPath, options = {}) {
     };
   }
 
+  if (exhaustion.reason === 'vision_fully_mapped' || exhaustion.reason === 'vision_no_actionable_scope') {
+    return {
+      ok: true,
+      idle: true,
+      source: 'vision_exhausted',
+      reason: exhaustion.reason,
+    };
+  }
+
   const result = deriveVisionCandidates(root, visionPath);
   if (!result.ok) {
     return { ok: false, error: result.error };
@@ -2289,7 +2311,7 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     if (seeded.source === 'roadmap_open_work') {
       log(`Roadmap-derived: ${visionObjective}`);
     } else if (seeded.source === 'roadmap_replenishment') {
-      log(`Roadmap-replenishment (roadmap exhausted, vision open): ${visionObjective}`);
+      log(`Roadmap exhausted, vision still open, deriving next increment: ${visionObjective}`);
     } else {
       log(`Vision-derived: ${visionObjective}`);
     }
@@ -2551,6 +2573,23 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
     while (!stopping) {
       const step = await advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log);
 
+      if (step.status === 'failed' && isGovernedRunStillActiveForSession(root, context.config, session)) {
+        session.status = 'running';
+        writeContinuousSession(root, session);
+        emitRunEvent(root, 'session_failed_recovered_active_run', {
+          run_id: session.current_run_id || null,
+          phase: null,
+          status: 'active',
+          payload: {
+            session_id: session.session_id,
+            failed_action: step.action || null,
+            failed_reason: step.stop_reason || null,
+          },
+        });
+        log('Session failure recovered - governed run still active, continuing.');
+        continue;
+      }
+
       // Terminal states
       if (step.status === 'completed' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked' || step.status === 'stopped' || step.status === 'vision_exhausted' || step.status === 'vision_expansion_exhausted' || step.status === 'session_budget') {
         const terminalMessage = describeContinuousTerminalStep(step, contOpts);

package/src/lib/dispatch-bundle.js

@@ -797,6 +797,9 @@ function renderContext(state, config, root, turn, role) {
       lines.push('');
       lines.push(`- **Turn:** ${lastTurn.turn_id}`);
       lines.push(`- **Role:** ${lastTurn.role}`);
+      if (lastTurn.runtime_id) {
+        lines.push(`- **Runtime:** ${lastTurn.runtime_id}`);
+      }
       lines.push(`- **Summary:** ${lastTurn.summary}`);
       if (lastTurn.decisions?.length) {
         lines.push('- **Decisions:**');
@@ -1412,12 +1415,13 @@ function renderDecisionHistory(root, warnings = []) {
   const lines = [];
   lines.push('## Decision History');
   lines.push('');
-  lines.push('| ID | Phase | Role | Statement |');
-  lines.push('|----|-------|------|-----------|');
+  lines.push('| ID | Phase | Role | Runtime | Statement |');
+  lines.push('|----|-------|------|---------|-----------|');
   for (const d of displayed) {
     // Escape pipes in statement to avoid breaking the table
     const stmt = (d.statement || '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
-    lines.push(`| ${d.id} | ${d.phase || ''} | ${d.role || ''} | ${stmt} |`);
+    const runtimeId = (d.runtime_id || '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+    lines.push(`| ${d.id} | ${d.phase || ''} | ${d.role || ''} | ${runtimeId} | ${stmt} |`);
   }
   if (totalCount > DECISION_HISTORY_MAX_ENTRIES) {
     lines.push('');

package/src/lib/dispatch-progress.js

@@ -199,6 +199,15 @@ export function createDispatchProgressTracker(root, turn, options = {}) {
       writeProgress();
     },
 
+    /** Record adapter keepalive without treating it as governed startup proof. */
+    heartbeat(summary = 'Adapter keepalive') {
+      state.activity_type = 'heartbeat';
+      state.activity_summary = summary;
+      state.last_activity_at = new Date().toISOString();
+      dirty = true;
+      maybeWrite();
+    },
+
     /** Update PID after spawn (local_cli). */
     setPid(newPid) {
       state.pid = newPid;

package/src/lib/governed-state.js

@@ -3672,7 +3672,7 @@ export function assignGovernedTurn(root, config, roleId, options = {}) {
   const baseline = captureBaseline(root);
 
   const now = new Date().toISOString();
-  const timeoutMinutes = 20;
+  const timeoutMinutes = config?.timeouts?.per_turn_minutes || 120;
   const nextSequence = (state.turn_sequence || 0) + 1;
 
   // Record which turns are concurrent siblings (for conflict detection context)
@@ -3954,7 +3954,7 @@ export function reissueTurn(root, config, opts = {}) {
 
   // Create the new turn
   const newTurnId = `turn_${randomBytes(8).toString('hex')}`;
-  const timeoutMinutes = 20;
+  const timeoutMinutes = config?.timeouts?.per_turn_minutes || 120;
   const nextSequence = (state.turn_sequence || 0) + 1;
 
   const newTurn = {
@@ -5238,6 +5238,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
         turn_id: turnResult.turn_id,
         role: turnResult.role,
         phase: state.phase,
+        runtime_id: turnResult.runtime_id,
         category: decision.category,
         statement: decision.statement,
         rationale: decision.rationale,
@@ -6488,7 +6489,7 @@ export function rejectGovernedTurn(root, config, validationResult, reasonOrOptio
     const retryStartedAt = new Date().toISOString();
     retryTurn.baseline = captureBaseline(root);
     retryTurn.started_at = retryStartedAt;
-    retryTurn.deadline_at = new Date(Date.now() + 20 * 60 * 1000).toISOString();
+    retryTurn.deadline_at = new Date(Date.now() + (config?.timeouts?.per_turn_minutes || 120) * 60 * 1000).toISOString();
 
     if (isConflictReject) {
       retryTurn.assigned_sequence = Math.max(

package/src/lib/normalized-config.js

@@ -444,6 +444,7 @@ export function validateV4Config(data, projectRoot) {
       }
       if (rt.type === 'local_cli') {
         validateRuntimePositiveInteger(`Runtime "${id}": startup_watchdog_ms`, rt.startup_watchdog_ms, errors);
+        validateRuntimePositiveInteger(`Runtime "${id}": startup_heartbeat_ms`, rt.startup_heartbeat_ms, errors);
       }
       // Validate prompt_transport for local_cli runtimes
       if (rt.type === 'local_cli' && rt.prompt_transport) {
@@ -639,6 +640,7 @@ export function validateRunLoopConfig(runLoop) {
     return errors;
   }
   validateRunLoopPositiveInteger('run_loop.startup_watchdog_ms', runLoop.startup_watchdog_ms, errors);
+  validateRunLoopPositiveInteger('run_loop.startup_heartbeat_ms', runLoop.startup_heartbeat_ms, errors);
   validateRunLoopPositiveInteger('run_loop.stale_turn_threshold_ms', runLoop.stale_turn_threshold_ms, errors);
   if (runLoop.continuous !== undefined && runLoop.continuous !== null) {
     validateRunLoopContinuousConfig('run_loop.continuous', runLoop.continuous, errors);

package/src/lib/recovery-classification.js

@@ -0,0 +1,158 @@
+const DOMAINS = ['ghost', 'budget', 'credential', 'crash'];
+const OUTCOMES = ['recovered', 'exhausted', 'manual', 'pending'];
+
+const EVENT_CLASSIFICATIONS = {
+  auto_retried_ghost: {
+    domain: 'ghost',
+    severity: 'medium',
+    outcome: 'recovered',
+    mechanism: 'auto_retry',
+    summary: 'Ghost turn reissued automatically',
+  },
+  ghost_retry_exhausted: {
+    domain: 'ghost',
+    severity: 'high',
+    outcome: 'exhausted',
+    mechanism: 'auto_retry',
+    summary: 'Ghost retry budget exhausted',
+  },
+  auto_retried_productive_timeout: {
+    domain: 'ghost',
+    severity: 'medium',
+    outcome: 'recovered',
+    mechanism: 'auto_retry',
+    summary: 'Productive timeout reissued automatically',
+  },
+  productive_timeout_retry_exhausted: {
+    domain: 'ghost',
+    severity: 'high',
+    outcome: 'exhausted',
+    mechanism: 'auto_retry',
+    summary: 'Productive timeout retry budget exhausted',
+  },
+  budget_exceeded_warn: {
+    domain: 'budget',
+    severity: 'medium',
+    outcome: 'pending',
+    mechanism: 'config_change',
+    summary: 'Budget warning threshold exceeded',
+  },
+  retained_claude_auth_escalation_reclassified: {
+    domain: 'credential',
+    severity: 'medium',
+    outcome: 'pending',
+    mechanism: 'env_refresh',
+    summary: 'Claude credential escalation reclassified',
+  },
+  continuous_paused_active_run_recovered: {
+    domain: 'crash',
+    severity: 'medium',
+    outcome: 'recovered',
+    mechanism: 'loop_guard',
+    summary: 'Paused continuous session recovered active run',
+  },
+  session_failed_recovered_active_run: {
+    domain: 'crash',
+    severity: 'medium',
+    outcome: 'recovered',
+    mechanism: 'loop_guard',
+    summary: 'Failed continuous step recovered active run',
+  },
+};
+
+function getEventPayload(event) {
+  return event && typeof event.payload === 'object' && !Array.isArray(event.payload)
+    ? event.payload
+    : {};
+}
+
+function escalateSeverity(eventType, payload, severity) {
+  if (eventType === 'ghost_retry_exhausted' && payload.exhaustion_reason === 'same_signature_repeat') {
+    return 'critical';
+  }
+  if (eventType === 'budget_exceeded_warn' && typeof payload.remaining_usd === 'number' && payload.remaining_usd <= 0) {
+    return 'high';
+  }
+  return severity;
+}
+
+function emptyOutcomeCounts() {
+  return Object.fromEntries(OUTCOMES.map((outcome) => [outcome, 0]));
+}
+
+function emptyDomainCounts() {
+  return Object.fromEntries(DOMAINS.map((domain) => [domain, { total: 0, ...emptyOutcomeCounts() }]));
+}
+
+function formatSummary(eventType, payload, fallback) {
+  if (payload.recovery_class && typeof payload.recovery_class === 'string') return payload.recovery_class;
+  if (payload.warning && typeof payload.warning === 'string') return payload.warning;
+  if (payload.recovery_action && typeof payload.recovery_action === 'string') return payload.recovery_action;
+  return fallback || eventType;
+}
+
+export function classifyRecoveryEvent(event) {
+  if (!event || typeof event !== 'object' || Array.isArray(event)) return null;
+  const eventType = event.event_type || event.type;
+  const base = EVENT_CLASSIFICATIONS[eventType];
+  if (!base) return null;
+
+  const payload = getEventPayload(event);
+  return {
+    domain: base.domain,
+    severity: escalateSeverity(eventType, payload, base.severity),
+    outcome: base.outcome,
+    mechanism: base.mechanism,
+  };
+}
+
+export function buildRecoveryClassificationReport(events) {
+  const byDomain = emptyDomainCounts();
+  const byOutcome = emptyOutcomeCounts();
+  const timeline = [];
+
+  for (const event of Array.isArray(events) ? events : []) {
+    const classification = classifyRecoveryEvent(event);
+    if (!classification) continue;
+
+    byDomain[classification.domain].total += 1;
+    byDomain[classification.domain][classification.outcome] += 1;
+    byOutcome[classification.outcome] += 1;
+
+    const eventType = event.event_type || event.type;
+    const payload = getEventPayload(event);
+    timeline.push({
+      event_id: event.event_id || null,
+      timestamp: event.timestamp || null,
+      event_type: eventType,
+      domain: classification.domain,
+      severity: classification.severity,
+      outcome: classification.outcome,
+      mechanism: classification.mechanism,
+      summary: formatSummary(eventType, payload, EVENT_CLASSIFICATIONS[eventType]?.summary),
+    });
+  }
+
+  timeline.sort((left, right) => {
+    const leftTime = Date.parse(left.timestamp || '');
+    const rightTime = Date.parse(right.timestamp || '');
+    const normalizedLeft = Number.isNaN(leftTime) ? Number.POSITIVE_INFINITY : leftTime;
+    const normalizedRight = Number.isNaN(rightTime) ? Number.POSITIVE_INFINITY : rightTime;
+    if (normalizedLeft !== normalizedRight) return normalizedLeft - normalizedRight;
+    return String(left.event_id || '').localeCompare(String(right.event_id || ''), 'en');
+  });
+
+  const totalRecoveryEvents = timeline.length;
+  const hasCritical = timeline.some((entry) => entry.severity === 'critical');
+  const healthScore = hasCritical || byOutcome.exhausted > byOutcome.recovered
+    ? 'critical'
+    : (byOutcome.exhausted > 0 || byOutcome.manual > 0 ? 'degraded' : 'healthy');
+
+  return {
+    total_recovery_events: totalRecoveryEvents,
+    by_domain: byDomain,
+    by_outcome: byOutcome,
+    timeline,
+    health_score: healthScore,
+  };
+}

package/src/lib/report.js

@@ -12,6 +12,7 @@ import {
 import { buildCoordinatorRepoStatusEntries } from './coordinator-repo-status-presentation.js';
 import { summarizeCoordinatorEvent } from './coordinator-event-narrative.js';
 import { extractGateActionDigest } from './gate-actions.js';
+import { buildRecoveryClassificationReport } from './recovery-classification.js';
 
 export const GOVERNANCE_REPORT_VERSION = '0.1';
 
@@ -703,6 +704,19 @@ function extractRecoverySummary(artifact) {
   };
 }
 
+function extractRecoveryClassification(artifact) {
+  const report = buildRecoveryClassificationReport(extractRunEventTimeline(artifact));
+  return report.total_recovery_events > 0 ? report : null;
+}
+
+function formatRecoveryOutcomeCounts(counts) {
+  return `${counts.recovered} recovered, ${counts.exhausted} exhausted, ${counts.manual} manual, ${counts.pending} pending`;
+}
+
+function formatRecoveryDomainLabel(domain) {
+  return domain.charAt(0).toUpperCase() + domain.slice(1);
+}
+
 function extractCoordinatorTimeline(artifact) {
   const data = extractFileData(artifact, '.agentxchain/multirepo/history.jsonl');
   if (!Array.isArray(data) || data.length === 0) return [];
@@ -1008,6 +1022,7 @@ function buildRunSubject(artifact) {
   const gateSummary = extractGateSummary(artifact);
   const intakeLinks = extractIntakeLinks(artifact);
   const recoverySummary = extractRecoverySummary(artifact);
+  const recoveryClassification = extractRecoveryClassification(artifact);
   const nextActions = deriveGovernedRunNextActions(artifact.state, artifact.config);
   const continuity = extractContinuityMetadata(artifact);
   const governanceEvents = extractGovernanceEventDigest(artifact);
@@ -1057,6 +1072,7 @@ function buildRunSubject(artifact) {
       gate_summary: gateSummary,
       intake_links: intakeLinks,
       recovery_summary: recoverySummary,
+      recovery_classification: recoveryClassification,
       next_actions: nextActions,
       continuity,
       workflow_kit_artifacts: extractWorkflowKitArtifacts(artifact),
@@ -1539,6 +1555,26 @@ export function formatGovernanceReportText(report) {
       }
     }
 
+    if (run.recovery_classification) {
+      const rc = run.recovery_classification;
+      lines.push('', 'Recovery Classification:');
+      lines.push(`  Health: ${rc.health_score}`);
+      lines.push(`  Events: ${rc.total_recovery_events} total (${formatRecoveryOutcomeCounts(rc.by_outcome)})`);
+      lines.push('  By Domain:');
+      for (const [domain, counts] of Object.entries(rc.by_domain)) {
+        lines.push(`    ${formatRecoveryDomainLabel(domain)}: ${counts.total} (${formatRecoveryOutcomeCounts(counts)})`);
+      }
+      if (rc.timeline.length > 0) {
+        const { items: boundedRecoveryEvents, omitted: recoveryEventsOmitted } = boundedSlice(rc.timeline);
+        lines.push('  Timeline:');
+        for (let i = 0; i < boundedRecoveryEvents.length; i++) {
+          const evt = boundedRecoveryEvents[i];
+          lines.push(`    ${i + 1}. ${evt.timestamp || 'n/a'} | ${evt.domain} | ${evt.severity} | ${evt.outcome} | ${evt.mechanism} | ${evt.summary}`);
+        }
+        if (recoveryEventsOmitted > 0) lines.push(`    (${recoveryEventsOmitted} more recovery events omitted)`);
+      }
+    }
+
     if (run.next_actions && run.next_actions.length > 0) {
       lines.push('', 'Next Actions:');
       for (let i = 0; i < run.next_actions.length; i++) {
@@ -2137,6 +2173,27 @@ export function formatGovernanceReportMarkdown(report) {
       }
     }
 
+    if (run.recovery_classification) {
+      const rc = run.recovery_classification;
+      lines.push('', '## Recovery Classification', '');
+      lines.push(`- Health: \`${rc.health_score}\``);
+      lines.push(`- Events: ${rc.total_recovery_events} total (${formatRecoveryOutcomeCounts(rc.by_outcome)})`);
+      lines.push('', '| Domain | Total | Recovered | Exhausted | Manual | Pending |', '|--------|-------|-----------|-----------|--------|---------|');
+      for (const [domain, counts] of Object.entries(rc.by_domain)) {
+        lines.push(`| ${formatRecoveryDomainLabel(domain)} | ${counts.total} | ${counts.recovered} | ${counts.exhausted} | ${counts.manual} | ${counts.pending} |`);
+      }
+      if (rc.timeline.length > 0) {
+        const { items: boundedRecoveryEvents, omitted: recoveryEventsOmitted } = boundedSlice(rc.timeline);
+        lines.push('', '| # | Time | Domain | Severity | Outcome | Mechanism | Summary |', '|---|------|--------|----------|---------|-----------|---------|');
+        for (let i = 0; i < boundedRecoveryEvents.length; i++) {
+          const evt = boundedRecoveryEvents[i];
+          const summary = (evt.summary || '').replace(/\|/g, '\\|');
+          lines.push(`| ${i + 1} | \`${evt.timestamp || 'n/a'}\` | \`${evt.domain}\` | \`${evt.severity}\` | \`${evt.outcome}\` | \`${evt.mechanism}\` | ${summary} |`);
+        }
+        if (recoveryEventsOmitted > 0) lines.push('', `*(${recoveryEventsOmitted} more recovery events omitted)*`);
+      }
+    }
+
     if (run.next_actions && run.next_actions.length > 0) {
       lines.push('', '## Next Actions', '');
       for (let i = 0; i < run.next_actions.length; i++) {
@@ -2877,6 +2934,40 @@ function renderRunHtml(report) {
     sections.push(`<div class="section">${htmlSection('Recovery', recoveryHtml)}</div>`);
   }
 
+  if (run.recovery_classification) {
+    const rc = run.recovery_classification;
+    const domainRows = Object.entries(rc.by_domain).map(([domain, counts]) => [
+      esc(formatRecoveryDomainLabel(domain)),
+      String(counts.total),
+      String(counts.recovered),
+      String(counts.exhausted),
+      String(counts.manual),
+      String(counts.pending),
+    ]);
+    const { items: boundedRecoveryEvents, omitted: recoveryEventsOmitted } = boundedSlice(rc.timeline);
+    const timelineRows = boundedRecoveryEvents.map((evt, index) => [
+      String(index + 1),
+      `<code>${esc(evt.timestamp || 'n/a')}</code>`,
+      `<code>${esc(evt.domain)}</code>`,
+      `<code>${esc(evt.severity)}</code>`,
+      `<code>${esc(evt.outcome)}</code>`,
+      `<code>${esc(evt.mechanism)}</code>`,
+      esc(evt.summary || ''),
+    ]);
+    let classificationHtml = htmlDl([
+      ['Health', `<code>${esc(rc.health_score)}</code>`],
+      ['Events', `${rc.total_recovery_events} total (${esc(formatRecoveryOutcomeCounts(rc.by_outcome))})`],
+    ]);
+    classificationHtml += htmlSection('By Domain', htmlTable(['Domain', 'Total', 'Recovered', 'Exhausted', 'Manual', 'Pending'], domainRows), 3);
+    if (timelineRows.length > 0) {
+      classificationHtml += htmlSection('Timeline', htmlTable(['#', 'Time', 'Domain', 'Severity', 'Outcome', 'Mechanism', 'Summary'], timelineRows), 3);
+    }
+    if (recoveryEventsOmitted > 0) {
+      classificationHtml += `<p><em>(${recoveryEventsOmitted} more recovery events omitted)</em></p>`;
+    }
+    sections.push(`<div class="section">${htmlSection('Recovery Classification', classificationHtml)}</div>`);
+  }
+
   if (run.next_actions?.length > 0) {
     const nextHtml = '<ol>' + run.next_actions.map((action) =>
       `<li><code>${esc(action.command)}</code>: ${esc(action.reason)}</li>`

package/src/lib/run-events.js

@@ -8,6 +8,7 @@
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { classifyRecoveryEvent } from './recovery-classification.js';
 
 export const RUN_EVENTS_PATH = '.agentxchain/events.jsonl';
 
@@ -72,6 +73,11 @@ export const VALID_RUN_EVENTS = [
  */
 export function emitRunEvent(root, eventType, details = {}) {
   const event_id = `evt_${randomBytes(8).toString('hex')}`;
+  const payload = details.payload || {};
+  const recoveryClassification = classifyRecoveryEvent({ event_type: eventType, payload });
+  const classifiedPayload = recoveryClassification && !payload.recovery_classification
+    ? { ...payload, recovery_classification: recoveryClassification }
+    : payload;
   const entry = {
     event_id,
     event_type: eventType,
@@ -81,7 +87,7 @@ export function emitRunEvent(root, eventType, details = {}) {
     status: details.status || null,
     turn: details.turn || null,
     intent_id: details.intent_id || null,
-    payload: details.payload || {},
+    payload: classifiedPayload,
   };
 
   try {

package/src/lib/schemas/agentxchain-config.schema.json

@@ -100,6 +100,11 @@
           "minimum": 1,
           "description": "Milliseconds to wait after dispatch for worker attach/first-output proof before retaining the turn as failed_start. Default 180000."
         },
+        "startup_heartbeat_ms": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Milliseconds between local_cli adapter startup keepalive diagnostics while a spawned subprocess is silent before first-output proof. Default 30000."
+        },
         "stale_turn_threshold_ms": {
           "type": "integer",
           "minimum": 1,
@@ -409,6 +414,11 @@
           "minimum": 1,
           "description": "Optional local_cli-specific override for the startup watchdog. When set, this runtime uses the declared threshold before falling back to run_loop.startup_watchdog_ms."
         },
+        "startup_heartbeat_ms": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Optional local_cli-specific startup keepalive diagnostic interval. When set, this runtime uses the declared interval before falling back to run_loop.startup_heartbeat_ms."
+        },
         "prompt_transport": {
           "enum": ["argv", "stdin", "dispatch_bundle_only"]
         },

package/src/lib/turn-checkpoint.js

@@ -201,14 +201,21 @@ function extractGitError(err) {
   return stderr || stdout || err?.message || 'git command failed';
 }
 
+function normalizeRuntimeId(entry) {
+  return typeof entry?.runtime_id === 'string' && entry.runtime_id.trim()
+    ? entry.runtime_id.trim()
+    : null;
+}
+
 function buildCheckpointCommit(entry) {
-  const subject = `checkpoint: ${entry.turn_id} (role=${entry.role}, phase=${entry.phase})`;
+  const runtimeId = normalizeRuntimeId(entry) || '(unknown)';
+  const subject = `checkpoint: ${entry.turn_id} (role=${entry.role}, phase=${entry.phase}, runtime=${runtimeId})`;
   const bodyLines = [
     `Summary: ${entry.summary || '(none)'}`,
     `Turn-ID: ${entry.turn_id}`,
     `Role: ${entry.role || '(unknown)'}`,
     `Phase: ${entry.phase || '(unknown)'}`,
-    `Runtime: ${entry.runtime_id || '(unknown)'}`,
+    `Runtime: ${runtimeId}`,
   ];
   if (entry.intent_id) bodyLines.push(`Intent-ID: ${entry.intent_id}`);
   if (entry.accepted_at) bodyLines.push(`Accepted-At: ${entry.accepted_at}`);
@@ -450,6 +457,7 @@ export function checkpointAcceptedTurn(root, opts = {}) {
 
   const checkpointSha = git(root, ['rev-parse', 'HEAD']);
   const checkpointedAt = new Date().toISOString();
+  const runtimeId = normalizeRuntimeId(entry);
 
   const historyEntries = readHistoryEntries(root).map((historyEntry) => (
     historyEntry.turn_id === entry.turn_id
@@ -470,6 +478,7 @@ export function checkpointAcceptedTurn(root, opts = {}) {
         turn_id: entry.turn_id,
         role: entry.role || null,
         phase: entry.phase || null,
+        runtime_id: runtimeId,
         checkpoint_sha: checkpointSha,
         checkpointed_at: checkpointedAt,
         intent_id: entry.intent_id || null,
@@ -480,7 +489,7 @@ export function checkpointAcceptedTurn(root, opts = {}) {
       run_id: state.run_id || null,
       phase: state.phase || null,
       status: state.status || null,
-      turn: { turn_id: entry.turn_id, role_id: entry.role || null },
+      turn: { turn_id: entry.turn_id, role_id: entry.role || null, runtime_id: runtimeId },
       intent_id: entry.intent_id || null,
       payload: { checkpoint_sha: checkpointSha, checkpointed_at: checkpointedAt },
     });