@remnic/core 1.1.0 → 1.1.2

package/dist/chunk-ASAITVLA.js

@@ -0,0 +1,64 @@
+// src/buffer-surprise-report.ts
+async function reportBufferSurpriseDistribution(readEvents, options = {}) {
+  const limit = typeof options.limit === "number" && options.limit > 0 ? Math.floor(options.limit) : 200;
+  const raw = await readEvents({ limit, since: options.since });
+  const sinceMs = typeof options.since === "string" && options.since.length > 0 ? Date.parse(options.since) : Number.NaN;
+  const rows = raw.filter((row) => {
+    if (!row || row.event !== "BUFFER_SURPRISE") return false;
+    if (typeof row.surpriseScore !== "number") return false;
+    if (!Number.isFinite(row.surpriseScore)) return false;
+    if (row.surpriseScore < 0 || row.surpriseScore > 1) return false;
+    if (typeof row.triggeredFlush !== "boolean") return false;
+    if (Number.isFinite(sinceMs)) {
+      const ts = Date.parse(row.timestamp);
+      if (!Number.isFinite(ts) || ts <= sinceMs) return false;
+    }
+    return true;
+  });
+  if (rows.length === 0) {
+    return {
+      count: 0,
+      triggeredCount: 0,
+      triggeredRate: 0,
+      mean: 0,
+      median: 0,
+      p90: 0,
+      min: 0,
+      max: 0,
+      currentThreshold: null
+    };
+  }
+  const scores = rows.map((r) => r.surpriseScore).sort((a, b) => a - b);
+  const triggeredCount = rows.reduce(
+    (acc, r) => acc + (r.triggeredFlush ? 1 : 0),
+    0
+  );
+  const sum = scores.reduce((acc, v) => acc + v, 0);
+  const mean = sum / scores.length;
+  const median = percentile(scores, 0.5);
+  const p90 = percentile(scores, 0.9);
+  const mostRecent = rows[rows.length - 1];
+  const currentThreshold = mostRecent && typeof mostRecent.threshold === "number" ? mostRecent.threshold : null;
+  return {
+    count: scores.length,
+    triggeredCount,
+    triggeredRate: triggeredCount / scores.length,
+    mean,
+    median,
+    p90,
+    min: scores[0],
+    max: scores[scores.length - 1],
+    currentThreshold
+  };
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const clamped = Math.max(0, Math.min(1, p));
+  const rank = Math.max(1, Math.ceil(clamped * sorted.length));
+  return sorted[rank - 1];
+}
+
+export {
+  reportBufferSurpriseDistribution
+};
+//# sourceMappingURL=chunk-ASAITVLA.js.map

package/dist/chunk-ASAITVLA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/buffer-surprise-report.ts"],"sourcesContent":["/**\n * Buffer-surprise telemetry report (issue #563 PR 3).\n *\n * Reads the append-only `state/buffer-surprise-ledger.jsonl` file written\n * by `SmartBuffer` and summarizes the recent distribution of surprise\n * scores for the Doctor surface. This module is intentionally standalone\n * and pure — the only I/O is reading the ledger via the injected\n * `readEvents` callback, so it can be exercised directly in tests\n * without touching the filesystem.\n *\n * # Output shape\n *\n * `BufferSurpriseDistribution` has fields sized for a one-screen Doctor\n * display:\n *\n *   - `count`            — rows considered in the summary window.\n *   - `triggeredCount`   — rows whose `triggeredFlush === true`.\n *   - `triggeredRate`    — `triggeredCount / count`, or `0` when empty.\n *   - `mean`             — arithmetic mean of `surpriseScore`.\n *   - `median`           — middle value (50th percentile).\n *   - `p90`              — 90th percentile (tail of novelty).\n *   - `min`, `max`       — window extremes.\n *   - `currentThreshold` — threshold from the MOST RECENT row, or `null`.\n *\n * All percentile math uses the nearest-rank method (no interpolation) so\n * the report is stable across small windows.\n *\n * # Why a pure function + injected reader?\n *\n * The Doctor surface is exercised both at runtime (through the CLI and\n * gateway tools) and in tests. A pure distribution helper fed from an\n * arbitrary `readEvents` callback keeps the report logic trivially\n * testable without spinning up a real `StorageManager`.\n */\n\nimport type { BufferSurpriseEvent } from \"./types.js\";\n\nexport interface BufferSurpriseDistribution {\n  count: number;\n  triggeredCount: number;\n  triggeredRate: number;\n  mean: number;\n  median: number;\n  p90: number;\n  min: number;\n  max: number;\n  currentThreshold: number | null;\n}\n\nexport interface BufferSurpriseReportOptions {\n  /**\n   * Maximum number of recent rows to include. Defaults to `200` — large\n   * enough to see a distribution, small enough to read in one sitting.\n   */\n  limit?: number;\n  /** Lower-bound ISO timestamp; rows at or before this are excluded. */\n  since?: string;\n}\n\n/**\n * Reader callback shape. The helper does not want to know whether the\n * rows come from a file, a queue, or an in-memory buffer.\n */\nexport type BufferSurpriseReader = (\n  options: BufferSurpriseReportOptions,\n) => Promise<readonly BufferSurpriseEvent[]>;\n\n/**\n * Summarize the recent buffer-surprise distribution. Returns the empty\n * distribution shape when the ledger has no applicable rows — callers can\n * detect this via `count === 0` and render \"no data yet\".\n */\nexport async function reportBufferSurpriseDistribution(\n  readEvents: BufferSurpriseReader,\n  options: BufferSurpriseReportOptions = {},\n): Promise<BufferSurpriseDistribution> {\n  const limit =\n    typeof options.limit === \"number\" && options.limit > 0\n      ? Math.floor(options.limit)\n      : 200;\n  const raw = await readEvents({ limit, since: options.since });\n\n  // Filter for sanity: finite numeric scores in [0, 1], event tag match,\n  // and the optional `since` lower bound. Malformed rows are skipped.\n  const sinceMs =\n    typeof options.since === \"string\" && options.since.length > 0\n      ? Date.parse(options.since)\n      : Number.NaN;\n  const rows = raw.filter((row): row is BufferSurpriseEvent => {\n    if (!row || row.event !== \"BUFFER_SURPRISE\") return false;\n    if (typeof row.surpriseScore !== \"number\") return false;\n    if (!Number.isFinite(row.surpriseScore)) return false;\n    if (row.surpriseScore < 0 || row.surpriseScore > 1) return false;\n    // `triggeredFlush` must be a real boolean — not a string or other\n    // truthy value. A row with `triggeredFlush: \"false\"` (string from a\n    // JSON-parsing bug upstream) would otherwise be counted as\n    // triggered, inflating the rate and misleading operators tuning the\n    // threshold from real traffic.\n    if (typeof row.triggeredFlush !== \"boolean\") return false;\n    if (Number.isFinite(sinceMs)) {\n      const ts = Date.parse(row.timestamp);\n      if (!Number.isFinite(ts) || ts <= sinceMs) return false;\n    }\n    return true;\n  });\n\n  if (rows.length === 0) {\n    return {\n      count: 0,\n      triggeredCount: 0,\n      triggeredRate: 0,\n      mean: 0,\n      median: 0,\n      p90: 0,\n      min: 0,\n      max: 0,\n      currentThreshold: null,\n    };\n  }\n\n  const scores = rows.map((r) => r.surpriseScore).sort((a, b) => a - b);\n  const triggeredCount = rows.reduce(\n    (acc, r) => acc + (r.triggeredFlush ? 1 : 0),\n    0,\n  );\n  const sum = scores.reduce((acc, v) => acc + v, 0);\n  const mean = sum / scores.length;\n\n  // Nearest-rank percentiles keep the output stable for small windows.\n  const median = percentile(scores, 0.5);\n  const p90 = percentile(scores, 0.9);\n\n  // \"Current\" threshold is whichever was in force for the most recent row\n  // — not necessarily the one configured right now, but the value the\n  // ledger rows were judged against. That's what operators need to reason\n  // about the distribution.\n  const mostRecent = rows[rows.length - 1];\n  const currentThreshold =\n    mostRecent && typeof mostRecent.threshold === \"number\"\n      ? mostRecent.threshold\n      : null;\n\n  return {\n    count: scores.length,\n    triggeredCount,\n    triggeredRate: triggeredCount / scores.length,\n    mean,\n    median,\n    p90,\n    min: scores[0]!,\n    max: scores[scores.length - 1]!,\n    currentThreshold,\n  };\n}\n\n/**\n * Nearest-rank percentile of a pre-sorted ascending array.\n *\n * Returns `sorted[ceil(p * n) - 1]`, with `p` clamped to `[0, 1]`.\n * This avoids the interpolation ambiguity of R-7/R-8 percentiles and is\n * stable when the window is small (e.g. 3-5 rows).\n */\nfunction percentile(sorted: readonly number[], p: number): number {\n  if (sorted.length === 0) return 0;\n  const clamped = Math.max(0, Math.min(1, p));\n  const rank = Math.max(1, Math.ceil(clamped * sorted.length));\n  return sorted[rank - 1]!;\n}\n"],"mappings":";AAwEA,eAAsB,iCACpB,YACA,UAAuC,CAAC,GACH;AACrC,QAAM,QACJ,OAAO,QAAQ,UAAU,YAAY,QAAQ,QAAQ,IACjD,KAAK,MAAM,QAAQ,KAAK,IACxB;AACN,QAAM,MAAM,MAAM,WAAW,EAAE,OAAO,OAAO,QAAQ,MAAM,CAAC;AAI5D,QAAM,UACJ,OAAO,QAAQ,UAAU,YAAY,QAAQ,MAAM,SAAS,IACxD,KAAK,MAAM,QAAQ,KAAK,IACxB,OAAO;AACb,QAAM,OAAO,IAAI,OAAO,CAAC,QAAoC;AAC3D,QAAI,CAAC,OAAO,IAAI,UAAU,kBAAmB,QAAO;AACpD,QAAI,OAAO,IAAI,kBAAkB,SAAU,QAAO;AAClD,QAAI,CAAC,OAAO,SAAS,IAAI,aAAa,EAAG,QAAO;AAChD,QAAI,IAAI,gBAAgB,KAAK,IAAI,gBAAgB,EAAG,QAAO;AAM3D,QAAI,OAAO,IAAI,mBAAmB,UAAW,QAAO;AACpD,QAAI,OAAO,SAAS,OAAO,GAAG;AAC5B,YAAM,KAAK,KAAK,MAAM,IAAI,SAAS;AACnC,UAAI,CAAC,OAAO,SAAS,EAAE,KAAK,MAAM,QAAS,QAAO;AAAA,IACpD;AACA,WAAO;AAAA,EACT,CAAC;AAED,MAAI,KAAK,WAAW,GAAG;AACrB,WAAO;AAAA,MACL,OAAO;AAAA,MACP,gBAAgB;AAAA,MAChB,eAAe;AAAA,MACf,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,kBAAkB;AAAA,IACpB;AAAA,EACF;AAEA,QAAM,SAAS,KAAK,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACpE,QAAM,iBAAiB,KAAK;AAAA,IAC1B,CAAC,KAAK,MAAM,OAAO,EAAE,iBAAiB,IAAI;AAAA,IAC1C;AAAA,EACF;AACA,QAAM,MAAM,OAAO,OAAO,CAAC,KAAK,MAAM,MAAM,GAAG,CAAC;AAChD,QAAM,OAAO,MAAM,OAAO;AAG1B,QAAM,SAAS,WAAW,QAAQ,GAAG;AACrC,QAAM,MAAM,WAAW,QAAQ,GAAG;AAMlC,QAAM,aAAa,KAAK,KAAK,SAAS,CAAC;AACvC,QAAM,mBACJ,cAAc,OAAO,WAAW,cAAc,WAC1C,WAAW,YACX;AAEN,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd;AAAA,IACA,eAAe,iBAAiB,OAAO;AAAA,IACvC;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK,OAAO,CAAC;AAAA,IACb,KAAK,OAAO,OAAO,SAAS,CAAC;AAAA,IAC7B;AAAA,EACF;AACF;AASA,SAAS,WAAW,QAA2B,GAAmB;AAChE,MAAI,OAAO,WAAW,EAAG,QAAO;AAChC,QAAM,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC;AAC1C,QAAM,OAAO,KAAK,IAAI,GAAG,KAAK,KAAK,UAAU,OAAO,MAAM,CAAC;AAC3D,SAAO,OAAO,OAAO,CAAC;AACxB;","names":[]}

package/dist/{chunk-44ICJRF3.js → chunk-AYXIPSZO.js}

@@ -1,14 +1,14 @@
 import {
   getGatewayRuntimeAuthForModel,
   resolveProviderApiKey
-} from "./chunk-XZ2TIKGC.js";
+} from "./chunk-Y7R2XJ5Q.js";
+import {
+  loadModelsJsonProviders
+} from "./chunk-ODWDQNRE.js";
 import {
   buildChatCompletionTokenLimit,
   shouldAssumeOpenAiChatCompletions
 } from "./chunk-Y27UJK6V.js";
-import {
-  loadModelsJsonProviders
-} from "./chunk-ODWDQNRE.js";
 import {
   extractJsonCandidates
 } from "./chunk-UZB5KHKX.js";
@@ -458,4 +458,4 @@ function extractResponsesOutputText(data) {
 export {
   FallbackLlmClient
 };
-//# sourceMappingURL=chunk-44ICJRF3.js.map
+//# sourceMappingURL=chunk-AYXIPSZO.js.map

package/dist/{chunk-MBJHSA7F.js → chunk-BECYBZLX.js}

@@ -1,13 +1,13 @@
 import {
   cloneDefaultSessionObserverBands
 } from "./chunk-Z5LAYHGJ.js";
+import {
+  normalizeEntitySchemas
+} from "./chunk-4DJQYKMN.js";
 import {
   readEnvVar,
   resolveHomeDir
 } from "./chunk-MARWOCVP.js";
-import {
-  normalizeEntitySchemas
-} from "./chunk-4DJQYKMN.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -160,7 +160,8 @@ var VALID_MEMORY_CATEGORIES = /* @__PURE__ */ new Set([
   "moment",
   "skill",
   "rule",
-  "procedure"
+  "procedure",
+  "reasoning_trace"
 ]);
 var DEFAULT_BEHAVIOR_LOOP_PROTECTED_PARAMS = [
   "maxMemoryTokens",
@@ -192,7 +193,14 @@ var MEMORY_OS_PRESETS = {
     compressionGuidelineSemanticRefinementEnabled: false,
     maxProactiveQuestionsPerExtraction: 0,
     maxCompressionTokensPerHour: 0,
-    behaviorLoopAutoTuneEnabled: false
+    behaviorLoopAutoTuneEnabled: false,
+    // Issue #567 PR 4/5 flipped `procedural.enabled` default to `true`.
+    // The conservative preset intentionally keeps the feature OFF to
+    // match its restrictive intent (no proactive extraction, no
+    // compression guideline learning, etc.). Users who want procedural
+    // memory on a conservative preset must set `procedural.enabled: true`
+    // explicitly.
+    procedural: { enabled: false }
   },
   balanced: {
     maxMemoryTokens: 2e3,
@@ -274,16 +282,28 @@ function resolveMemoryOsPreset(value) {
 function parseConfig(raw) {
   const baseCfg = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   const memoryOsPreset = resolveMemoryOsPreset(baseCfg.memoryOsPreset);
-  const cfg = memoryOsPreset ? {
-    ...MEMORY_OS_PRESETS[memoryOsPreset],
-    ...baseCfg,
-    memoryOsPreset
-  } : baseCfg;
+  let cfg;
+  if (memoryOsPreset) {
+    const preset = MEMORY_OS_PRESETS[memoryOsPreset];
+    const presetProcedural = preset.procedural && typeof preset.procedural === "object" && !Array.isArray(preset.procedural) ? preset.procedural : void 0;
+    const baseProcedural = baseCfg.procedural && typeof baseCfg.procedural === "object" && !Array.isArray(baseCfg.procedural) ? baseCfg.procedural : void 0;
+    const mergedProcedural = presetProcedural && baseProcedural ? { ...presetProcedural, ...baseProcedural } : baseProcedural ?? presetProcedural;
+    cfg = {
+      ...preset,
+      ...baseCfg,
+      memoryOsPreset
+    };
+    if (mergedProcedural !== void 0) {
+      cfg.procedural = mergedProcedural;
+    }
+  } else {
+    cfg = baseCfg;
+  }
   let apiKey;
   if (typeof cfg.openaiApiKey === "string" && cfg.openaiApiKey.length > 0) {
     apiKey = resolveEnvVars(cfg.openaiApiKey);
   } else {
-    apiKey = process.env.OPENAI_API_KEY;
+    apiKey = readEnvVar("OPENAI_API_KEY");
   }
   const model = typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : "gpt-5.2";
   const captureMode = cfg.captureMode === "explicit" || cfg.captureMode === "hybrid" ? cfg.captureMode : "implicit";
@@ -327,19 +347,37 @@ function parseConfig(raw) {
     ) ? rawCodexCompat.compactionFlushMode : "auto",
     fingerprintDedup: rawCodexCompat.fingerprintDedup !== false
   };
+  if (cfg.procedural !== void 0 && (cfg.procedural === null || typeof cfg.procedural !== "object" || Array.isArray(cfg.procedural))) {
+    throw new Error(
+      `procedural must be an object (got ${JSON.stringify(cfg.procedural)}). Use procedural: { enabled: false } to opt out; omit the key to use the default-on behavior (issue #567 PR 4).`
+    );
+  }
   const rawProcedural = cfg.procedural && typeof cfg.procedural === "object" && !Array.isArray(cfg.procedural) ? cfg.procedural : {};
   const proceduralMinCoerced = coerceNumber(rawProcedural.minOccurrences);
   const proceduralMinRaw = proceduralMinCoerced !== void 0 ? Math.floor(proceduralMinCoerced) : 3;
   const successFloorRaw = coerceNumber(rawProcedural.successFloor);
-  const successFloor = successFloorRaw !== void 0 && successFloorRaw >= 0 && successFloorRaw <= 1 ? successFloorRaw : 0.7;
+  const successFloor = successFloorRaw !== void 0 && successFloorRaw >= 0 && successFloorRaw <= 1 ? successFloorRaw : 0.75;
   const autoPromoteOccRaw = coerceNumber(rawProcedural.autoPromoteOccurrences);
   const autoPromoteOccurrences = autoPromoteOccRaw !== void 0 && Number.isFinite(autoPromoteOccRaw) ? autoPromoteOccRaw <= 0 ? 0 : Math.min(1e4, Math.max(1, Math.floor(autoPromoteOccRaw))) : 8;
   const lookbackCoerced = coerceNumber(rawProcedural.lookbackDays);
-  const lookbackDays = lookbackCoerced !== void 0 && Number.isFinite(lookbackCoerced) ? Math.min(3650, Math.max(1, Math.floor(lookbackCoerced))) : 30;
+  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))) : 3;
+  const recallMaxProcedures = recallMaxCoerced !== void 0 && Number.isFinite(recallMaxCoerced) ? Math.min(10, Math.max(1, Math.floor(recallMaxCoerced))) : 2;
+  const rawEnabledValue = rawProcedural.enabled;
+  let proceduralEnabled;
+  if (rawEnabledValue === void 0) {
+    proceduralEnabled = true;
+  } else {
+    const enabledCoerced = coerceBool(rawEnabledValue);
+    if (enabledCoerced === void 0) {
+      throw new Error(
+        `procedural.enabled must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawEnabledValue)}). Omit the key to use the default-on behavior (issue #567 PR 4).`
+      );
+    }
+    proceduralEnabled = enabledCoerced;
+  }
   const procedural = {
-    enabled: coerceBool(rawProcedural.enabled) === true,
+    enabled: proceduralEnabled,
     /** `0` skips all mining (`minOccurrences_zero`); otherwise clusters need at least this many members. */
     minOccurrences: Math.min(1e3, Math.max(0, proceduralMinRaw)),
     successFloor,
@@ -349,6 +387,13 @@ function parseConfig(raw) {
     proceduralMiningCronAutoRegister: coerceBool(rawProcedural.proceduralMiningCronAutoRegister) === true,
     recallMaxProcedures
   };
+  const rawCodingMode = cfg.codingMode && typeof cfg.codingMode === "object" && !Array.isArray(cfg.codingMode) ? cfg.codingMode : {};
+  const codingProjectScopeRaw = coerceBool(rawCodingMode.projectScope);
+  const codingBranchScopeRaw = coerceBool(rawCodingMode.branchScope);
+  const codingMode = {
+    projectScope: codingProjectScopeRaw === void 0 ? true : codingProjectScopeRaw,
+    branchScope: codingBranchScopeRaw === true
+  };
   const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? cfg.memoryDir : DEFAULT_MEMORY_DIR;
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
@@ -435,15 +480,15 @@ function parseConfig(raw) {
     enabled: rawAgentAccessHttp?.enabled === true,
     host: typeof rawAgentAccessHttp?.host === "string" && rawAgentAccessHttp.host.trim().length > 0 ? rawAgentAccessHttp.host.trim() : "127.0.0.1",
     port: typeof rawAgentAccessHttp?.port === "number" ? Math.max(0, Math.floor(rawAgentAccessHttp.port)) : 4318,
-    authToken: typeof rawAgentAccessHttp?.authToken === "string" && rawAgentAccessHttp.authToken.trim().length > 0 ? resolveEnvVars(rawAgentAccessHttp.authToken) : process.env.OPENCLAW_REMNIC_ACCESS_TOKEN ?? process.env.OPENCLAW_ENGRAM_ACCESS_TOKEN,
-    principal: typeof rawAgentAccessHttp?.principal === "string" && rawAgentAccessHttp.principal.trim().length > 0 ? resolveEnvVars(rawAgentAccessHttp.principal) : process.env.OPENCLAW_ENGRAM_ACCESS_PRINCIPAL?.trim() || void 0,
+    authToken: typeof rawAgentAccessHttp?.authToken === "string" && rawAgentAccessHttp.authToken.trim().length > 0 ? resolveEnvVars(rawAgentAccessHttp.authToken) : readEnvVar("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnvVar("OPENCLAW_ENGRAM_ACCESS_TOKEN"),
+    principal: typeof rawAgentAccessHttp?.principal === "string" && rawAgentAccessHttp.principal.trim().length > 0 ? resolveEnvVars(rawAgentAccessHttp.principal) : readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() || void 0,
     maxBodyBytes: typeof rawAgentAccessHttp?.maxBodyBytes === "number" ? Math.max(1, Math.floor(rawAgentAccessHttp.maxBodyBytes)) : 131072
   };
   let baseUrl;
   if (typeof cfg.openaiBaseUrl === "string" && cfg.openaiBaseUrl.length > 0) {
     baseUrl = normalizeOpenaiBaseUrl(resolveEnvVars(cfg.openaiBaseUrl), "config");
   } else {
-    baseUrl = normalizeOpenaiBaseUrl(process.env.OPENAI_BASE_URL, "env");
+    baseUrl = normalizeOpenaiBaseUrl(readEnvVar("OPENAI_BASE_URL"), "env");
   }
   const sharedCrossSignalSemanticEnabled = cfg.sharedCrossSignalSemanticEnabled === true || cfg.crossSignalsSemanticEnabled === true;
   const sharedCrossSignalSemanticTimeoutMs = typeof cfg.sharedCrossSignalSemanticTimeoutMs === "number" ? Math.max(1, Math.floor(cfg.sharedCrossSignalSemanticTimeoutMs)) : typeof cfg.crossSignalsSemanticTimeoutMs === "number" ? Math.max(1, Math.floor(cfg.crossSignalsSemanticTimeoutMs)) : 4e3;
@@ -456,6 +501,36 @@ function parseConfig(raw) {
     triggerMode,
     bufferMaxTurns: typeof cfg.bufferMaxTurns === "number" ? cfg.bufferMaxTurns : 5,
     bufferMaxMinutes: typeof cfg.bufferMaxMinutes === "number" ? cfg.bufferMaxMinutes : 15,
+    // Surprise-gated buffer flush (issue #563, D-MEM). See types.ts for
+    // semantics. Default off so PR 2 ships as a pure no-op until an operator
+    // opts in. PR 4 benchmarks the flag and may flip the default.
+    //
+    // Use `coerceBool` rather than a strict `=== true` check: CLI operators
+    // set booleans via `--config bufferSurpriseTriggerEnabled=true` which
+    // arrives as the string `"true"` — the strict form would silently
+    // leave the flag off. Matches the coercion contract established for
+    // other boolean config keys (CLAUDE.md rule #36).
+    bufferSurpriseTriggerEnabled: coerceBool(cfg.bufferSurpriseTriggerEnabled) === true,
+    // Numeric surprise knobs go through `coerceNumber` so CLI operators
+    // can pass `--config bufferSurpriseThreshold=0.5` without the string
+    // silently dropping to the default. Matches the coercion contract
+    // applied to other numeric config keys (CLAUDE.md rule #28).
+    bufferSurpriseThreshold: clampSurpriseThreshold(
+      coerceNumber(cfg.bufferSurpriseThreshold),
+      0.35
+    ),
+    bufferSurpriseK: clampSurpriseK(
+      coerceNumber(cfg.bufferSurpriseK),
+      5
+    ),
+    bufferSurpriseRecentMemoryCount: clampSurpriseRecentMemoryCount(
+      coerceNumber(cfg.bufferSurpriseRecentMemoryCount),
+      20
+    ),
+    bufferSurpriseProbeTimeoutMs: clampSurpriseProbeTimeoutMs(
+      coerceNumber(cfg.bufferSurpriseProbeTimeoutMs),
+      2e3
+    ),
     consolidateEveryN: typeof cfg.consolidateEveryN === "number" ? cfg.consolidateEveryN : 3,
     highSignalPatterns: Array.isArray(cfg.highSignalPatterns) ? cfg.highSignalPatterns : [],
     maxMemoryTokens: typeof cfg.maxMemoryTokens === "number" ? cfg.maxMemoryTokens : 2e3,
@@ -544,6 +619,49 @@ function parseConfig(raw) {
     // QMD path.  Operators can opt out with
     // recallDirectAnswerEnabled=false.
     recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? true,
+    // Graph-based retrieval tier (issue #559 PR 4).  Default `false` —
+    // the tier ships off pending the `retrieval-graph` bench in PR 5.
+    recallGraphEnabled: coerceBool(cfg.recallGraphEnabled) ?? false,
+    recallGraphDamping: (() => {
+      const n = coerceNumber(cfg.recallGraphDamping);
+      return n !== void 0 && n >= 0 && n < 1 ? n : 0.85;
+    })(),
+    // Fractional integer values (e.g. `0.5`) are REJECTED rather than
+    // silently floored to zero — CLAUDE.md rule 51 ("Reject invalid
+    // user input instead of silently defaulting"). Users who set a
+    // fractional iteration cap almost certainly meant an integer and
+    // quietly flooring their value to 0 turns off the tier without
+    // warning.
+    recallGraphIterations: (() => {
+      if (cfg.recallGraphIterations === void 0) return 20;
+      const n = coerceNumber(cfg.recallGraphIterations);
+      if (n === void 0 || !Number.isFinite(n) || n < 0 || n > 500) {
+        throw new Error(
+          `recallGraphIterations must be an integer in [0, 500] (got ${JSON.stringify(cfg.recallGraphIterations)}).`
+        );
+      }
+      if (!Number.isInteger(n)) {
+        throw new Error(
+          `recallGraphIterations must be an integer (got fractional value ${n}).`
+        );
+      }
+      return n;
+    })(),
+    recallGraphTopK: (() => {
+      if (cfg.recallGraphTopK === void 0) return 50;
+      const n = coerceNumber(cfg.recallGraphTopK);
+      if (n === void 0 || !Number.isFinite(n) || n < 0 || n > 1e4) {
+        throw new Error(
+          `recallGraphTopK must be an integer in [0, 10000] (got ${JSON.stringify(cfg.recallGraphTopK)}).`
+        );
+      }
+      if (!Number.isInteger(n)) {
+        throw new Error(
+          `recallGraphTopK must be an integer (got fractional value ${n}).`
+        );
+      }
+      return n;
+    })(),
     recallDirectAnswerTokenOverlapFloor: (() => {
       const n = coerceNumber(cfg.recallDirectAnswerTokenOverlapFloor);
       return n !== void 0 && n >= 0 && n <= 1 ? n : 0.55;
@@ -561,6 +679,71 @@ function parseConfig(raw) {
     ) ? cfg.recallDirectAnswerEligibleTaxonomyBuckets.filter(
       (v) => typeof v === "string" && v.length > 0
     ) : ["decisions", "principles", "conventions", "runbooks", "entities"],
+    // Cross-namespace query-budget limiter (issue #565 PR 4/5).
+    // Defaults to false — ships disabled so existing deployments are
+    // unaffected. When enabled, the read path throttles a principal that
+    // issues a burst of recalls against namespaces other than their own.
+    recallCrossNamespaceBudgetEnabled: coerceBool(cfg.recallCrossNamespaceBudgetEnabled) ?? false,
+    recallCrossNamespaceBudgetWindowMs: (() => {
+      const n = coerceNumber(cfg.recallCrossNamespaceBudgetWindowMs);
+      return n !== void 0 && n > 0 ? Math.floor(n) : 6e4;
+    })(),
+    recallCrossNamespaceBudgetSoftLimit: (() => {
+      const n = coerceNumber(cfg.recallCrossNamespaceBudgetSoftLimit);
+      return n !== void 0 && n >= 0 ? Math.floor(n) : 10;
+    })(),
+    recallCrossNamespaceBudgetHardLimit: (() => {
+      const n = coerceNumber(cfg.recallCrossNamespaceBudgetHardLimit);
+      return n !== void 0 && n > 0 ? Math.floor(n) : 30;
+    })(),
+    // Recall-audit anomaly detector (issue #565 PR 5/5). Defaults off so
+    // existing deployments are unaffected; enable explicitly to let the
+    // access surfaces flag suspicious query patterns derived from the
+    // audit trail. Thresholds floor AFTER validating the floored value
+    // is still >= 1 — a `0.5` input that floors to 0 would turn every
+    // detector into a flood-on-anything, flipping the default to
+    // max-noise instead of max-silence.
+    recallAuditAnomalyDetectionEnabled: coerceBool(cfg.recallAuditAnomalyDetectionEnabled) ?? false,
+    recallAuditAnomalyWindowMs: (() => {
+      const n = coerceNumber(cfg.recallAuditAnomalyWindowMs);
+      if (n === void 0) return 5 * 6e4;
+      const floored = Math.floor(n);
+      return floored >= 1 ? floored : 5 * 6e4;
+    })(),
+    recallAuditAnomalyRepeatQueryLimit: (() => {
+      const n = coerceNumber(cfg.recallAuditAnomalyRepeatQueryLimit);
+      if (n === void 0) return 5;
+      const floored = Math.floor(n);
+      return floored >= 1 ? floored : 5;
+    })(),
+    recallAuditAnomalyNamespaceWalkLimit: (() => {
+      const n = coerceNumber(cfg.recallAuditAnomalyNamespaceWalkLimit);
+      if (n === void 0) return 3;
+      const floored = Math.floor(n);
+      return floored >= 1 ? floored : 3;
+    })(),
+    recallAuditAnomalyHighCardinalityLimit: (() => {
+      const n = coerceNumber(cfg.recallAuditAnomalyHighCardinalityLimit);
+      if (n === void 0) return 50;
+      const floored = Math.floor(n);
+      return floored >= 1 ? floored : 50;
+    })(),
+    recallAuditAnomalyRapidFireLimit: (() => {
+      const n = coerceNumber(cfg.recallAuditAnomalyRapidFireLimit);
+      if (n === void 0) return 30;
+      const floored = Math.floor(n);
+      return floored >= 1 ? floored : 30;
+    })(),
+    // Memory Worth recall filter (issue #560 PR 4, default flipped in PR 5).
+    // Bench result on the seeded fixture: precision@5 lifts from 0.00 to
+    // 0.60 across all 50 cases with zero regressions. See
+    // `runMemoryWorthBench` in memory-worth-bench.ts. Operators can still
+    // opt out with recallMemoryWorthFilterEnabled=false.
+    recallMemoryWorthFilterEnabled: coerceBool(cfg.recallMemoryWorthFilterEnabled) ?? true,
+    recallMemoryWorthHalfLifeMs: (() => {
+      const n = coerceNumber(cfg.recallMemoryWorthHalfLifeMs);
+      return n !== void 0 && n >= 0 ? n : 0;
+    })(),
     // Memory Linking (Phase 3A)
     memoryLinkingEnabled: cfg.memoryLinkingEnabled === true,
     // Off by default initially
@@ -637,6 +820,7 @@ function parseConfig(raw) {
     activeRecallAllowChainedActiveMemory: cfg.activeRecallAllowChainedActiveMemory === true,
     dreaming,
     procedural,
+    codingMode,
     heartbeat,
     slotBehavior,
     codexCompat,
@@ -709,6 +893,17 @@ function parseConfig(raw) {
     ) : ["correction", "commitment", "procedure"],
     semanticConsolidationIntervalHours: typeof cfg.semanticConsolidationIntervalHours === "number" ? Math.max(1, Math.floor(cfg.semanticConsolidationIntervalHours)) : 168,
     semanticConsolidationMaxPerRun: typeof cfg.semanticConsolidationMaxPerRun === "number" ? Math.max(0, Math.floor(cfg.semanticConsolidationMaxPerRun)) : 100,
+    // Operator-aware consolidation prompt (issue #561 PR 3).  Defaults
+    // to `false` to match sibling `*Enabled` flags' least-privileged
+    // convention.  Operators opt in by setting `true` (or truthy
+    // coercions like "true", "1", "yes", "on") when they want the
+    // consolidation LLM to emit SPLIT/MERGE/UPDATE operator selection
+    // on the `derived_via` frontmatter field.  Uses `coerceBool` per
+    // Gotcha #36 so CLI / env-string inputs coerce correctly.  When
+    // disabled, `derived_via` is still populated via the cluster-shape
+    // heuristic (chooseConsolidationOperator) so PR 2's provenance
+    // wiring keeps working without operator-aware prompts.
+    operatorAwareConsolidationEnabled: coerceBool(cfg.operatorAwareConsolidationEnabled) ?? false,
     creationMemoryEnabled: cfg.creationMemoryEnabled === true,
     memoryUtilityLearningEnabled: cfg.memoryUtilityLearningEnabled === true,
     promotionByOutcomeEnabled: cfg.promotionByOutcomeEnabled === true,
@@ -782,6 +977,21 @@ function parseConfig(raw) {
     extractionJudgeModel: typeof cfg.extractionJudgeModel === "string" ? cfg.extractionJudgeModel : "",
     extractionJudgeBatchSize: typeof cfg.extractionJudgeBatchSize === "number" && Number.isFinite(cfg.extractionJudgeBatchSize) ? Math.max(1, Math.round(cfg.extractionJudgeBatchSize)) : 20,
     extractionJudgeShadow: cfg.extractionJudgeShadow === true,
+    // Defer cap (issue #562 PR 2): max re-deferrals for the same candidate
+    // 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).
+    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-
+    // training/<date>.jsonl — NOT in the shared memory directory.
+    // Uses `coerceBool` per CLAUDE.md gotcha 36 for CLI-string parity.
+    collectJudgeTrainingPairs: coerceBool(cfg.collectJudgeTrainingPairs) === true,
+    judgeTrainingDir: typeof cfg.judgeTrainingDir === "string" ? cfg.judgeTrainingDir : "",
     // Inline source attribution (issue #369). Opt-in to preserve
     // backwards compatibility with existing downstream consumers.
     inlineSourceAttributionEnabled: cfg.inlineSourceAttributionEnabled === true,
@@ -913,6 +1123,8 @@ function parseConfig(raw) {
     recallMmrEnabled: cfg.recallMmrEnabled !== false,
     recallMmrLambda: typeof cfg.recallMmrLambda === "number" && Number.isFinite(cfg.recallMmrLambda) ? Math.min(1, Math.max(0, cfg.recallMmrLambda)) : 0.7,
     recallMmrTopN: typeof cfg.recallMmrTopN === "number" && Number.isFinite(cfg.recallMmrTopN) ? Math.max(0, Math.floor(cfg.recallMmrTopN)) : 40,
+    // Issue #564 PR 3: off by default; enable explicitly after bench validation.
+    recallReasoningTraceBoostEnabled: coerceBool(cfg.recallReasoningTraceBoostEnabled) ?? false,
     qmdRecallCacheTtlMs: typeof cfg.qmdRecallCacheTtlMs === "number" ? Math.max(0, Math.floor(cfg.qmdRecallCacheTtlMs)) : 6e4,
     qmdRecallCacheStaleTtlMs: typeof cfg.qmdRecallCacheStaleTtlMs === "number" ? Math.max(0, Math.floor(cfg.qmdRecallCacheStaleTtlMs)) : 10 * 6e4,
     qmdRecallCacheMaxEntries: typeof cfg.qmdRecallCacheMaxEntries === "number" ? Math.max(0, Math.floor(cfg.qmdRecallCacheMaxEntries)) : 128,
@@ -1196,6 +1408,22 @@ function clampNonNegativeNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
   return Math.max(0, Math.floor(value));
 }
+function clampSurpriseThreshold(value, fallback) {
+  if (value === void 0) return fallback;
+  return Math.min(1, Math.max(0, value));
+}
+function clampSurpriseK(value, fallback) {
+  if (value === void 0) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function clampSurpriseRecentMemoryCount(value, fallback) {
+  if (value === void 0) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function clampSurpriseProbeTimeoutMs(value, fallback) {
+  if (value === void 0) return fallback;
+  return Math.max(1, Math.floor(value));
+}
 function parseRecallSectionEntry(raw) {
   const entry = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   return {
@@ -1255,7 +1483,24 @@ function buildDefaultRecallPipeline(cfg) {
     { id: "verbatim-artifacts", enabled: cfg.verbatimArtifactsEnabled === true },
     {
       id: "procedure-recall",
-      enabled: typeof cfg.procedural === "object" && cfg.procedural !== null && !Array.isArray(cfg.procedural) && cfg.procedural.enabled === true,
+      // Default-on since issue #567 PR 4/5: the master `procedural.enabled`
+      // gate now defaults to `true` when the key is omitted, so the recall
+      // pipeline must stay in sync. Explicit `false` (or any coerceBool
+      // falsy variant) still disables recall injection.
+      //
+      // CLAUDE.md rule 48 (least-privileged defaults) + Cursor review on #609:
+      // never fail open on unrecognized values. Only `coerced === true` or
+      // the "key omitted" path enables the section. `parseConfig` throws
+      // on invalid values upstream, so this branch only ever sees boolean
+      // results — `coerced === undefined` should never happen in practice,
+      // but defense-in-depth keeps the section disabled if it ever does.
+      enabled: (() => {
+        const proceduralRaw = typeof cfg.procedural === "object" && cfg.procedural !== null && !Array.isArray(cfg.procedural) ? cfg.procedural : void 0;
+        if (proceduralRaw === void 0) return true;
+        const rawEnabled = proceduralRaw.enabled;
+        if (rawEnabled === void 0) return true;
+        return coerceBool(rawEnabled) === true;
+      })(),
       maxChars: 2400
     },
     { id: "memory-boxes", enabled: cfg.memoryBoxesEnabled === true },
@@ -1361,4 +1606,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-MBJHSA7F.js.map
+//# sourceMappingURL=chunk-BECYBZLX.js.map