@remnic/core 1.1.1 → 1.1.3

package/dist/{chunk-BK2EFTE2.js → chunk-JWSENLQI.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";
@@ -54,6 +54,46 @@ var DEFAULT_WORKSPACE_DIR = path.join(
   ".openclaw",
   "workspace"
 );
+function coerceBooleanLike(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+      return false;
+    }
+  }
+  return void 0;
+}
+function isSecretRefShape(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.source === "string" && obj.source.trim().length > 0;
+}
+function parseAgentAccessAuthToken(raw) {
+  if (raw === void 0 || raw === null) {
+    return readEnvVar("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnvVar("OPENCLAW_ENGRAM_ACCESS_TOKEN");
+  }
+  if (typeof raw === "string") {
+    if (raw.trim().length === 0) {
+      return readEnvVar("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnvVar("OPENCLAW_ENGRAM_ACCESS_TOKEN");
+    }
+    return resolveEnvVars(raw);
+  }
+  if (isSecretRefShape(raw)) {
+    return raw;
+  }
+  throw new Error(
+    "unsupported SecretRef shape for agentAccessHttp.authToken \u2014 expected a string or an object with a non-empty `source` field (see https://github.com/joshuaswarren/remnic/issues/757)"
+  );
+}
 function resolveEnvVars(value) {
   const resolved = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, envVar) => {
     const envValue = readEnvVar(envVar);
@@ -137,6 +177,7 @@ function parseSemanticChunkingConfig(raw) {
   if (typeof src.fallbackToRecursive === "boolean") out.fallbackToRecursive = src.fallbackToRecursive;
   return out;
 }
+var DEFAULT_REASONING_MODEL = "gpt-5.2";
 var VALID_EFFORTS = ["none", "low", "medium", "high"];
 var VALID_TRIGGERS = ["smart", "every_n", "time_based"];
 var VALID_IDENTITY_INJECTION_MODES = ["recovery_only", "minimal", "full"];
@@ -303,9 +344,9 @@ function parseConfig(raw) {
   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 model = typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : DEFAULT_REASONING_MODEL;
   const captureMode = cfg.captureMode === "explicit" || cfg.captureMode === "hybrid" ? cfg.captureMode : "implicit";
   const rawEffort = cfg.reasoningEffort;
   const reasoningEffort = rawEffort && VALID_EFFORTS.includes(rawEffort) ? rawEffort : "low";
@@ -329,6 +370,58 @@ function parseConfig(raw) {
     narrativePromptStyle: rawDreaming.narrativePromptStyle === "diary" || rawDreaming.narrativePromptStyle === "analytical" ? rawDreaming.narrativePromptStyle : "reflective",
     watchFile: rawDreaming.watchFile !== false
   };
+  const rawDreamsBlock = cfg.dreams && typeof cfg.dreams === "object" && !Array.isArray(cfg.dreams) ? cfg.dreams : {};
+  const rawDreamsPhases = rawDreamsBlock.phases && typeof rawDreamsBlock.phases === "object" && !Array.isArray(rawDreamsBlock.phases) ? rawDreamsBlock.phases : {};
+  const rawDreamsLightSleep = rawDreamsPhases.lightSleep && typeof rawDreamsPhases.lightSleep === "object" && !Array.isArray(rawDreamsPhases.lightSleep) ? rawDreamsPhases.lightSleep : {};
+  const rawDreamsRem = rawDreamsPhases.rem && typeof rawDreamsPhases.rem === "object" && !Array.isArray(rawDreamsPhases.rem) ? rawDreamsPhases.rem : {};
+  const rawDreamsDeepSleep = rawDreamsPhases.deepSleep && typeof rawDreamsPhases.deepSleep === "object" && !Array.isArray(rawDreamsPhases.deepSleep) ? rawDreamsPhases.deepSleep : {};
+  const legacyLifecyclePolicyEnabled = coerceBooleanLike(cfg.lifecyclePolicyEnabled) ?? true;
+  const legacyLifecyclePromoteHeatThreshold = typeof cfg.lifecyclePromoteHeatThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecyclePromoteHeatThreshold)) : 0.55;
+  const legacyLifecycleStaleDecayThreshold = typeof cfg.lifecycleStaleDecayThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecycleStaleDecayThreshold)) : 0.65;
+  const legacyLifecycleArchiveDecayThreshold = typeof cfg.lifecycleArchiveDecayThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecycleArchiveDecayThreshold)) : 0.85;
+  const legacySemanticConsolidationEnabled = cfg.semanticConsolidationEnabled === true;
+  const legacySemanticConsolidationIntervalHours = typeof cfg.semanticConsolidationIntervalHours === "number" ? Math.max(1, Math.floor(cfg.semanticConsolidationIntervalHours)) : 168;
+  const legacySemanticConsolidationThreshold = typeof cfg.semanticConsolidationThreshold === "number" ? cfg.semanticConsolidationThreshold : 0.8;
+  const legacySemanticConsolidationMinClusterSize = typeof cfg.semanticConsolidationMinClusterSize === "number" ? Math.max(2, Math.floor(cfg.semanticConsolidationMinClusterSize)) : 3;
+  const legacySemanticConsolidationMaxPerRun = typeof cfg.semanticConsolidationMaxPerRun === "number" ? Math.max(0, Math.floor(cfg.semanticConsolidationMaxPerRun)) : 100;
+  const legacyConsolidationMinIntervalMs = typeof cfg.consolidationMinIntervalMs === "number" ? cfg.consolidationMinIntervalMs : 10 * 6e4;
+  const legacyVersioningEnabled = cfg.versioningEnabled === true;
+  const legacyVersioningMaxPerPage = typeof cfg.versioningMaxPerPage === "number" ? Math.max(0, Math.floor(cfg.versioningMaxPerPage)) : 50;
+  const legacyDeepSleepEnabled = cfg.nightlyGovernanceCronAutoRegister === true || cfg.qmdTierMigrationEnabled === true || legacyVersioningEnabled;
+  const dreamsLightSleepEnabledRaw = coerceBooleanLike(rawDreamsLightSleep.enabled);
+  const dreamsLightSleep = {
+    // new key wins; fall back to resolved legacy default
+    enabled: dreamsLightSleepEnabledRaw !== void 0 ? dreamsLightSleepEnabledRaw : legacyLifecyclePolicyEnabled,
+    cadenceMs: typeof rawDreamsLightSleep.cadenceMs === "number" ? Math.max(0, Math.floor(rawDreamsLightSleep.cadenceMs)) : 0,
+    // 0 = no override; orchestrator uses its own internal cadence
+    promoteHeatThreshold: typeof rawDreamsLightSleep.promoteHeatThreshold === "number" ? Math.min(1, Math.max(0, rawDreamsLightSleep.promoteHeatThreshold)) : legacyLifecyclePromoteHeatThreshold,
+    staleDecayThreshold: typeof rawDreamsLightSleep.staleDecayThreshold === "number" ? Math.min(1, Math.max(0, rawDreamsLightSleep.staleDecayThreshold)) : legacyLifecycleStaleDecayThreshold,
+    archiveDecayThreshold: typeof rawDreamsLightSleep.archiveDecayThreshold === "number" ? Math.min(1, Math.max(0, rawDreamsLightSleep.archiveDecayThreshold)) : legacyLifecycleArchiveDecayThreshold,
+    filterStaleEnabled: rawDreamsLightSleep.filterStaleEnabled !== void 0 ? coerceBooleanLike(rawDreamsLightSleep.filterStaleEnabled) === true : cfg.lifecycleFilterStaleEnabled === true
+  };
+  const dreamsRemEnabledRaw = coerceBooleanLike(rawDreamsRem.enabled);
+  const dreamsRem = {
+    enabled: dreamsRemEnabledRaw !== void 0 ? dreamsRemEnabledRaw : legacySemanticConsolidationEnabled,
+    cadenceMs: typeof rawDreamsRem.cadenceMs === "number" ? Math.max(0, Math.floor(rawDreamsRem.cadenceMs)) : legacySemanticConsolidationIntervalHours * 36e5,
+    similarityThreshold: typeof rawDreamsRem.similarityThreshold === "number" ? Math.min(1, Math.max(0, rawDreamsRem.similarityThreshold)) : legacySemanticConsolidationThreshold,
+    minClusterSize: typeof rawDreamsRem.minClusterSize === "number" ? Math.max(2, Math.floor(rawDreamsRem.minClusterSize)) : legacySemanticConsolidationMinClusterSize,
+    maxPerRun: typeof rawDreamsRem.maxPerRun === "number" ? Math.max(0, Math.floor(rawDreamsRem.maxPerRun)) : legacySemanticConsolidationMaxPerRun,
+    minIntervalMs: typeof rawDreamsRem.minIntervalMs === "number" ? Math.max(0, Math.floor(rawDreamsRem.minIntervalMs)) : legacyConsolidationMinIntervalMs
+  };
+  const dreamsDeepSleepEnabledRaw = coerceBooleanLike(rawDreamsDeepSleep.enabled);
+  const dreamsDeepSleep = {
+    enabled: dreamsDeepSleepEnabledRaw !== void 0 ? dreamsDeepSleepEnabledRaw : legacyDeepSleepEnabled,
+    enabledExplicitlySet: dreamsDeepSleepEnabledRaw !== void 0,
+    cadenceMs: typeof rawDreamsDeepSleep.cadenceMs === "number" ? Math.max(0, Math.floor(rawDreamsDeepSleep.cadenceMs)) : 24 * 36e5,
+    // default: 24 h (mirrors nightly governance cron)
+    versioningEnabled: rawDreamsDeepSleep.versioningEnabled !== void 0 ? coerceBooleanLike(rawDreamsDeepSleep.versioningEnabled) === true : legacyVersioningEnabled,
+    versioningMaxPerPage: typeof rawDreamsDeepSleep.versioningMaxPerPage === "number" ? Math.max(0, Math.floor(rawDreamsDeepSleep.versioningMaxPerPage)) : legacyVersioningMaxPerPage
+  };
+  const dreamsPhases = {
+    lightSleep: dreamsLightSleep,
+    rem: dreamsRem,
+    deepSleep: dreamsDeepSleep
+  };
   const rawHeartbeat = cfg.heartbeat && typeof cfg.heartbeat === "object" && !Array.isArray(cfg.heartbeat) ? cfg.heartbeat : {};
   const heartbeat = {
     enabled: rawHeartbeat.enabled === true,
@@ -390,9 +483,13 @@ function parseConfig(raw) {
   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 codingGlobalFallbackRaw = coerceBool(rawCodingMode.globalFallback);
   const codingMode = {
     projectScope: codingProjectScopeRaw === void 0 ? true : codingProjectScopeRaw,
-    branchScope: codingBranchScopeRaw === true
+    branchScope: codingBranchScopeRaw === true,
+    // Default true — project-scoped sessions include the root namespace in
+    // read fallbacks so globally useful memories remain visible. CLAUDE.md #30.
+    globalFallback: codingGlobalFallbackRaw === void 0 ? true : codingGlobalFallbackRaw
   };
   const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? cfg.memoryDir : DEFAULT_MEMORY_DIR;
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
@@ -480,15 +577,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: parseAgentAccessAuthToken(rawAgentAccessHttp?.authToken),
+    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;
@@ -541,7 +638,10 @@ function parseConfig(raw) {
     qmdColdTierEnabled: cfg.qmdColdTierEnabled === true,
     qmdColdCollection: typeof cfg.qmdColdCollection === "string" && cfg.qmdColdCollection.length > 0 ? cfg.qmdColdCollection : "openclaw-engram-cold",
     qmdColdMaxResults: typeof cfg.qmdColdMaxResults === "number" ? cfg.qmdColdMaxResults : 8,
-    qmdTierMigrationEnabled: cfg.qmdTierMigrationEnabled === true,
+    // Issue #678 PR 2/4: gate hot/cold tier migration (a deep-sleep activity)
+    // on dreams.phases.deepSleep.enabled. When deep sleep is disabled,
+    // tier migration is forced off regardless of legacy flag.
+    qmdTierMigrationEnabled: dreamsDeepSleep.enabled && cfg.qmdTierMigrationEnabled === true,
     qmdTierDemotionMinAgeDays: typeof cfg.qmdTierDemotionMinAgeDays === "number" ? Math.max(0, Math.floor(cfg.qmdTierDemotionMinAgeDays)) : 14,
     qmdTierDemotionValueThreshold: typeof cfg.qmdTierDemotionValueThreshold === "number" ? Math.max(0, Math.min(1, cfg.qmdTierDemotionValueThreshold)) : 0.35,
     qmdTierPromotionValueThreshold: typeof cfg.qmdTierPromotionValueThreshold === "number" ? Math.max(0, Math.min(1, cfg.qmdTierPromotionValueThreshold)) : 0.7,
@@ -619,6 +719,22 @@ function parseConfig(raw) {
     // QMD path.  Operators can opt out with
     // recallDirectAnswerEnabled=false.
     recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? true,
+    // Disclosure auto-escalation (issue #677 PR 4/4).  Default `manual`
+    // so pre-#677 callers see unchanged behavior.  Reject anything
+    // outside the allow-list rather than silently defaulting (CLAUDE.md
+    // rule 51).
+    recallDisclosureEscalation: (() => {
+      const raw2 = cfg.recallDisclosureEscalation;
+      if (raw2 === void 0 || raw2 === null) return "manual";
+      if (raw2 === "manual" || raw2 === "auto") return raw2;
+      throw new Error(
+        `recallDisclosureEscalation must be "manual" or "auto" (got ${JSON.stringify(raw2)}).`
+      );
+    })(),
+    recallDisclosureEscalationThreshold: (() => {
+      const n = coerceNumber(cfg.recallDisclosureEscalationThreshold);
+      return n !== void 0 && n >= 0 && n <= 1 ? n : 0.5;
+    })(),
     // 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,
@@ -819,7 +935,14 @@ function parseConfig(raw) {
     activeRecallAttachRecallExplain: cfg.activeRecallAttachRecallExplain === true,
     activeRecallAllowChainedActiveMemory: cfg.activeRecallAllowChainedActiveMemory === true,
     dreaming,
+    dreamsPhases,
     procedural,
+    // At-rest encryption (issue #690 PR 3/4)
+    // coerceBool handles CLI string inputs: `--config secureStoreEnabled=true`
+    // arrives as the string "true" which `=== true` would reject (CLAUDE.md #36).
+    secureStoreEnabled: coerceBool(cfg.secureStoreEnabled) === true,
+    secureStoreEncryptOnWrite: coerceBool(cfg.secureStoreEncryptOnWrite) !== false,
+    // default: true
     codingMode,
     heartbeat,
     slotBehavior,
@@ -830,7 +953,12 @@ function parseConfig(raw) {
     daySummaryEnabled: cfg.daySummaryEnabled !== false,
     // default: true
     hourlySummaryCronAutoRegister: cfg.hourlySummaryCronAutoRegister === true,
-    nightlyGovernanceCronAutoRegister: cfg.nightlyGovernanceCronAutoRegister === true,
+    // Codex P1 on PR 763 round 2: gate the nightly-governance cron
+    // (deep-sleep's primary scheduled execution path) on
+    // dreams.phases.deepSleep.enabled. When the phase is disabled the
+    // cron must NOT auto-register, otherwise `deepSleep.enabled=false`
+    // is a contract lie — deep-sleep keeps running.
+    nightlyGovernanceCronAutoRegister: dreamsDeepSleep.enabled && cfg.nightlyGovernanceCronAutoRegister === true,
     summaryRecallHours: typeof cfg.summaryRecallHours === "number" ? cfg.summaryRecallHours : 24,
     maxSummaryCount: typeof cfg.maxSummaryCount === "number" ? cfg.maxSummaryCount : 6,
     summaryModel: typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : model,
@@ -884,15 +1012,25 @@ function parseConfig(raw) {
     verifiedRecallEnabled: cfg.verifiedRecallEnabled === true,
     semanticRulePromotionEnabled: cfg.semanticRulePromotionEnabled === true,
     semanticRuleVerificationEnabled: cfg.semanticRuleVerificationEnabled === true,
-    semanticConsolidationEnabled: cfg.semanticConsolidationEnabled === true,
+    // Issue #678 PR 2/4: when `dreams.phases.rem.*` is set, the resolved
+    // dreamsPhases value WINS over the legacy top-level key. The runtime
+    // gates (orchestrator's `runSemanticConsolidation`) read these legacy
+    // fields, so we must propagate the precedence here, not just in the
+    // `dreamsPhases` object.
+    semanticConsolidationEnabled: dreamsRem.enabled && dreamsRem.cadenceMs > 0,
     semanticConsolidationModel: typeof cfg.semanticConsolidationModel === "string" && cfg.semanticConsolidationModel.length > 0 ? cfg.semanticConsolidationModel : "auto",
-    semanticConsolidationThreshold: typeof cfg.semanticConsolidationThreshold === "number" ? cfg.semanticConsolidationThreshold : 0.8,
-    semanticConsolidationMinClusterSize: typeof cfg.semanticConsolidationMinClusterSize === "number" ? Math.max(2, Math.floor(cfg.semanticConsolidationMinClusterSize)) : 3,
+    semanticConsolidationThreshold: dreamsRem.similarityThreshold,
+    semanticConsolidationMinClusterSize: dreamsRem.minClusterSize,
     semanticConsolidationExcludeCategories: Array.isArray(cfg.semanticConsolidationExcludeCategories) ? cfg.semanticConsolidationExcludeCategories.filter(
       (c) => typeof c === "string" && c.length > 0
     ) : ["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,
+    // semanticConsolidationIntervalHours is derived from dreamsRem.cadenceMs
+    // when an override is set (rounded up to the nearest hour). Preserve
+    // explicit zero so legacy schedulers see the same disable-by-zero signal
+    // as the dreams.phases.rem config; the runtime enabled flag is also
+    // disabled above so zero does not mean "run every maintenance cycle".
+    semanticConsolidationIntervalHours: rawDreamsRem.cadenceMs !== void 0 ? Math.max(0, Math.ceil(dreamsRem.cadenceMs / 36e5)) : legacySemanticConsolidationIntervalHours,
+    semanticConsolidationMaxPerRun: dreamsRem.maxPerRun,
     // 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
@@ -904,6 +1042,90 @@ function parseConfig(raw) {
     // heuristic (chooseConsolidationOperator) so PR 2's provenance
     // wiring keeps working without operator-aware prompts.
     operatorAwareConsolidationEnabled: coerceBool(cfg.operatorAwareConsolidationEnabled) ?? false,
+    // Pattern reinforcement (issue #687 PR 2/4).  Defaults: off, weekly
+    // cadence, min cluster size 3, target categories preference / fact
+    // / decision.  All bounds clamped at parse time so invalid inputs
+    // (negative numbers, non-arrays, non-strings) fail safe to defaults
+    // rather than crash the job.
+    patternReinforcementEnabled: coerceBool(cfg.patternReinforcementEnabled) ?? false,
+    patternReinforcementCadenceMs: (() => {
+      const raw2 = coerceNumber(cfg.patternReinforcementCadenceMs);
+      if (raw2 === void 0 || !Number.isFinite(raw2)) {
+        return 7 * 24 * 60 * 60 * 1e3;
+      }
+      return Math.max(0, Math.floor(raw2));
+    })(),
+    patternReinforcementMinCount: (() => {
+      const raw2 = coerceNumber(cfg.patternReinforcementMinCount);
+      if (raw2 === void 0 || !Number.isFinite(raw2)) return 3;
+      return Math.min(1e3, Math.max(2, Math.floor(raw2)));
+    })(),
+    patternReinforcementCategories: Array.isArray(cfg.patternReinforcementCategories) ? cfg.patternReinforcementCategories.filter((v) => typeof v === "string").map((v) => v.trim()).filter((v) => v.length > 0) : ["preference", "fact", "decision"],
+    // issue #687 PR 3/4: reinforcement recall boost config.
+    reinforcementRecallBoostEnabled: coerceBool(cfg.reinforcementRecallBoostEnabled) ?? false,
+    reinforcementRecallBoostWeight: (() => {
+      if (cfg.reinforcementRecallBoostWeight === void 0) return 0.05;
+      const n = coerceNumber(cfg.reinforcementRecallBoostWeight);
+      if (n === void 0 || !Number.isFinite(n) || n < 0 || n > 1) {
+        throw new Error(
+          `reinforcementRecallBoostWeight must be a number in [0, 1] (got ${JSON.stringify(cfg.reinforcementRecallBoostWeight)}).`
+        );
+      }
+      return n;
+    })(),
+    reinforcementRecallBoostMax: (() => {
+      if (cfg.reinforcementRecallBoostMax === void 0) return 0.3;
+      const n = coerceNumber(cfg.reinforcementRecallBoostMax);
+      if (n === void 0 || !Number.isFinite(n) || n < 0 || n > 1) {
+        throw new Error(
+          `reinforcementRecallBoostMax must be a number in [0, 1] (got ${JSON.stringify(cfg.reinforcementRecallBoostMax)}).`
+        );
+      }
+      return n;
+    })(),
+    // Async peer profile reasoner (issue #679 PR 2/5). Defaults to
+    // `false` (opt-in) per Gotchas #30/#48 — least-privileged default.
+    // `coerceBool` handles "true"/"1"/"yes"/"on" CLI strings (Gotcha
+    // #36). Numeric thresholds clamp at zero (Gotcha #28 + #45 — 0
+    // is a documented disable value for both, so the schema minimum
+    // matches and we do NOT silently bump to 1).
+    peerProfileReasonerEnabled: coerceBool(cfg.peerProfileReasonerEnabled) ?? false,
+    // Cursor M on PR #736: use the routing alias `"auto"` rather than
+    // a hardcoded model identifier. Matches the convention established
+    // by sibling `semanticConsolidationModel`. Operators can still
+    // override via config; the value is logged for telemetry only.
+    peerProfileReasonerModel: typeof cfg.peerProfileReasonerModel === "string" && cfg.peerProfileReasonerModel.trim().length > 0 ? cfg.peerProfileReasonerModel.trim() : "auto",
+    // Cursor L on PR #736: numeric config keys must coerce string CLI
+    // values (Gotcha #28 — `--config peerProfileReasonerMaxFieldsPerRun=2`
+    // arrives as the string "2"). Pre-fix `typeof === "number"`
+    // rejected string inputs and silently fell back to defaults. The
+    // shared `coerceNonNegativeInt` helper accepts both forms, throws
+    // on invalid input (Gotcha #51 — reject rather than silently
+    // default), and falls back to the documented default when the
+    // key is absent. 0 is a valid documented disable value here, so
+    // the helper does NOT bump to 1.
+    peerProfileReasonerMinInteractions: coerceNonNegativeInt(
+      cfg.peerProfileReasonerMinInteractions,
+      5,
+      "peerProfileReasonerMinInteractions"
+    ),
+    peerProfileReasonerMaxFieldsPerRun: coerceNonNegativeInt(
+      cfg.peerProfileReasonerMaxFieldsPerRun,
+      8,
+      "peerProfileReasonerMaxFieldsPerRun"
+    ),
+    // Peer profile recall injection (issue #679 PR 3/5). Default-off
+    // per Gotcha #30/#48 (least-privileged default, new feature gate).
+    // `coerceBool` handles CLI string forms "true"/"1"/"yes"/"on"
+    // (Gotcha #36). `coerceNonNegativeInt` handles string CLI values
+    // (Gotcha #28) and documents 0 as the disable value (Gotcha #45 —
+    // schema minimum must also be 0 so they stay consistent).
+    peerProfileRecallEnabled: coerceBool(cfg.peerProfileRecallEnabled) ?? false,
+    peerProfileRecallMaxFields: coerceNonNegativeInt(
+      cfg.peerProfileRecallMaxFields,
+      5,
+      "peerProfileRecallMaxFields"
+    ),
     creationMemoryEnabled: cfg.creationMemoryEnabled === true,
     memoryUtilityLearningEnabled: cfg.memoryUtilityLearningEnabled === true,
     promotionByOutcomeEnabled: cfg.promotionByOutcomeEnabled === true,
@@ -972,6 +1194,10 @@ function parseConfig(raw) {
       }
       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).
+    extractionScopeClassificationEnabled: coerceBool(cfg.extractionScopeClassificationEnabled) !== false,
     // Extraction judge (issue #376). Opt-in LLM-as-judge fact-worthiness gate.
     extractionJudgeEnabled: cfg.extractionJudgeEnabled === true,
     extractionJudgeModel: typeof cfg.extractionJudgeModel === "string" ? cfg.extractionJudgeModel : "",
@@ -997,7 +1223,8 @@ function parseConfig(raw) {
     inlineSourceAttributionEnabled: cfg.inlineSourceAttributionEnabled === true,
     inlineSourceAttributionFormat: typeof cfg.inlineSourceAttributionFormat === "string" && cfg.inlineSourceAttributionFormat.trim().length > 0 ? cfg.inlineSourceAttributionFormat : "[Source: agent={agent}, session={sessionId}, ts={ts}]",
     consolidationRequireNonZeroExtraction: cfg.consolidationRequireNonZeroExtraction !== false,
-    consolidationMinIntervalMs: typeof cfg.consolidationMinIntervalMs === "number" ? cfg.consolidationMinIntervalMs : 10 * 6e4,
+    // Issue #678 PR 2/4: dreams.phases.rem.minIntervalMs WINS when set.
+    consolidationMinIntervalMs: dreamsRem.minIntervalMs,
     // QMD maintenance (debounced singleflight)
     qmdMaintenanceEnabled: cfg.qmdMaintenanceEnabled !== false,
     qmdMaintenanceDebounceMs: typeof cfg.qmdMaintenanceDebounceMs === "number" ? cfg.qmdMaintenanceDebounceMs : 3e4,
@@ -1185,16 +1412,36 @@ function parseConfig(raw) {
     factArchivalMaxImportance: typeof cfg.factArchivalMaxImportance === "number" ? cfg.factArchivalMaxImportance : 0.3,
     factArchivalMaxAccessCount: typeof cfg.factArchivalMaxAccessCount === "number" ? cfg.factArchivalMaxAccessCount : 2,
     factArchivalProtectedCategories: Array.isArray(cfg.factArchivalProtectedCategories) ? cfg.factArchivalProtectedCategories.filter((c) => typeof c === "string") : ["commitment", "preference", "decision", "principle", "procedure"],
-    // v8.3 lifecycle policy engine (default off)
-    lifecyclePolicyEnabled: cfg.lifecyclePolicyEnabled === true,
-    lifecycleFilterStaleEnabled: cfg.lifecycleFilterStaleEnabled === true,
-    lifecyclePromoteHeatThreshold: typeof cfg.lifecyclePromoteHeatThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecyclePromoteHeatThreshold)) : 0.55,
-    lifecycleStaleDecayThreshold: typeof cfg.lifecycleStaleDecayThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecycleStaleDecayThreshold)) : 0.65,
-    lifecycleArchiveDecayThreshold: typeof cfg.lifecycleArchiveDecayThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecycleArchiveDecayThreshold)) : 0.85,
+    // Lifecycle policy engine (issue #686 PR 3/6 — flipped default to
+    // `true`).  Tier infrastructure (`tier-routing.ts`,
+    // `tier-migration.ts`, separate cold QMD collection) has shipped
+    // for several releases.  Default-on lets the year-2 retention
+    // story land for every install instead of staying gated behind
+    // an opt-in flag the typical operator never reaches.  Operators
+    // who need pre-#686 behavior (no automatic hot↔cold migration,
+    // no recall-time stale filtering) can set
+    // `lifecyclePolicyEnabled: false` explicitly. Coerce string/number
+    // boolean-likes (e.g. CLI `--config lifecyclePolicyEnabled=false`)
+    // before applying the default — otherwise an explicit false-ish
+    // input falls through and silently re-enables the policy.
+    // Issue #678 PR 2/4: dreams.phases.lightSleep.* WINS over legacy keys.
+    // The runtime gate (orchestrator's `runLifecyclePolicyPass`) reads
+    // these legacy fields, so propagate the precedence here.
+    lifecyclePolicyEnabled: dreamsLightSleep.enabled,
+    lifecycleFilterStaleEnabled: dreamsLightSleep.filterStaleEnabled,
+    lifecyclePromoteHeatThreshold: dreamsLightSleep.promoteHeatThreshold,
+    lifecycleStaleDecayThreshold: dreamsLightSleep.staleDecayThreshold,
+    lifecycleArchiveDecayThreshold: dreamsLightSleep.archiveDecayThreshold,
     lifecycleProtectedCategories: Array.isArray(cfg.lifecycleProtectedCategories) ? cfg.lifecycleProtectedCategories.filter(
       (c) => typeof c === "string" && VALID_MEMORY_CATEGORIES.has(c)
     ) : ["decision", "principle", "commitment", "preference", "procedure"],
-    lifecycleMetricsEnabled: typeof cfg.lifecycleMetricsEnabled === "boolean" ? cfg.lifecycleMetricsEnabled : cfg.lifecyclePolicyEnabled === true,
+    // Mirror the *resolved* lifecyclePolicyEnabled default (not the
+    // raw input) — otherwise omitting both flags returns `false` for
+    // metrics even though the policy is enabled by default since
+    // #686 PR 3/6.
+    // Issue #678 PR 2/4: mirror the resolved dreams light-sleep enabled flag
+    // (which already incorporates dreams.phases precedence + legacy fallback).
+    lifecycleMetricsEnabled: coerceBooleanLike(cfg.lifecycleMetricsEnabled) ?? dreamsLightSleep.enabled,
     // v8.3 proactive + policy learning (default off)
     proactiveExtractionEnabled: cfg.proactiveExtractionEnabled === true,
     contextCompressionActionsEnabled: cfg.contextCompressionActionsEnabled === true,
@@ -1314,6 +1561,20 @@ function parseConfig(raw) {
     graphLateralInhibitionEnabled: cfg.graphLateralInhibitionEnabled !== false,
     graphLateralInhibitionBeta: typeof cfg.graphLateralInhibitionBeta === "number" ? Math.max(0, Math.min(1, cfg.graphLateralInhibitionBeta)) : 0.15,
     graphLateralInhibitionTopM: typeof cfg.graphLateralInhibitionTopM === "number" ? Math.max(0, Math.round(cfg.graphLateralInhibitionTopM)) : 7,
+    // Issue #681 PR 2/3 — graph-edge confidence decay maintenance.
+    // Boolean coerced via shared helper (gotcha #36: string "false" is truthy).
+    graphEdgeDecayEnabled: coerceBooleanLike(cfg.graphEdgeDecayEnabled) ?? false,
+    graphEdgeDecayCadenceMs: typeof cfg.graphEdgeDecayCadenceMs === "number" && Number.isFinite(cfg.graphEdgeDecayCadenceMs) ? Math.max(6e4, Math.floor(cfg.graphEdgeDecayCadenceMs)) : 7 * 24 * 60 * 60 * 1e3,
+    graphEdgeDecayWindowMs: typeof cfg.graphEdgeDecayWindowMs === "number" && Number.isFinite(cfg.graphEdgeDecayWindowMs) ? Math.max(6e4, Math.floor(cfg.graphEdgeDecayWindowMs)) : 90 * 24 * 60 * 60 * 1e3,
+    graphEdgeDecayPerWindow: typeof cfg.graphEdgeDecayPerWindow === "number" && Number.isFinite(cfg.graphEdgeDecayPerWindow) ? Math.max(0, Math.min(1, cfg.graphEdgeDecayPerWindow)) : 0.1,
+    graphEdgeDecayFloor: typeof cfg.graphEdgeDecayFloor === "number" && Number.isFinite(cfg.graphEdgeDecayFloor) ? Math.max(0, Math.min(1, cfg.graphEdgeDecayFloor)) : 0.1,
+    graphEdgeDecayVisibilityThreshold: typeof cfg.graphEdgeDecayVisibilityThreshold === "number" && Number.isFinite(cfg.graphEdgeDecayVisibilityThreshold) ? Math.max(0, Math.min(1, cfg.graphEdgeDecayVisibilityThreshold)) : 0.2,
+    // Issue #681 PR 3/3 — confidence-aware traversal & PageRank refinement.
+    // Floor clamps to [0, 1] so misconfigured input cannot accept negative
+    // confidences or reject every edge. Iterations floors at 0 so a
+    // documented 0 disables PageRank refinement and BFS scores pass through.
+    graphTraversalConfidenceFloor: typeof cfg.graphTraversalConfidenceFloor === "number" && Number.isFinite(cfg.graphTraversalConfidenceFloor) ? Math.min(1, Math.max(0, cfg.graphTraversalConfidenceFloor)) : 0.2,
+    graphTraversalPageRankIterations: typeof cfg.graphTraversalPageRankIterations === "number" && Number.isFinite(cfg.graphTraversalPageRankIterations) && cfg.graphTraversalPageRankIterations >= 0 ? Math.floor(cfg.graphTraversalPageRankIterations) : 8,
     // v8.2: Temporal Memory Tree
     temporalMemoryTreeEnabled: cfg.temporalMemoryTreeEnabled === true,
     tmtHourlyMinMemories: typeof cfg.tmtHourlyMinMemories === "number" ? cfg.tmtHourlyMinMemories : 3,
@@ -1346,6 +1607,212 @@ function parseConfig(raw) {
       const codexHome = typeof raw2.codexHome === "string" && raw2.codexHome.trim().length > 0 ? raw2.codexHome.trim() : null;
       return { installExtension, codexHome };
     })(),
+    // Live connectors (issue #683 PR 2/N).
+    //
+    // Per CLAUDE.md gotcha #30 and #48, every concrete connector ships
+    // disabled-by-default and the parser MUST reject malformed top-level
+    // shapes loudly (gotcha #51) rather than silently producing an empty
+    // object.
+    //
+    // We do NOT validate credential strings here — the connector module
+    // re-validates on every sync pass via `validateGoogleDriveConfig`.
+    // That keeps secret-store-driven values (which may legitimately be
+    // empty until the operator runs setup) round-trippable through the
+    // config layer without crashing the orchestrator at boot.
+    connectors: (() => {
+      if (cfg.connectors !== void 0 && (cfg.connectors === null || typeof cfg.connectors !== "object" || Array.isArray(cfg.connectors))) {
+        throw new Error(
+          `connectors must be an object (got ${JSON.stringify(cfg.connectors)}). Use connectors: {} to opt out of every live connector.`
+        );
+      }
+      const rawConnectors = cfg.connectors && typeof cfg.connectors === "object" && !Array.isArray(cfg.connectors) ? cfg.connectors : {};
+      if (rawConnectors.googleDrive !== void 0 && (rawConnectors.googleDrive === null || typeof rawConnectors.googleDrive !== "object" || Array.isArray(rawConnectors.googleDrive))) {
+        throw new Error(
+          `connectors.googleDrive must be an object (got ${JSON.stringify(rawConnectors.googleDrive)}).`
+        );
+      }
+      const rawDrive = rawConnectors.googleDrive && typeof rawConnectors.googleDrive === "object" && !Array.isArray(rawConnectors.googleDrive) ? rawConnectors.googleDrive : {};
+      const driveEnabled = coerceBool(rawDrive.enabled) === true;
+      const driveClientId = typeof rawDrive.clientId === "string" ? rawDrive.clientId : "";
+      const driveClientSecret = typeof rawDrive.clientSecret === "string" ? rawDrive.clientSecret : "";
+      const driveRefreshToken = typeof rawDrive.refreshToken === "string" ? rawDrive.refreshToken : "";
+      const drivePollCoerced = coerceNumber(rawDrive.pollIntervalMs);
+      let drivePollIntervalMs = 3e5;
+      if (drivePollCoerced !== void 0) {
+        if (!Number.isFinite(drivePollCoerced) || !Number.isInteger(drivePollCoerced) || drivePollCoerced < 1e3 || drivePollCoerced > 864e5) {
+          throw new Error(
+            `connectors.googleDrive.pollIntervalMs must be an integer in [1000, 86400000] ms (got ${JSON.stringify(rawDrive.pollIntervalMs)})`
+          );
+        }
+        drivePollIntervalMs = drivePollCoerced;
+      }
+      let driveFolderIds = [];
+      if (rawDrive.folderIds !== void 0) {
+        if (!Array.isArray(rawDrive.folderIds)) {
+          throw new Error(
+            `connectors.googleDrive.folderIds must be an array of strings (got ${typeof rawDrive.folderIds})`
+          );
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const value of rawDrive.folderIds) {
+          if (typeof value !== "string") {
+            throw new Error(
+              `connectors.googleDrive.folderIds entries must be strings; found ${typeof value}`
+            );
+          }
+          const trimmed = value.trim();
+          if (trimmed.length === 0) continue;
+          if (seen.has(trimmed)) continue;
+          seen.add(trimmed);
+          driveFolderIds.push(trimmed);
+        }
+      }
+      if (rawConnectors.notion !== void 0 && (rawConnectors.notion === null || typeof rawConnectors.notion !== "object" || Array.isArray(rawConnectors.notion))) {
+        throw new Error(
+          `connectors.notion must be an object (got ${JSON.stringify(rawConnectors.notion)}).`
+        );
+      }
+      const rawNotion = rawConnectors.notion && typeof rawConnectors.notion === "object" && !Array.isArray(rawConnectors.notion) ? rawConnectors.notion : {};
+      const notionEnabled = coerceBool(rawNotion.enabled) === true;
+      const notionToken = typeof rawNotion.token === "string" ? rawNotion.token : "";
+      const notionPollCoerced = coerceNumber(rawNotion.pollIntervalMs);
+      let notionPollIntervalMs = 3e5;
+      if (notionPollCoerced !== void 0) {
+        if (!Number.isFinite(notionPollCoerced) || !Number.isInteger(notionPollCoerced) || notionPollCoerced < 1e3 || notionPollCoerced > 864e5) {
+          throw new Error(
+            `connectors.notion.pollIntervalMs must be an integer in [1000, 86400000] ms (got ${JSON.stringify(rawNotion.pollIntervalMs)})`
+          );
+        }
+        notionPollIntervalMs = notionPollCoerced;
+      }
+      let notionDatabaseIds = [];
+      if (rawNotion.databaseIds !== void 0) {
+        if (!Array.isArray(rawNotion.databaseIds)) {
+          throw new Error(
+            `connectors.notion.databaseIds must be an array of strings (got ${typeof rawNotion.databaseIds})`
+          );
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const value of rawNotion.databaseIds) {
+          if (typeof value !== "string") {
+            throw new Error(
+              `connectors.notion.databaseIds entries must be strings; found ${typeof value}`
+            );
+          }
+          const trimmed = value.trim();
+          if (trimmed.length === 0) continue;
+          if (seen.has(trimmed)) continue;
+          seen.add(trimmed);
+          notionDatabaseIds.push(trimmed);
+        }
+      }
+      if (rawConnectors.gmail !== void 0 && (rawConnectors.gmail === null || typeof rawConnectors.gmail !== "object" || Array.isArray(rawConnectors.gmail))) {
+        throw new Error(
+          `connectors.gmail must be an object (got ${JSON.stringify(rawConnectors.gmail)}).`
+        );
+      }
+      const rawGmail = rawConnectors.gmail && typeof rawConnectors.gmail === "object" && !Array.isArray(rawConnectors.gmail) ? rawConnectors.gmail : {};
+      const gmailEnabled = coerceBool(rawGmail.enabled) === true;
+      const gmailClientId = typeof rawGmail.clientId === "string" ? rawGmail.clientId : "";
+      const gmailClientSecret = typeof rawGmail.clientSecret === "string" ? rawGmail.clientSecret : "";
+      const gmailRefreshToken = typeof rawGmail.refreshToken === "string" ? rawGmail.refreshToken : "";
+      const gmailUserId = typeof rawGmail.userId === "string" && rawGmail.userId.trim().length > 0 ? rawGmail.userId.trim() : "me";
+      const gmailQuery = typeof rawGmail.query === "string" ? rawGmail.query : "in:inbox";
+      const gmailPollCoerced = coerceNumber(rawGmail.pollIntervalMs);
+      let gmailPollIntervalMs = 3e5;
+      if (rawGmail.pollIntervalMs !== void 0) {
+        if (gmailPollCoerced === void 0) {
+          throw new Error(
+            `connectors.gmail.pollIntervalMs must be a finite number; got ${JSON.stringify(rawGmail.pollIntervalMs)}`
+          );
+        }
+        if (gmailPollCoerced <= 0) {
+          throw new Error(
+            `connectors.gmail.pollIntervalMs must be positive; got ${JSON.stringify(rawGmail.pollIntervalMs)}`
+          );
+        }
+        if (!Number.isInteger(gmailPollCoerced) || gmailPollCoerced < 1e3 || gmailPollCoerced > 864e5) {
+          throw new Error(
+            `connectors.gmail.pollIntervalMs must be an integer in [1000, 86400000] ms (got ${JSON.stringify(rawGmail.pollIntervalMs)})`
+          );
+        }
+        gmailPollIntervalMs = gmailPollCoerced;
+      }
+      if (rawConnectors.github !== void 0 && (rawConnectors.github === null || typeof rawConnectors.github !== "object" || Array.isArray(rawConnectors.github))) {
+        throw new Error(
+          `connectors.github must be an object (got ${JSON.stringify(rawConnectors.github)}).`
+        );
+      }
+      const rawGitHub = rawConnectors.github && typeof rawConnectors.github === "object" && !Array.isArray(rawConnectors.github) ? rawConnectors.github : {};
+      const githubEnabled = coerceBool(rawGitHub.enabled) === true;
+      const githubToken = typeof rawGitHub.token === "string" ? rawGitHub.token : "";
+      const githubUserLogin = typeof rawGitHub.userLogin === "string" ? rawGitHub.userLogin : "";
+      const githubPollCoerced = coerceNumber(rawGitHub.pollIntervalMs);
+      let githubPollIntervalMs = 3e5;
+      if (githubPollCoerced !== void 0) {
+        if (!Number.isFinite(githubPollCoerced) || !Number.isInteger(githubPollCoerced) || githubPollCoerced < 1e3 || githubPollCoerced > 864e5) {
+          throw new Error(
+            `connectors.github.pollIntervalMs must be an integer in [1000, 86400000] ms (got ${JSON.stringify(rawGitHub.pollIntervalMs)})`
+          );
+        }
+        githubPollIntervalMs = githubPollCoerced;
+      }
+      let githubRepos = [];
+      if (rawGitHub.repos !== void 0) {
+        if (!Array.isArray(rawGitHub.repos)) {
+          throw new Error(
+            `connectors.github.repos must be an array of strings (got ${typeof rawGitHub.repos})`
+          );
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const value of rawGitHub.repos) {
+          if (typeof value !== "string") {
+            throw new Error(
+              `connectors.github.repos entries must be strings; found ${typeof value}`
+            );
+          }
+          const trimmed = value.trim();
+          if (trimmed.length === 0) continue;
+          if (seen.has(trimmed)) continue;
+          seen.add(trimmed);
+          githubRepos.push(trimmed);
+        }
+      }
+      const githubIncludeDiscussions = coerceBool(rawGitHub.includeDiscussions) === true;
+      return {
+        googleDrive: {
+          enabled: driveEnabled,
+          clientId: driveClientId,
+          clientSecret: driveClientSecret,
+          refreshToken: driveRefreshToken,
+          pollIntervalMs: drivePollIntervalMs,
+          folderIds: driveFolderIds
+        },
+        notion: {
+          enabled: notionEnabled,
+          token: notionToken,
+          databaseIds: notionDatabaseIds,
+          pollIntervalMs: notionPollIntervalMs
+        },
+        gmail: {
+          enabled: gmailEnabled,
+          clientId: gmailClientId,
+          clientSecret: gmailClientSecret,
+          refreshToken: gmailRefreshToken,
+          userId: gmailUserId,
+          query: gmailQuery,
+          pollIntervalMs: gmailPollIntervalMs
+        },
+        github: {
+          enabled: githubEnabled,
+          token: githubToken,
+          userLogin: githubUserLogin,
+          repos: githubRepos,
+          pollIntervalMs: githubPollIntervalMs,
+          includeDiscussions: githubIncludeDiscussions
+        }
+      };
+    })(),
     // MECE Taxonomy (#366)
     // Coerce string booleans from CLI (e.g. --config taxonomyEnabled=true) — gotcha #36
     taxonomyEnabled: coerceBool(cfg.taxonomyEnabled) ?? false,
@@ -1360,9 +1827,10 @@ function parseConfig(raw) {
     // Codex CLI — marketplace integration (#418)
     codexMarketplaceEnabled: cfg.codexMarketplaceEnabled !== false,
     // default: true
-    // Page-level versioning (issue #371)
-    versioningEnabled: cfg.versioningEnabled === true,
-    versioningMaxPerPage: typeof cfg.versioningMaxPerPage === "number" ? Math.max(0, Math.floor(cfg.versioningMaxPerPage)) : 50,
+    // Page-level versioning (issue #371). Issue #678 PR 2/4:
+    // dreams.phases.deepSleep.* WINS over legacy keys.
+    versioningEnabled: dreamsDeepSleep.enabled && dreamsDeepSleep.versioningEnabled,
+    versioningMaxPerPage: dreamsDeepSleep.versioningMaxPerPage,
     versioningSidecarDir: typeof cfg.versioningSidecarDir === "string" && cfg.versioningSidecarDir.trim().length > 0 ? cfg.versioningSidecarDir.trim() : ".versions",
     // Binary file lifecycle management (#367)
     binaryLifecycleEnabled: cfg.binaryLifecycleEnabled === true,
@@ -1408,6 +1876,17 @@ function clampNonNegativeNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
   return Math.max(0, Math.floor(value));
 }
+function coerceNonNegativeInt(value, fallback, keyName) {
+  if (value === void 0 || value === null) return fallback;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || coerced < 0) {
+    const label = keyName ? ` (${keyName})` : "";
+    throw new Error(
+      `config value${label} must be a non-negative finite number; got ${JSON.stringify(value)}`
+    );
+  }
+  return Math.floor(coerced);
+}
 function clampSurpriseThreshold(value, fallback) {
   if (value === void 0) return fallback;
   return Math.min(1, Math.max(0, value));
@@ -1603,7 +2082,8 @@ function buildRecallPipelineConfig(cfg) {
 
 export {
   coerceInstallExtension,
+  DEFAULT_REASONING_MODEL,
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-BK2EFTE2.js.map
+//# sourceMappingURL=chunk-JWSENLQI.js.map