agentxchain 2.134.1 → 2.135.0

package/package.json

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

package/src/commands/doctor.js

@@ -61,6 +61,7 @@ export async function doctorCommand(opts = {}) {
 function governedDoctor(root, rawConfig, opts) {
   const checks = [];
   const cliVersionHealth = getCliVersionHealth();
+  let stateRunId = null;
 
   checks.push(buildCliVersionCheck(cliVersionHealth));
 
@@ -109,6 +110,7 @@ function governedDoctor(root, rawConfig, opts) {
   if (existsSync(statePath)) {
     try {
       const stateData = JSON.parse(readFileSync(statePath, 'utf8'));
+      stateRunId = stateData.run_id || null;
       if (stateData.schema_version) {
         checks.push({ id: 'state_health', name: 'State health', level: 'pass', detail: `schema_version: ${stateData.schema_version}, status: ${stateData.status || 'unknown'}` });
       } else {
@@ -354,7 +356,7 @@ function governedDoctor(root, rawConfig, opts) {
 
   // 11. Pending intake intents (BUG-15 — informational)
   {
-    const pendingIntents = findPendingApprovedIntents(root);
+    const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId });
     if (pendingIntents.length > 0) {
       const summary = pendingIntents.map(pi => `[${pi.priority}] ${pi.intent_id}`).join(', ');
       checks.push({

package/src/commands/restart.js

@@ -342,7 +342,7 @@ export async function restartCommand(opts) {
   if (activeTurnCount === 0) {
     // BUG-21 fix: consume approved intents (same as resume path) so intent_id
     // propagates into turn metadata and all lifecycle events.
-    const consumed = consumeNextApprovedIntent(root, { role: roleId });
+    const consumed = consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null });
     let assignedState;
     let turnId;
     let assignedRole = roleId;

package/src/commands/resume.js

@@ -267,7 +267,9 @@ export async function resumeCommand(opts) {
   }
 
   const shouldBindIntent = opts.intent !== false;
-  const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+  const consumed = shouldBindIntent
+    ? consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null })
+    : { ok: false };
   if (consumed.ok) {
     state = loadProjectState(root, config);
     if (!state) {

package/src/commands/status.js

@@ -147,7 +147,7 @@ function renderGovernedStatus(context, opts) {
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
   const humanEscalation = findCurrentHumanEscalation(root, state);
   const preemptionMarker = readPreemptionMarker(root);
-  const pendingIntents = findPendingApprovedIntents(root);
+  const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId || null });
   const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
     ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)

package/src/commands/step.js

@@ -316,7 +316,9 @@ export async function stepCommand(opts) {
       }
 
       const shouldBindIntent = opts.intent !== false;
-      const consumed = shouldBindIntent ? consumeNextApprovedIntent(root, { role: roleId }) : { ok: false };
+      const consumed = shouldBindIntent
+        ? consumeNextApprovedIntent(root, { role: roleId, run_id: state?.run_id || null })
+        : { ok: false };
       if (consumed.ok) {
         state = loadProjectState(root, config);
         if (!state) {

package/src/lib/continuous-run.js

@@ -350,8 +350,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: false, status: 'failed', action: 'vision_missing', stop_reason: `VISION.md not found at ${absVisionPath}` };
   }
 
-  // Step 1: Check intake queue for pending work
-  const queued = findNextDispatchableIntent(root);
+  // Step 1: Check intake queue for pending work (BUG-34: scope to current run)
+  const queued = findNextDispatchableIntent(root, { run_id: session.current_run_id });
   let targetIntentId = null;
   let visionObjective = null;
 

package/src/lib/dispatch-bundle.js

@@ -332,25 +332,8 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('');
   }
 
-  if (turn.intake_context) {
-    lines.push('### Active Injected Intent — respond to this as your primary charter');
-    lines.push('');
-    if (turn.intake_context.charter) {
-      lines.push(turn.intake_context.charter);
-      lines.push('');
-    }
-    if (Array.isArray(turn.intake_context.acceptance_contract) && turn.intake_context.acceptance_contract.length > 0) {
-      lines.push('Acceptance contract:');
-      turn.intake_context.acceptance_contract.forEach((requirement, index) => {
-        lines.push(`${index + 1}. ${requirement}`);
-      });
-      lines.push('');
-    }
-    lines.push('You must explicitly address every acceptance item in your turn summary, artifacts, or verification evidence. Do not treat this as background context.');
-    lines.push('');
-  }
-
-  // Retry context
+  // BUG-35: retry context must appear BEFORE the injected intent so the agent
+  // sees the blocker (gate failure) first and the repair guidance (intent) second.
   if (turn.attempt > 1 && turn.last_rejection) {
     lines.push('## Previous Attempt Failed');
     lines.push('');
@@ -369,6 +352,24 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('');
   }
 
+  if (turn.intake_context) {
+    lines.push('### Active Injected Intent — respond to this as your primary charter');
+    lines.push('');
+    if (turn.intake_context.charter) {
+      lines.push(turn.intake_context.charter);
+      lines.push('');
+    }
+    if (Array.isArray(turn.intake_context.acceptance_contract) && turn.intake_context.acceptance_contract.length > 0) {
+      lines.push('Acceptance contract:');
+      turn.intake_context.acceptance_contract.forEach((requirement, index) => {
+        lines.push(`${index + 1}. ${requirement}`);
+      });
+      lines.push('');
+    }
+    lines.push('You must explicitly address every acceptance item in your turn summary, artifacts, or verification evidence. Do not treat this as background context.');
+    lines.push('');
+  }
+
   if (turn.conflict_context) {
     lines.push('## File Conflict - Retry Required');
     lines.push('');

package/src/lib/governed-state.js

@@ -2154,6 +2154,42 @@ export function initializeGovernedRun(root, config, options = {}) {
   };
 
   writeState(root, updatedState);
+
+  // BUG-34: retroactive migration — archive stale intents from prior runs.
+  // Intents with an approved_run_id from a DIFFERENT run are archived.
+  // Intents with no approved_run_id are adopted into the current run
+  // (they were created while the project was idle or pre-run).
+  try {
+    const intentsDir = join(root, '.agentxchain', 'intake', 'intents');
+    if (existsSync(intentsDir)) {
+      const DISPATCHABLE = new Set(['planned', 'approved']);
+      const intNow = new Date().toISOString();
+      for (const f of readdirSync(intentsDir).filter(x => x.endsWith('.json') && !x.startsWith('.tmp-'))) {
+        const ip = join(intentsDir, f);
+        try {
+          const intent = JSON.parse(readFileSync(ip, 'utf8'));
+          if (!intent || !DISPATCHABLE.has(intent.status)) continue;
+          if (intent.cross_run_durable === true) continue;
+          if (intent.approved_run_id === runId) continue;
+
+          if (intent.approved_run_id && intent.approved_run_id !== runId) {
+            // Intent from a different run — archive it
+            intent.status = 'suppressed';
+            intent.updated_at = intNow;
+            intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${runId} initialization`;
+            if (!intent.history) intent.history = [];
+            intent.history.push({ from: 'approved', to: 'suppressed', at: intNow, reason: intent.archived_reason });
+          } else if (!intent.approved_run_id) {
+            // Legacy intent with no run binding — adopt into current run
+            intent.approved_run_id = runId;
+            intent.updated_at = intNow;
+          }
+          safeWriteJson(ip, intent);
+        } catch { /* non-fatal per-intent */ }
+      }
+    }
+  } catch { /* non-fatal — intent migration is best-effort */ }
+
   emitRunEvent(root, 'run_started', {
     run_id: runId,
     phase: updatedState.phase,
@@ -3107,6 +3143,70 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // ── Gate semantic coverage validation (BUG-36) ────────────────────────────
+  // When a turn proposes a phase transition, pre-evaluate the gate. If the gate
+  // would fail AND the failing files are not in files_changed, reject the turn
+  // early — the agent didn't do the work required for the transition.
+  if (turnResult.phase_transition_request) {
+    const preGateResult = evaluatePhaseExit({
+      state,
+      config,
+      acceptedTurn: turnResult,
+      root,
+    });
+
+    if (preGateResult.action === 'gate_failed') {
+      // Gate is failing. Check if any of the failing reasons reference files
+      // that this turn didn't modify.
+      const declaredFiles = new Set((turnResult.files_changed || []).map(f => f.replace(/^\.\//, '')));
+      const exitGateId = preGateResult.gate_id || 'unknown_gate';
+
+      // Extract file paths from gate failure reasons and missing_files
+      const failingFiles = [
+        ...(preGateResult.missing_files || []),
+      ];
+
+      // Also extract file paths from failure reasons (e.g., ".planning/IMPLEMENTATION_NOTES.md: ...")
+      for (const reason of (preGateResult.reasons || [])) {
+        const fileMatch = reason.match(/(?:Required file missing|file): ([^\s,]+)/);
+        if (fileMatch) failingFiles.push(fileMatch[1]);
+        // Also catch paths at the start of semantic failure messages
+        const semanticMatch = reason.match(/^([^\s:]+\.md):/);
+        if (semanticMatch) failingFiles.push(semanticMatch[1]);
+      }
+
+      const uniqueFailingFiles = [...new Set(failingFiles.map(f => f.replace(/^\.\//, '')))];
+      const uncoveredFiles = uniqueFailingFiles.filter(f => !declaredFiles.has(f));
+
+      const gateSemanticMode = config.gate_semantic_coverage_mode || 'strict';
+      if (uncoveredFiles.length > 0 && gateSemanticMode === 'strict') {
+        const coverageError = `Gate "${exitGateId}" is failing on ${uncoveredFiles.join(', ')}. Your turn did not modify ${uncoveredFiles.length === 1 ? 'that file' : 'those files'}. Either edit the file(s) to satisfy the gate, or remove the phase transition request.`;
+        transitionToFailedAcceptance(root, state, currentTurn, coverageError, {
+          error_code: 'gate_semantic_coverage',
+          stage: 'gate_semantic_coverage',
+          extra: {
+            gate_id: exitGateId,
+            uncovered_files: uncoveredFiles,
+            declared_files: [...declaredFiles],
+            gate_reasons: preGateResult.reasons,
+          },
+        });
+        return {
+          ok: false,
+          error: coverageError,
+          validation: {
+            ...validation,
+            ok: false,
+            stage: 'gate_semantic_coverage',
+            error_class: 'gate_coverage_error',
+            errors: uncoveredFiles.map(f => `Gate "${exitGateId}" is failing on "${f}". Your turn did not modify that file.`),
+            warnings: [],
+          },
+        };
+      }
+    }
+  }
+
   const observedArtifact = buildObservedArtifact(observation, baseline);
   const normalizedVerification = normalizeVerification(turnResult.verification, runtimeType);
   const artifactType = turnResult.artifact?.type || 'review';

package/src/lib/intake.js

@@ -504,15 +504,35 @@ export function intakeStatus(root, intentId) {
   return { ok: true, summary, exitCode: 0 };
 }
 
-export function findNextDispatchableIntent(root) {
+export function findNextDispatchableIntent(root, options = {}) {
   const dirs = intakeDirs(root);
   if (!existsSync(dirs.intents)) {
     return { ok: false, error: 'no intents directory' };
   }
 
-  const intents = readJsonDir(dirs.intents)
+  const scopeRunId = options.run_id || null;
+
+  let intents = readJsonDir(dirs.intents)
     .filter((intent) => intent && DISPATCHABLE_STATUSES.has(intent.status));
 
+  // BUG-34: when run_id scoping is active, filter out intents that belong to
+  // a different run. An intent belongs to the current run if:
+  //   (a) it has approved_run_id matching the current run, OR
+  //   (b) it has no approved_run_id AND is marked cross_run_durable, OR
+  //   (c) it was injected in the current run (approved_run_id matches)
+  // Legacy intents (no approved_run_id, no cross_run_durable) are excluded
+  // because they are stale leftovers from prior runs.
+  if (scopeRunId) {
+    intents = intents.filter((intent) => {
+      if (intent.approved_run_id === scopeRunId) return true;
+      if (intent.cross_run_durable === true) return true;
+      // Legacy intent with no run binding — stale, skip it
+      if (!intent.approved_run_id) return false;
+      // Intent bound to a different run — stale, skip it
+      return false;
+    });
+  }
+
   if (intents.length === 0) {
     return { ok: false, error: 'no dispatchable intents' };
   }
@@ -550,12 +570,23 @@ export function findNextDispatchableIntent(root) {
  * Return all approved-but-unconsumed intents sorted by priority (BUG-15).
  * Used by `status` to surface the pending intent queue.
  */
-export function findPendingApprovedIntents(root) {
+export function findPendingApprovedIntents(root, options = {}) {
   const dirs = intakeDirs(root);
   if (!existsSync(dirs.intents)) return [];
 
+  const scopeRunId = options.run_id || null;
+
   return readJsonDir(dirs.intents)
-    .filter((intent) => intent && intent.status === 'approved')
+    .filter((intent) => {
+      if (!intent || intent.status !== 'approved') return false;
+      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent
+      if (scopeRunId) {
+        if (intent.approved_run_id === scopeRunId) return true;
+        if (intent.cross_run_durable === true) return true;
+        return false;
+      }
+      return true;
+    })
     .sort((a, b) => {
       const aPriority = PRIORITY_RANK[a.priority] ?? Number.MAX_SAFE_INTEGER;
       const bPriority = PRIORITY_RANK[b.priority] ?? Number.MAX_SAFE_INTEGER;
@@ -574,6 +605,59 @@ export function findPendingApprovedIntents(root) {
     }));
 }
 
+/**
+ * BUG-34: Archive stale intents from prior runs.
+ * Called during run initialization to prevent cross-run intent leakage.
+ * Transitions approved/planned intents that don't belong to the new run into
+ * 'suppressed' status with an archival reason.
+ *
+ * @param {string} root
+ * @param {string} newRunId - the run_id of the newly initialized run
+ * @returns {{ archived: number }}
+ */
+export function archiveStaleIntents(root, newRunId) {
+  const dirs = intakeDirs(root);
+  if (!existsSync(dirs.intents)) return { archived: 0, adopted: 0 };
+
+  const now = nowISO();
+  let archived = 0;
+  let adopted = 0;
+
+  const files = readdirSync(dirs.intents).filter(f => f.endsWith('.json') && !f.startsWith('.tmp-'));
+  for (const file of files) {
+    const intentPath = join(dirs.intents, file);
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    if (!intent || !DISPATCHABLE_STATUSES.has(intent.status)) continue;
+    if (intent.cross_run_durable === true) continue;
+    if (intent.approved_run_id === newRunId) continue;
+
+    if (intent.approved_run_id && intent.approved_run_id !== newRunId) {
+      // Intent from a different run — archive it
+      intent.status = 'suppressed';
+      intent.updated_at = now;
+      intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${newRunId} initialization`;
+      if (!intent.history) intent.history = [];
+      intent.history.push({ from: 'approved', to: 'suppressed', at: now, reason: intent.archived_reason });
+      safeWriteJson(intentPath, intent);
+      archived++;
+    } else if (!intent.approved_run_id) {
+      // Legacy intent with no run binding — adopt into current run
+      intent.approved_run_id = newRunId;
+      intent.updated_at = now;
+      safeWriteJson(intentPath, intent);
+      adopted++;
+    }
+  }
+
+  return { archived, adopted };
+}
+
 /**
  * Unified intent consumption entry point (BUG-16).
  * Both manual (resume/step --resume) and continuous/scheduler paths should call
@@ -584,7 +668,22 @@ export function findPendingApprovedIntents(root) {
  * @returns {{ ok: boolean, intentId?: string, intent?: object, error?: string }}
  */
 export function consumeNextApprovedIntent(root, options = {}) {
-  const queued = findNextDispatchableIntent(root);
+  let runId = options.run_id || null;
+  if (!runId) {
+    try {
+      const context = loadProjectContext(root);
+      const state = context ? loadProjectState(root, context.config) : null;
+      runId = state?.run_id || null;
+    } catch {
+      runId = null;
+    }
+  }
+
+  if (runId && options.auto_archive_stale !== false) {
+    archiveStaleIntents(root, runId);
+  }
+
+  const queued = findNextDispatchableIntent(root, { run_id: runId });
   if (!queued.ok) {
     return { ok: false, error: queued.error || 'no dispatchable intents' };
   }
@@ -717,6 +816,23 @@ export function approveIntent(root, intentId, options = {}) {
   const reason = options.reason || (previousStatus === 'blocked' ? 're-approved after block resolution' : 'approved for planning');
   const now = nowISO();
 
+  // BUG-34: stamp the current run_id on approval so the intent is scoped to
+  // the run that approved it. Intents without approved_run_id are treated as
+  // legacy/unbound and filtered out by run-scoped queries.
+  if (!intent.approved_run_id) {
+    const statePath = join(root, '.agentxchain', 'state.json');
+    if (existsSync(statePath)) {
+      try {
+        const state = JSON.parse(readFileSync(statePath, 'utf8'));
+        if (state.run_id) {
+          intent.approved_run_id = state.run_id;
+        }
+      } catch {
+        // non-fatal — stamp is best-effort during approval
+      }
+    }
+  }
+
   intent.status = 'approved';
   intent.approved_by = approver;
   intent.updated_at = now;