@remnic/core 1.0.3 → 1.1.1

package/dist/{chunk-OJFGVJS6.js → chunk-BK2EFTE2.js}

@@ -99,6 +99,31 @@ function normalizeMemoryRelativeDir(raw, fallback) {
   const normalized = trimmed.replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0 && segment !== "." && segment !== "..").join("/");
   return normalized.length > 0 ? normalized : fallback;
 }
+function parseContradictionScanConfig(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {
+      enabled: false,
+      similarityFloor: 0.82,
+      topicOverlapFloor: 0.4,
+      maxPairsPerRun: 500,
+      cooldownDays: 14,
+      autoMergeDuplicates: false
+    };
+  }
+  const src = raw;
+  const simFloor = coerceNumber(src.similarityFloor) ?? 0.82;
+  const topicFloor = coerceNumber(src.topicOverlapFloor) ?? 0.4;
+  const maxPairs = coerceNumber(src.maxPairsPerRun) ?? 500;
+  const cooldown = coerceNumber(src.cooldownDays) ?? 14;
+  return {
+    enabled: coerceBool(src.enabled) === true,
+    similarityFloor: Math.min(1, Math.max(0, simFloor)),
+    topicOverlapFloor: Math.min(1, Math.max(0, topicFloor)),
+    maxPairsPerRun: Math.max(1, maxPairs),
+    cooldownDays: Math.max(0, cooldown),
+    autoMergeDuplicates: coerceBool(src.autoMergeDuplicates) === true
+  };
+}
 function parseSemanticChunkingConfig(raw) {
   if (!raw || typeof raw !== "object") return {};
   const src = raw;
@@ -135,7 +160,8 @@ var VALID_MEMORY_CATEGORIES = /* @__PURE__ */ new Set([
   "moment",
   "skill",
   "rule",
-  "procedure"
+  "procedure",
+  "reasoning_trace"
 ]);
 var DEFAULT_BEHAVIOR_LOOP_PROTECTED_PARAMS = [
   "maxMemoryTokens",
@@ -167,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,
@@ -249,11 +282,23 @@ 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);
@@ -302,18 +347,52 @@ 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 proceduralMinRaw = typeof rawProcedural.minOccurrences === "number" && Number.isFinite(rawProcedural.minOccurrences) ? Math.floor(rawProcedural.minOccurrences) : 3;
+  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.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))) : 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 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,
-    /** 0 disables miner emission threshold (no clusters qualify). */
+    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: typeof rawProcedural.successFloor === "number" && Number.isFinite(rawProcedural.successFloor) && rawProcedural.successFloor >= 0 && rawProcedural.successFloor <= 1 ? rawProcedural.successFloor : 0.7,
-    autoPromoteOccurrences: typeof rawProcedural.autoPromoteOccurrences === "number" && Number.isFinite(rawProcedural.autoPromoteOccurrences) ? rawProcedural.autoPromoteOccurrences <= 0 ? 0 : Math.min(1e4, Math.max(1, Math.floor(rawProcedural.autoPromoteOccurrences))) : 8,
+    successFloor,
+    autoPromoteOccurrences,
     autoPromoteEnabled: coerceBool(rawProcedural.autoPromoteEnabled) === true,
-    lookbackDays: typeof rawProcedural.lookbackDays === "number" && Number.isFinite(rawProcedural.lookbackDays) ? Math.min(3650, Math.max(1, Math.floor(rawProcedural.lookbackDays))) : 30,
+    lookbackDays,
     proceduralMiningCronAutoRegister: coerceBool(rawProcedural.proceduralMiningCronAutoRegister) === true,
-    recallMaxProcedures: typeof rawProcedural.recallMaxProcedures === "number" && Number.isFinite(rawProcedural.recallMaxProcedures) ? Math.min(10, Math.max(1, Math.floor(rawProcedural.recallMaxProcedures))) : 3
+    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;
@@ -422,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,
@@ -497,13 +606,62 @@ function parseConfig(raw) {
     contradictionSimilarityThreshold: typeof cfg.contradictionSimilarityThreshold === "number" ? cfg.contradictionSimilarityThreshold : 0.7,
     contradictionMinConfidence: typeof cfg.contradictionMinConfidence === "number" ? cfg.contradictionMinConfidence : 0.9,
     contradictionAutoResolve: cfg.contradictionAutoResolve !== false,
+    // Contradiction Scan cron (issue #520)
+    contradictionScan: parseContradictionScanConfig(cfg.contradictionScan),
     // Temporal Supersession (issue #375)
     temporalSupersessionEnabled: cfg.temporalSupersessionEnabled !== false,
     // On by default
     temporalSupersessionIncludeInRecall: cfg.temporalSupersessionIncludeInRecall === true,
     // Off by default
-    // Direct-answer retrieval tier (issue #518)
-    recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? false,
+    // Direct-answer retrieval tier (issue #518).  Default on — the
+    // tier runs in observation mode: it annotates
+    // LastRecallSnapshot.tierExplain but never short-circuits the
+    // 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;
@@ -521,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
@@ -597,6 +820,7 @@ function parseConfig(raw) {
     activeRecallAllowChainedActiveMemory: cfg.activeRecallAllowChainedActiveMemory === true,
     dreaming,
     procedural,
+    codingMode,
     heartbeat,
     slotBehavior,
     codexCompat,
@@ -669,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,
@@ -742,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,
@@ -765,6 +1015,22 @@ function parseConfig(raw) {
     localLlmFastModel: typeof cfg.localLlmFastModel === "string" && cfg.localLlmFastModel.length > 0 ? cfg.localLlmFastModel : "",
     localLlmFastUrl: typeof cfg.localLlmFastUrl === "string" && cfg.localLlmFastUrl.length > 0 ? cfg.localLlmFastUrl : typeof cfg.localLlmUrl === "string" && cfg.localLlmUrl.length > 0 ? cfg.localLlmUrl : "http://localhost:1234/v1",
     localLlmFastTimeoutMs: typeof cfg.localLlmFastTimeoutMs === "number" ? cfg.localLlmFastTimeoutMs : 15e3,
+    // Thinking-mode suppression on the main local LLM (issue #548).
+    // Default true — extraction / consolidation produce structured
+    // JSON and gain nothing from chain-of-thought; thinking-capable
+    // models burn their token budget on reasoning and blow the
+    // default 60s timeout.  Operators who need thinking on the main
+    // client (e.g. for narrative tasks) can set this to false via
+    // config or --config CLI flag.  The fast-tier `fastLlm` always
+    // disables thinking and is unaffected by this flag.
+    //
+    // Injection is backend-gated inside LocalLlmClient: the
+    // `chat_template_kwargs` field is only sent when the detected
+    // backend is in `THINKING_COMPATIBLE_BACKENDS` (LM Studio, vLLM).
+    // Strict OpenAI-compatible backends reject unknown request
+    // fields with 400, so the client fails open on unknown backends
+    // rather than tripping the 400 cooldown (Codex P1 on PR #550).
+    localLlmDisableThinking: coerceBool(cfg.localLlmDisableThinking) ?? true,
     // Gateway config (passed from index.ts for fallback AI)
     gatewayConfig: cfg.gatewayConfig,
     // Gateway model source (v9.2) — route LLM calls through gateway agent model chain
@@ -857,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,
@@ -1140,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 {
@@ -1199,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 },
@@ -1305,4 +1606,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-OJFGVJS6.js.map
+//# sourceMappingURL=chunk-BK2EFTE2.js.map