agentxchain 2.155.66 → 2.155.68

package/package.json

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

package/src/lib/adapters/local-cli-adapter.js

@@ -19,7 +19,7 @@
 
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { delimiter, join } from 'path';
 import {
   getDispatchContextPath,
   getDispatchLogPath,
@@ -33,7 +33,9 @@ import { hasMeaningfulStagedResult } from '../staged-result-proof.js';
 import {
   getClaudeSubprocessAuthIssue,
   hasClaudeAuthenticationFailureText,
+  hasClaudeNodeIncompatibilityText,
   isClaudeLocalCliRuntime,
+  resolveClaudeCompatibleNodeBinary,
 } from '../claude-local-auth.js';
 
 const DIAGNOSTIC_ENV_KEYS = [
@@ -135,6 +137,7 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
   const spawnEnv = { ...process.env, AGENTXCHAIN_TURN_ID: turn.turn_id };
   const stdinBytes = transport === 'stdin' ? Buffer.byteLength(fullPrompt, 'utf8') : 0;
   const diagnosticArgs = redactPromptArgs(args, fullPrompt, transport);
+  const spawnSpec = resolveClaudeSpawnSpec(runtime, command, args, spawnEnv);
   const claudeAuthIssue = await getClaudeSubprocessAuthIssue(runtime, spawnEnv);
 
   if (claudeAuthIssue) {
@@ -163,14 +166,17 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
       appendDiagnostic(logs, 'spawn_prepare', {
         runtime_id: runtimeId,
         turn_id: turn.turn_id,
-        command,
-        args: diagnosticArgs,
+        command: spawnSpec.command,
+        args: spawnSpec.args === args ? diagnosticArgs : redactPromptArgs(spawnSpec.args, fullPrompt, transport),
+        configured_command: spawnSpec.command === command ? undefined : command,
+        configured_args: spawnSpec.command === command ? undefined : diagnosticArgs,
+        spawn_wrapper: spawnSpec.wrapper,
         cwd: runtimeCwd,
         prompt_transport: transport,
         stdin_bytes: stdinBytes,
         env: pickDiagnosticEnv(spawnEnv),
       });
-      child = spawn(command, args, {
+      child = spawn(spawnSpec.command, spawnSpec.args, {
         cwd: runtimeCwd,
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
@@ -447,6 +453,22 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
           error: `Claude local_cli authentication failed. ${recovery}`,
           logs,
         });
+      } else if (isClaudeLocalCliRuntime(runtime) && hasClaudeNodeRuntimeIncompatibilityOutput(logs)) {
+        const recovery = 'Run AgentXchain with Node.js 20.5+ available to the Claude local_cli runtime, then resume continuous mode.';
+        settle({
+          ok: false,
+          blocked: true,
+          exitCode,
+          timedOut: false,
+          aborted: false,
+          firstOutputAt,
+          classified: {
+            error_class: 'claude_node_incompatible',
+            recovery,
+          },
+          error: `Claude local_cli runtime is using an incompatible Node.js version. ${recovery}`,
+          logs,
+        });
       } else if (startupTimedOut) {
         settle({
           ok: false,
@@ -665,6 +687,55 @@ function hasClaudeAuthFailureOutput(logs) {
   return logs.some((line) => hasClaudeAuthenticationFailureText(line));
 }
 
+function hasClaudeNodeRuntimeIncompatibilityOutput(logs) {
+  if (!Array.isArray(logs)) return false;
+  return hasClaudeNodeIncompatibilityText(logs.join('\n'));
+}
+
+function resolveCommandPath(command, pathValue) {
+  if (!command || command.includes('/')) {
+    return existsSync(command) ? command : null;
+  }
+  const parts = String(pathValue || '').split(delimiter).filter(Boolean);
+  for (const dir of parts) {
+    const candidate = join(dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function resolveClaudeSpawnSpec(runtime, command, args, env) {
+  if (command !== 'claude' || !isClaudeLocalCliRuntime(runtime)) {
+    return { command, args, wrapper: null };
+  }
+  const nodeBinary = resolveClaudeCompatibleNodeBinary(env);
+  if (!nodeBinary) {
+    return { command, args, wrapper: null };
+  }
+  const claudeEntry = resolveCommandPath(command, env?.PATH);
+  if (!claudeEntry) {
+    return { command, args, wrapper: null };
+  }
+  if (!isNodeEntrypoint(claudeEntry)) {
+    return { command, args, wrapper: null };
+  }
+  return {
+    command: nodeBinary,
+    args: [claudeEntry, ...args],
+    wrapper: 'claude_compatible_node',
+  };
+}
+
+function isNodeEntrypoint(filePath) {
+  try {
+    const head = readFileSync(filePath, 'utf8').slice(0, 256);
+    const firstLine = head.split(/\r?\n/, 1)[0] || '';
+    return /^#!.*(?:^|[\/\s])(?:env\s+)?node(?:\s|$)/.test(firstLine);
+  } catch {
+    return false;
+  }
+}
+
 function pickDiagnosticEnv(env) {
   return Object.fromEntries(
     DIAGNOSTIC_ENV_KEYS

package/src/lib/claude-local-auth.js

@@ -1,4 +1,5 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
 
 const CLAUDE_ENV_AUTH_KEYS = [
   'ANTHROPIC_API_KEY',
@@ -11,6 +12,8 @@ const CLAUDE_ENV_AUTH_KEYS = [
 const DEFAULT_SMOKE_PROBE_TIMEOUT_MS = 10_000;
 const DEFAULT_SMOKE_PROBE_STDIN = 'ok';
 const CLAUDE_AUTH_FAILURE_RE = /authentication_failed|authentication_error|invalid authentication credentials|unauthorized|API Error:\s*401/i;
+const CLAUDE_NODE_INCOMPATIBILITY_RE = /TypeError:\s*Object not disposable|Object not disposable[\s\S]{0,2000}Node\.js v(?:1[0-9]|20\.[0-4]\.)/i;
+const CLAUDE_COMPATIBLE_NODE_MIN = { major: 20, minor: 5, patch: 0 };
 
 function normalizeCommandTokens(runtime) {
   if (Array.isArray(runtime?.command)) {
@@ -37,10 +40,77 @@ export function hasClaudeAuthenticationFailureText(text) {
   return typeof text === 'string' && CLAUDE_AUTH_FAILURE_RE.test(text);
 }
 
+export function hasClaudeNodeIncompatibilityText(text) {
+  return typeof text === 'string' && CLAUDE_NODE_INCOMPATIBILITY_RE.test(text);
+}
+
 export function hasClaudeBareFlag(runtime) {
   return normalizeCommandTokens(runtime).includes('--bare');
 }
 
+function parseNodeVersion(raw) {
+  const match = String(raw || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+  };
+}
+
+export function isClaudeCompatibleNodeVersion(raw) {
+  const version = parseNodeVersion(raw);
+  if (!version) return false;
+  if (version.major !== CLAUDE_COMPATIBLE_NODE_MIN.major) {
+    return version.major > CLAUDE_COMPATIBLE_NODE_MIN.major;
+  }
+  if (version.minor !== CLAUDE_COMPATIBLE_NODE_MIN.minor) {
+    return version.minor > CLAUDE_COMPATIBLE_NODE_MIN.minor;
+  }
+  return version.patch >= CLAUDE_COMPATIBLE_NODE_MIN.patch;
+}
+
+function isExecutable(filePath) {
+  if (!filePath) return false;
+  try {
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function candidateNodeVersion(filePath) {
+  if (!isExecutable(filePath)) return null;
+  const result = spawnSync(filePath, ['--version'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: 2000,
+  });
+  if (result.status !== 0) return null;
+  return String(result.stdout || '').trim();
+}
+
+export function resolveClaudeCompatibleNodeBinary(env = process.env) {
+  if (env?.AGENTXCHAIN_CLAUDE_NODE && isExecutable(env.AGENTXCHAIN_CLAUDE_NODE)) {
+    return env.AGENTXCHAIN_CLAUDE_NODE;
+  }
+
+  const candidates = [
+    process.execPath,
+    '/opt/homebrew/opt/node@20/bin/node',
+    '/opt/homebrew/bin/node',
+    '/usr/local/bin/node',
+  ];
+  for (const candidate of candidates) {
+    const version = candidateNodeVersion(candidate);
+    if (isClaudeCompatibleNodeVersion(version)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 export function getClaudeEnvAuthPresence(env = process.env) {
   return Object.fromEntries(
     CLAUDE_ENV_AUTH_KEYS.map((key) => [key, Boolean(env?.[key])]),

package/src/lib/continuous-run.js

@@ -55,12 +55,15 @@ import {
 import { checkpointAcceptedTurn } from './turn-checkpoint.js';
 import {
   hasClaudeAuthenticationFailureText,
+  hasClaudeNodeIncompatibilityText,
   isClaudeLocalCliRuntime,
+  resolveClaudeCompatibleNodeBinary,
 } from './claude-local-auth.js';
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 const PRODUCTIVE_TIMEOUT_RETRY_MAX_PER_RUN = 1;
 const PRODUCTIVE_TIMEOUT_RETRY_DEADLINE_MINUTES = 60;
+const PROVIDER_REQUEST_TIMEOUT_RE = /request timed out|timed out waiting for (?:provider|api)|provider request timed out/i;
 
 function getRoadmapReplenishmentTriageHints(root) {
   const context = loadProjectContext(root);
@@ -315,6 +318,8 @@ function getBlockedCategory(state) {
 
 const CLAUDE_AUTH_RECOVERY_ACTION =
   'Refresh Claude credentials before resuming: export a valid ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN, then run agentxchain step --resume.';
+const CLAUDE_NODE_RECOVERY_ACTION =
+  'Run AgentXchain with Node.js 20.5+ available to the Claude local_cli runtime, then resume continuous mode.';
 
 function findRetainedClaudeAuthEscalation(root, state, config) {
   if (!state || state.status !== 'blocked') return null;
@@ -394,6 +399,104 @@ function maybeReclassifyRetainedClaudeAuthEscalation(context, session, state, lo
   return nextState;
 }
 
+function findRetainedClaudeNodeIncompatGhost(root, state, config) {
+  if (!state || state.status !== 'blocked') return null;
+  if (state.blocked_reason?.category !== 'ghost_turn') return null;
+  const activeTurns = state.active_turns || {};
+  const turnId = state.blocked_reason?.turn_id || null;
+  const candidateIds = turnId && activeTurns[turnId] ? [turnId] : Object.keys(activeTurns);
+  for (const candidateId of candidateIds) {
+    const turn = activeTurns[candidateId];
+    if (!turn || turn.status !== 'failed_start') continue;
+    if (turn.failed_start_reason !== 'stdout_attach_failed') continue;
+    const runtime = config?.runtimes?.[turn.runtime_id];
+    if (!isClaudeLocalCliRuntime(runtime)) continue;
+    const logPath = join(root, getDispatchLogPath(candidateId));
+    if (!existsSync(logPath)) continue;
+    let logText = '';
+    try {
+      logText = readFileSync(logPath, 'utf8');
+    } catch {
+      continue;
+    }
+    if (!hasClaudeNodeIncompatibilityText(logText)) continue;
+    return { turn_id: candidateId, turn, previous_blocked_on: state.blocked_on || null };
+  }
+  return null;
+}
+
+function reclassifyRetainedClaudeNodeIncompatGhost(context, session, state, candidate, nodeBinary, log = console.log) {
+  const { root } = context;
+  if (nodeBinary) {
+    const reissued = reissueTurn(root, context.config, {
+      turnId: candidate.turn_id,
+      reason: 'auto_retry_claude_node_runtime',
+    });
+    if (!reissued.ok) {
+      log(`Claude Node runtime auto-retry skipped: ${reissued.error}`);
+      return null;
+    }
+    const runId = session.current_run_id || state.run_id || reissued.state?.run_id || null;
+    const nextState = clearGhostBlockerAfterReissue(root, reissued.state);
+    delete session.ghost_retry;
+    Object.assign(session, {
+      status: 'running',
+      current_run_id: runId,
+    });
+    writeContinuousSession(root, session);
+    emitRunEvent(root, 'auto_retried_ghost', {
+      run_id: runId,
+      phase: nextState.phase || state.phase || null,
+      status: 'active',
+      turn: { turn_id: reissued.newTurn.turn_id, role_id: reissued.newTurn.assigned_role || null },
+      payload: {
+        old_turn_id: candidate.turn_id,
+        new_turn_id: reissued.newTurn.turn_id,
+        failure_type: 'stdout_attach_failed',
+        recovery_class: 'claude_node_runtime_recovered',
+        runtime_id: candidate.turn.runtime_id || null,
+        node_binary: nodeBinary,
+      },
+    });
+    log(`Claude Node runtime recovered; auto-retried ${candidate.turn_id} -> ${reissued.newTurn.turn_id}.`);
+    return {
+      ok: true,
+      status: 'running',
+      action: 'auto_retried_claude_node_runtime',
+      run_id: runId,
+      old_turn_id: candidate.turn_id,
+      new_turn_id: reissued.newTurn.turn_id,
+    };
+  }
+
+  const blockedAt = new Date().toISOString();
+  const nextState = {
+    ...state,
+    status: 'blocked',
+    blocked_on: 'dispatch:claude_node_incompatible',
+    blocked_reason: {
+      category: 'dispatch_error',
+      blocked_at: blockedAt,
+      turn_id: candidate.turn_id,
+      reclassified_from: {
+        blocked_on: state.blocked_on || null,
+        category: state.blocked_reason?.category || null,
+      },
+      recovery: {
+        typed_reason: 'dispatch_error',
+        owner: 'human',
+        recovery_action: CLAUDE_NODE_RECOVERY_ACTION,
+        turn_retained: true,
+        detail: `claude_node_incompatible: ${CLAUDE_NODE_RECOVERY_ACTION}`,
+      },
+    },
+    escalation: null,
+  };
+  writeGovernedState(root, nextState);
+  log(`Reclassified retained Claude Node runtime blocker for ${candidate.turn_id} as dispatch:claude_node_incompatible.`);
+  return nextState;
+}
+
 const RECOVERABLE_ACTIVE_TURN_STATUSES = new Set(['assigned', 'dispatched', 'starting', 'running']);
 
 function hasOnlyRecoverableActiveTurns(activeTurns = {}) {
@@ -537,7 +640,16 @@ function findPrimaryProductiveTimeoutTurn(root, state) {
       ...(Array.isArray(turn.last_rejection?.validation_errors) ? turn.last_rejection.validation_errors : []),
     ].join('\n');
     const looksDeadlineKilled = /code 143|dispatch timed out|timed out/i.test(reason);
-    if (!looksDeadlineKilled) continue;
+    let looksProviderTimedOut = false;
+    const logPath = join(root, getDispatchLogPath(candidateId));
+    if (!looksDeadlineKilled && existsSync(logPath)) {
+      try {
+        looksProviderTimedOut = PROVIDER_REQUEST_TIMEOUT_RE.test(readFileSync(logPath, 'utf8'));
+      } catch {
+        looksProviderTimedOut = false;
+      }
+    }
+    if (!looksDeadlineKilled && !looksProviderTimedOut) continue;
     if (!turn.first_output_at) continue;
     const stagingPath = join(root, getTurnStagingResultPath(candidateId));
     if (existsSync(stagingPath)) continue;
@@ -1800,7 +1912,20 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   const startupGovernedState = loadProjectState(root, context.config);
   if (startupGovernedState?.status === 'blocked') {
     const reclassifiedState = maybeReclassifyRetainedClaudeAuthEscalation(context, session, startupGovernedState, log);
-    const effectiveBlockedState = reclassifiedState || startupGovernedState;
+    let effectiveBlockedState = reclassifiedState || startupGovernedState;
+    const nodeCandidate = findRetainedClaudeNodeIncompatGhost(root, effectiveBlockedState, context.config);
+    if (nodeCandidate) {
+      const nodeRecovery = reclassifyRetainedClaudeNodeIncompatGhost(
+        context,
+        session,
+        effectiveBlockedState,
+        nodeCandidate,
+        resolveClaudeCompatibleNodeBinary(process.env),
+        log,
+      );
+      if (nodeRecovery?.status === 'running') return nodeRecovery;
+      if (nodeRecovery) effectiveBlockedState = nodeRecovery;
+    }
     const retried = await maybeAutoRetryContinuousBlocker(context, session, contOpts, effectiveBlockedState, log);
     if (retried) return retried;
     session.status = 'paused';