agentxchain 2.147.0 → 2.149.1

package/src/lib/turn-checkpoint.js

@@ -57,6 +57,14 @@ function normalizeFilesChanged(filesChanged) {
   return normalizeCheckpointableFiles(filesChanged);
 }
 
+function normalizeGitBaselineRef(ref) {
+  if (typeof ref !== 'string' || !ref.startsWith('git:')) {
+    return null;
+  }
+  const gitRef = ref.slice(4).trim();
+  return gitRef || null;
+}
+
 function supportsLegacyFilesChangedRecovery(entry) {
   const artifactType = entry?.artifact?.type;
   return artifactType === 'workspace' || artifactType === 'patch';
@@ -139,6 +147,85 @@ function buildCheckpointCommit(entry) {
   return { subject, body: bodyLines.join('\n') };
 }
 
+function diffMissingDeclaredPaths(declaredFiles, stagedFiles) {
+  const stagedSet = new Set((Array.isArray(stagedFiles) ? stagedFiles : []).map((value) => value.trim()).filter(Boolean));
+  return (Array.isArray(declaredFiles) ? declaredFiles : []).filter((filePath) => !stagedSet.has(filePath));
+}
+
+/**
+ * Partition paths that were missing from the staged-diff into
+ * (a) paths genuinely absent from git (untracked or dirty without staging)
+ * (b) paths already committed upstream (tracked in HEAD, no pending diff)
+ * (c) paths tracked and clean at HEAD but unchanged since the accepted
+ *     baseline — the BUG-55A wrong-lineage case (actor committed the file
+ *     off the accepted lineage, e.g. on a throwaway side-branch or the
+ *     lineage was reset to baseline).
+ *
+ * BUG-55A completeness must fail on (a) and (c). (c) has a different
+ * operator-visible recovery path than (a): the file DID exist in some
+ * commit but is not reachable from the accepted baseline + HEAD comparison
+ * the governed run relies on. Surface it separately so the CLI can tell
+ * the operator which failure they hit.
+ */
+function partitionDeclaredPathsByUpstreamPresence(root, missingPaths, options = {}) {
+  const baselineRef = normalizeGitBaselineRef(options.baselineRef);
+  const genuinelyMissing = [];
+  const divergentFromAcceptedLineage = [];
+  const alreadyCommittedUpstream = [];
+  for (const filePath of missingPaths) {
+    let tracked = false;
+    try {
+      git(root, ['ls-files', '--error-unmatch', '--', filePath]);
+      tracked = true;
+    } catch {
+      tracked = false;
+    }
+    if (!tracked) {
+      genuinelyMissing.push(filePath);
+      continue;
+    }
+    let hasDivergence = false;
+    try {
+      const headDiff = git(root, ['diff', 'HEAD', '--', filePath]);
+      const cachedDiff = git(root, ['diff', '--cached', '--', filePath]);
+      hasDivergence = Boolean(headDiff) || Boolean(cachedDiff);
+    } catch {
+      hasDivergence = true;
+    }
+    if (hasDivergence) {
+      genuinelyMissing.push(filePath);
+      continue;
+    }
+
+    // BUG-55A wrong-branch guard: a path only counts as already checkpointed
+    // if the current branch differs from the accepted baseline on that path.
+    if (baselineRef) {
+      let changedSinceAcceptedBaseline = false;
+      try {
+        const baselineDiff = git(root, ['diff', baselineRef, 'HEAD', '--', filePath]);
+        changedSinceAcceptedBaseline = Boolean(baselineDiff);
+      } catch {
+        changedSinceAcceptedBaseline = true;
+      }
+      if (!changedSinceAcceptedBaseline) {
+        divergentFromAcceptedLineage.push(filePath);
+        continue;
+      }
+    }
+
+    alreadyCommittedUpstream.push(filePath);
+  }
+  // Preserve the pre-existing return shape: `genuinelyMissing` is the union
+  // that the completeness gate must fail on. `divergent_from_accepted_lineage`
+  // is an additional, operator-facing subcategory that callers can surface
+  // without changing the pass/fail contract.
+  return {
+    genuinelyMissing: [...genuinelyMissing, ...divergentFromAcceptedLineage],
+    divergentFromAcceptedLineage,
+    alreadyCommittedUpstream,
+  };
+}
+
 export function detectPendingCheckpoint(root, dirtyFiles = []) {
   const actorDirtyFiles = normalizeFilesChanged(dirtyFiles);
   if (actorDirtyFiles.length === 0) return { required: false };
@@ -233,12 +320,36 @@ export function checkpointAcceptedTurn(root, opts = {}) {
     };
   }
 
+  const rawMissingFromStage = diffMissingDeclaredPaths(filesChanged, staged);
+  const { genuinelyMissing, divergentFromAcceptedLineage, alreadyCommittedUpstream } =
+    partitionDeclaredPathsByUpstreamPresence(root, rawMissingFromStage, {
+      baselineRef: entry?.observed_artifact?.baseline_ref ?? null,
+    });
+  if (genuinelyMissing.length > 0) {
+    const baseMessage = `Checkpoint completeness failure: accepted turn ${entry.turn_id} declared ${filesChanged.length} checkpointable file(s), but Git staged only ${staged.length} and ${genuinelyMissing.length} declared path(s) are absent from git. Missing from checkpoint: ${genuinelyMissing.join(', ')}.`;
+    const lineageHint = divergentFromAcceptedLineage.length > 0
+      ? ` Wrong-lineage paths (tracked at HEAD but unchanged since accepted baseline — actor likely committed off the accepted lineage): ${divergentFromAcceptedLineage.join(', ')}.`
+      : '';
+    return {
+      ok: false,
+      turn: entry,
+      error: `${baseMessage}${lineageHint}`,
+      missing_declared_paths: genuinelyMissing,
+      divergent_from_accepted_lineage: divergentFromAcceptedLineage,
+      already_committed_upstream: alreadyCommittedUpstream,
+      staged_paths: staged,
+    };
+  }
+
   if (staged.length === 0) {
     return {
       ok: true,
       skipped: true,
       turn: entry,
-      reason: `Accepted turn ${entry.turn_id} has no staged repo changes to checkpoint.`,
+      reason: alreadyCommittedUpstream.length > 0
+        ? `Accepted turn ${entry.turn_id} has no staged repo changes to checkpoint; all ${alreadyCommittedUpstream.length} declared file(s) already present in HEAD.`
+        : `Accepted turn ${entry.turn_id} has no staged repo changes to checkpoint.`,
+      already_committed_upstream: alreadyCommittedUpstream,
     };
   }
 

package/src/lib/turn-result-validator.js

@@ -600,6 +600,15 @@ function validateVerification(tr) {
     }
   }
 
+  if (Array.isArray(v.commands)) {
+    for (let i = 0; i < v.commands.length; i++) {
+      const command = v.commands[i];
+      if (typeof command !== 'string' || command.trim().length === 0) {
+        errors.push(`verification.commands[${i}] must be a non-empty string.`);
+      }
+    }
+  }
+
   // machine_evidence exit codes should be consistent with status
   if (Array.isArray(v.machine_evidence)) {
     for (let i = 0; i < v.machine_evidence.length; i++) {
@@ -608,8 +617,8 @@ function validateVerification(tr) {
         errors.push(`verification.machine_evidence[${i}] must be an object.`);
         continue;
       }
-      if (typeof entry.command !== 'string') {
-        errors.push(`verification.machine_evidence[${i}].command must be a string.`);
+      if (typeof entry.command !== 'string' || entry.command.trim().length === 0) {
+        errors.push(`verification.machine_evidence[${i}].command must be a non-empty string.`);
       }
       if (typeof entry.exit_code !== 'number' || !Number.isInteger(entry.exit_code)) {
         errors.push(`verification.machine_evidence[${i}].exit_code must be an integer.`);