agentxchain 2.128.0 → 2.130.0

package/src/lib/governed-state.js

@@ -26,6 +26,7 @@ import { evaluatePolicies } from './policy-evaluator.js';
 import { buildTimeoutBlockedReason, evaluateTimeouts } from './timeout-evaluator.js';
 import {
   captureBaseline,
+  captureDirtyWorkspaceSnapshot,
   observeChanges,
   attributeObservedChangesToTurn,
   buildConflictCandidateFiles,
@@ -35,6 +36,7 @@ import {
   compareDeclaredVsObserved,
   deriveAcceptedRef,
   checkCleanBaseline,
+  isOperationalPath,
 } from './repo-observer.js';
 import { getMaxConcurrentTurns } from './normalized-config.js';
 import { getTurnStagingResultPath, getTurnStagingDir, getDispatchTurnDir, getReviewArtifactPath } from './turn-paths.js';
@@ -60,6 +62,7 @@ import {
   summarizeVerificationReplay,
 } from './verification-replay.js';
 import { executeGateActions } from './gate-actions.js';
+import { detectPendingCheckpoint } from './turn-checkpoint.js';
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
@@ -403,6 +406,32 @@ export function getActiveTurn(state) {
   return turns.length === 1 ? turns[0] : null;
 }
 
+/**
+ * BUG-18: Detect state/bundle desync — every active turn referenced in
+ * state.json must have a corresponding dispatch bundle directory on disk.
+ *
+ * @param {string} root - project root
+ * @param {object} state - governed state
+ * @returns {{ ok: boolean, desynced: Array<{ turn_id: string, role: string, expected_path: string }> }}
+ */
+export function detectStateBundleDesync(root, state) {
+  const activeTurns = getActiveTurns(state);
+  const desynced = [];
+
+  for (const [turnId, turn] of Object.entries(activeTurns)) {
+    const bundleDir = join(root, '.agentxchain', 'dispatch', 'turns', turnId);
+    if (!existsSync(bundleDir)) {
+      desynced.push({
+        turn_id: turnId,
+        role: turn.assigned_role || 'unknown',
+        expected_path: `.agentxchain/dispatch/turns/${turnId}`,
+      });
+    }
+  }
+
+  return { ok: desynced.length === 0, desynced };
+}
+
 function resolveRecoveryTurnId(state, preferredTurnId = null) {
   const activeTurns = getActiveTurns(state);
   if (preferredTurnId && activeTurns[preferredTurnId]) {
@@ -2059,7 +2088,7 @@ export function initializeGovernedRun(root, config, options = {}) {
  * @param {string} roleId - the role to assign
  * @returns {{ ok: boolean, error?: string, warnings?: string[], state?: object }}
  */
-export function assignGovernedTurn(root, config, roleId) {
+export function assignGovernedTurn(root, config, roleId, options = {}) {
   let state = readState(root);
   if (!state) {
     return { ok: false, error: 'No governed state.json found' };
@@ -2161,6 +2190,10 @@ export function assignGovernedTurn(root, config, roleId) {
   const writeAuthority = role.write_authority || 'review_only';
   const cleanCheck = checkCleanBaseline(root, writeAuthority);
   if (!cleanCheck.clean) {
+    const pendingCheckpoint = detectPendingCheckpoint(root, cleanCheck.dirty_files || []);
+    if (pendingCheckpoint.required) {
+      return { ok: false, error: pendingCheckpoint.message, error_code: 'checkpoint_required' };
+    }
     return { ok: false, error: cleanCheck.reason };
   }
 
@@ -2243,6 +2276,9 @@ export function assignGovernedTurn(root, config, roleId) {
     assigned_sequence: nextSequence,
     concurrent_with: concurrentWith,
   };
+  if (options.intakeContext) {
+    newTurn.intake_context = options.intakeContext;
+  }
 
   // Attach delegation context if this turn fulfills a pending delegation
   const delegationQueue = state.delegation_queue || [];
@@ -2288,12 +2324,15 @@ export function assignGovernedTurn(root, config, roleId) {
     phase: updatedState.phase,
     status: updatedState.status,
     turn: { turn_id: turnId, role_id: roleId },
+    intent_id: options.intakeContext?.intent_id || null,
   });
 
-  // Session checkpoint — non-fatal, written after every successful turn assignment
+  // Session checkpoint — non-fatal, written after every successful turn assignment.
+  // Pass the captured baseline so session.json agrees with state.json (BUG-2 fix).
   writeSessionCheckpoint(root, updatedState, 'turn_assigned', {
     role: roleId,
     dispatch_dir: `.agentxchain/dispatch/turns/${turnId}`,
+    turn_baseline: baseline,
   });
 
   const assignedTurn = updatedState.active_turns[turnId];
@@ -2304,6 +2343,274 @@ export function assignGovernedTurn(root, config, roleId) {
   return result;
 }
 
+/**
+ * Refresh a turn's baseline dirty_snapshot to include files that became dirty
+ * between assignment and dispatch. This prevents acceptance from blaming the
+ * turn for operator edits made while the turn was pending (BUG-1 fix).
+ *
+ * Merges new dirty entries into the existing snapshot — existing entries are
+ * preserved, new entries are added. The baseline.clean flag is updated to
+ * reflect the merged snapshot.
+ *
+ * @param {string} root - project root
+ * @param {string} [turnId] - specific turn to refresh (defaults to single active turn)
+ * @returns {{ ok: boolean, refreshed_files?: string[], error?: string }}
+ */
+export function refreshTurnBaselineSnapshot(root, turnId) {
+  const state = readState(root);
+  if (!state) return { ok: false, error: 'No governed state found' };
+
+  const activeTurns = getActiveTurns(state);
+  const resolvedTurnId = turnId || Object.keys(activeTurns)[0];
+  if (!resolvedTurnId) return { ok: false, error: 'No active turn to refresh' };
+
+  const turn = activeTurns[resolvedTurnId];
+  if (!turn) return { ok: false, error: `Turn ${resolvedTurnId} not found in active turns` };
+  if (!turn.baseline) return { ok: false, error: 'Turn has no baseline to refresh' };
+
+  const currentSnapshot = captureDirtyWorkspaceSnapshot(root);
+  const existingSnapshot = turn.baseline.dirty_snapshot || {};
+  const merged = { ...existingSnapshot };
+  const refreshedFiles = [];
+
+  for (const [filePath, marker] of Object.entries(currentSnapshot)) {
+    if (!(filePath in merged)) {
+      merged[filePath] = marker;
+      refreshedFiles.push(filePath);
+    }
+  }
+
+  if (refreshedFiles.length === 0) {
+    return { ok: true, refreshed_files: [] };
+  }
+
+  // Update the turn's baseline with the merged snapshot
+  const updatedTurn = {
+    ...turn,
+    baseline: {
+      ...turn.baseline,
+      dirty_snapshot: merged,
+      // Recalculate clean: filter out operational and baseline-exempt paths
+      clean: Object.keys(merged).filter(f => !isOperationalPath(f)).length === 0,
+    },
+  };
+
+  const updatedState = {
+    ...state,
+    active_turns: {
+      ...activeTurns,
+      [resolvedTurnId]: updatedTurn,
+    },
+  };
+  writeState(root, updatedState);
+
+  return { ok: true, refreshed_files: refreshedFiles };
+}
+
+/**
+ * Reissue an active turn against current repo state.
+ *
+ * Invalidates the current turn, archives its state, captures a fresh baseline
+ * from current HEAD/workspace, and creates a new turn with the same role and
+ * phase. Covers baseline drift, runtime drift, authority drift, and operator-
+ * initiated reissue. (BUG-7 fix)
+ *
+ * @param {string} root - project root
+ * @param {object} config - normalized config
+ * @param {object} opts
+ * @param {string} [opts.turnId] - specific turn to reissue
+ * @param {string} [opts.reason] - reason for reissue
+ * @returns {{ ok: boolean, state?: object, newTurn?: object, baselineDelta?: object, error?: string }}
+ */
+/**
+ * Detect runtime/authority drift for all active turns against current config.
+ * Returns an array of drift descriptors. Empty array = no drift.
+ */
+export function detectActiveTurnBindingDrift(state, config) {
+  const activeTurns = getActiveTurns(state);
+  const drifts = [];
+
+  for (const turn of Object.values(activeTurns)) {
+    const roleId = turn.assigned_role;
+    const role = config.roles?.[roleId];
+    if (!role) continue;
+
+    const currentRuntimeId = role.runtime_id || role.runtime;
+    const currentAuthority = role.write_authority;
+    const turnRuntimeId = turn.runtime_id;
+
+    const runtimeChanged = currentRuntimeId && turnRuntimeId && currentRuntimeId !== turnRuntimeId;
+    const authorityChanged = currentAuthority && turn.write_authority && currentAuthority !== turn.write_authority;
+
+    // Check runtime type change even if runtime_id matches
+    const currentRuntimeType = config.runtimes?.[currentRuntimeId]?.type;
+    const turnRuntimeType = config.runtimes?.[turnRuntimeId]?.type;
+    const runtimeTypeChanged = currentRuntimeType && turnRuntimeType && currentRuntimeType !== turnRuntimeType;
+
+    if (runtimeChanged || authorityChanged || runtimeTypeChanged) {
+      drifts.push({
+        turn_id: turn.turn_id,
+        role_id: roleId,
+        runtime_changed: Boolean(runtimeChanged || runtimeTypeChanged),
+        old_runtime: turnRuntimeId,
+        new_runtime: currentRuntimeId,
+        authority_changed: Boolean(authorityChanged),
+        old_authority: turn.write_authority,
+        new_authority: currentAuthority,
+        recovery_command: `agentxchain reissue-turn --turn ${turn.turn_id} --reason "config rebinding"`,
+      });
+    }
+  }
+
+  return drifts;
+}
+
+export function reissueTurn(root, config, opts = {}) {
+  const state = readState(root);
+  if (!state) return { ok: false, error: 'No governed state found' };
+
+  const activeTurns = getActiveTurns(state);
+  const turnId = opts.turnId || Object.keys(activeTurns)[0];
+  if (!turnId) return { ok: false, error: 'No active turn to reissue' };
+
+  const oldTurn = activeTurns[turnId];
+  if (!oldTurn) return { ok: false, error: `Turn ${turnId} not found in active turns` };
+
+  const roleId = oldTurn.assigned_role;
+  const role = config.roles?.[roleId];
+  if (!role) return { ok: false, error: `Role "${roleId}" not found in config` };
+
+  const reason = opts.reason || 'operator-initiated reissue';
+  const now = new Date().toISOString();
+
+  // Capture old baseline for delta computation
+  const oldBaseline = oldTurn.baseline || {};
+  const oldRuntimeId = oldTurn.runtime_id;
+
+  // Resolve current runtime binding (may have changed in config)
+  const currentRuntimeId = role.runtime;
+  const currentRuntime = config.runtimes?.[currentRuntimeId];
+  if (!currentRuntime) {
+    return { ok: false, error: `Runtime "${currentRuntimeId}" not found in config for role "${roleId}"` };
+  }
+
+  // Capture fresh baseline
+  const newBaseline = captureBaseline(root);
+
+  // Archive the old turn as a history entry
+  appendJsonl(root, HISTORY_PATH, {
+    turn_id: oldTurn.turn_id,
+    run_id: state.run_id,
+    role: roleId,
+    phase: state.phase,
+    status: 'reissued',
+    summary: `Turn reissued: ${reason}`,
+    files_changed: [],
+    assigned_sequence: oldTurn.assigned_sequence,
+    accepted_at: now,
+    duration_ms: oldTurn.started_at ? Date.now() - new Date(oldTurn.started_at).getTime() : 0,
+    reissue_reason: reason,
+  });
+
+  // Decision ledger entry
+  appendJsonl(root, LEDGER_PATH, {
+    timestamp: now,
+    decision: 'turn_reissued',
+    turn_id: oldTurn.turn_id,
+    role: roleId,
+    phase: state.phase,
+    reason,
+    old_baseline: {
+      head_ref: oldBaseline.head_ref,
+      clean: oldBaseline.clean,
+    },
+    new_baseline: {
+      head_ref: newBaseline.head_ref,
+      clean: newBaseline.clean,
+    },
+  });
+
+  // Create the new turn
+  const newTurnId = `turn_${randomBytes(8).toString('hex')}`;
+  const timeoutMinutes = 20;
+  const nextSequence = (state.turn_sequence || 0) + 1;
+
+  const newTurn = {
+    turn_id: newTurnId,
+    assigned_role: roleId,
+    status: 'running',
+    attempt: (oldTurn.attempt || 1) + 1,
+    started_at: now,
+    deadline_at: new Date(Date.now() + timeoutMinutes * 60 * 1000).toISOString(),
+    runtime_id: currentRuntimeId,
+    baseline: newBaseline,
+    assigned_sequence: nextSequence,
+    concurrent_with: Object.keys(activeTurns).filter(id => id !== turnId),
+    reissued_from: oldTurn.turn_id,
+  };
+
+  // Copy delegation context if present
+  if (oldTurn.delegation_context) {
+    newTurn.delegation_context = oldTurn.delegation_context;
+  }
+
+  // Remove old turn, add new turn
+  const newActiveTurns = { ...activeTurns };
+  delete newActiveTurns[turnId];
+  newActiveTurns[newTurnId] = newTurn;
+
+  const updatedState = {
+    ...state,
+    turn_sequence: nextSequence,
+    active_turns: newActiveTurns,
+  };
+
+  writeState(root, updatedState);
+
+  // Emit event
+  emitRunEvent(root, 'turn_reissued', {
+    run_id: state.run_id,
+    phase: state.phase,
+    status: state.status,
+    turn: { turn_id: newTurnId, role_id: roleId },
+    intent_id: oldTurn.intake_context?.intent_id || null,
+    payload: {
+      old_turn_id: oldTurn.turn_id,
+      reason,
+      old_head: oldBaseline.head_ref,
+      new_head: newBaseline.head_ref,
+      old_runtime: oldRuntimeId,
+      new_runtime: currentRuntimeId,
+    },
+  });
+
+  // Session checkpoint
+  writeSessionCheckpoint(root, updatedState, 'turn_reissued', {
+    role: roleId,
+    turn_baseline: newBaseline,
+  });
+
+  // Compute baseline delta for display
+  const baselineDelta = {
+    head_changed: oldBaseline.head_ref !== newBaseline.head_ref,
+    old_head: oldBaseline.head_ref,
+    new_head: newBaseline.head_ref,
+    runtime_changed: oldRuntimeId !== currentRuntimeId,
+    old_runtime: oldRuntimeId,
+    new_runtime: currentRuntimeId,
+    dirty_files_changed: JSON.stringify(oldBaseline.dirty_snapshot || {}) !== JSON.stringify(newBaseline.dirty_snapshot || {}),
+    added_dirty_files: Object.keys(newBaseline.dirty_snapshot || {}).filter(f => !(f in (oldBaseline.dirty_snapshot || {}))),
+    removed_dirty_files: Object.keys(oldBaseline.dirty_snapshot || {}).filter(f => !(f in (newBaseline.dirty_snapshot || {}))),
+  };
+
+  return {
+    ok: true,
+    state: attachLegacyCurrentTurnAlias(updatedState),
+    newTurn,
+    baselineDelta,
+  };
+}
+
 /**
  * Estimate the budget for a single turn based on role/runtime configuration.
  * Used for DEC-PARALLEL-011 budget reservation.
@@ -2366,6 +2673,51 @@ export function acceptGovernedTurn(root, config, opts = {}) {
   }
 }
 
+/**
+ * Transition an active turn to failed_acceptance and emit the corresponding
+ * event. Called from acceptance failure paths so the turn is never left stuck
+ * in 'running' after the subprocess has exited (BUG-3 + BUG-4 fix).
+ */
+function transitionToFailedAcceptance(root, state, turn, reason, details = {}) {
+  const activeTurns = getActiveTurns(state);
+  const updatedTurn = {
+    ...turn,
+    status: 'failed_acceptance',
+    failed_at: new Date().toISOString(),
+    failure_reason: reason,
+  };
+  const updatedState = {
+    ...state,
+    active_turns: {
+      ...activeTurns,
+      [turn.turn_id]: updatedTurn,
+    },
+  };
+  writeState(root, updatedState);
+
+  // BUG-4: emit acceptance_failed event
+  emitRunEvent(root, 'acceptance_failed', {
+    run_id: state.run_id,
+    phase: state.phase,
+    status: state.status,
+    turn: { turn_id: turn.turn_id, role_id: turn.assigned_role },
+    intent_id: turn.intake_context?.intent_id || null,
+    payload: {
+      reason,
+      error_code: details.error_code || 'acceptance_failed',
+      stage: details.stage || 'unknown',
+      ...details.extra,
+    },
+  });
+
+  // Session checkpoint for recovery
+  writeSessionCheckpoint(root, updatedState, 'acceptance_failed', {
+    role: turn.assigned_role,
+  });
+
+  return updatedState;
+}
+
 function _acceptGovernedTurnLocked(root, config, opts) {
   // Re-read state under lock (a sibling acceptance may have committed)
   let state = readState(root);
@@ -2433,7 +2785,25 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   }
 
   const turnStagingPath = getTurnStagingResultPath(currentTurn.turn_id);
-  const resolvedStagingPath = existsSync(join(root, turnStagingPath)) ? turnStagingPath : STAGING_PATH;
+  let resolvedStagingPath = existsSync(join(root, turnStagingPath)) ? turnStagingPath : STAGING_PATH;
+  // BUG-22: verify legacy staging file belongs to the active turn before consuming
+  if (resolvedStagingPath === STAGING_PATH) {
+    try {
+      const legacyAbs = join(root, STAGING_PATH);
+      if (existsSync(legacyAbs)) {
+        const raw = JSON.parse(readFileSync(legacyAbs, 'utf8'));
+        if (raw.turn_id && raw.turn_id !== currentTurn.turn_id) {
+          return {
+            ok: false,
+            error: `Stale staging data: ${STAGING_PATH} contains turn_id "${raw.turn_id}" but active turn is "${currentTurn.turn_id}". Remove the stale file or use the turn-scoped staging path.`,
+            error_code: 'stale_staging',
+          };
+        }
+      }
+    } catch {
+      // Parse error handled by downstream validation
+    }
+  }
   const stagedTurn = loadHookStagedTurn(root, resolvedStagingPath);
   const validationState = attachLegacyCurrentTurnAlias({
     ...state,
@@ -2526,9 +2896,15 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   }
 
   if (!validation.ok) {
+    const failError = `Validation failed at stage ${validation.stage}: ${validation.errors.join('; ')}`;
+    transitionToFailedAcceptance(root, state, currentTurn, failError, {
+      error_code: 'validation_failed',
+      stage: validation.stage,
+      extra: { errors: validation.errors },
+    });
     return {
       ok: false,
-      error: `Validation failed at stage ${validation.stage}: ${validation.errors.join('; ')}`,
+      error: failError,
       validation,
     };
   }
@@ -2541,9 +2917,14 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       if (dec.overrides) {
         const overrideCheck = validateOverride(root, { ...dec, role: dec.role || turnResult.role }, config);
         if (!overrideCheck.ok) {
+          const overrideError = `Override validation failed: ${overrideCheck.error}`;
+          transitionToFailedAcceptance(root, state, currentTurn, overrideError, {
+            error_code: 'override_validation_failed',
+            stage: 'override_validation',
+          });
           return {
             ok: false,
-            error: `Override validation failed: ${overrideCheck.error}`,
+            error: overrideError,
             error_code: 'override_validation_failed',
           };
         }
@@ -2598,9 +2979,15 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     },
   );
   if (diffComparison.errors.length > 0) {
+    const mismatchError = `Observed artifact mismatch: ${diffComparison.errors.join('; ')}`;
+    transitionToFailedAcceptance(root, state, currentTurn, mismatchError, {
+      error_code: 'artifact_mismatch',
+      stage: 'artifact_observation',
+      extra: { undeclared_files: diffComparison.errors, warnings: diffComparison.warnings },
+    });
     return {
       ok: false,
-      error: `Observed artifact mismatch: ${diffComparison.errors.join('; ')}`,
+      error: mismatchError,
       validation: {
         ...validation,
         ok: false,
@@ -2612,6 +2999,57 @@ 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;
+  if (intakeCtx && Array.isArray(intakeCtx.acceptance_contract) && intakeCtx.acceptance_contract.length > 0) {
+    const intentCoverage = evaluateIntentCoverage(turnResult, intakeCtx);
+    const priority = intakeCtx.priority || currentTurn.intake_context?.priority || 'p0';
+    const intentCoverageMode = config.intent_coverage_mode
+      || (priority === 'p0' ? 'strict' : 'lenient');
+
+    if (intentCoverage.unaddressed.length > 0) {
+      if (intentCoverageMode === 'strict') {
+        const coverageError = `Intent coverage incomplete: ${intentCoverage.unaddressed.length} acceptance item(s) not addressed: ${intentCoverage.unaddressed.join('; ')}`;
+        transitionToFailedAcceptance(root, state, currentTurn, coverageError, {
+          error_code: 'intent_coverage_incomplete',
+          stage: 'intent_coverage',
+          extra: {
+            intent_id: intakeCtx.intent_id,
+            addressed: intentCoverage.addressed,
+            unaddressed: intentCoverage.unaddressed,
+          },
+        });
+        return {
+          ok: false,
+          error: coverageError,
+          validation: {
+            ...validation,
+            ok: false,
+            stage: 'intent_coverage',
+            error_class: 'intent_coverage_error',
+            errors: [`Unaddressed acceptance items: ${intentCoverage.unaddressed.join('; ')}`],
+            warnings: [],
+          },
+        };
+      }
+      // Lenient mode — emit warning event but allow acceptance to proceed
+      emitRunEvent(root, 'turn_incomplete_intent_coverage', {
+        run_id: state.run_id,
+        phase: state.phase,
+        status: state.status,
+        turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+        intent_id: intakeCtx.intent_id,
+        payload: {
+          addressed: intentCoverage.addressed,
+          unaddressed: intentCoverage.unaddressed,
+          mode: 'lenient',
+        },
+      });
+    }
+  }
+
   const observedArtifact = buildObservedArtifact(observation, baseline);
   const normalizedVerification = normalizeVerification(turnResult.verification, runtimeType);
   const artifactType = turnResult.artifact?.type || 'review';
@@ -2632,9 +3070,15 @@ function _acceptGovernedTurnLocked(root, config, opts) {
 
   if (policyResult.blocks.length > 0) {
     const blockMessages = policyResult.blocks.map((v) => v.message);
+    const policyError = `Policy violation: ${blockMessages.join('; ')}`;
+    transitionToFailedAcceptance(root, state, currentTurn, policyError, {
+      error_code: 'policy_violation',
+      stage: 'policy_evaluation',
+      extra: { violations: policyResult.violations },
+    });
     return {
       ok: false,
-      error: `Policy violation: ${blockMessages.join('; ')}`,
+      error: policyError,
       error_code: 'policy_violation',
       policy_violations: policyResult.violations,
     };
@@ -2848,6 +3292,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     normalized_verification: normalizedVerification,
     ...(verificationReplay ? { verification_replay: summarizeVerificationReplay(verificationReplay) } : {}),
     artifact: turnResult.artifact || {},
+    intent_id: currentTurn.intake_context?.intent_id || null,
     observed_artifact: observedArtifact,
     proposed_next_role: turnResult.proposed_next_role,
     phase_transition_request: turnResult.phase_transition_request,
@@ -3442,6 +3887,106 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // ── BUG-19: Post-acceptance gate reconciliation ────────────────────────
+  // If a previous gate failure is cached in last_gate_failure, re-evaluate
+  // whether the conditions are now satisfied after this turn's artifacts.
+  // This prevents stale gate failures from surviving after a turn fixes them.
+  // Only clear if ALL failure conditions are now resolved.
+  if (updatedState.last_gate_failure && updatedState.status !== 'completed' && updatedState.status !== 'blocked') {
+    const staleGate = updatedState.last_gate_failure;
+    let allConditionsResolved = true;
+
+    // Check if missing_files are now present
+    if (Array.isArray(staleGate.missing_files) && staleGate.missing_files.length > 0) {
+      const stillMissing = staleGate.missing_files.filter(f => !existsSync(join(root, f)));
+      if (stillMissing.length > 0) {
+        allConditionsResolved = false;
+      }
+    }
+
+    // Check if missing_verification is still an issue
+    // Verification failures can only be resolved by the specific gate re-evaluation
+    // during a phase_transition_request, not by post-acceptance reconciliation,
+    // because verification is turn-specific — the prior turn's verification status
+    // is what the gate evaluated, and a different turn's pass doesn't retroactively
+    // fix the prior turn's failure.
+    if (staleGate.missing_verification) {
+      allConditionsResolved = false;
+    }
+
+    // Only clear if there were resolvable conditions and they are all resolved
+    const hadResolvableConditions = Array.isArray(staleGate.missing_files) && staleGate.missing_files.length > 0;
+    if (allConditionsResolved && hadResolvableConditions) {
+      updatedState.last_gate_failure = null;
+      if (staleGate.gate_id) {
+        updatedState.phase_gate_status = {
+          ...(updatedState.phase_gate_status || {}),
+          [staleGate.gate_id]: 'cleared_by_reconciliation',
+        };
+      }
+      ledgerEntries.push({
+        type: 'gate_reconciliation',
+        gate_id: staleGate.gate_id,
+        gate_type: staleGate.gate_type,
+        phase: updatedState.phase,
+        reason: 'post_acceptance_reconciliation',
+        previously_missing_files: staleGate.missing_files || [],
+        reconciled_at: now,
+        reconciled_by_turn: currentTurn.turn_id,
+      });
+    }
+  }
+
+  // ── BUG-20: Post-acceptance intent satisfaction ─────────────────────────
+  // When a turn bound to an injected intent is accepted successfully, transition
+  // the intent to 'completed' so it disappears from the pending queue.
+  if (currentTurn.intake_context?.intent_id) {
+    const intentId = currentTurn.intake_context.intent_id;
+    try {
+      const intentPath = join(root, '.agentxchain', 'intake', 'intents', `${intentId}.json`);
+      if (existsSync(intentPath)) {
+        const intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+        if (intent.status === 'executing') {
+          intent.status = 'completed';
+          intent.completed_at = now;
+          intent.run_completed_at = updatedState.completed_at || now;
+          intent.run_final_turn = currentTurn.turn_id;
+          intent.updated_at = now;
+          intent.satisfying_turn = currentTurn.turn_id;
+          if (!Array.isArray(intent.history)) intent.history = [];
+          intent.history.push({
+            from: 'executing',
+            to: 'completed',
+            at: now,
+            turn_id: currentTurn.turn_id,
+            role: currentTurn.assigned_role,
+            run_id: updatedState.run_id,
+            reason: 'turn accepted — acceptance contract satisfied',
+          });
+          writeFileSync(intentPath, JSON.stringify(intent, null, 2));
+
+          // Create observation scaffold (same as resolve path)
+          const obsDir = join(root, '.agentxchain', 'intake', 'observations', intentId);
+          mkdirSync(obsDir, { recursive: true });
+
+          // Emit intent_satisfied event
+          emitRunEvent(root, 'intent_satisfied', {
+            run_id: updatedState.run_id,
+            phase: updatedState.phase,
+            status: updatedState.status,
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            intent_id: intentId,
+            payload: {
+              satisfying_turn: currentTurn.turn_id,
+            },
+          });
+        }
+      }
+    } catch {
+      // Non-fatal — intent satisfaction is advisory
+    }
+  }
+
   // ── Transaction journal: prepare before committing writes ──────────────
   const transactionId = generateId('txn');
   const journal = {
@@ -3558,6 +4103,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     phase: updatedState.phase,
     status: updatedState.status,
     turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+    intent_id: currentTurn.intake_context?.intent_id || null,
     payload: turnAcceptedPayload,
   });
 
@@ -3576,6 +4122,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       phase: updatedState.phase,
       status: 'blocked',
       turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+      intent_id: currentTurn.intake_context?.intent_id || null,
       payload: { category: updatedState.blocked_reason?.category || 'needs_human' },
     });
   }
@@ -3765,15 +4312,19 @@ export function rejectGovernedTurn(root, config, validationResult, reasonOrOptio
       conflict_context: conflictContext,
     };
 
+    // BUG-8 fix: ALWAYS refresh the baseline on retry, not just for conflict rejects.
+    // A retry is a new attempt — it must start from current repo state, not the
+    // moment the failed attempt was originally dispatched.
+    const retryStartedAt = new Date().toISOString();
+    retryTurn.baseline = captureBaseline(root);
+    retryTurn.started_at = retryStartedAt;
+    retryTurn.deadline_at = new Date(Date.now() + 20 * 60 * 1000).toISOString();
+
     if (isConflictReject) {
-      const retryStartedAt = new Date().toISOString();
-      retryTurn.baseline = captureBaseline(root);
       retryTurn.assigned_sequence = Math.max(
         state.turn_sequence || 0,
         currentTurn.assigned_sequence || 0,
       );
-      retryTurn.started_at = retryStartedAt;
-      retryTurn.deadline_at = new Date(Date.now() + 20 * 60 * 1000).toISOString();
       retryTurn.concurrent_with = Object.keys(getActiveTurns(state)).filter((turnId) => turnId !== currentTurn.turn_id);
     }
 
@@ -3796,6 +4347,7 @@ export function rejectGovernedTurn(root, config, validationResult, reasonOrOptio
       phase: updatedState.phase,
       status: updatedState.status,
       turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+      intent_id: currentTurn.intake_context?.intent_id || null,
       payload: {
         attempt: currentAttempt,
         retrying: true,
@@ -3869,6 +4421,7 @@ export function rejectGovernedTurn(root, config, validationResult, reasonOrOptio
     phase: updatedState.phase,
     status: 'blocked',
     turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+    intent_id: currentTurn.intake_context?.intent_id || null,
     payload: {
       attempt: currentAttempt,
       retrying: false,
@@ -3882,6 +4435,7 @@ export function rejectGovernedTurn(root, config, validationResult, reasonOrOptio
     run_id: updatedState.run_id,
     phase: updatedState.phase,
     status: 'blocked',
+    intent_id: currentTurn.intake_context?.intent_id || null,
     payload: { category: 'retries_exhausted' },
   });
 
@@ -4268,6 +4822,65 @@ function deriveNextRecommendedRole(turnResult, state, config) {
   return routing?.entry_role || null;
 }
 
+// ── Intent coverage evaluation (BUG-14) ──────────────────────────────────────
+//
+// Checks whether a turn result addresses the acceptance items from an injected
+// intent.  Uses a hybrid approach: structural (`intent_response` field) first,
+// with semantic fallback scanning `summary`, `decisions`, and `files_changed`.
+
+function evaluateIntentCoverage(turnResult, intakeContext) {
+  const acceptanceItems = intakeContext.acceptance_contract || [];
+  const addressed = [];
+  const unaddressed = [];
+
+  // Build the structural response map if present
+  const responseMap = new Map();
+  if (Array.isArray(turnResult.intent_response)) {
+    for (const entry of turnResult.intent_response) {
+      if (entry && typeof entry.item === 'string' && typeof entry.status === 'string') {
+        responseMap.set(entry.item.toLowerCase().trim(), entry);
+      }
+    }
+  }
+
+  // Build a searchable corpus from the turn result for semantic fallback
+  const corpus = [
+    turnResult.summary || '',
+    ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
+    ...(turnResult.objections || []).map(o => o.statement || ''),
+    ...(turnResult.files_changed || []),
+    ...(turnResult.artifacts_created || []),
+    ...(Array.isArray(turnResult.intent_response) ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`) : []),
+  ].join('\n').toLowerCase();
+
+  for (const item of acceptanceItems) {
+    const normalizedItem = item.toLowerCase().trim();
+
+    // Check 1: Structural — intent_response field with explicit status
+    const structuralEntry = responseMap.get(normalizedItem);
+    if (structuralEntry && ['addressed', 'deferred', 'rejected'].includes(structuralEntry.status)) {
+      addressed.push(item);
+      continue;
+    }
+
+    // Check 2: Semantic fallback — significant keyword overlap
+    const words = normalizedItem.split(/\s+/).filter(w => w.length > 3);
+    if (words.length === 0) {
+      addressed.push(item);
+      continue;
+    }
+    const matchedWords = words.filter(w => corpus.includes(w));
+    const coverage = matchedWords.length / words.length;
+    if (coverage >= 0.5) {
+      addressed.push(item);
+    } else {
+      unaddressed.push(item);
+    }
+  }
+
+  return { addressed, unaddressed };
+}
+
 export {
   STATE_PATH,
   HISTORY_PATH,