agentxchain 2.139.0 → 2.141.1

package/bin/agentxchain.js

@@ -1031,6 +1031,7 @@ intakeCmd
   .command('resolve')
   .description('Resolve an executing intent by reading the governed run outcome')
   .option('--intent <id>', 'Intent ID to resolve')
+  .option('--outcome <status>', 'Force transition to this status (e.g., "completed")')
   .option('-j, --json', 'Output as JSON')
   .action(intakeResolveCommand);
 

package/package.json

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

package/scripts/release-preflight.sh

@@ -153,7 +153,7 @@ if [[ "$PUBLISH_GATE" -eq 1 ]]; then
     test/release-notes-gate.test.js
     test/release-identity-hardening.test.js
     test/normalized-config.test.js
-    test/conformance.test.js
+    test/protocol-conformance.test.js
     test/beta-scenario-emission-guard.test.js
     test/claim-reality-preflight.test.js
     test/beta-tester-scenarios/*.test.js

package/src/commands/intake-resolve.js

@@ -15,7 +15,11 @@ export async function intakeResolveCommand(opts) {
     process.exit(1);
   }
 
-  const result = resolveIntent(root, opts.intent);
+  const resolveOpts = {};
+  if (opts.outcome) {
+    resolveOpts.outcome = opts.outcome;
+  }
+  const result = resolveIntent(root, opts.intent, resolveOpts);
 
   if (opts.json) {
     console.log(JSON.stringify(result, null, 2));

package/src/lib/governed-state.js

@@ -37,6 +37,7 @@ import {
   deriveAcceptedRef,
   checkCleanBaseline,
   isOperationalPath,
+  isBaselineExemptPath,
 } from './repo-observer.js';
 import { getMaxConcurrentTurns } from './normalized-config.js';
 import { getTurnStagingResultPath, getTurnStagingDir, getDispatchTurnDir, getReviewArtifactPath } from './turn-paths.js';
@@ -106,6 +107,34 @@ function buildInitialPhaseGateStatus(config) {
   );
 }
 
+function buildObservationDrift(beforeObservation, afterObservation) {
+  const beforeFiles = (Array.isArray(beforeObservation?.files_changed) ? beforeObservation.files_changed : [])
+    .filter((filePath) => !isBaselineExemptPath(filePath));
+  const afterFiles = (Array.isArray(afterObservation?.files_changed) ? afterObservation.files_changed : [])
+    .filter((filePath) => !isBaselineExemptPath(filePath));
+  const beforeSet = new Set(beforeFiles);
+  const afterSet = new Set(afterFiles);
+  const beforeMarkers = beforeObservation?.file_markers && typeof beforeObservation.file_markers === 'object'
+    ? beforeObservation.file_markers
+    : {};
+  const afterMarkers = afterObservation?.file_markers && typeof afterObservation.file_markers === 'object'
+    ? afterObservation.file_markers
+    : {};
+
+  const added = afterFiles.filter((filePath) => !beforeSet.has(filePath));
+  const removed = beforeFiles.filter((filePath) => !afterSet.has(filePath));
+  const markerChanged = beforeFiles.filter((filePath) => (
+    afterSet.has(filePath) && beforeMarkers[filePath] !== afterMarkers[filePath]
+  ));
+
+  return {
+    added,
+    removed,
+    marker_changed: markerChanged,
+    drifted_files: [...new Set([...added, ...removed, ...markerChanged])].sort(),
+  };
+}
+
 function listIntakeIntentFiles(root) {
   const intentsDir = join(root, INTAKE_INTENTS_DIR);
   if (!existsSync(intentsDir)) return [];
@@ -115,6 +144,50 @@ function listIntakeIntentFiles(root) {
     .map((name) => join(intentsDir, name));
 }
 
+// BUG-45: Reconcile embedded intake_context against the live intent file.
+// The embedded copy is historical state; the live intent file is authoritative.
+// If the live intent cannot be read, acceptance must fail closed instead of
+// silently reusing the stale embedded contract.
+const INTENT_TERMINAL_STATES = ['completed', 'satisfied', 'superseded', 'suppressed', 'failed', 'rejected'];
+
+function reconcileIntakeContext(root, intakeCtx) {
+  if (!intakeCtx || !intakeCtx.intent_id) {
+    return { ok: true, intakeCtx };
+  }
+
+  try {
+    const intentPath = join(root, INTAKE_INTENTS_DIR, `${intakeCtx.intent_id}.json`);
+    if (!existsSync(intentPath)) {
+      return {
+        ok: false,
+        error: `Intent reconciliation failed: live intent ${intakeCtx.intent_id} not found at ${INTAKE_INTENTS_DIR}/${intakeCtx.intent_id}.json`,
+      };
+    }
+
+    const liveIntent = JSON.parse(readFileSync(intentPath, 'utf8'));
+
+    // If the intent has reached a terminal state, skip coverage enforcement
+    if (INTENT_TERMINAL_STATES.includes(liveIntent.status)) {
+      return { ok: true, intakeCtx: null };
+    }
+
+    // Intent is still active — use the CURRENT acceptance_contract from disk
+    if (Array.isArray(liveIntent.acceptance_contract)) {
+      return {
+        ok: true,
+        intakeCtx: { ...intakeCtx, acceptance_contract: liveIntent.acceptance_contract },
+      };
+    }
+
+    return { ok: true, intakeCtx };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Intent reconciliation failed: could not read live intent ${intakeCtx.intent_id}: ${error.message}`,
+    };
+  }
+}
+
 function retireApprovedPhaseScopedIntents(root, state, config, exitedPhase, now) {
   const retired = [];
 
@@ -3166,11 +3239,17 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     currentTurn,
     historyEntries,
   );
-  const observation = attributeObservedChangesToTurn(rawObservation, currentTurn, historyEntries, {
+  const observationAttributionOptions = {
     currentDeclaredFiles: turnResult.files_changed || [],
     concurrentSiblingIds: pendingConcurrentSiblingDeclarations.map((entry) => entry.turn_id),
     pendingConcurrentSiblingDeclarations,
-  });
+  };
+  const observation = attributeObservedChangesToTurn(
+    rawObservation,
+    currentTurn,
+    historyEntries,
+    observationAttributionOptions,
+  );
   const role = config.roles?.[turnResult.role];
   const runtimeId = turnResult.runtime_id;
   const runtime = config.runtimes?.[runtimeId];
@@ -3222,10 +3301,33 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     };
   }
 
-  // ── Intent coverage validation (BUG-14) ──────────────────────────────────
-  // When a turn is bound to an injected intent, verify the turn result
-  // addresses each acceptance item.  Default: strict for p0, lenient for others.
-  const intakeCtx = currentTurn.intake_context;
+  // ── BUG-45: Reconcile intake_context against live intent state ──────────
+  // The embedded intake_context is a snapshot from dispatch time. The intent
+  // may have since been completed, satisfied, or had its contract updated.
+  // Re-read the live intent file and reconcile before evaluating coverage.
+  const intakeReconciliation = reconcileIntakeContext(root, currentTurn.intake_context);
+  if (!intakeReconciliation.ok) {
+    transitionToFailedAcceptance(root, state, currentTurn, intakeReconciliation.error, {
+      error_code: 'intent_reconciliation_failed',
+      stage: 'intent_reconciliation',
+      extra: {
+        intent_id: currentTurn.intake_context?.intent_id || null,
+      },
+    });
+    return {
+      ok: false,
+      error: intakeReconciliation.error,
+      validation: {
+        ...validation,
+        ok: false,
+        stage: 'intent_reconciliation',
+        error_class: 'intent_reconciliation_error',
+        errors: [intakeReconciliation.error],
+        warnings: validation.warnings,
+      },
+    };
+  }
+  const intakeCtx = intakeReconciliation.intakeCtx;
   if (intakeCtx && Array.isArray(intakeCtx.acceptance_contract) && intakeCtx.acceptance_contract.length > 0) {
     const intentCoverage = evaluateIntentCoverage(turnResult, intakeCtx, {
       state,
@@ -3336,6 +3438,30 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     ? replayVerificationMachineEvidence({ root, verification: turnResult.verification })
     : null;
 
+  if (verificationReplay?.workspace_guard?.ok === false) {
+    const replayError = verificationReplay.workspace_guard.cleanup_error
+      || 'Verification replay mutated actor-owned workspace files and cleanup failed.';
+    transitionToFailedAcceptance(root, state, currentTurn, replayError, {
+      error_code: 'verification_replay_drift',
+      stage: 'verification_replay',
+      extra: {
+        replay_side_effect_files: verificationReplay.workspace_guard.restored_files || [],
+      },
+    });
+    return {
+      ok: false,
+      error: replayError,
+      validation: {
+        ...validation,
+        ok: false,
+        stage: 'verification_replay',
+        error_class: 'verification_replay_error',
+        errors: [replayError],
+        warnings: validation.warnings,
+      },
+    };
+  }
+
   // Policy evaluation — declarative governance rules (spec: POLICY_ENGINE_SPEC.md)
   const policyResult = evaluatePolicies(config.policies || [], {
     currentPhase: state.phase,
@@ -3571,6 +3697,38 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  const finalObservation = attributeObservedChangesToTurn(
+    observeChanges(root, baseline),
+    currentTurn,
+    historyEntries,
+    observationAttributionOptions,
+  );
+  const observationDrift = buildObservationDrift(observation, finalObservation);
+  if (observationDrift.drifted_files.length > 0) {
+    const driftError = `Acceptance mutated actor-owned workspace after artifact observation: ${observationDrift.drifted_files.join(', ')}`;
+    transitionToFailedAcceptance(root, state, currentTurn, driftError, {
+      error_code: 'acceptance_drift',
+      stage: 'artifact_observation',
+      extra: {
+        added_files: observationDrift.added,
+        removed_files: observationDrift.removed,
+        marker_changed_files: observationDrift.marker_changed,
+      },
+    });
+    return {
+      ok: false,
+      error: driftError,
+      validation: {
+        ...validation,
+        ok: false,
+        stage: 'artifact_observation',
+        error_class: 'artifact_error',
+        errors: [driftError],
+        warnings: validation.warnings,
+      },
+    };
+  }
+
   const acceptedSequence = (state.turn_sequence || 0) + 1;
   const historyEntry = {
     turn_id: turnResult.turn_id,

package/src/lib/intake.js

@@ -1270,7 +1270,7 @@ export function handoffIntent(root, intentId, options = {}) {
 // Resolve — execution exit and intent closure linkage (V3-S5)
 // ---------------------------------------------------------------------------
 
-export function resolveIntent(root, intentId) {
+export function resolveIntent(root, intentId, opts = {}) {
   const loadedIntent = readIntent(root, intentId);
   if (!loadedIntent.ok) {
     return loadedIntent;
@@ -1298,6 +1298,38 @@ export function resolveIntent(root, intentId) {
     };
   }
 
+  // BUG-45: operator-forced completion — transition executing → completed
+  // when the operator knows the work is done but the framework hasn't retired
+  // the intent automatically (e.g., retained-turn deadlock recovery).
+  if (opts.outcome === 'completed' && intent.status === 'executing') {
+    const now = nowISO();
+    const previousStatus = intent.status;
+    intent.status = 'completed';
+    intent.completed_at = now;
+    intent.updated_at = now;
+    if (!Array.isArray(intent.history)) intent.history = [];
+    intent.history.push({
+      from: previousStatus,
+      to: 'completed',
+      at: now,
+      reason: opts.reason || 'operator-resolved: intent marked completed via intake resolve --outcome completed',
+    });
+
+    const obsDir = join(dirs.base, 'observations', intent.intent_id);
+    mkdirSync(obsDir, { recursive: true });
+
+    safeWriteJson(intentPath, intent);
+    return {
+      ok: true,
+      intent,
+      previous_status: previousStatus,
+      new_status: 'completed',
+      run_outcome: 'completed',
+      no_change: false,
+      exitCode: 0,
+    };
+  }
+
   if (intent.target_workstream) {
     return resolveCoordinatorBackedIntent(root, intentPath, dirs, intent);
   }

package/src/lib/repo-observer.js

@@ -29,6 +29,8 @@ const OPERATIONAL_PATH_PREFIXES = [
   '.agentxchain/intake/',
   '.agentxchain/locks/',
   '.agentxchain/transactions/',
+  '.agentxchain/missions/',
+  '.agentxchain/multirepo/',
 ];
 
 // Orchestrator-owned state files that agents must never be blamed for modifying.
@@ -38,6 +40,7 @@ const ORCHESTRATOR_STATE_FILES = [
   '.agentxchain/session.json',
   '.agentxchain/history.jsonl',
   '.agentxchain/decision-ledger.jsonl',
+  '.agentxchain/repo-decisions.jsonl',
   '.agentxchain/lock.json',
   '.agentxchain/hook-audit.jsonl',
   '.agentxchain/hook-annotations.jsonl',
@@ -50,6 +53,7 @@ const ORCHESTRATOR_STATE_FILES = [
   '.agentxchain/human-escalations.jsonl',
   '.agentxchain/sla-reminders.json',
   'TALK.md',
+  'HUMAN_TASKS.md',
 ];
 
 // Evidence paths may legitimately remain dirty across turns without blocking the
@@ -70,7 +74,7 @@ export function isOperationalPath(filePath) {
     || ORCHESTRATOR_STATE_FILES.includes(filePath);
 }
 
-function isBaselineExemptPath(filePath) {
+export function isBaselineExemptPath(filePath) {
   return isOperationalPath(filePath)
     || BASELINE_EXEMPT_PATH_PREFIXES.some(prefix => filePath.startsWith(prefix));
 }

package/src/lib/verification-replay.js

@@ -1,4 +1,10 @@
-import { spawnSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { isOperationalPath } from './repo-observer.js';
 
 export const DEFAULT_VERIFICATION_REPLAY_TIMEOUT_MS = 30_000;
 
@@ -22,10 +28,15 @@ export function replayVerificationMachineEvidence({ root, verification, timeoutM
     return payload;
   }
 
-  payload.commands = machineEvidence.map((entry, index) => replayEvidenceCommand(root, entry, index, timeoutMs));
-  payload.replayed_commands = payload.commands.length;
-  payload.matched_commands = payload.commands.filter((entry) => entry.matched).length;
-  payload.overall = payload.commands.every((entry) => entry.matched) ? 'match' : 'mismatch';
+  const workspaceGuard = createReplayWorkspaceGuard(root);
+  try {
+    payload.commands = machineEvidence.map((entry, index) => replayEvidenceCommand(root, entry, index, timeoutMs));
+    payload.replayed_commands = payload.commands.length;
+    payload.matched_commands = payload.commands.filter((entry) => entry.matched).length;
+    payload.overall = payload.commands.every((entry) => entry.matched) ? 'match' : 'mismatch';
+  } finally {
+    payload.workspace_guard = workspaceGuard.cleanup();
+  }
 
   return payload;
 }
@@ -69,3 +80,186 @@ export function summarizeVerificationReplay(payload) {
     ...(payload.reason ? { reason: payload.reason } : {}),
   };
 }
+
+function createReplayWorkspaceGuard(root) {
+  if (!isGitRepo(root)) {
+    return {
+      cleanup() {
+        return { ok: true, restored_files: [], cleanup_error: null };
+      },
+    };
+  }
+
+  const backupDir = mkdtempSync(join(tmpdir(), 'axc-verification-replay-'));
+  const beforeState = captureDirtyWorkspaceState(root, backupDir);
+
+  return {
+    cleanup() {
+      const restoredFiles = new Set();
+
+      try {
+        const afterFiles = collectDirtyActorFiles(root);
+        const candidateFiles = new Set([...beforeState.files.keys(), ...afterFiles]);
+
+        for (const filePath of candidateFiles) {
+          const beforeInfo = beforeState.files.get(filePath);
+          const currentMarker = getWorkspaceFileMarker(root, filePath);
+
+          if (beforeInfo) {
+            if (currentMarker !== beforeInfo.marker) {
+              restorePreReplayPath(root, filePath, beforeInfo);
+              restoredFiles.add(filePath);
+            }
+            continue;
+          }
+
+          restoreCleanPath(root, filePath);
+          restoredFiles.add(filePath);
+        }
+
+        const remainingDrift = detectWorkspaceDrift(root, beforeState.files);
+        if (remainingDrift.length > 0) {
+          return {
+            ok: false,
+            restored_files: [...restoredFiles].sort(),
+            cleanup_error: `Verification replay left actor-owned workspace drift after cleanup: ${remainingDrift.join(', ')}`,
+          };
+        }
+
+        return {
+          ok: true,
+          restored_files: [...restoredFiles].sort(),
+          cleanup_error: null,
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          restored_files: [...restoredFiles].sort(),
+          cleanup_error: err?.message || String(err),
+        };
+      } finally {
+        rmSync(backupDir, { recursive: true, force: true });
+      }
+    },
+  };
+}
+
+function captureDirtyWorkspaceState(root, backupDir) {
+  const files = new Map();
+  for (const filePath of collectDirtyActorFiles(root)) {
+    const absPath = join(root, filePath);
+    const backupPath = join(backupDir, filePath);
+    const existed = existsSync(absPath);
+    const marker = getWorkspaceFileMarker(root, filePath);
+
+    if (existed) {
+      mkdirSync(dirname(backupPath), { recursive: true });
+      cpSync(absPath, backupPath, { force: true, recursive: true });
+    }
+
+    files.set(filePath, { existed, marker, backupPath });
+  }
+  return { files };
+}
+
+function detectWorkspaceDrift(root, beforeFiles) {
+  const afterFiles = collectDirtyActorFiles(root);
+  const candidates = new Set([...beforeFiles.keys(), ...afterFiles]);
+  const drift = [];
+
+  for (const filePath of candidates) {
+    const beforeInfo = beforeFiles.get(filePath);
+    const currentMarker = getWorkspaceFileMarker(root, filePath);
+    if (beforeInfo) {
+      if (currentMarker !== beforeInfo.marker) {
+        drift.push(filePath);
+      }
+      continue;
+    }
+    drift.push(filePath);
+  }
+
+  return drift.sort();
+}
+
+function restorePreReplayPath(root, filePath, beforeInfo) {
+  const absPath = join(root, filePath);
+  if (!beforeInfo.existed) {
+    rmSync(absPath, { recursive: true, force: true });
+    return;
+  }
+
+  rmSync(absPath, { recursive: true, force: true });
+  mkdirSync(dirname(absPath), { recursive: true });
+  cpSync(beforeInfo.backupPath, absPath, { force: true, recursive: true });
+}
+
+function restoreCleanPath(root, filePath) {
+  const absPath = join(root, filePath);
+  if (isTrackedPath(root, filePath)) {
+    execFileSync('git', ['restore', '--source=HEAD', '--staged', '--worktree', '--', filePath], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return;
+  }
+
+  rmSync(absPath, { recursive: true, force: true });
+}
+
+function collectDirtyActorFiles(root) {
+  return [...new Set([
+    ...readGitLines(root, ['diff', '--name-only', 'HEAD']),
+    ...readGitLines(root, ['diff', '--name-only', '--cached']),
+    ...readGitLines(root, ['ls-files', '--others', '--exclude-standard']),
+  ])]
+    .filter((filePath) => filePath && !isOperationalPath(filePath))
+    .sort();
+}
+
+function readGitLines(root, args) {
+  try {
+    const output = execFileSync('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function isTrackedPath(root, filePath) {
+  try {
+    execFileSync('git', ['ls-files', '--error-unmatch', '--', filePath], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isGitRepo(root) {
+  try {
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getWorkspaceFileMarker(root, filePath) {
+  const absPath = join(root, filePath);
+  if (!existsSync(absPath)) {
+    return '__deleted__';
+  }
+
+  const content = readFileSync(absPath);
+  return createHash('sha1').update(content).digest('hex');
+}