agentxchain 2.155.64 → 2.155.65

package/package.json

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

package/src/commands/run.js

@@ -497,11 +497,36 @@ export async function executeGovernedRun(context, opts = {}) {
             : 0,
           recommendation: `Turn ${turn.turn_id} failed to start within the startup watchdog window. Run \`agentxchain reissue-turn --turn ${turn.turn_id} --reason ghost\` to recover.`,
         });
-        return { accept: false, blocked: true, reason: adapterResult.error || 'turn startup failed' };
+        return {
+          accept: false,
+          blocked: true,
+          blockedAlreadyPersisted: true,
+          reason: adapterResult.error || 'turn startup failed',
+        };
       }
 
       // Adapter failure
       if (!adapterResult.ok) {
+        if (adapterResult.blocked === true) {
+          const classified = adapterResult.classified || null;
+          const detail = classified
+            ? `${classified.error_class}: ${classified.recovery}`
+            : (adapterResult.error || 'adapter dispatch failed');
+          return {
+            accept: false,
+            blocked: true,
+            blockedOn: `dispatch:${classified?.error_class || 'subprocess_failed'}`,
+            blockedCategory: 'dispatch_error',
+            recovery: {
+              typed_reason: 'dispatch_error',
+              owner: 'human',
+              recovery_action: classified?.recovery || 'Resolve the dispatch issue, then run agentxchain step --resume',
+              turn_retained: true,
+              detail,
+            },
+            reason: detail,
+          };
+        }
         if (shouldSuggestManualQaFallback({
           roleId,
           runtimeId,

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

@@ -30,7 +30,7 @@ import {
 } from '../turn-paths.js';
 import { verifyDispatchManifestForAdapter } from '../dispatch-manifest.js';
 import { hasMeaningfulStagedResult } from '../staged-result-proof.js';
-import { getClaudeSubprocessAuthIssue } from '../claude-local-auth.js';
+import { getClaudeSubprocessAuthIssue, isClaudeLocalCliRuntime } from '../claude-local-auth.js';
 
 const DIAGNOSTIC_ENV_KEYS = [
   'PATH',
@@ -43,6 +43,7 @@ const DIAGNOSTIC_ENV_KEYS = [
 const DIAGNOSTIC_STDERR_EXCERPT_LIMIT = 800;
 const DEFAULT_STARTUP_WATCHDOG_MS = 180_000;
 const DEFAULT_STARTUP_WATCHDOG_SIGKILL_GRACE_MS = 10_000;
+const CLAUDE_AUTH_FAILURE_RE = /authentication_failed|authentication_error|invalid authentication credentials|unauthorized|API Error:\s*401/i;
 
 /**
  * Launch a local CLI subprocess for a governed turn.
@@ -427,6 +428,22 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
 
       if (hasResult) {
         settle({ ok: true, exitCode, timedOut: false, aborted: false, logs, firstOutputAt });
+      } else if (isClaudeLocalCliRuntime(runtime) && hasClaudeAuthFailureOutput(logs)) {
+        const recovery = 'Refresh Claude credentials before resuming: export a valid ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN, then run agentxchain step --resume.';
+        settle({
+          ok: false,
+          blocked: true,
+          exitCode,
+          timedOut: false,
+          aborted: false,
+          firstOutputAt,
+          classified: {
+            error_class: 'claude_auth_failed',
+            recovery,
+          },
+          error: `Claude local_cli authentication failed. ${recovery}`,
+          logs,
+        });
       } else if (startupTimedOut) {
         settle({
           ok: false,
@@ -640,6 +657,11 @@ function appendDiagnostic(logs, label, payload) {
   logs.push(`[adapter:diag] ${label} ${JSON.stringify(payload)}\n`);
 }
 
+function hasClaudeAuthFailureOutput(logs) {
+  if (!Array.isArray(logs)) return false;
+  return logs.some((line) => typeof line === 'string' && CLAUDE_AUTH_FAILURE_RE.test(line));
+}
+
 function pickDiagnosticEnv(env) {
   return Object.fromEntries(
     DIAGNOSTIC_ENV_KEYS

package/src/lib/run-loop.js

@@ -461,6 +461,9 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
       emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
     } else {
       if (dispatchResult?.blocked === true) {
+        if (dispatchResult.blockedAlreadyPersisted !== true) {
+          persistDispatchBlocker(root, config, turn, dispatchResult, errors);
+        }
         history.push({ role: roleId, turn_id: turn.turn_id, accepted: false, blocked: true });
         const blockedState = loadState(root, config);
         emit({ type: 'blocked', state: blockedState });
@@ -653,6 +656,9 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
   }
 
   if (dispatchResult?.blocked === true) {
+    if (dispatchResult.blockedAlreadyPersisted !== true) {
+      persistDispatchBlocker(root, config, turn, dispatchResult, errors);
+    }
     history.push({ role: roleId, turn_id: turn.turn_id, accepted: false, blocked: true });
     const blockedState = loadState(root, config);
     emit({ type: 'blocked', state: blockedState });
@@ -847,3 +853,25 @@ function persistDispatchTimeout(root, config, turn, timeoutResult, errors) {
   errors.push(`dispatch timed out for ${turn.assigned_role} after ${timeoutResult.limit_minutes}m`);
   return blocked;
 }
+
+function persistDispatchBlocker(root, config, turn, dispatchResult, errors) {
+  const recovery = dispatchResult.recovery || {
+    typed_reason: 'dispatch_error',
+    owner: 'human',
+    recovery_action: 'Resolve the dispatch issue, then run agentxchain step --resume',
+    turn_retained: true,
+    detail: dispatchResult.reason || 'adapter dispatch failed',
+  };
+  const blocked = markRunBlocked(root, {
+    blockedOn: dispatchResult.blockedOn || 'dispatch:subprocess_failed',
+    category: dispatchResult.blockedCategory || 'dispatch_error',
+    recovery,
+    turnId: turn.turn_id,
+    notificationConfig: config,
+  });
+  if (!blocked.ok) {
+    errors.push(`markRunBlocked(dispatch): ${blocked.error}`);
+    return { state: loadState(root, config) };
+  }
+  return blocked;
+}