@remnic/core 9.65.2 → 9.65.4

package/dist/{chunk-BWLRUMOG.js → chunk-DPNXADEI.js}

@@ -11,6 +11,11 @@ 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";
@@ -67,6 +72,9 @@ import {
 import {
   parseExternalWikiRecallGuard
 } from "./chunk-JV3C2MNQ.js";
+import {
+  parseSkillProjectionConfig
+} from "./chunk-236PXYG7.js";
 import {
   parseProvenanceConfig
 } from "./chunk-NXH34IPL.js";
@@ -167,6 +175,87 @@ function parseProceduralMaintenanceConfig(raw) {
   };
 }
 
+// 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"];
@@ -951,6 +1040,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,
@@ -1760,6 +2184,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
   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 skillProjection = parseSkillProjectionConfig(rawProcedural.skillProjection);
   const rawEnabledValue = rawProcedural.enabled;
   let proceduralEnabled;
   if (rawEnabledValue === void 0) {
@@ -1783,7 +2208,8 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     autoPromoteEnabled: coerceBool(rawProcedural.autoPromoteEnabled) === true,
     lookbackDays,
     proceduralMiningCronAutoRegister: coerceBool(rawProcedural.proceduralMiningCronAutoRegister) === true,
-    recallMaxProcedures
+    recallMaxProcedures,
+    skillProjection
   };
   const wearables = parseWearablesConfig(cfg.wearables);
   const { activity, meetings, provenance } = parseCaptureCompanionConfigs(cfg);
@@ -2160,6 +2586,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,
@@ -2594,6 +3022,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,
@@ -3988,6 +4417,8 @@ function parseTrustScoreWeights(value) {
 }
 
 export {
+  DRIFT_DETECTION_DEFAULTS,
+  parseDriftDetectionConfig,
   KNOWN_WEARABLE_SOURCE_IDS,
   defaultWearableCleanupSettings,
   defaultWearableSourceSettings,
@@ -4000,10 +4431,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-BWLRUMOG.js.map
+//# sourceMappingURL=chunk-DPNXADEI.js.map