agentxchain 2.155.63 → 2.155.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.63",
+  "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/continuous-run.js

@@ -52,6 +52,7 @@ import {
   formatLegacyIntentMigrationNotice,
   formatPhantomIntentSupersessionNotice,
 } from './intent-startup-migration.js';
+import { checkpointAcceptedTurn } from './turn-checkpoint.js';
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 const PRODUCTIVE_TIMEOUT_RETRY_MAX_PER_RUN = 1;
@@ -574,6 +575,59 @@ async function maybeAutoRetryContinuousBlocker(context, session, contOpts, block
     || await maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log);
 }
 
+function extractCheckpointTurnIdFromExecution(execution) {
+  const errors = Array.isArray(execution?.result?.errors) ? execution.result.errors : [];
+  for (const error of errors) {
+    const text = String(error || '');
+    const match = text.match(/\bcheckpoint-turn\s+--turn\s+(turn_[A-Za-z0-9_-]+)/);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+function maybeAutoCheckpointBlockedExecution(context, session, contOpts, execution, log = console.log) {
+  if (!contOpts.autoCheckpoint) return null;
+  const turnId = extractCheckpointTurnIdFromExecution(execution);
+  if (!turnId) return null;
+
+  const checkpoint = checkpointAcceptedTurn(context.root, { turnId });
+  if (!checkpoint.ok) {
+    log(`Auto-checkpoint skipped for ${turnId}: ${checkpoint.error || 'checkpoint failed'}`);
+    return null;
+  }
+  if (checkpoint.already_checkpointed || checkpoint.skipped) {
+    log(`Auto-checkpoint skipped for ${turnId}: ${checkpoint.reason || 'no checkpoint changes were created'}`);
+    return null;
+  }
+
+  session.status = 'running';
+  session.current_run_id = session.current_run_id || execution?.result?.state?.run_id || null;
+  writeContinuousSession(context.root, session);
+
+  emitRunEvent(context.root, 'continuous_auto_checkpoint_recovered', {
+    run_id: session.current_run_id || execution?.result?.state?.run_id || null,
+    phase: execution?.result?.state?.phase || null,
+    status: 'active',
+    turn: { turn_id: turnId, role_id: null },
+    payload: {
+      session_id: session.session_id,
+      checkpoint_sha: checkpoint.checkpoint_sha || null,
+      already_checkpointed: Boolean(checkpoint.already_checkpointed),
+      recovered_files_changed: checkpoint.recovered_files_changed || checkpoint.files_changed || null,
+    },
+  });
+
+  log(`Auto-checkpoint recovered accepted turn ${turnId}; continuing active run.`);
+  return {
+    ok: true,
+    status: 'running',
+    action: 'auto_checkpoint_recovered',
+    run_id: session.current_run_id,
+    turn_id: turnId,
+    checkpoint_sha: checkpoint.checkpoint_sha || null,
+  };
+}
+
 async function maybeAutoRetryGhostBlocker(context, session, contOpts, blockedState, log = console.log) {
   const { root, config } = context;
   const decision = classifyGhostRetryDecision({
@@ -1784,6 +1838,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     const resumeStopReason = execution.result?.stop_reason;
 
     if (isBlockedContinuousExecution(execution)) {
+      const checkpointed = maybeAutoCheckpointBlockedExecution(context, session, contOpts, execution, log);
+      if (checkpointed) return checkpointed;
       const blockedState = execution?.result?.state || loadProjectState(root, context.config);
       const retried = await maybeAutoRetryContinuousBlocker(context, session, contOpts, blockedState, log);
       if (retried) return retried;
@@ -1852,6 +1908,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     const resumeStopReason = execution.result?.stop_reason;
 
     if (isBlockedContinuousExecution(execution)) {
+      const checkpointed = maybeAutoCheckpointBlockedExecution(context, session, contOpts, execution, log);
+      if (checkpointed) return checkpointed;
       const blockedState = execution?.result?.state || loadProjectState(root, context.config);
       const retried = await maybeAutoRetryContinuousBlocker(context, session, contOpts, blockedState, log);
       if (retried) return retried;
@@ -2044,6 +2102,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   }
 
   if (isBlockedContinuousExecution(execution)) {
+    const checkpointed = maybeAutoCheckpointBlockedExecution(context, session, contOpts, execution, log);
+    if (checkpointed) return checkpointed;
     const blockedState = execution?.result?.state || loadProjectState(root, context.config);
     const retried = await maybeAutoRetryContinuousBlocker(context, session, contOpts, blockedState, log);
     if (retried) return retried;

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;
+}