agentxchain 2.155.62 → 2.155.64

package/package.json

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

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/turn-checkpoint.js

@@ -96,7 +96,69 @@ function recoverLegacyCheckpointFiles(root, entry, opts = {}) {
   return getActorDirtyFiles(root, opts.dirtyFiles);
 }
 
-function persistRecoveredFilesChanged(root, turnId, recoveredFiles) {
+function extractObservedDiffSummaryPaths(entry) {
+  const summary = entry?.observed_artifact?.diff_summary;
+  if (typeof summary !== 'string' || summary.trim().length === 0) {
+    return [];
+  }
+
+  const paths = [];
+  for (const line of summary.split('\n')) {
+    const tableMatch = line.match(/^\s*(.+?)\s+\|\s+/);
+    if (tableMatch?.[1]) {
+      paths.push(tableMatch[1].trim());
+      continue;
+    }
+
+    const untrackedMatch = line.match(/^\s*-\s+(.+)$/);
+    if (untrackedMatch?.[1]) {
+      paths.push(untrackedMatch[1].trim());
+    }
+  }
+
+  return normalizeFilesChanged(paths);
+}
+
+function recoverSupplementalCheckpointFiles(root, entry, opts = {}) {
+  if (!supportsLegacyFilesChangedRecovery(entry) || !entry?.checkpoint_sha) {
+    return [];
+  }
+
+  const state = readState(root);
+  if (state && Object.keys(state.active_turns || {}).length > 0) {
+    return [];
+  }
+
+  const acceptedHistory = queryAcceptedTurnHistory(root);
+  if (acceptedHistory[0]?.turn_id !== entry?.turn_id) {
+    return [];
+  }
+
+  const actorDirtyFiles = getActorDirtyFiles(root, opts.dirtyFiles);
+  if (actorDirtyFiles.length === 0) {
+    return [];
+  }
+
+  const observedSummaryFiles = new Set(extractObservedDiffSummaryPaths(entry));
+  if (observedSummaryFiles.size === 0) {
+    return [];
+  }
+
+  const declared = new Set(normalizeFilesChanged(entry.files_changed));
+  const recoverable = actorDirtyFiles.filter((filePath) => (
+    !declared.has(filePath) && observedSummaryFiles.has(filePath)
+  ));
+  if (recoverable.length === 0) {
+    return [];
+  }
+
+  const unrecoverable = actorDirtyFiles.filter((filePath) => (
+    !declared.has(filePath) && !observedSummaryFiles.has(filePath)
+  ));
+  return unrecoverable.length === 0 ? recoverable : [];
+}
+
+function persistRecoveredFilesChanged(root, turnId, recoveredFiles, source = 'legacy_dirty_worktree') {
   const normalizedRecoveredFiles = normalizeFilesChanged(recoveredFiles);
   if (normalizedRecoveredFiles.length === 0) return;
 
@@ -110,15 +172,21 @@ function persistRecoveredFilesChanged(root, turnId, recoveredFiles) {
       ? historyEntry.observed_artifact
       : null;
 
+    const existingFiles = normalizeFilesChanged(historyEntry.files_changed);
+    const mergedFiles = normalizeFilesChanged([...existingFiles, ...normalizedRecoveredFiles]);
+
     return {
       ...historyEntry,
-      files_changed: normalizedRecoveredFiles,
+      files_changed: mergedFiles,
       files_changed_recovered_at: recoveredAt,
-      files_changed_recovery_source: 'legacy_dirty_worktree',
+      files_changed_recovery_source: source,
       observed_artifact: observedArtifact
         ? {
             ...observedArtifact,
-            files_changed: normalizedRecoveredFiles,
+            files_changed: normalizeFilesChanged([
+              ...(Array.isArray(observedArtifact.files_changed) ? observedArtifact.files_changed : []),
+              ...normalizedRecoveredFiles,
+            ]),
           }
         : observedArtifact,
     };
@@ -234,7 +302,17 @@ export function detectPendingCheckpoint(root, dirtyFiles = []) {
   if (!resolved.ok || !resolved.entry) return { required: false };
 
   const entry = resolved.entry;
-  if (entry.checkpoint_sha) return { required: false };
+  if (entry.checkpoint_sha) {
+    const supplementalFiles = recoverSupplementalCheckpointFiles(root, entry, { dirtyFiles: actorDirtyFiles });
+    if (supplementalFiles.length === 0) return { required: false };
+    return {
+      required: true,
+      turn_id: entry.turn_id,
+      recovered_files_changed: supplementalFiles,
+      supplemental: true,
+      message: `Accepted turn ${entry.turn_id} is checkpointed but still owns ${supplementalFiles.length} dirty actor file(s) from its observed diff summary. Run agentxchain checkpoint-turn --turn ${entry.turn_id} to create a supplemental checkpoint before assigning the next code-writing turn.`,
+    };
+  }
 
   const turnFiles = normalizeFilesChanged(entry.files_changed);
   const recoveredFiles = turnFiles.length === 0
@@ -267,7 +345,10 @@ export function checkpointAcceptedTurn(root, opts = {}) {
   }
 
   const entry = resolved.entry;
-  if (entry.checkpoint_sha) {
+  const supplementalFilesChanged = entry.checkpoint_sha
+    ? recoverSupplementalCheckpointFiles(root, entry)
+    : [];
+  if (entry.checkpoint_sha && supplementalFilesChanged.length === 0) {
     return {
       ok: true,
       already_checkpointed: true,
@@ -281,11 +362,14 @@ export function checkpointAcceptedTurn(root, opts = {}) {
     ? recoverLegacyCheckpointFiles(root, entry)
     : [];
   const filesChanged = declaredFilesChanged.length > 0
-    ? declaredFilesChanged
+    ? normalizeFilesChanged([...declaredFilesChanged, ...supplementalFilesChanged])
     : recoveredFilesChanged;
   if (recoveredFilesChanged.length > 0) {
     persistRecoveredFilesChanged(root, entry.turn_id, recoveredFilesChanged);
   }
+  if (supplementalFilesChanged.length > 0) {
+    persistRecoveredFilesChanged(root, entry.turn_id, supplementalFilesChanged, 'supplemental_dirty_worktree');
+  }
 
   if (filesChanged.length === 0) {
     return {