agentxchain 2.135.0 → 2.136.0

package/src/lib/governed-state.js

@@ -46,6 +46,10 @@ import { emitRunEvent } from './run-events.js';
 import { writeSessionCheckpoint } from './session-checkpoint.js';
 import { recordRunHistory } from './run-history.js';
 import { buildDefaultRunProvenance } from './run-provenance.js';
+import {
+  archiveStaleIntentsForRun,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 import {
   ensureHumanEscalation,
   findCurrentHumanEscalation,
@@ -1243,6 +1247,13 @@ function buildConflictContext(turn) {
         files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
       }))
     : [];
+  const forwardRevisionTurnsSince = Array.isArray(conflictError.forward_revision_turns)
+    ? conflictError.forward_revision_turns.map((entry) => ({
+        turn_id: entry.turn_id,
+        role: entry.role,
+        files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
+      }))
+    : [];
 
   return {
     prior_attempt_turn_id: turn.turn_id,
@@ -1250,6 +1261,8 @@ function buildConflictContext(turn) {
     conflict_type: conflictError.type || 'file_conflict',
     conflicting_files: Array.isArray(conflictError.conflicting_files) ? conflictError.conflicting_files : [],
     accepted_turns_since: acceptedTurnsSince,
+    forward_revision_files: Array.isArray(conflictError.forward_revision_files) ? conflictError.forward_revision_files : [],
+    forward_revision_turns_since: forwardRevisionTurnsSince,
     non_conflicting_files_preserved: Array.isArray(conflictError.non_conflicting_files)
       ? conflictError.non_conflicting_files
       : [],
@@ -2049,6 +2062,7 @@ export function reactivateGovernedRun(root, state, details = {}) {
 
   const now = new Date().toISOString();
   const wasEscalation = state.status === 'blocked' && typeof state.blocked_on === 'string' && state.blocked_on.startsWith('escalation:');
+  const wasNonProgress = state.blocked_on === 'non_progress';
   const humanEscalation = findCurrentHumanEscalation(root, state);
   const nextState = {
     ...state,
@@ -2058,8 +2072,33 @@ export function reactivateGovernedRun(root, state, details = {}) {
     escalation: null,
   };
 
+  // BUG-38: reset non-progress tracking when acknowledging non-progress block
+  if (wasNonProgress || details.acknowledge_non_progress) {
+    nextState.non_progress_signature = null;
+    nextState.non_progress_count = 0;
+  }
+
   writeState(root, nextState);
 
+  const startupIntents = nextState.run_id
+    ? archiveStaleIntentsForRun(root, nextState.run_id, {
+      protocolVersion: nextState.protocol_version || state.protocol_version || '2.x',
+    })
+    : { archived_migration_intent_ids: [], migration_notice: null };
+
+  if (startupIntents.archived_migration_intent_ids?.length > 0) {
+    emitRunEvent(root, 'intents_migrated', {
+      run_id: nextState.run_id,
+      phase: nextState.phase,
+      status: nextState.status,
+      payload: {
+        archived_count: startupIntents.archived_migration_intent_ids.length,
+        archived_intent_ids: startupIntents.archived_migration_intent_ids,
+        reason: 'pre-BUG-34 intents with approved_run_id: null archived during run reactivation',
+      },
+    });
+  }
+
   if (humanEscalation) {
     resolveHumanEscalation(root, humanEscalation.escalation_id, {
       resolved_at: now,
@@ -2101,7 +2140,11 @@ export function reactivateGovernedRun(root, state, details = {}) {
     });
   }
 
-  return { ok: true, state: attachLegacyCurrentTurnAlias(nextState) };
+  return {
+    ok: true,
+    state: attachLegacyCurrentTurnAlias(nextState),
+    migration_notice: formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids),
+  };
 }
 
 // ── Core Operations ──────────────────────────────────────────────────────────
@@ -2155,40 +2198,24 @@ 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 */ }
+  const startupIntents = archiveStaleIntentsForRun(root, runId, {
+    protocolVersion: updatedState.protocol_version || '2.x',
+  });
+  const archivedMigrationIntentIds = startupIntents.archived_migration_intent_ids || [];
+
+  // BUG-39: emit intents_migrated event when pre-BUG-34 intents were archived
+  if (archivedMigrationIntentIds.length > 0) {
+    emitRunEvent(root, 'intents_migrated', {
+      run_id: runId,
+      phase: updatedState.phase,
+      status: 'active',
+      payload: {
+        archived_count: archivedMigrationIntentIds.length,
+        archived_intent_ids: archivedMigrationIntentIds,
+        reason: 'pre-BUG-34 intents with approved_run_id: null archived during run initialization',
+      },
+    });
+  }
 
   emitRunEvent(root, 'run_started', {
     run_id: runId,
@@ -2196,7 +2223,10 @@ export function initializeGovernedRun(root, config, options = {}) {
     status: 'active',
     payload: { provenance: provenance || {} },
   });
-  return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState) };
+  // BUG-39: return migration notice so callers can display it
+  const migrationNotice = startupIntents.migration_notice;
+
+  return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState), migration_notice: migrationNotice };
 }
 
 /**
@@ -3160,22 +3190,10 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       // 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 uniqueFailingFiles = [...new Set(
+        (preGateResult.failing_files || preGateResult.missing_files || [])
+          .map(f => f.replace(/^\.\//, ''))
+      )];
       const uncoveredFiles = uniqueFailingFiles.filter(f => !declaredFiles.has(f));
 
       const gateSemanticMode = config.gate_semantic_coverage_mode || 'strict';
@@ -4207,6 +4225,118 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // ── BUG-38: Non-progress convergence guard ─────────────────────────────
+  // Track whether consecutive accepted turns leave the same gate failure
+  // intact without modifying the gated files. When the count reaches the
+  // configurable threshold, block the run to prevent infinite loops.
+  // Proactively evaluates the current phase exit gate on every accepted turn
+  // — not just when a transition is requested — to detect stalled patterns.
+  if (updatedState.status === 'active') {
+    const declaredFiles = new Set((turnResult.files_changed || []).map(f => f.replace(/^\.\//, '')));
+    const npThreshold = config.run_loop?.non_progress_threshold ?? 3;
+
+    // Proactively evaluate the exit gate for the current phase.
+    // evaluatePhaseExit requires a phase_transition_request, so we synthesize
+    // one pointing to the next phase from routing for probing purposes.
+    let proactiveGateFailure = null;
+    try {
+      const currentRouting = config.routing?.[updatedState.phase];
+      if (currentRouting?.exit_gate) {
+        // Find the next phase to use as synthetic transition target
+        const phases = config.phases || [];
+        const currentIdx = phases.findIndex(p => p.id === updatedState.phase);
+        const nextPhaseId = currentIdx >= 0 && currentIdx < phases.length - 1
+          ? phases[currentIdx + 1].id
+          : (currentRouting.allowed_next_roles ? Object.keys(config.routing).find(k => k !== updatedState.phase) : null);
+
+        if (nextPhaseId) {
+          const probeTurn = { ...turnResult, phase_transition_request: nextPhaseId };
+          const probeResult = evaluatePhaseExit({
+            state: updatedState,
+            config,
+            acceptedTurn: probeTurn,
+            root,
+          });
+          if (probeResult.action === 'gate_failed') {
+            proactiveGateFailure = probeResult;
+          }
+        }
+      }
+    } catch { /* non-fatal — probe is advisory */ }
+
+    // Fall back to last_gate_failure if proactive evaluation didn't find one
+    const effectiveGateFailure = proactiveGateFailure || updatedState.last_gate_failure;
+
+    if (effectiveGateFailure && (effectiveGateFailure.gate_id || effectiveGateFailure.gate_type)) {
+      const gateId = effectiveGateFailure.gate_id || effectiveGateFailure.gate_type || 'unknown';
+      // Compute gate failure signature: gate_id + sorted failing files + sorted reasons
+      const failingFiles = [...(effectiveGateFailure.missing_files || effectiveGateFailure.failing_files || [])].sort();
+      const reasons = [...(effectiveGateFailure.reasons || [])].sort();
+      const signature = `${gateId}::${failingFiles.join(',')}::${reasons.join(',')}`;
+
+      // Check if any of the gated files were modified by this turn
+      const gatedFilesModified = failingFiles.some(f => declaredFiles.has(f.replace(/^\.\//, '')));
+
+      const prevSignature = state.non_progress_signature || null;
+      const prevCount = state.non_progress_count || 0;
+
+      if (signature === prevSignature && !gatedFilesModified) {
+        // Same gate failure, gated files untouched — increment counter
+        const newCount = prevCount + 1;
+        updatedState.non_progress_signature = signature;
+        updatedState.non_progress_count = newCount;
+
+        if (newCount >= npThreshold) {
+          // Threshold reached — block the run
+          updatedState.status = 'blocked';
+          updatedState.blocked_on = 'non_progress';
+          updatedState.blocked_reason = buildBlockedReason({
+            category: 'non_progress',
+            recovery: {
+              typed_reason: `Non-progress detected: ${newCount} accepted turns have not reduced gate failure "${gateId}".`,
+              recovery_action: 'agentxchain resume --acknowledge-non-progress',
+              detail: `Gate "${gateId}" has been failing on ${failingFiles.join(', ')} for ${newCount} consecutive turns. The gated file(s) were never modified.`,
+            },
+            turnId: currentTurn.turn_id,
+            blockedAt: now,
+          });
+
+          ledgerEntries.push({
+            type: 'non_progress_block',
+            gate_id: gateId,
+            consecutive_turns: newCount,
+            threshold: npThreshold,
+            failing_files: failingFiles,
+            signature,
+            timestamp: now,
+          });
+
+          emitRunEvent(root, 'run_stalled', {
+            run_id: updatedState.run_id,
+            phase: updatedState.phase,
+            status: 'blocked',
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            payload: {
+              consecutive_non_progress_turns: newCount,
+              threshold: npThreshold,
+              gate_id: gateId,
+              failing_files: failingFiles,
+              signature,
+            },
+          });
+        }
+      } else {
+        // Gate failure changed or gated files were modified — reset counter
+        updatedState.non_progress_signature = signature;
+        updatedState.non_progress_count = 1;
+      }
+    } else {
+      // No gate failure — reset non-progress tracking
+      updatedState.non_progress_signature = null;
+      updatedState.non_progress_count = 0;
+    }
+  }
+
   // ── Transaction journal: prepare before committing writes ──────────────
   const transactionId = generateId('txn');
   const journal = {

package/src/lib/intake.js

@@ -17,6 +17,11 @@ import { getDispatchTurnDir } from './turn-paths.js';
 import { loadCoordinatorConfig } from './coordinator-config.js';
 import { loadCoordinatorState, readBarriers } from './coordinator-state.js';
 import { writeCoordinatorHandoff } from './intake-handoff.js';
+import {
+  archiveStaleIntentsForRun,
+  migratePreBug34Intents,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 
 const VALID_SOURCES = ['manual', 'ci_failure', 'git_ref_change', 'schedule', 'vision_scan'];
 const VALID_PRIORITIES = ['p0', 'p1', 'p2', 'p3'];
@@ -516,16 +521,14 @@ export function findNextDispatchableIntent(root, options = {}) {
     .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.
+  // a different run. `cross_run_durable` is only a pre-run holding state for
+  // freshly approved idle intents. Once a run starts, those intents must be
+  // rebound onto that run and the flag cleared; it must never override an
+  // existing run binding.
   if (scopeRunId) {
     intents = intents.filter((intent) => {
       if (intent.approved_run_id === scopeRunId) return true;
-      if (intent.cross_run_durable === true) return true;
+      if (!intent.approved_run_id && 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
@@ -579,10 +582,11 @@ export function findPendingApprovedIntents(root, options = {}) {
   return readJsonDir(dirs.intents)
     .filter((intent) => {
       if (!intent || intent.status !== 'approved') return false;
-      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent
+      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent.
+      // `cross_run_durable` only applies before the first run binding exists.
       if (scopeRunId) {
         if (intent.approved_run_id === scopeRunId) return true;
-        if (intent.cross_run_durable === true) return true;
+        if (!intent.approved_run_id && intent.cross_run_durable === true) return true;
         return false;
       }
       return true;
@@ -616,46 +620,7 @@ export function findPendingApprovedIntents(root, options = {}) {
  * @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 };
+  return archiveStaleIntentsForRun(root, newRunId);
 }
 
 /**
@@ -816,9 +781,11 @@ 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.
+  // BUG-34/39: stamp the current run_id on approval so the intent is scoped
+  // to the run that approved it. When approval happens before any governed
+  // run exists, hold the intent in a pre-run durable state so the *next* run
+  // initialization can bind it to that run. The flag is not an evergreen
+  // cross-run bypass; it exists only until first run binding happens.
   if (!intent.approved_run_id) {
     const statePath = join(root, '.agentxchain', 'state.json');
     if (existsSync(statePath)) {
@@ -826,10 +793,14 @@ export function approveIntent(root, intentId, options = {}) {
         const state = JSON.parse(readFileSync(statePath, 'utf8'));
         if (state.run_id) {
           intent.approved_run_id = state.run_id;
+        } else {
+          intent.cross_run_durable = true;
         }
       } catch {
         // non-fatal — stamp is best-effort during approval
       }
+    } else {
+      intent.cross_run_durable = true;
     }
   }
 

package/src/lib/intent-startup-migration.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { safeWriteJson } from './safe-write.js';
+
+const DISPATCHABLE_STATUSES = new Set(['planned', 'approved']);
+
+function nowISO() {
+  return new Date().toISOString();
+}
+
+function getIntentsDir(root) {
+  return join(root, '.agentxchain', 'intake', 'intents');
+}
+
+function listIntentFiles(intentsDir) {
+  if (!existsSync(intentsDir)) return [];
+  return readdirSync(intentsDir).filter((file) => file.endsWith('.json') && !file.startsWith('.tmp-'));
+}
+
+export function formatLegacyIntentMigrationNotice(intentIds) {
+  if (!Array.isArray(intentIds) || intentIds.length === 0) return null;
+  return `Archived ${intentIds.length} pre-BUG-34 intent(s): ${intentIds.join(', ')}`;
+}
+
+export function migratePreBug34Intents(root, runId, options = {}) {
+  const intentsDir = getIntentsDir(root);
+  if (!existsSync(intentsDir)) {
+    return {
+      archived_migration_count: 0,
+      archived_migration_intent_ids: [],
+      migration_notice: null,
+    };
+  }
+
+  const now = nowISO();
+  const archivedMigrationIntentIds = [];
+  const protocolVersion = options.protocolVersion || '2.x';
+
+  for (const file of listIntentFiles(intentsDir)) {
+    const intentPath = join(intentsDir, 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) continue;
+
+    const prevStatus = intent.status;
+    intent.status = 'archived_migration';
+    intent.updated_at = now;
+    intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during v${protocolVersion} migration on run ${runId}`;
+    if (!intent.history) intent.history = [];
+    intent.history.push({
+      from: prevStatus,
+      to: 'archived_migration',
+      at: now,
+      reason: intent.archived_reason,
+    });
+    safeWriteJson(intentPath, intent);
+    if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
+  }
+
+  return {
+    archived_migration_count: archivedMigrationIntentIds.length,
+    archived_migration_intent_ids: archivedMigrationIntentIds,
+    migration_notice: formatLegacyIntentMigrationNotice(archivedMigrationIntentIds),
+  };
+}
+
+export function archiveStaleIntentsForRun(root, runId, options = {}) {
+  const intentsDir = getIntentsDir(root);
+  if (!existsSync(intentsDir)) {
+    return {
+      archived: 0,
+      adopted: 0,
+      archived_migration_count: 0,
+      archived_migration_intent_ids: [],
+      migration_notice: null,
+    };
+  }
+
+  const now = nowISO();
+  let archived = 0;
+  let adopted = 0;
+
+  for (const file of listIntentFiles(intentsDir)) {
+    const intentPath = join(intentsDir, 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 && !intent.approved_run_id) {
+      intent.approved_run_id = runId;
+      delete intent.cross_run_durable;
+      intent.updated_at = now;
+      if (!intent.history) intent.history = [];
+      intent.history.push({
+        from: intent.status,
+        to: intent.status,
+        at: now,
+        reason: `pre-run durable approval bound to run ${runId}`,
+      });
+      safeWriteJson(intentPath, intent);
+      adopted += 1;
+      continue;
+    }
+
+    if (intent.cross_run_durable === true && intent.approved_run_id === runId) {
+      delete intent.cross_run_durable;
+      intent.updated_at = now;
+      safeWriteJson(intentPath, intent);
+      continue;
+    }
+
+    if (intent.approved_run_id && intent.approved_run_id !== runId) {
+      const prevStatus = intent.status;
+      intent.status = 'suppressed';
+      intent.updated_at = now;
+      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: prevStatus,
+        to: 'suppressed',
+        at: now,
+        reason: intent.archived_reason,
+      });
+      safeWriteJson(intentPath, intent);
+      archived += 1;
+    }
+  }
+
+  const migration = migratePreBug34Intents(root, runId, options);
+
+  return {
+    archived,
+    adopted,
+    archived_migration_count: migration.archived_migration_count,
+    archived_migration_intent_ids: migration.archived_migration_intent_ids,
+    migration_notice: migration.migration_notice,
+  };
+}

package/src/lib/normalized-config.js

@@ -1178,6 +1178,11 @@ export function normalizeV4(raw) {
       state: '.agentxchain/state.json',
       log: null,
     },
+    // Passthrough fields — these are runtime behavior overrides that don't
+    // need normalization but must survive the config pipeline.
+    ...(raw.gate_semantic_coverage_mode ? { gate_semantic_coverage_mode: raw.gate_semantic_coverage_mode } : {}),
+    ...(raw.intent_coverage_mode ? { intent_coverage_mode: raw.intent_coverage_mode } : {}),
+    ...(raw.run_loop ? { run_loop: raw.run_loop } : {}),
     compat: {
       next_owner_source: 'state-json',
       lock_based_coordination: false,