@remnic/core 10.0.3 → 10.0.5

package/dist/who-knows.js

@@ -9,29 +9,29 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-2NV7MMMM.js";
-import "./chunk-6JIHC5AS.js";
-import "./chunk-UHVXE24Y.js";
+} from "./chunk-XQSJXNWC.js";
+import "./chunk-37HCPM56.js";
 import "./chunk-46WM6JX2.js";
+import "./chunk-UHVXE24Y.js";
 import "./chunk-V4JZCTMK.js";
-import "./chunk-GUD6FYQG.js";
-import "./chunk-OV7EYM6M.js";
-import "./chunk-S7LWX2PQ.js";
-import "./chunk-T2YX56QI.js";
-import "./chunk-CYEPCZN5.js";
+import "./chunk-RSMIRLKM.js";
+import "./chunk-U6OXJQEH.js";
 import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
-import "./chunk-4O6WRBGE.js";
 import "./chunk-5BUCKFRE.js";
+import "./chunk-S7LWX2PQ.js";
+import "./chunk-T2YX56QI.js";
+import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-QCP75JGO.js";
-import "./chunk-A7Q43EUZ.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
+import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-X3724WL4.js";
-import "./chunk-S2HLHAZ4.js";
 import "./chunk-MRPOZBJC.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";
@@ -39,13 +39,12 @@ import "./chunk-2DT7PIDZ.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-EIFYYHAF.js";
 import "./chunk-ZIKENA2C.js";
-import "./chunk-345MEMRU.js";
+import "./chunk-3OUGSOJP.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
-import "./chunk-5GINB5LC.js";
 import "./chunk-3WU7XOFN.js";
-import "./chunk-G7D6GZ5J.js";
+import "./chunk-6MKLMEBE.js";
 import "./chunk-W5XWHTDO.js";
 import "./chunk-M5GVCJSJ.js";
 import "./chunk-RBOJCG4T.js";
@@ -53,12 +52,13 @@ import "./chunk-R7QY5ZVB.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-7CT3AI52.js";
-import "./chunk-IB63OVUB.js";
+import "./chunk-G7D6GZ5J.js";
+import "./chunk-AJ6ORARY.js";
+import "./chunk-IUM3VSHI.js";
 import "./chunk-G26YNEOC.js";
 import "./chunk-IM2GO42H.js";
 import "./chunk-TPSLVZHS.js";
 import "./chunk-SIGAGKNE.js";
-import "./chunk-IUM3VSHI.js";
 import "./chunk-23G5P7TA.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
@@ -68,12 +68,14 @@ import "./chunk-L2EXJQJP.js";
 import "./chunk-45GF7Y3V.js";
 import "./chunk-EP6BA7VV.js";
 import "./chunk-E2AWJ7KQ.js";
+import "./chunk-Z7L72ZHL.js";
+import "./chunk-4O4TKIXQ.js";
 import "./chunk-YCVB7X56.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
-import "./chunk-Z7L72ZHL.js";
-import "./chunk-4O4TKIXQ.js";
+import "./chunk-QWWMS4AE.js";
+import "./chunk-YBA52OKG.js";
 import "./chunk-5AYUHSAU.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-PO7NXNGC.js";
@@ -81,22 +83,20 @@ import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-22DYJLFN.js";
+import "./chunk-XVC7JU2N.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
+import "./chunk-PWPIERBM.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-N4PYB235.js";
-import "./chunk-AW4QUFQF.js";
+import "./chunk-BTNNL7ZW.js";
 import "./chunk-5FVVY2EB.js";
-import "./chunk-FFAZ2XFU.js";
-import "./chunk-RKDSELA3.js";
-import "./chunk-YBA52OKG.js";
-import "./chunk-PWPIERBM.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VUFL7X3H.js";
 import "./chunk-2EMROIXS.js";

package/dist/write-envelope.js

@@ -17,10 +17,10 @@ import "./chunk-BT7NVCML.js";
 import "./chunk-PO7NXNGC.js";
 import "./chunk-N4PYB235.js";
 import "./chunk-5FVVY2EB.js";
-import "./chunk-FFAZ2XFU.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-MAAL6OZV.js";
 import "./chunk-A6XUJE5D.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.3",
+  "version": "10.0.5",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3327,7 +3327,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.3"
+    "@remnic/coding-graph": "^10.0.5"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-cli.ts

@@ -207,6 +207,7 @@ function usage(): string {
     "Correct options (issue #1580 — one plan/apply pipeline for all corrections):",
     "  --text \"<correction>\"          plan a correction from natural language",
     "  --id <memoryId> (repeatable)   explicit target memory ids",
+    "  --duplicate-of <memoryId>      winner id; requires exactly one --id (skips the classifier)",
     "  --apply                        apply a pending plan (requires --plan-id + --confirm)",
     "  --plan-id <id>                 the plan to apply or discard",
     "  --confirm                      confirm the apply (safety guard, rule 48)",
@@ -297,6 +298,7 @@ const COMMAND_SPECS: Record<CommandName, CommandSpec> = {
     valueOptions: new Set([
       "text",
       "id",
+      "duplicate-of",
       "plan-id",
       "namespace",
       "session-key",
@@ -830,6 +832,7 @@ async function runCorrect(args: ParsedArgs, preferredId?: string): Promise<void>
   // so schema validation + namespace policy reach this path (same as MCP/HTTP).
   const text = requireOption(args, "text");
   const targetIds = getAllOptions(args, "id");
+  const duplicateOf = getLastOption(args, "duplicate-of");
   const planOp = getOperation("memory_correct_plan");
   if (!planOp) {
     throw new Error("access-boundary: operation not registered: memory_correct_plan");
@@ -838,6 +841,7 @@ async function runCorrect(args: ParsedArgs, preferredId?: string): Promise<void>
     {
       text,
       ...(targetIds.length > 0 ? { targetIds } : {}),
+      ...(duplicateOf ? { duplicateOf } : {}),
       ...(sessionKey ? { sessionKey } : {}),
       ...(namespace ? { namespace } : {}),
     },

package/src/access-http.ts

@@ -1999,6 +1999,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        ...(abortSignal ? { abortSignal } : {}),
       })) as { result: unknown };
       this.recordWriteRateLimitHit(req);
       this.respondJson(res, 200, output.result);

package/src/access-mcp-correction-tools.ts

@@ -0,0 +1,56 @@
+/**
+ * Correction MCP tool descriptors.
+ *
+ * Extracted from access-mcp.ts (over its fileSizeGrandfather ceiling) so
+ * `duplicateOf` can land without growing that file. Aliases are applied by
+ * the caller via withToolAliases.
+ */
+import type { McpTool } from "./access-mcp.js";
+
+export const correctionMcpTools: McpTool[] = [
+  {
+    name: "engram.memory_correct_plan",
+    description:
+      "Plan a memory correction from a plain-language statement. Returns a CorrectionPlan with a diff preview; apply via memory_correct_apply. Pass duplicateOf plus one targetIds entry to supersede that duplicate without calling the classifier.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: 'The natural-language correction (e.g. "we migrated to MySQL in March").',
+        },
+        targetIds: {
+          type: "array",
+          items: { type: "string" },
+          description:
+            "Optional explicit target memory ids. When omitted, the planner searches. With duplicateOf, pass exactly the duplicate id.",
+        },
+        duplicateOf: {
+          type: "string",
+          description:
+            "Optional winner memory id. Requires targetIds to be exactly the duplicate. Skips classification and drafts one recoverable supersede (no hard delete) linking the duplicate to this id.",
+        },
+        sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
+        namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." },
+      },
+      required: ["text"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "engram.memory_correct_apply",
+    description:
+      "Apply a planned memory correction by planId. Requires confirm: true when correction.applyRequiresConfirm is on (default).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        planId: { type: "string", description: "The plan id returned by memory_correct_plan." },
+        confirm: { type: "boolean", description: "Must be true to apply (safety guard)." },
+        sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
+        namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." },
+      },
+      required: ["planId"],
+      additionalProperties: false,
+    },
+  },
+];

package/src/access-mcp.ts

@@ -1,4 +1,5 @@
 import { sharedContextMcpTools } from "./access-mcp-shared-context-tools.js";
+import { correctionMcpTools } from "./access-mcp-correction-tools.js";
 import { randomUUID } from "node:crypto";
 import {
   MCP_ADMIN_OPS_MIGRATED_OPERATIONS,
@@ -2133,56 +2134,10 @@ export class EngramMcpServer {
       this.tools = [...this.tools, ...deltaTools];
     }
     if (this.correctionVisible) {
-      // Correction Contract (issue #1580) — one plan/apply pipeline for every
-      // memory correction. Both tools dispatch through the boundary operations
-      // (memory_correct_plan / memory_correct_apply) which delegate to the
-      // CorrectionService.
-      const planTool = withToolAliases(
-        {
-          name: "engram.memory_correct_plan",
-          description:
-            "Plan a memory correction from a plain-language statement (issue #1580). Returns a CorrectionPlan with a diff preview; apply via memory_correct_apply.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              text: {
-                type: "string",
-                description: 'The natural-language correction (e.g. "we migrated to MySQL in March").',
-              },
-              targetIds: {
-                type: "array",
-                items: { type: "string" },
-                description: "Optional explicit target memory ids. When omitted, the planner searches.",
-              },
-              sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
-              namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." },
-            },
-            required: ["text"],
-            additionalProperties: false,
-          },
-        },
-        this.emitLegacyTools
-      );
-      const applyTool = withToolAliases(
-        {
-          name: "engram.memory_correct_apply",
-          description:
-            "Apply a planned memory correction by planId (issue #1580). Requires confirm: true when correction.applyRequiresConfirm is on (default).",
-          inputSchema: {
-            type: "object",
-            properties: {
-              planId: { type: "string", description: "The plan id returned by memory_correct_plan." },
-              confirm: { type: "boolean", description: "Must be true to apply (safety guard, rule 48)." },
-              sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
-              namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." },
-            },
-            required: ["planId"],
-            additionalProperties: false,
-          },
-        },
-        this.emitLegacyTools
+      const correctionTools = correctionMcpTools.flatMap((tool) =>
+        withToolAliases(tool, this.emitLegacyTools),
       );
-      this.tools = [...this.tools, ...planTool, ...applyTool];
+      this.tools = [...this.tools, ...correctionTools];
     }
     if (this.chatVisible) {
       const chatTools = withToolAliases(

package/src/access-operations.ts

@@ -384,6 +384,7 @@ const memoryCorrectPlanSchema = z.preprocess(
   z.object({
     text: z.string().trim().min(1).max(10_000),
     targetIds: z.array(z.string().trim().min(1).max(512)).optional(),
+    duplicateOf: z.string().trim().min(1).max(512).optional(),
     sessionKey: z.string().trim().max(512).optional(),
     namespace: z.string().trim().max(256).optional(),
   }),
@@ -392,6 +393,7 @@ const memoryCorrectPlanSchema = z.preprocess(
 export interface MemoryCorrectPlanInput {
   text: string;
   targetIds?: string[];
+  duplicateOf?: string;
   sessionKey?: string;
   namespace?: string;
 }
@@ -414,6 +416,7 @@ export const memoryCorrectPlanOperation = defineOperation<
         {
           text: input.text,
           ...(input.targetIds ? { targetIds: input.targetIds } : {}),
+          ...(input.duplicateOf ? { duplicateOf: input.duplicateOf } : {}),
           ...(input.sessionKey ? { sessionKey: input.sessionKey } : {}),
           ...(input.namespace ? { namespace: input.namespace } : {}),
           ...(ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}),

package/src/access-service.ts

@@ -3349,24 +3349,6 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
           return Promise.resolve(false);
         }
       },
-      // Wire the orchestrator's extraction LLM so classify+draft actually
-      // drafts actions instead of always hitting the deterministic fallback
-      // (review thread PG5). The planner's classifyAndDraft already falls back
-      // on any LLM outage, so returning null (LLM disabled/cooldown) or a
-      // thrown error both degrade safely to the deterministic path (rule 13).
-      llmComplete: async ({ system, user }) => {
-        const result = await this.orchestrator.localLlm.chatCompletion(
-          [
-            { role: "system", content: system },
-            { role: "user", content: user },
-          ],
-          { operation: "correction-classify", priority: "background" }
-        );
-        if (!result) {
-          throw new Error("correction classify+draft: local LLM unavailable (disabled or in cooldown)");
-        }
-        return result.content;
-      },
     });
     this._correctionService = service;
     return service;
@@ -3389,11 +3371,20 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
   }
 
   async correctionPlan(request: CorrectionRequest, opts?: { abortSignal?: AbortSignal }): Promise<CorrectionPlan> {
+    let next = request;
     if (request.targetIds?.some((id) => isHandleToken(id))) {
-      const targetIds = request.targetIds.map((id) => this.resolveMemoryIdOrHandleInput(id, request.sessionKey));
-      return this.correctionService().plan({ ...request, targetIds }, opts);
+      next = {
+        ...next,
+        targetIds: request.targetIds.map((id) => this.resolveMemoryIdOrHandleInput(id, request.sessionKey)),
+      };
+    }
+    if (request.duplicateOf && isHandleToken(request.duplicateOf)) {
+      next = {
+        ...next,
+        duplicateOf: this.resolveMemoryIdOrHandleInput(request.duplicateOf, request.sessionKey),
+      };
     }
-    return this.correctionService().plan(request, opts);
+    return this.correctionService().plan(next, opts);
   }
 
   async correctionApply(

package/src/config.test.ts

@@ -2463,6 +2463,32 @@ test("parseConfig rejects invalid correction.planTtlHours instead of silently de
   assert.equal(parseConfig({}).correctionPlanTtlHours, 24, "absent → documented default");
 });
 
+test("parseConfig correction.classifyTimeoutMs defaults to 45000 and rejects invalid values", () => {
+  assert.equal(parseConfig({}).correctionClassifyTimeoutMs, 45_000);
+  assert.equal(parseConfig({ correction: { classifyTimeoutMs: 12000 } }).correctionClassifyTimeoutMs, 12_000);
+  assert.equal(
+    parseConfig({
+      correction: { classifyTimeoutMs: 8000 },
+      correctionClassifyTimeoutMs: 1000,
+    }).correctionClassifyTimeoutMs,
+    8000,
+    "nested correction.classifyTimeoutMs wins",
+  );
+  assert.equal(parseConfig({ correctionClassifyTimeoutMs: 15000 }).correctionClassifyTimeoutMs, 15_000);
+  for (const value of [0, -1, 3.7, "abc", 300_001, true]) {
+    assert.throws(
+      () => parseConfig({ correctionClassifyTimeoutMs: value } as Record<string, unknown>),
+      /Invalid correction\.classifyTimeoutMs/,
+      `correctionClassifyTimeoutMs=${JSON.stringify(value)} should throw`,
+    );
+    assert.throws(
+      () => parseConfig({ correction: { classifyTimeoutMs: value } } as Record<string, unknown>),
+      /Invalid correction\.classifyTimeoutMs/,
+      `nested classifyTimeoutMs=${JSON.stringify(value)} should throw`,
+    );
+  }
+});
+
 test("parseConfig correction.maxAffected rejects non-integers (Number.isInteger, #1678)", () => {
   // The error message says "integer" — 3.7 must be rejected, not silently floored to 3.
   for (const value of [3.7, 2.5, "1.5", 0.99]) {
@@ -2625,6 +2651,15 @@ test("parseConfig projection-rebuild knobs: defaults, boolean coercion, numeric
   assert.throws(() => parseConfig({ projectionRebuildIntervalMs: 1000 }), /projectionRebuildIntervalMs/);
   assert.throws(() => parseConfig({ projectionRebuildIntervalMs: 3600000.5 }), /projectionRebuildIntervalMs/);
   assert.throws(() => parseConfig({ projectionRebuildIntervalMs: "abc" }), /projectionRebuildIntervalMs/);
+
+  assert.equal(defaults.projectionRebuildHeapUsageLimit, 0.6);
+  assert.equal(parseConfig({ projectionRebuildHeapUsageLimit: 0.5 }).projectionRebuildHeapUsageLimit, 0.5);
+  assert.equal(parseConfig({ projectionRebuildHeapUsageLimit: "0.5" }).projectionRebuildHeapUsageLimit, 0.5);
+  assert.equal(parseConfig({ projectionRebuildHeapUsageLimit: 1 }).projectionRebuildHeapUsageLimit, 1);
+  assert.throws(() => parseConfig({ projectionRebuildHeapUsageLimit: 0 }), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseConfig({ projectionRebuildHeapUsageLimit: -0.2 }), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseConfig({ projectionRebuildHeapUsageLimit: 1.1 }), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseConfig({ projectionRebuildHeapUsageLimit: "abc" }), /projectionRebuildHeapUsageLimit/);
 });
 
 test("parseConfig forwards activity source settings", () => {

package/src/config.ts

@@ -28,6 +28,7 @@ import type {
 import { parseBackgroundGeneration } from "./background-generation-config.js";
 import { parseSearchBackend } from "./config-search-backend.js";
 import { parseLocalLlmConfig } from "./local-llm-config.js";
+import { parseCorrectionConfig } from "./correction/correction-config.js";
 import { parseConvergeConfig } from "./converge-config.js";
 import { parseExternalWikiRecallGuard } from "./external-wiki-guard.js";
 import { log } from "./logger.js";
@@ -81,6 +82,7 @@ import { parseCaptureCompanionConfigs } from "./location/parse-companions.js";
 import { parseLocationConfig } from "./location/config.js";
 import { parseOkfConfig } from "./okf/config.js";
 import { parseBoundedJsonlStateConfig } from "./bounded-jsonl-state.js";
+import { parseProjectionRebuildScheduleConfig } from "./projection-rebuild-config.js";
 import { parseCodingKnowledgeConfig } from "./coding/coding-knowledge-config.js";
 import { parseActionGateConfig } from "./coding/action-gate.js";
 import { parseChatConfig } from "./chat/chat-config.js";
@@ -1854,66 +1856,9 @@ export function parseConfig(
     // (docs kept honest — review: wire resolver before exposing the gate).
     temporalBiTemporal: coerceBool(cfg.temporalBiTemporal) ?? false,
     temporalExpiredInInjection: coerceBool(cfg.temporalExpiredInInjection) ?? false,
-    // Correction Contract (issue #1580). Parsed here so operators can actually
-    // set the documented toggles/limits (review thread Txp): parseConfig builds
-    // an explicit output, so without these lines the raw `correction` block /
-    // flat legacy keys are dropped and the runtime always sees defaults. Nested
-    // `correction.<key>` wins; flat `correction<Key>` is the legacy fallback.
-    correctionEnabled: (() => {
-      const nested = (cfg.correction as Record<string, unknown> | undefined)?.enabled;
-      const raw = nested !== undefined ? nested : cfg.correctionEnabled;
-      if (raw === undefined || raw === null) return true;
-      const v = coerceBool(raw);
-      if (v === undefined) {
-        throw new Error(`Invalid correction.enabled: expected a boolean, got ${JSON.stringify(raw)}`);
-      }
-      return v;
-    })(),
-    correctionApplyRequiresConfirm: (() => {
-      const nested = (cfg.correction as Record<string, unknown> | undefined)?.applyRequiresConfirm;
-      const raw = nested !== undefined ? nested : cfg.correctionApplyRequiresConfirm;
-      if (raw === undefined || raw === null) return true;
-      const v = coerceBool(raw);
-      if (v === undefined) {
-        throw new Error(`Invalid correction.applyRequiresConfirm: expected a boolean, got ${JSON.stringify(raw)}`);
-      }
-      return v;
-    })(),
-    correctionMaxAffected: (() => {
-      const rawNested = (cfg.correction as Record<string, unknown> | undefined)?.maxAffected;
-      const raw = rawNested !== undefined ? rawNested : cfg.correctionMaxAffected;
-      if (raw === undefined || raw === null) return 10;
-      const n = coerceNumber(raw);
-      // #1678 (thread Oiup6): the error message says "integer" — enforce it
-      // with Number.isInteger so 3.7 is rejected rather than silently floored.
-      if (n === undefined || !Number.isFinite(n) || n < 1 || !Number.isInteger(n)) {
-        throw new Error(`Invalid correction.maxAffected: expected an integer >= 1, got ${JSON.stringify(raw)}`);
-      }
-      return n;
-    })(),
-    correctionPlanTtlHours: (() => {
-      const nested = (cfg.correction as Record<string, unknown> | undefined)?.planTtlHours;
-      const fromNested = nested !== undefined ? coerceNumber(nested) : undefined;
-      if (fromNested !== undefined && fromNested >= 1) return fromNested;
-      // #1678 (threads Ohtvi/Ohyvf): reject invalid (0/negative/non-numeric)
-      // instead of silently defaulting to 24h — completes the config-reject
-      // class already enforced for enabled/applyRequiresConfirm/maxAffected.
-      if (nested !== undefined && fromNested === undefined) {
-        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
-      }
-      if (fromNested !== undefined && fromNested < 1) {
-        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
-      }
-      const fromFlat = coerceNumber(cfg.correctionPlanTtlHours);
-      if (fromFlat !== undefined && fromFlat >= 1) return fromFlat;
-      if (cfg.correctionPlanTtlHours !== undefined && fromFlat === undefined) {
-        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`);
-      }
-      if (fromFlat !== undefined && fromFlat < 1) {
-        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`);
-      }
-      return 24;
-    })(),
+    // Correction Contract (#1580). Nested `correction.<key>` wins over flat
+    // `correction<Key>`. Parser lives in correction/correction-config.ts.
+    ...parseCorrectionConfig(cfg),
     // Passive correction capture (issue #1581). Parsed from
     // `correctionCapture.<key>` (nested) or flat legacy keys. Default "off" —
     // operators opt in (rule 48). Invalid mode → rejected listing options (rule 51).
@@ -3560,11 +3505,7 @@ export function parseConfig(
       Number.isFinite(cfg.graphEdgeDecayVisibilityThreshold)
         ? Math.max(0, Math.min(1, cfg.graphEdgeDecayVisibilityThreshold))
         : 0.2,
-    // Issue #2119 — maintenance-scheduled memory-projection rebuild.
-    // Enabled-by-default (gotcha #36 coercion); interval via the strict shared parser (strings coerced, non-integer/sub-60s rejected — pattern #39).
-    projectionRebuildEnabled: coerceBooleanLike(cfg.projectionRebuildEnabled) ?? true,
-    projectionRebuildIntervalMs: parseIntegerAtLeast(
-      cfg.projectionRebuildIntervalMs, 6 * 60 * 60 * 1000, 60_000, "projectionRebuildIntervalMs"),
+    ...parseProjectionRebuildScheduleConfig(cfg, parseIntegerAtLeast),
     ...parseBoundedJsonlStateConfig(cfg, parseIntegerAtLeast),
     // Issue #681 PR 3/3 — confidence-aware traversal. Floor clamps to [0,1]; a
     // documented 0 iterations disables PageRank refinement (BFS scores pass through).

package/src/corpus-read-cancellation.ts

@@ -34,6 +34,13 @@ export interface CorpusReadOptions {
    * work, and on a tree large enough to matter there are thousands of them.
    */
   abortSignal?: AbortSignal;
+  /**
+   * When `false`, parsed memories are returned without the raw file text kept
+   * beside them (`rememberRawFrontmatter`). Default (unset) retains that copy.
+   * A `false` read bypasses the shared corpus caches so it cannot replace a
+   * raw-retaining snapshot other callers still need.
+   */
+  retainRaw?: boolean;
 }
 
 /** Stop a corpus read at a scan boundary when its caller has given up. */