agentxchain 2.154.0 → 2.154.3

package/package.json

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

package/src/lib/continuous-run.js

@@ -32,7 +32,9 @@ import {
   buildGhostRetryDiagnosticBundle,
   buildGhostRetryExhaustionMirror,
   classifyGhostRetryDecision,
+  extractLatestStderrDiagnostic,
 } from './ghost-retry.js';
+import { getDispatchLogPath } from './turn-paths.js';
 import { reconcileOperatorHead } from './operator-commit-reconcile.js';
 import { getContinuityStatus } from './continuity-status.js';
 import {
@@ -153,6 +155,25 @@ function clearGhostBlockerAfterReissue(root, state) {
   return nextState;
 }
 
+/**
+ * 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
+ * `spawn_error` lines. Best-effort — when the log is missing, unreadable, or
+ * contains only spawn_prepare diagnostics, returns a null record so the caller
+ * can still record the attempt with the runtime/role/timing fields.
+ */
+function readLatestDispatchDiagnostic(root, turnId) {
+  if (!turnId) return { stderr_excerpt: null, exit_code: null, exit_signal: null };
+  try {
+    const p = join(root, getDispatchLogPath(turnId));
+    if (!existsSync(p)) return { stderr_excerpt: null, exit_code: null, exit_signal: null };
+    const content = readFileSync(p, 'utf8');
+    return extractLatestStderrDiagnostic(content);
+  } catch {
+    return { stderr_excerpt: null, exit_code: null, exit_signal: null };
+  }
+}
+
 async function maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log = console.log) {
   const { root, config } = context;
   const decision = classifyGhostRetryDecision({
@@ -184,6 +205,11 @@ async function maybeAutoRetryGhostBlocker(context, session, contOpts, blockedSta
     const oldRoleId = oldTurn.assigned_role || reissued.newTurn.assigned_role || null;
     const oldRunningMs = oldTurn.failed_start_running_ms ?? null;
     const oldThresholdMs = oldTurn.failed_start_threshold_ms ?? null;
+    // Slice 2d: pull the adapter's process_exit / spawn_error diagnostic for
+    // the ghost turn so the per-attempt log entry is self-contained. Reads
+    // the dispatch stdout.log for the OLD turn id; the NEW reissued turn
+    // hasn't run yet so has nothing to surface.
+    const oldDiag = readLatestDispatchDiagnostic(root, oldTurnId);
     const nextSession = applyGhostRetryAttempt(session, {
       runId,
       oldTurnId,
@@ -195,6 +221,9 @@ async function maybeAutoRetryGhostBlocker(context, session, contOpts, blockedSta
       roleId: oldRoleId,
       runningMs: oldRunningMs,
       thresholdMs: oldThresholdMs,
+      stderrExcerpt: oldDiag.stderr_excerpt,
+      exitCode: oldDiag.exit_code,
+      exitSignal: oldDiag.exit_signal,
     });
     Object.assign(session, nextSession, {
       status: 'running',
@@ -383,6 +412,7 @@ export function maybeAutoReconcileOperatorCommits(context, session, contOpts, lo
   const detail = detailLines.join(' ');
 
   if (state) {
+    const blockedAt = new Date().toISOString();
     const nextState = {
       ...state,
       status: 'blocked',
@@ -390,10 +420,15 @@ export function maybeAutoReconcileOperatorCommits(context, session, contOpts, lo
       blocked_reason: {
         ...(state.blocked_reason || {}),
         category: 'operator_commit_reconcile_refused',
+        blocked_at: blockedAt,
+        turn_id: null,
         error_class: errorClass,
         recovery: {
           ...((state.blocked_reason || {}).recovery || {}),
+          typed_reason: 'operator_commit_reconcile_refused',
+          owner: 'human',
           recovery_action: 'agentxchain reconcile-state --accept-operator-head',
+          turn_retained: false,
           detail,
         },
       },

package/src/lib/ghost-retry.js

@@ -42,6 +42,12 @@ export const GHOST_FAILURE_TYPES = Object.freeze([
  * through a new DEC rather than silently widening.
  */
 export const SIGNATURE_REPEAT_THRESHOLD = 2;
+export const ATTEMPT_STDERR_EXCERPT_LIMIT = 800;
+
+function normalizeAttemptStderrExcerpt(value) {
+  if (typeof value !== 'string' || value.length === 0) return null;
+  return value.slice(0, ATTEMPT_STDERR_EXCERPT_LIMIT);
+}
 
 /**
  * Read (or default) the ghost_retry state object from a continuous session.
@@ -328,6 +334,9 @@ export function applyGhostRetryAttempt(session, {
   roleId = null,
   runningMs = null,
   thresholdMs = null,
+  stderrExcerpt = null,
+  exitCode = null,
+  exitSignal = null,
 }) {
   const base = resetGhostRetryForRun(session, runId);
   const at = nowIso || new Date().toISOString();
@@ -336,6 +345,18 @@ export function applyGhostRetryAttempt(session, {
   // diagnostic bundle. We cap its size to 10 entries to prevent unbounded
   // growth on misbehaving projects — the tail is what matters for pattern
   // detection.
+  //
+  // Slice 2d (Turn 201): fold the per-attempt adapter `process_exit` /
+  // `spawn_error` diagnostic fields (stderr_excerpt, exit_code, exit_signal)
+  // into the log entry. This makes `ghost_retry_exhausted.diagnostic_bundle`
+  // self-contained — an operator reading `continuous-session.json` or the
+  // event payload no longer has to cross-reference
+  // `.agentxchain/dispatch/turns/<turnId>/stdout.log` to see WHY the last few
+  // spawns failed. Bounded by the adapter's own 800-byte stderr excerpt cap
+  // (DIAGNOSTIC_STDERR_EXCERPT_LIMIT at local-cli-adapter.js:43) so session
+  // state does not grow unbounded on a noisy-stderr runtime. The local cap
+  // mirrors that adapter cap so direct callers cannot accidentally persist
+  // larger excerpts.
   const nextEntry = {
     attempt: base.attempts + 1,
     old_turn_id: oldTurnId ?? null,
@@ -345,6 +366,9 @@ export function applyGhostRetryAttempt(session, {
     failure_type: failureType ?? null,
     running_ms: runningMs ?? null,
     threshold_ms: thresholdMs ?? null,
+    stderr_excerpt: normalizeAttemptStderrExcerpt(stderrExcerpt),
+    exit_code: Number.isInteger(exitCode) ? exitCode : null,
+    exit_signal: typeof exitSignal === 'string' && exitSignal.length > 0 ? exitSignal : null,
     retried_at: at,
   };
   const attemptsLog = [...base.attempts_log, nextEntry].slice(-10);
@@ -413,6 +437,58 @@ export function buildGhostRetryExhaustionMirror({
   return `Auto-retry exhausted after ${count} attempts (${ft}).${suffix}`;
 }
 
+/**
+ * Slice 2d (Turn 201): extract the most recent `process_exit` / `spawn_error`
+ * adapter diagnostic from a rendered dispatch log. The adapter writes lines of
+ * the form `[adapter:diag] <label> <json>\n` (see
+ * `cli/src/lib/adapters/local-cli-adapter.js::appendDiagnostic`); ghost-turn
+ * failures always emit one of `process_exit` or `spawn_error` before settling.
+ *
+ * Returns `{ stderr_excerpt, exit_code, exit_signal }`. Each field is `null`
+ * when the log is empty, malformed, or did not surface that particular field.
+ * Purity: takes a string, does not read the filesystem; the caller is
+ * responsible for loading the log.
+ */
+export function extractLatestStderrDiagnostic(dispatchLogContent) {
+  if (typeof dispatchLogContent !== 'string' || dispatchLogContent.length === 0) {
+    return { stderr_excerpt: null, exit_code: null, exit_signal: null };
+  }
+  const LABELS = new Set(['process_exit', 'spawn_error']);
+  const lines = dispatchLogContent.split(/\n+/);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i];
+    if (!line || !line.startsWith('[adapter:diag] ')) continue;
+    const rest = line.slice('[adapter:diag] '.length);
+    const spaceIdx = rest.indexOf(' ');
+    if (spaceIdx <= 0) continue;
+    const label = rest.slice(0, spaceIdx);
+    if (!LABELS.has(label)) continue;
+    const jsonText = rest.slice(spaceIdx + 1);
+    let payload;
+    try {
+      payload = JSON.parse(jsonText);
+    } catch {
+      continue;
+    }
+    if (!payload || typeof payload !== 'object') continue;
+    const stderr = typeof payload.stderr_excerpt === 'string' && payload.stderr_excerpt.length > 0
+      ? payload.stderr_excerpt
+      : null;
+    const rawExit = payload.exit_code;
+    const exitCode = Number.isInteger(rawExit) ? rawExit : null;
+    const rawSignal = payload.signal ?? payload.exit_signal ?? null;
+    const exitSignal = typeof rawSignal === 'string' && rawSignal.length > 0 ? rawSignal : null;
+    if (stderr === null && exitCode === null && exitSignal === null && label === 'process_exit') {
+      // Nothing useful on this line — keep looking for an earlier entry that
+      // had stderr or an exit code. Prevents a final benign process_exit from
+      // masking a prior spawn_error with real evidence.
+      continue;
+    }
+    return { stderr_excerpt: stderr, exit_code: exitCode, exit_signal: exitSignal };
+  }
+  return { stderr_excerpt: null, exit_code: null, exit_signal: null };
+}
+
 /**
  * Slice 2c: build the per-attempt diagnostic bundle that rides on the
  * `ghost_retry_exhausted` event payload AND gets surfaced in CLI status so