agentxchain 2.154.1 → 2.154.5

package/package.json

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

package/src/commands/resume.js

@@ -44,6 +44,33 @@ import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
 import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
+function hasStandingPendingExitGate(state, config) {
+  const phase = state?.phase;
+  const gateId = phase ? config?.routing?.[phase]?.exit_gate : null;
+  return Boolean(gateId && (state?.phase_gate_status || {})[gateId] === 'pending');
+}
+
+function latestCompletedTurnWantsPhaseContinuation(root, state, config) {
+  const turnId = state?.last_completed_turn_id || state?.blocked_reason?.turn_id || null;
+  if (!turnId) return false;
+  const historyPath = join(root, config?.files?.history || '.agentxchain/history.jsonl');
+  if (!existsSync(historyPath)) return false;
+  const lines = readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    let entry = null;
+    try {
+      entry = JSON.parse(lines[index]);
+    } catch {
+      continue;
+    }
+    if (entry?.turn_id !== turnId) continue;
+    if (entry.phase_transition_request) return true;
+    const proposed = typeof entry.proposed_next_role === 'string' ? entry.proposed_next_role.trim() : '';
+    return Boolean(proposed && proposed !== 'human');
+  }
+  return false;
+}
+
 export async function resumeCommand(opts) {
   const context = loadProjectContext();
   if (!context) {
@@ -143,7 +170,23 @@ export async function resumeCommand(opts) {
   // patched defensively) once the schema citation + migration citation are
   // documented in code and the coverage matrix.
 
-  if (state.status === 'blocked' && activeCount > 0 && resumeVia === 'operator_unblock') {
+  // BUG-52 third variant (Turn 203/204): operator_unblock must run the
+  // standing-gate reconcile path regardless of `activeCount`, but only when the
+  // current phase actually has a standing pending exit gate and the blocked
+  // turn was trying to continue into a non-human phase role. The tester's
+  // v2.151.0 lights-out repro on `tusq.dev` left `active_turns: {}` with
+  // `phase_gate_status.planning_signoff: "pending"`, so the old
+  // `activeCount > 0` guard skipped the only path that could synthesize the
+  // missing transition source. Non-gate human escalations (OAuth, external
+  // decisions, schedule recovery with `proposed_next_role: "human"`) must keep
+  // the normal unblock/resume behavior instead of being forced through a
+  // phase-transition materialization check.
+  if (
+    state.status === 'blocked'
+    && resumeVia === 'operator_unblock'
+    && hasStandingPendingExitGate(state, config)
+    && latestCompletedTurnWantsPhaseContinuation(root, state, config)
+  ) {
     const reactivated = reactivateGovernedRun(root, state, { via: resumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));

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',

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