@remnic/core 9.65.1 → 9.65.3

package/dist/{chunk-YQ3CBLL4.js → chunk-76PL4XLG.js}

@@ -11,6 +11,14 @@ import {
 import {
   parseLocationConfig
 } from "./chunk-7PHI6GUI.js";
+import {
+  PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
+  normalizeActionIntent,
+  sanitizePayloadString
+} from "./chunk-D2YNNDML.js";
+import {
+  parseSubjectRuntimeConfig
+} from "./chunk-AAXJNINV.js";
 import {
   cloneDefaultSessionObserverBands
 } from "./chunk-Z5LAYHGJ.js";
@@ -96,6 +104,155 @@ import {
 // src/config.ts
 import path from "path";
 
+// src/procedural/maintenance-config.ts
+function parseProceduralMaintenanceConfig(raw) {
+  if (raw !== void 0 && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
+    throw new Error(
+      `procedural.maintenance must be an object (got ${JSON.stringify(raw)}). Omit the key to keep maintenance disabled (issue #2370).`
+    );
+  }
+  const rawMaintenance = raw && typeof raw === "object" ? raw : {};
+  let enabled = false;
+  if (rawMaintenance.enabled !== void 0) {
+    const coerced = coerceBool(rawMaintenance.enabled);
+    if (coerced === void 0) {
+      throw new Error(
+        `procedural.maintenance.enabled must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawMaintenance.enabled)}).`
+      );
+    }
+    enabled = coerced;
+  }
+  const parseInteger = (key, fallback, min, max) => {
+    const value = rawMaintenance[key];
+    if (value === void 0) return fallback;
+    const coerced = coerceNumber(value);
+    if (coerced === void 0 || !Number.isFinite(coerced)) {
+      throw new Error(
+        `procedural.maintenance.${key} must be a finite number (got ${JSON.stringify(value)}).`
+      );
+    }
+    if (!Number.isInteger(coerced)) {
+      throw new Error(
+        `procedural.maintenance.${key} must be an integer (got ${JSON.stringify(value)}).`
+      );
+    }
+    if (coerced < min || coerced > max) {
+      throw new Error(
+        `procedural.maintenance.${key} must be between ${min} and ${max} (got ${JSON.stringify(value)}).`
+      );
+    }
+    return coerced;
+  };
+  let retireFailRatio = 2;
+  if (rawMaintenance.retireFailRatio !== void 0) {
+    const coerced = coerceNumber(rawMaintenance.retireFailRatio);
+    if (coerced === void 0 || !Number.isFinite(coerced) || coerced <= 0) {
+      throw new Error(
+        `procedural.maintenance.retireFailRatio must be a positive finite number (got ${JSON.stringify(rawMaintenance.retireFailRatio)}).`
+      );
+    }
+    retireFailRatio = coerced;
+  }
+  let mergeEnabled = true;
+  if (rawMaintenance.mergeEnabled !== void 0) {
+    const coerced = coerceBool(rawMaintenance.mergeEnabled);
+    if (coerced === void 0) {
+      throw new Error(
+        `procedural.maintenance.mergeEnabled must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawMaintenance.mergeEnabled)}).`
+      );
+    }
+    mergeEnabled = coerced;
+  }
+  return {
+    enabled,
+    retireIdleDays: parseInteger("retireIdleDays", 90, 0, 36500),
+    retireMinOutcomes: parseInteger("retireMinOutcomes", 5, 1, 1e5),
+    retireFailRatio,
+    mergeEnabled
+  };
+}
+
+// src/preferences/drift-config.ts
+var DRIFT_DETECTION_DEFAULTS = {
+  enabled: false,
+  minAgeDays: 60,
+  lookbackDays: 45,
+  maxCandidatesPerRun: 25,
+  recallDamping: false,
+  stalePenalty: 0.8,
+  annotateAfterDays: 0
+};
+function parseFlag(src, key, fallback) {
+  const value = src[key];
+  if (value === void 0 || value === null) return fallback;
+  const coerced = coerceBool(value);
+  if (coerced === void 0) {
+    throw new Error(
+      `driftDetection.${key} must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(value)}).`
+    );
+  }
+  return coerced;
+}
+function parseDayCount(src, key, fallback) {
+  const value = src[key];
+  if (value === void 0 || value === null) return fallback;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || !Number.isFinite(coerced)) {
+    throw new Error(`driftDetection.${key} must be a finite number (got ${JSON.stringify(value)}).`);
+  }
+  if (!Number.isInteger(coerced)) {
+    throw new Error(`driftDetection.${key} must be an integer (got ${JSON.stringify(value)}).`);
+  }
+  if (coerced < 0 || coerced > 36500) {
+    throw new Error(`driftDetection.${key} must be between 0 and 36500 (got ${JSON.stringify(value)}).`);
+  }
+  return coerced;
+}
+function parseDriftDetectionConfig(raw) {
+  if (raw === void 0 || raw === null) return { ...DRIFT_DETECTION_DEFAULTS };
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(
+      `driftDetection must be an object (got ${JSON.stringify(raw)}). Omit the key to keep drift detection disabled (issue #2371).`
+    );
+  }
+  const src = raw;
+  const rawMax = src.maxCandidatesPerRun;
+  let maxCandidatesPerRun = DRIFT_DETECTION_DEFAULTS.maxCandidatesPerRun;
+  if (rawMax !== void 0 && rawMax !== null) {
+    const coerced = coerceNumber(rawMax);
+    if (coerced === void 0 || !Number.isInteger(coerced) || coerced < 0) {
+      throw new Error(
+        `driftDetection.maxCandidatesPerRun must be an integer >= 0 (got ${JSON.stringify(rawMax)}). Use 0 to disable the scan.`
+      );
+    }
+    maxCandidatesPerRun = coerced;
+  }
+  const rawPenalty = src.stalePenalty;
+  let stalePenalty = DRIFT_DETECTION_DEFAULTS.stalePenalty;
+  if (rawPenalty !== void 0 && rawPenalty !== null) {
+    const coerced = coerceNumber(rawPenalty);
+    if (coerced === void 0 || !Number.isFinite(coerced) || coerced <= 0 || coerced > 1) {
+      throw new Error(
+        `driftDetection.stalePenalty must be a number in (0, 1] (got ${JSON.stringify(rawPenalty)}). Use 1 to disable damping without changing the flag.`
+      );
+    }
+    stalePenalty = coerced;
+  }
+  return {
+    enabled: parseFlag(src, "enabled", DRIFT_DETECTION_DEFAULTS.enabled),
+    minAgeDays: parseDayCount(src, "minAgeDays", DRIFT_DETECTION_DEFAULTS.minAgeDays),
+    lookbackDays: parseDayCount(src, "lookbackDays", DRIFT_DETECTION_DEFAULTS.lookbackDays),
+    maxCandidatesPerRun,
+    recallDamping: parseFlag(src, "recallDamping", DRIFT_DETECTION_DEFAULTS.recallDamping),
+    stalePenalty,
+    annotateAfterDays: parseDayCount(
+      src,
+      "annotateAfterDays",
+      DRIFT_DETECTION_DEFAULTS.annotateAfterDays
+    )
+  };
+}
+
 // src/wearables/config.ts
 var KNOWN_WEARABLE_SOURCE_IDS = ["limitless", "bee", "omi"];
 var MEMORY_MODES = ["off", "review", "auto", "smart"];
@@ -880,6 +1037,341 @@ function parseOkfConfig(raw) {
   };
 }
 
+// src/coding/action-gate.ts
+var ACTION_GATE_DEFAULT_MAX_ADVISORIES_PER_TURN = 3;
+var MAX_ADVISORY_CHARS = 400;
+var MAX_ACTION_TERMS = 24;
+var MIN_TERM_CHARS = 3;
+var MIN_TERM_OVERLAP_RATIO = 0.6;
+var MAX_TRACKED_SESSIONS = 200;
+var MAX_TRACKED_IDS_PER_SESSION = 200;
+var ACTION_GATE_DEFAULTS = {
+  enabled: false,
+  timeoutMs: PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
+  maxAdvisoriesPerTurn: ACTION_GATE_DEFAULT_MAX_ADVISORIES_PER_TURN
+};
+function parseActionGateConfig(raw) {
+  if (raw !== void 0 && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
+    throw new Error(
+      `actionGate must be an object (got ${JSON.stringify(raw)}). Use actionGate: { enabled: true } to opt in.`
+    );
+  }
+  const block = raw ?? {};
+  const rawEnabled = block.enabled;
+  let enabled = ACTION_GATE_DEFAULTS.enabled;
+  if (rawEnabled !== void 0) {
+    const coerced = coerceBool(rawEnabled);
+    if (coerced === void 0) {
+      throw new Error(
+        `actionGate.enabled must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawEnabled)}).`
+      );
+    }
+    enabled = coerced;
+  }
+  const rawTimeout = coerceNumber(block.timeoutMs);
+  const timeoutMs = rawTimeout !== void 0 && Number.isFinite(rawTimeout) ? Math.min(5e3, Math.max(1, Math.floor(rawTimeout))) : ACTION_GATE_DEFAULTS.timeoutMs;
+  const rawMax = coerceNumber(block.maxAdvisoriesPerTurn);
+  const maxAdvisoriesPerTurn = rawMax !== void 0 && Number.isFinite(rawMax) ? Math.min(20, Math.max(0, Math.floor(rawMax))) : ACTION_GATE_DEFAULTS.maxAdvisoriesPerTurn;
+  return { enabled, timeoutMs, maxAdvisoriesPerTurn };
+}
+function actionTermsFor(intent) {
+  const raw = intent.kind === "command" ? [intent.command, ...intent.args ?? []] : [intent.filePath, intent.editKind, intent.symbol ?? "", intent.range ?? ""];
+  const terms = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const piece of raw) {
+    for (const token of sanitizePayloadString(piece ?? "").toLowerCase().split(/[^a-z0-9._-]+/)) {
+      const term = token.replace(/^[._-]+|[._-]+$/g, "");
+      if (term.length < MIN_TERM_CHARS || seen.has(term)) continue;
+      seen.add(term);
+      terms.push(term);
+      if (terms.length >= MAX_ACTION_TERMS) return terms;
+    }
+  }
+  return terms;
+}
+function isFailureClassMemory(memory) {
+  const fm = memory.frontmatter;
+  if (fm.status !== void 0 && fm.status !== "active") return false;
+  if (fm.category === "correction") return true;
+  if (fm.structuredAttributes?.needsRepair === "true") return true;
+  const failures = typeof fm.mw_fail === "number" ? fm.mw_fail : 0;
+  const successes = typeof fm.mw_success === "number" ? fm.mw_success : 0;
+  return failures > 0 && failures > successes;
+}
+function createFailureMemoryCandidateSource(deps) {
+  return {
+    id: "failure-memory",
+    async find(query) {
+      if (query.actionTerms.length === 0) return { ok: true, candidates: [] };
+      let memories;
+      try {
+        memories = await deps.listMemories({
+          namespace: query.namespace,
+          memoryDir: query.memoryDir,
+          signal: query.signal
+        });
+      } catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+      }
+      const required = Math.max(1, Math.ceil(query.actionTerms.length * MIN_TERM_OVERLAP_RATIO));
+      const candidates = [];
+      for (const memory of memories) {
+        if (!isFailureClassMemory(memory)) continue;
+        const haystack = `${memory.content} ${(memory.frontmatter.tags ?? []).join(" ")}`.toLowerCase();
+        let hits = 0;
+        for (const term of query.actionTerms) if (haystack.includes(term)) hits += 1;
+        if (hits < required) continue;
+        candidates.push({
+          memoryId: memory.frontmatter.id,
+          score: hits,
+          advisoryText: `[ActionGate] A stored failure memory matches this action: "${memory.content}".`
+        });
+      }
+      candidates.sort((left, right) => {
+        const byScore = (right.score ?? 0) - (left.score ?? 0);
+        return byScore !== 0 ? byScore : left.memoryId.localeCompare(right.memoryId);
+      });
+      return { ok: true, candidates };
+    }
+  };
+}
+function createTrajectoryCandidateSource(gate) {
+  return {
+    id: "causal-trajectory",
+    async find(query) {
+      const result = await gate.evaluate({
+        sessionKey: query.sessionKey,
+        strategyId: query.strategyId,
+        intent: query.intent,
+        codingContext: query.codingContext,
+        memoryDir: query.memoryDir,
+        causalTrajectoryStoreDir: query.causalTrajectoryStoreDir,
+        signal: query.signal
+      });
+      if (result.status === "ERROR_FAIL_OPEN") {
+        return { ok: false, reason: result.reason ?? "pre-action gate failed open" };
+      }
+      if (result.status !== "MATCH_WARN" || !result.matchedTrajectoryId || !result.advisoryText) {
+        return { ok: true, candidates: [] };
+      }
+      return {
+        ok: true,
+        candidates: [
+          {
+            memoryId: result.matchedTrajectoryId,
+            // Trajectory matches are exact fingerprint hits: rank above lexical ones.
+            score: Number.MAX_SAFE_INTEGER,
+            advisoryText: result.advisoryText
+          }
+        ]
+      };
+    }
+  };
+}
+var ActionGateService = class {
+  config;
+  sources;
+  audit;
+  clock;
+  now;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(config, deps = {}) {
+    this.config = config;
+    this.sources = deps.sources ?? [];
+    this.audit = deps.audit;
+    this.clock = deps.clock ?? Date.now;
+    this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /**
+   * Memory ids the gate already delivered in this session. Turn-start recall
+   * filters these out before its own cap, honouring the filter-then-cap order.
+   */
+  suppressedForTurnStart(sessionKey) {
+    if (!this.config.enabled) return [];
+    return [...this.sessions.get(sessionKey)?.deliveredByGate ?? []];
+  }
+  /** Record ids turn-start recall injected, so the gate will not repeat them. */
+  noteTurnStartDelivery(sessionKey, memoryIds) {
+    if (!this.config.enabled || memoryIds.length === 0) return;
+    const state = this.sessionState(sessionKey, void 0);
+    for (const id of memoryIds) this.addTracked(state.deliveredByTurnStart, id);
+  }
+  resetSession(sessionKey) {
+    this.sessions.delete(sessionKey);
+  }
+  async evaluate(request) {
+    const startedAt = this.clock();
+    if (!this.config.enabled) {
+      return {
+        status: "DISABLED",
+        advisories: [],
+        suppressedIds: [],
+        degradations: [],
+        reason: "actionGate.enabled is false",
+        latencyMs: 0
+      };
+    }
+    if (this.config.maxAdvisoriesPerTurn === 0) {
+      return this.finish(request, startedAt, {
+        status: "DISABLED",
+        advisories: [],
+        suppressedIds: [],
+        degradations: [],
+        reason: "actionGate.maxAdvisoriesPerTurn is 0"
+      });
+    }
+    let fingerprint;
+    try {
+      fingerprint = normalizeActionIntent(request.intent, request.strategyId, request.codingContext).fingerprint;
+    } catch (error) {
+      return this.finish(request, startedAt, {
+        status: "ERROR_FAIL_OPEN",
+        advisories: [],
+        suppressedIds: [],
+        degradations: [],
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const deadline = startedAt + this.config.timeoutMs;
+    const collected = await this.collect(request, fingerprint, deadline);
+    const state = this.sessionState(request.sessionKey, request.turnId);
+    const advisories = [];
+    const suppressedIds = [];
+    for (const { sourceId, candidate } of collected.candidates) {
+      if (state.deliveredThisTurn.has(candidate.memoryId) || state.deliveredByTurnStart.has(candidate.memoryId)) {
+        suppressedIds.push(candidate.memoryId);
+        continue;
+      }
+      if (advisories.length >= this.config.maxAdvisoriesPerTurn) {
+        suppressedIds.push(candidate.memoryId);
+        continue;
+      }
+      advisories.push({
+        memoryId: candidate.memoryId,
+        sourceId,
+        text: sanitizePayloadString(candidate.advisoryText).replace(/\s+/g, " ").slice(0, MAX_ADVISORY_CHARS)
+      });
+      this.addTracked(state.deliveredThisTurn, candidate.memoryId);
+      this.addTracked(state.deliveredByGate, candidate.memoryId);
+    }
+    const status = advisories.length > 0 ? "MATCH_WARN" : collected.degradations.length > 0 ? "ERROR_FAIL_OPEN" : "NO_MATCH";
+    return this.finish(request, startedAt, {
+      status,
+      advisories,
+      suppressedIds,
+      degradations: collected.degradations,
+      fingerprint,
+      reason: status === "ERROR_FAIL_OPEN" ? collected.degradations[0] : void 0
+    });
+  }
+  async collect(request, fingerprint, deadline) {
+    if (this.sources.length === 0) return { candidates: [], degradations: [] };
+    const timeoutAbort = new AbortController();
+    const signal = request.signal ? AbortSignal.any([request.signal, timeoutAbort.signal]) : timeoutAbort.signal;
+    const query = {
+      sessionKey: request.sessionKey,
+      fingerprint,
+      actionTerms: actionTermsFor(request.intent),
+      strategyId: request.strategyId,
+      intent: request.intent,
+      codingContext: request.codingContext,
+      memoryDir: request.memoryDir,
+      namespace: request.namespace,
+      causalTrajectoryStoreDir: request.causalTrajectoryStoreDir,
+      signal
+    };
+    const remaining = Math.max(1, deadline - this.clock());
+    let onTimeout;
+    const timeoutResult = new Promise((resolve) => {
+      onTimeout = resolve;
+    });
+    const timer = setTimeout(() => {
+      timeoutAbort.abort();
+      onTimeout({ ok: false, reason: `action gate timed out after ${this.config.timeoutMs}ms` });
+    }, remaining);
+    try {
+      const settled = await Promise.all(
+        this.sources.map(async (source) => {
+          let result;
+          try {
+            result = await Promise.race([source.find(query), timeoutResult]);
+          } catch (error) {
+            result = { ok: false, reason: error instanceof Error ? error.message : String(error) };
+          }
+          return { source, result };
+        })
+      );
+      const candidates = [];
+      const degradations = [];
+      for (const { source, result } of settled) {
+        if (!result.ok) {
+          degradations.push(`${source.id}: ${result.reason}`);
+          continue;
+        }
+        for (const candidate of result.candidates) candidates.push({ sourceId: source.id, candidate });
+      }
+      candidates.sort((left, right) => {
+        const byScore = (right.candidate.score ?? 0) - (left.candidate.score ?? 0);
+        if (byScore !== 0) return byScore;
+        const bySource = left.sourceId.localeCompare(right.sourceId);
+        return bySource !== 0 ? bySource : left.candidate.memoryId.localeCompare(right.candidate.memoryId);
+      });
+      return { candidates, degradations };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  finish(request, startedAt, decision) {
+    const latencyMs = Math.max(0, this.clock() - startedAt);
+    const result = { ...decision, latencyMs };
+    if (this.audit) {
+      const record = {
+        ts: this.now().toISOString(),
+        sessionKey: request.sessionKey,
+        turnId: request.turnId,
+        status: result.status,
+        latencyMs,
+        fingerprint: result.fingerprint,
+        deliveredIds: result.advisories.map((advisory) => advisory.memoryId),
+        suppressedIds: result.suppressedIds,
+        degradations: result.degradations,
+        reason: result.reason
+      };
+      void Promise.resolve().then(() => this.audit?.(record)).catch(() => void 0);
+    }
+    return result;
+  }
+  sessionState(sessionKey, turnId) {
+    let state = this.sessions.get(sessionKey);
+    if (!state) {
+      if (this.sessions.size >= MAX_TRACKED_SESSIONS) {
+        const oldest = this.sessions.keys().next().value;
+        if (oldest !== void 0) this.sessions.delete(oldest);
+      }
+      state = {
+        turnId: turnId ?? "",
+        deliveredThisTurn: /* @__PURE__ */ new Set(),
+        deliveredByGate: /* @__PURE__ */ new Set(),
+        deliveredByTurnStart: /* @__PURE__ */ new Set()
+      };
+      this.sessions.set(sessionKey, state);
+    }
+    if (turnId !== void 0 && state.turnId !== turnId) {
+      state.turnId = turnId;
+      state.deliveredThisTurn.clear();
+    }
+    return state;
+  }
+  addTracked(set, value) {
+    if (set.has(value)) return;
+    if (set.size >= MAX_TRACKED_IDS_PER_SESSION) {
+      const oldest = set.values().next().value;
+      if (oldest !== void 0) set.delete(oldest);
+    }
+    set.add(value);
+  }
+};
+
 // src/chat/chat-config.ts
 var DEFAULT_CHAT_CONFIG = {
   enabled: false,
@@ -1688,6 +2180,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
   const lookbackDays = lookbackCoerced !== void 0 && Number.isFinite(lookbackCoerced) ? Math.min(3650, Math.max(1, Math.floor(lookbackCoerced))) : 14;
   const recallMaxCoerced = coerceNumber(rawProcedural.recallMaxProcedures);
   const recallMaxProcedures = recallMaxCoerced !== void 0 && Number.isFinite(recallMaxCoerced) ? Math.min(10, Math.max(1, Math.floor(recallMaxCoerced))) : 2;
+  const maintenance = parseProceduralMaintenanceConfig(rawProcedural.maintenance);
   const rawEnabledValue = rawProcedural.enabled;
   let proceduralEnabled;
   if (rawEnabledValue === void 0) {
@@ -1702,6 +2195,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     proceduralEnabled = enabledCoerced;
   }
   const procedural = {
+    maintenance,
     enabled: proceduralEnabled,
     /** `0` skips all mining (`minOccurrences_zero`); otherwise clusters need at least this many members. */
     minOccurrences: Math.min(1e3, Math.max(0, proceduralMinRaw)),
@@ -2087,6 +2581,8 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     contradictionAutoResolve: cfg.contradictionAutoResolve !== false,
     // Contradiction Scan cron (issue #520)
     contradictionScan: parseContradictionScanConfig(cfg.contradictionScan),
+    // Preference drift detection (issue #2371)
+    driftDetection: parseDriftDetectionConfig(cfg.driftDetection),
     dependencyPropagation: parseDependencyPropagationConfig(cfg),
     // Temporal Supersession (issue #375)
     temporalSupersessionEnabled: cfg.temporalSupersessionEnabled !== false,
@@ -2521,6 +3017,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     bridgeMode: cfg.bridgeMode === void 0 ? "embedded" : String(cfg.bridgeMode),
     codexCompat,
     codingKnowledge: parseCodingKnowledgeConfig(cfg.codingKnowledge),
+    actionGate: parseActionGateConfig(cfg.actionGate),
     chat: parseChatConfig(cfg.chat),
     supportPassport: parseSupportPassportConfig(cfg.supportPassport),
     hourlySummariesEnabled: cfg.hourlySummariesEnabled !== false,
@@ -2789,10 +3286,10 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
       }
       return "low";
     })(),
-    // Extraction scope classification. When enabled, the extraction prompt
-    // asks the LLM to classify each fact as "project" or "global". Global
-    // facts are promoted to the shared namespace. Default true (rule 30 gate).
+    // Extraction scope classification (rule 30 gate): "global" facts promote
+    // to the shared namespace. Default true.
     extractionScopeClassificationEnabled: coerceBool(cfg.extractionScopeClassificationEnabled) !== false,
+    ...parseSubjectRuntimeConfig(cfg),
     // Extraction judge (issue #376). Opt-in LLM-as-judge fact-worthiness gate.
     extractionJudgeEnabled: cfg.extractionJudgeEnabled === true,
     extractionJudgeModel: typeof cfg.extractionJudgeModel === "string" ? cfg.extractionJudgeModel : "",
@@ -2802,10 +3299,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     // text before the verdict is forcibly converted to reject.
     extractionJudgeMaxDeferrals: typeof cfg.extractionJudgeMaxDeferrals === "number" && Number.isFinite(cfg.extractionJudgeMaxDeferrals) && cfg.extractionJudgeMaxDeferrals >= 1 ? Math.floor(cfg.extractionJudgeMaxDeferrals) : 2,
     // Judge telemetry (issue #562 PR 3): opt-in structured emit to the
-    // observation ledger for defer-rate / latency metrics.
-    // Uses `coerceBool` so CLI-style string inputs (`"true"`, `"false"`,
-    // `"1"`, `"0"`) are accepted consistently with the rest of the
-    // codebase (CLAUDE.md gotcha 36).
+    // observation ledger; `coerceBool` accepts CLI-style strings (gotcha 36).
     extractionJudgeTelemetryEnabled: coerceBool(cfg.extractionJudgeTelemetryEnabled) === true,
     // Judge training-pair collection (issue #562 PR 4): opt-in shim for a
     // future GRPO training pipeline. Rows land under ~/.remnic/judge-
@@ -3918,6 +4412,8 @@ function parseTrustScoreWeights(value) {
 }
 
 export {
+  DRIFT_DETECTION_DEFAULTS,
+  parseDriftDetectionConfig,
   KNOWN_WEARABLE_SOURCE_IDS,
   defaultWearableCleanupSettings,
   defaultWearableSourceSettings,
@@ -3930,10 +4426,18 @@ export {
   detectMeetings,
   DEFAULT_MEETINGS_CONFIG,
   parseMeetingsConfig,
+  ACTION_GATE_DEFAULT_MAX_ADVISORIES_PER_TURN,
+  ACTION_GATE_DEFAULTS,
+  parseActionGateConfig,
+  actionTermsFor,
+  isFailureClassMemory,
+  createFailureMemoryCandidateSource,
+  createTrajectoryCandidateSource,
+  ActionGateService,
   isOpenaiApiKeyDisabled,
   resolveEnvVars,
   DEFAULT_REASONING_MODEL,
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-YQ3CBLL4.js.map
+//# sourceMappingURL=chunk-76PL4XLG.js.map