@remnic/core 9.3.724 → 9.3.726

package/src/correction/correction-contract.ts

@@ -263,25 +263,50 @@ export function validateRedactionPattern(pattern: string): string {
       `redaction_rule.pattern exceeds the ${REDACTION_PATTERN_MAX}-character bound.`,
     );
   }
-  // Reject patterns that could match an unbounded string (catastrophic /
-  // overly-broad). A literal or a bounded regex is fine; a bare `.*` / `.`
-  // regex is not. We do NOT execute the regex (ReDoS); we only inspect shape.
-  if (isRegexLike(trimmed) && isOverlyBroadRegex(trimmed)) {
+  // Reject patterns that could match an unbounded string (overly-broad) OR
+  // exhibit catastrophic backtracking (nested quantifiers like `(a+)+`). We do
+  // NOT execute the regex (that would be ReDoS itself); we only inspect shape.
+  if (isRegexLike(trimmed) && isUnsafeRedactionRegex(trimmed)) {
     throw new CorrectionContractError(
-      "redaction_rule.pattern is too broad — use a bounded literal or a more specific pattern.",
+      "redaction_rule.pattern is unsafe — use a bounded literal or a regex without nested quantifiers / overlapping alternation.",
     );
   }
+  // #1669 P2: reject zero-width regex (empty body or matches empty string)
+  // that would withhold every fact.
+  if (isRegexLike(trimmed)) {
+    const regexBody = trimmed.slice(1, -1);
+    if (regexBody.length === 0) {
+      throw new CorrectionContractError("redaction_rule.pattern body is empty — use a non-empty regex.");
+    }
+    try {
+      if (new RegExp(regexBody).test("")) {
+        throw new CorrectionContractError(
+          "redaction_rule.pattern matches the empty string — it would withhold every fact.",
+        );
+      }
+    } catch (e) {
+      if (e instanceof CorrectionContractError) throw e;
+      // Compilation failed — the extraction-time defense handles it.
+    }
+  }
   return trimmed;
 }
 
-/** Heuristic: treat `/.../` or presence of regex metacharacters as regex. */
+/** Only `/.../`-wrapped patterns are treated as regex; everything else is a
+ *  literal (review thread P1 — consistent with extraction-redaction-rules.ts). */
 function isRegexLike(pattern: string): boolean {
-  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2) return true;
-  return /[\\^$.|?*+()[\]{}]/.test(pattern);
+  return pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2;
 }
 
-/** Reject a regex that would match an arbitrary-length run of any character. */
-function isOverlyBroadRegex(pattern: string): boolean {
+/**
+ * Reject a regex that would either match an arbitrary-length run of any
+ * character (overly-broad) OR exhibit catastrophic backtracking (ReDoS).
+ * Mirrors the safe-regex heuristic in extraction-redaction-rules.ts so the
+ * apply-time chokepoint and the extraction-time defense agree on what is
+ * pathological — intentionally not imported to keep the two modules decoupled
+ * (contract owns validation; extraction owns consultation).
+ */
+function isUnsafeRedactionRegex(pattern: string): boolean {
   const body = pattern.startsWith("/") && pattern.endsWith("/")
     ? pattern.slice(1, -1)
     : pattern;
@@ -289,6 +314,39 @@ function isOverlyBroadRegex(pattern: string): boolean {
   if (/(?:^|[^\\])\(\.\*\)|(?:^|[^\\])\.\*|(?:^|[^\\])\.\+|^\.([^*+]?)$/.test(body)) {
     return true;
   }
+  // Nested quantifier: a group (...) whose body ends with a quantifier and
+  // which is itself quantified → exponential blowup on near-miss inputs
+  // (classic ReDoS shapes: (a+)+, (a*)*, (a?)+). Also catches overlapping
+  // alternation under repetition: (a|a)+ where branches share a prefix.
+  if (body.length > 512) return true;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== "(") continue;
+    let depth = 1;
+    let j = i + 1;
+    while (j < body.length && depth > 0) {
+      if (body[j] === "\\") { j += 2; continue; }
+      if (body[j] === "(") depth++;
+      else if (body[j] === ")") depth--;
+      j++;
+    }
+    if (depth !== 0) continue;
+    const afterGroup = body[j];
+    if (afterGroup !== "+" && afterGroup !== "*" && afterGroup !== "{") continue;
+    const groupBody = body.slice(i + 1, j - 1);
+    if (/[+*?]$/.test(groupBody) || /\{\d+,?\d*\}[+*?]?$/.test(groupBody)) {
+      return true;
+    }
+    if (groupBody.includes("|")) {
+      const branches = groupBody.split("|");
+      if (branches.length >= 2) {
+        const firstChars = new Set(branches.map((b) => b[0]).filter(Boolean));
+        if (firstChars.size < branches.filter((b) => b.length > 0).length) {
+          return true;
+        }
+      }
+    }
+    i = j;
+  }
   return false;
 }
 

package/src/correction/correction-executor.test.ts

@@ -27,7 +27,7 @@ import {
   type CorrectionPlan,
 } from "./correction-contract.js";
 import { CorrectionPlanner, type PlannerCandidate, type PlannerDeps } from "./correction-planner.js";
-import { CorrectionExecutor, type ExecutorDeps, type ExecutorMemory } from "./correction-executor.js";
+import { CorrectionExecutor, CORRECTION_ERROR_MAX, sanitizeErrorMessage, type ExecutorDeps, type ExecutorMemory } from "./correction-executor.js";
 
 // ---------------------------------------------------------------------------
 // Fakes
@@ -36,7 +36,7 @@ import { CorrectionExecutor, type ExecutorDeps, type ExecutorMemory } from "./co
 interface FakeState {
   /** memoryId → current memory state. */
   memories: Map<string, ExecutorMemory & { status: string; supersededBy?: string; validUntil?: string }>;
-  tombstones: Array<{ reason: string; sourceMemoryId: string; rawContent: string }>;
+  tombstones: Array<{ reason: string; sourceMemoryId: string; rawContent: string; supersessionKey?: string; supersessionKeys?: string[]; contentHash?: string }>;
   redactionRules: string[];
   auditRecords: Array<{ planId: string; outcome: CorrectionOutcome }>;
   replacementFailOnLoserId?: string;
@@ -740,3 +740,113 @@ test("OgIqt: plan marked `applying` before mutations; markConsumed failure leave
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// #1672 / #1678 regression tests
+// ---------------------------------------------------------------------------
+
+test("#1672 item 4 (executor): retract forwards supersessionKeys + contentHash into the tombstone dep", async () => {
+  await withTempDir(async (dir) => {
+    const candidates = new Map<string, PlannerCandidate>([
+      ["mem-s", { memoryId: "mem-s", path: "facts/mem-s.md", content: "structured", excerpt: "structured", score: 1 }],
+    ]);
+    const state: FakeState = {
+      memories: new Map([
+        ["mem-s", fakeMemory({
+          memoryId: "mem-s",
+          content: "structured",
+          supersessionKeys: ["entity-deploy::day", "entity-deploy::week"],
+          contentHash: "canonical-hash-xyz",
+        })],
+      ]),
+      tombstones: [],
+      redactionRules: [],
+      auditRecords: [],
+      propagateCalls: 0,
+      writtenReplacements: [],
+    };
+    const plannerDeps: PlannerDeps = {
+      ...makePlannerDeps(dir, candidates),
+      classifyAndDraft: async () => ({
+        classification: "outdated",
+        confidence: 0.9,
+        actions: [{ kind: "retract", memoryId: "mem-s" }],
+        relevance: [{ memoryId: "mem-s", why: "stale" }],
+        warnings: [],
+      }),
+    };
+    const planner = new CorrectionPlanner(plannerDeps);
+    const plan = await planner.plan({ text: "structured", targetIds: ["mem-s"] }, ["default"]);
+    const executor = new CorrectionExecutor(makeExecutorDeps(state), planner);
+    const outcome = await executor.apply("default", plan.planId, { confirm: true });
+    assert.equal(outcome.status, "applied");
+    assert.equal(state.tombstones.length, 1, "exactly one tombstone dep call for the retract");
+    assert.deepEqual(state.tombstones[0].supersessionKeys, ["entity-deploy::day", "entity-deploy::week"],
+      "the tombstone dep must receive the FULL supersessionKeys set");
+    assert.equal(state.tombstones[0].contentHash, "canonical-hash-xyz",
+      "the tombstone dep must receive the canonical contentHash (exact tier)");
+  });
+});
+
+test("#1678: rescope outcome reports the DESTINATION memory id, not the source", async () => {
+  await withTempDir(async (dir) => {
+    const candidates = new Map<string, PlannerCandidate>([
+      ["mem-r", { memoryId: "mem-r", path: "facts/mem-r.md", content: "fact", excerpt: "fact", score: 1 }],
+    ]);
+    const state: FakeState = {
+      memories: new Map([["mem-r", fakeMemory({ memoryId: "mem-r", content: "fact" })]]),
+      tombstones: [],
+      redactionRules: [],
+      auditRecords: [],
+      propagateCalls: 0,
+      writtenReplacements: [],
+    };
+    const plannerDeps: PlannerDeps = {
+      ...makePlannerDeps(dir, candidates),
+      classifyAndDraft: async () => ({
+        classification: "wrong_scope",
+        confidence: 0.9,
+        actions: [{ kind: "rescope", memoryId: "mem-r", toNamespace: "other-ns" }],
+        relevance: [{ memoryId: "mem-r", why: "wrong scope" }],
+        warnings: [],
+      }),
+    };
+    const planner = new CorrectionPlanner(plannerDeps);
+    const plan = await planner.plan({ text: "fact", targetIds: ["mem-r"] }, ["default"]);
+    const executor = new CorrectionExecutor(makeExecutorDeps(state), planner);
+    const outcome = await executor.apply("default", plan.planId, { confirm: true });
+    const result = outcome.results.find((r) => r.action.kind === "rescope");
+    assert.equal(result!.status, "applied");
+    // The fake rescopeMemory returns `rescoped-${memoryId}`. The outcome must
+    // report THAT destination id — not the source (which is archived by the move).
+    assert.equal(result!.memoryId, "rescoped-mem-r",
+      "rescope outcome must report the destination id, not the archived source");
+  });
+});
+
+test("#1678: sanitizeErrorMessage strips absolute paths and caps length", () => {
+  // POSIX absolute path is replaced with <path>.
+  const posix = sanitizeErrorMessage("failed to read /Users/josh/secrets/key.pem during apply");
+  assert.ok(!posix.includes("/Users/josh"), "POSIX abs path must be stripped: " + posix);
+  assert.ok(posix.includes("<path>"), "stripped path must leave a <path> placeholder: " + posix);
+  // Windows absolute path is replaced with <path>.
+  const win = sanitizeErrorMessage("cannot open C:\\Users\\josh\\vault\\token.txt");
+  assert.ok(!/C:\\Users/i.test(win), "Windows abs path must be stripped: " + win);
+  // Length cap.
+  const long = sanitizeErrorMessage("x".repeat(CORRECTION_ERROR_MAX + 500));
+  assert.ok(long.length <= CORRECTION_ERROR_MAX + 1, "over-long message must be capped (cap + ellipsis)");
+  assert.ok(long.endsWith("…"), "capped message must end with an ellipsis");
+  // A clean message passes through unchanged.
+  assert.equal(sanitizeErrorMessage("memory not found: mem-42"), "memory not found: mem-42");
+  // Paths starting with a dot component (/.config/remnic/token) — previously
+  // leaked because the regex required the first path char to be [A-Za-z].
+  const dotPath = sanitizeErrorMessage("ENOENT: /.config/remnic/token not found");
+  assert.ok(!dotPath.includes("/.config"), "dot-leading path must be stripped: " + dotPath);
+  assert.ok(!dotPath.includes("token"), "path suffix must be consumed: " + dotPath);
+  assert.ok(dotPath.includes("<path>"), "must leave <path> placeholder: " + dotPath);
+  // Paths containing special chars like @ in component names.
+  const atPath = sanitizeErrorMessage("cannot stat /tmp/foo@bar/secret.txt");
+  assert.ok(!atPath.includes("/tmp/foo@bar"), "@-path must be stripped: " + atPath);
+  assert.ok(!atPath.includes("secret.txt"), "path suffix must be consumed: " + atPath);
+  assert.ok(atPath.includes("<path>"), "must leave <path> placeholder: " + atPath);
+});

package/src/correction/correction-executor.ts

@@ -47,8 +47,22 @@ export interface ExecutorMemory {
   category: string;
   /** True when the memory has frontmatter provenance (#1575 sourceQuote). */
   sourceQuote?: string;
-  /** Structured-attribute supersession key, when one exists. */
+  /** Structured-attribute supersession key, when one exists (legacy single-key). */
   supersessionKey?: string;
+  /**
+   * ALL derived supersession keys for the memory's structuredAttributes
+   * (#1672 item 4). A paraphrased re-observation may place the tombstoned
+   * attribute at a different position in structuredAttributes; without an
+   * entry for every matched key the keyed tier misses and the fact
+   * resurrects. Mirrors temporal-supersession's per-key emission.
+   */
+  supersessionKeys?: string[];
+  /**
+   * Canonical contentHash from the retired memory's frontmatter (#1672 item
+   * 4 / #1579). Carried into the tombstone so the exact tier matches
+   * re-extraction rather than recomputing from a citation-annotated body.
+   */
+  contentHash?: string;
   entityRef?: string;
   /** Raw content used for the tombstone hash (rule 23). */
   rawContent: string;
@@ -117,6 +131,15 @@ export interface ExecutorDeps {
       rawContent: string;
       entityRef?: string;
       supersessionKey?: string;
+      /**
+       * ALL derived supersession keys (#1672 item 4). When present, the
+       * implementation emits one tombstone per key so a paraphrased
+       * re-observation placing the attribute at a different key position is
+       * still blocked at the keyed tier.
+       */
+      supersessionKeys?: string[];
+      /** Canonical contentHash from the retired memory's frontmatter (#1672 item 4). */
+      contentHash?: string;
     },
   ): Promise<string | null>;
   /**
@@ -342,8 +365,12 @@ export class CorrectionExecutor {
             continue;
           }
           const destId = await this.deps.rescopeMemory(namespace, action.memoryId, action.toNamespace);
-          results.push({ action, status: "applied", memoryId: action.memoryId });
-          appliedTouched.push(action.memoryId);
+          // #1678 (thread OiiV6): report the DESTINATION memory id, not the
+          // source. The source is archived by the move; callers that re-fetch
+          // the reported id need the live (destination) memory, otherwise they
+          // observe an archived fact and the correction looks like a no-op.
+          results.push({ action, status: "applied", memoryId: destId });
+          appliedTouched.push(action.memoryId); // source id for source-side propagation
           // Propagate the destination memory in its namespace too (review
           // thread: propagate-rescoped-destination) — best-effort.
           try {
@@ -448,6 +475,15 @@ export class CorrectionExecutor {
         rawContent: memory.rawContent,
         ...(memory.entityRef ? { entityRef: memory.entityRef } : {}),
         ...(memory.supersessionKey ? { supersessionKey: memory.supersessionKey } : {}),
+        // #1672 item 4: carry the canonical contentHash (exact tier) and the
+        // full supersession-key set (keyed tier) so paraphrased re-observations
+        // of the same supersession identity are blocked, not just the literal
+        // body. Without these the tombstone projected from a structured fact
+        // dropped both fields and the fact could resurrect.
+        ...(memory.contentHash ? { contentHash: memory.contentHash } : {}),
+        ...(memory.supersessionKeys && memory.supersessionKeys.length > 0
+          ? { supersessionKeys: memory.supersessionKeys }
+          : {}),
       });
       await this.deps.retireMemory(namespace, memoryId, {
         status: reason === "supersession" ? "superseded" : "retracted",
@@ -467,7 +503,31 @@ export class CorrectionExecutor {
   }
 }
 
+/**
+ * Sanitize an error message before it lands in a CorrectionOutcome result
+ * (#1678). Outcome results are surfaced to MCP/HTTP/CLI callers and may be
+ * persisted in the audit memory, so they must not leak absolute filesystem
+ * paths (host layout / usernames / secrets in paths) or unbounded verbosity.
+ * Strip absolute paths and cap length; never reveal more than the message's
+ * short-form. The original error is still thrown/logged in full internally.
+ */
+export const CORRECTION_ERROR_MAX = 500;
+export function sanitizeErrorMessage(raw: string): string {
+  // Collapse any absolute POSIX path (/Users/foo/..., /.config/..., /tmp/a@b/...) and
+  // Windows path (C:\Users\...) to a neutral <path> placeholder.
+  // Capture the leading delimiter (start/space/quote) in group 1 so the path
+  // itself is consumed and replaced — the prior non-capturing prefix bound $1
+  // to the path, which survived and had <path> appended AFTER it.
+  const stripped = raw
+    .replace(/(^|[\s:'"(])\/(?:[^\s'">)\\]+\/)+[^\s'">)\\]*/g, "$1<path>")
+    .replace(/(^|[\s:'"(])[A-Za-z]:\\[^\s'">)\\]+(?:\\[^\s'">) ]*)*/g, "$1<path>");
+  const trimmed = stripped.trim();
+  return trimmed.length > CORRECTION_ERROR_MAX
+    ? `${trimmed.slice(0, CORRECTION_ERROR_MAX)}…`
+    : trimmed;
+}
+
 function errMsg(err: unknown): string {
-  if (err instanceof Error) return err.message;
-  return String(err);
+  const raw = err instanceof Error ? err.message : String(err);
+  return sanitizeErrorMessage(raw);
 }

package/src/correction/correction-planner.test.ts

@@ -444,3 +444,50 @@ test("OgIql: untargeted search uses tokenized keyword matching (not exact-prefix
     assert.equal(classifyCandidates[0].memoryId, "mem-db");
   });
 });
+
+test("#1678: never_store plan redacts the request text in the persisted pending-plan file", async () => {
+  await withTempDir(async (dir) => {
+    const secret = "my API key is sk-secret-DO-NOT-STORE-12345";
+    const state: StubState = {
+      candidatesById: new Map([["mem-s", makeCandidate({ memoryId: "mem-s", content: secret })]]),
+      llmResult: {
+        classification: "never_store",
+        confidence: 0.95,
+        actions: [{ kind: "redaction_rule", pattern: "sk-secret-\\d+" }],
+        relevance: [],
+        warnings: [],
+      },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const planner = new CorrectionPlanner(makeDeps(dir, state));
+    // The in-memory plan keeps the original text (the executor's audit body
+    // re-applies its own redaction).
+    const plan = await planner.plan({ text: secret, targetIds: ["mem-s"] }, ["default"]);
+    assert.equal(plan.request.text, secret, "in-memory plan keeps the original request text");
+    assert.equal(plan.classification, "never_store");
+
+    // The persisted file MUST NOT contain the secret.
+    const filePath = path.join(dir, "state", "corrections", "pending", `${plan.planId}.json`);
+    const raw = await readFile(filePath, "utf-8");
+    assert.ok(!raw.includes("sk-secret-DO-NOT-STORE"),
+      "the persisted pending-plan file must NOT contain the never-store secret (request.text is redacted)");
+    assert.ok(raw.includes("redacted"),
+      "the persisted request text must be the redaction placeholder");
+    // The redaction_rule.pattern is NOT redacted on disk: the executor's apply
+    // flow reloads via loadPlan and needs the real pattern to call
+    // registerRedactionRule. Redacting it would register a placeholder (#vZln).
+    // The pattern's transient exposure is bounded by the pending-plan TTL +
+    // consumed-on-apply lifecycle.
+    assert.ok(raw.includes("sk-secret"),
+      "the redaction_rule.pattern survives on disk for the apply flow (bounded by pending-plan TTL)");
+
+    // loadPlan reads from disk → the reloaded plan has the redacted text.
+    const reloaded = await planner.loadPlan("default", plan.planId);
+    assert.ok(reloaded, "plan round-trips");
+    assert.notEqual(reloaded!.request.text, secret,
+      "loaded plan must carry the redacted text, not the original secret");
+    assert.ok(reloaded!.request.text.includes("redacted"));
+  });
+});

package/src/correction/correction-planner.ts

@@ -129,6 +129,13 @@ export interface LlmClassificationResult {
   fallback?: boolean;
 }
 
+/**
+ * Placeholder substituted for the request text when persisting a never-store /
+ * redaction-rule plan (#1678 thread Oid8t). Mirrors the durable-audit
+ * redaction so the transient pending-plan file never holds the secret.
+ */
+const REDACTED_REQUEST_TEXT = "[redacted — never-store/redaction correction text withheld from the pending-plan file]";
+
 // ---------------------------------------------------------------------------
 // Planner
 // ---------------------------------------------------------------------------
@@ -382,10 +389,31 @@ export class CorrectionPlanner {
   private async persist(plan: CorrectionPlan): Promise<CorrectionPlan> {
     const dir = await this.pendingDir(plan.namespace);
     const target = path.join(dir, `${plan.planId}.json`);
+    // #1678 (thread Oid8t): never-store/redaction corrections carry the very
+    // secret/pattern the user asked Remnic NOT to retain. The durable audit
+    // already withholds the text; the TRANSIENT pending-plan file must too,
+    // or the secret sits on disk (pending until apply/discard + TTL). Redact
+    // the request text in the persisted copy for never_store classifications
+    // or any redaction_rule action. The in-memory plan keeps the original
+    // text so the executor's audit body (which re-applies its own redaction)
+    // is unaffected; only the on-disk JSON is sanitized.
+    const sensitive =
+      plan.classification === "never_store" ||
+      plan.actions.some((a) => a.kind === "redaction_rule");
+    // #1678 (threads vMLN/vZln): redact request.text (the executor does not
+    // need the raw request text for redaction_rule actions). The pattern is
+    // NOT redacted: the executor's apply flow reloads via loadPlan (disk) and
+    // needs the real pattern to call registerRedactionRule. Redacting it would
+    // register a placeholder and the extraction redaction (#1669) would never
+    // block the intended content. The pattern's transient on-disk exposure is
+    // bounded by the pending-plan TTL + consumed-on-apply lifecycle.
+    const persistedPlan: CorrectionPlan = sensitive
+      ? { ...plan, request: { ...plan.request, text: REDACTED_REQUEST_TEXT } }
+      : plan;
     await serializeMutations(`correction-plan:${target}`, async () => {
       await mkdir(dir, { recursive: true });
       const tmp = `${target}.${process.pid}.${Date.now().toString(36)}.tmp`;
-      await writeFile(tmp, `${JSON.stringify(plan)}\n`, "utf-8");
+      await writeFile(tmp, `${JSON.stringify(persistedPlan)}\n`, "utf-8");
       // rename() is atomic on POSIX for same-filesystem renames (rule 54).
       await rename(tmp, target);
     });
@@ -450,6 +478,17 @@ export class CorrectionPlanner {
       const plan = parsePlan(raw);
       if (!plan) return;
       plan.status = status;
+      // #1669 thread P1: scrub redaction_rule patterns from consumed plans so
+      // a never-store pattern does not persist on disk after apply/discard.
+      // The executor reloads via loadPlan only between "applying" (step 1) and
+      // "applied" (step 4), so scrubbing at the terminal status is safe.
+      if (status !== "applying") {
+        plan.actions = plan.actions.map((a) =>
+          a.kind === "redaction_rule"
+            ? { ...a, pattern: "[redacted — pattern applied]" }
+            : a,
+        );
+      }
       const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
       await writeFile(tmp, `${JSON.stringify(plan)}\n`, "utf-8");
       await rename(tmp, file);

package/src/correction/correction-storage-integration.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Correction storage-integration regression tests (#1672).
+ *
+ * Proves the three wiring-level fixes that prevent fact resurrection and
+ * stale-candidate planning:
+ *  - item 2: isEligibleCorrectionCandidate excludes archived memories.
+ *  - item 3: applyEditMemory recomputes contentHash from the patched body.
+ *  - item 4: appendTombstoneFn emits one tombstone per derived supersession key.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { StorageManager, ContentHashIndex } from "../storage.js";
+import { sanitizeMemoryContent } from "../sanitize.js";
+import {
+  isEligibleCorrectionCandidate,
+  applyEditMemory,
+  appendTombstoneFn,
+} from "./correction-access-wiring.js";
+import type { MemoryFile } from "../types.js";
+
+async function makeStorage(prefix = "remnic-corr-wiring-") {
+  StorageManager.clearAllStaticCaches();
+  const baseDir = await mkdtemp(path.join(tmpdir(), prefix));
+  const storage = new StorageManager(baseDir);
+  await storage.ensureDirectories();
+  storage.invalidateAllMemoriesCacheForDir();
+  storage.setTombstonesConfig({
+    enabled: true,
+    semanticMatch: false,
+    semanticThreshold: 0.9,
+    namespace: "default",
+  });
+  return { storage, baseDir, cleanup: async () => { StorageManager.clearAllStaticCaches(); await rm(baseDir, { recursive: true, force: true }); } };
+}
+
+function fakeMemoryFile(over: Partial<MemoryFile["frontmatter"]> & { id: string }): MemoryFile {
+  const { id: _id, ...rest } = over;
+  return {
+    path: "facts/x.md",
+    content: over.id,
+    frontmatter: {
+      id: over.id,
+      category: "fact",
+      created: "2026-01-01T00:00:00.000Z",
+      updated: "2026-01-01T00:00:00.000Z",
+      source: "test",
+      confidence: 0.9,
+      ...rest,
+    } as MemoryFile["frontmatter"],
+  } as MemoryFile;
+}
+
+// ---------------------------------------------------------------------------
+// item 2: lifecycle-aware candidate filter
+// ---------------------------------------------------------------------------
+
+test("#1672 item 2: isEligibleCorrectionCandidate accepts an active, non-archived memory", () => {
+  const m = fakeMemoryFile({ id: "m1", status: "active" });
+  assert.equal(isEligibleCorrectionCandidate(m), true);
+});
+
+test("#1672 item 2: isEligibleCorrectionCandidate rejects an archived memory even when status is active", () => {
+  const m = fakeMemoryFile({ id: "m2", status: "active", archivedAt: "2026-07-01T00:00:00.000Z" });
+  assert.equal(isEligibleCorrectionCandidate(m), false);
+});
+
+test("#1672 item 2: isEligibleCorrectionCandidate rejects a non-active status", () => {
+  const m = fakeMemoryFile({ id: "m3", status: "superseded" });
+  assert.equal(isEligibleCorrectionCandidate(m), false);
+});
+
+test("#1672 item 2: isEligibleCorrectionCandidate rejects archived memory with no explicit status", () => {
+  const m = fakeMemoryFile({ id: "m4", archivedAt: "2026-07-01T00:00:00.000Z" });
+  assert.equal(isEligibleCorrectionCandidate(m), false);
+});
+
+// ---------------------------------------------------------------------------
+// item 3: contentHash recomputed on edit
+// ---------------------------------------------------------------------------
+
+test("#1672 item 3: applyEditMemory recomputes contentHash from the patched body", async () => {
+  const { storage, cleanup } = await makeStorage();
+  try {
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+    const id = await storage.writeMemory("fact", "the database is MySQL", { source: "test" });
+    const before = await storage.getMemoryById(id);
+    assert.ok(before?.frontmatter.contentHash, "writeMemory must set an initial contentHash");
+    const oldHash = before!.frontmatter.contentHash!;
+
+    await applyEditMemory(wiring, "default", id, "the database is PostgreSQL");
+
+    const after = await storage.getMemoryById(id);
+    assert.ok(after, "edited memory must still exist");
+    const expectedHash = ContentHashIndex.computeHash(sanitizeMemoryContent("the database is PostgreSQL").text);
+    assert.equal(after!.frontmatter.contentHash, expectedHash,
+      "contentHash must match the PATCHED body (recomputed on edit)");
+    assert.notEqual(after!.frontmatter.contentHash, oldHash,
+      "contentHash must differ from the pre-edit hash");
+    assert.equal(after!.content, "the database is PostgreSQL");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1672 item 3: applyEditMemory leaves non-fact contentHash untouched (only facts are hashed)", async () => {
+  const { storage, cleanup } = await makeStorage();
+  try {
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+    const id = await storage.writeMemory("preference", "likes dark mode", { source: "test" });
+    await applyEditMemory(wiring, "default", id, "likes light mode");
+    const after = await storage.getMemoryById(id);
+    assert.equal(after!.content, "likes light mode");
+    // Non-fact categories are not content-hash indexed, so no hash is forced.
+    assert.ok(!after!.frontmatter.contentHash, "non-fact edit must not synthesize a contentHash");
+  } finally {
+    await cleanup();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// item 4: per-key tombstone emission
+// ---------------------------------------------------------------------------
+
+test("#1672 item 4: appendTombstoneFn emits one tombstone per supersession key, each carrying contentHash", async () => {
+  const { storage, cleanup } = await makeStorage();
+  try {
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+    const keys = ["entity-deploy::day", "entity-deploy::week"];
+    const firstId = await appendTombstoneFn(wiring, "default", {
+      reason: "supersession",
+      sourceMemoryId: "fact-structured",
+      rawContent: "deploys happen on Tuesdays",
+      supersessionKeys: keys,
+      contentHash: "canonical-hash-abc",
+    });
+    assert.ok(firstId, "appendTombstoneFn must return the first tombstone id");
+
+    // Read the tombstone store directly to count entries.
+    const store = (storage as any).tombstoneStore ?? await (storage as any).getTombstoneStore();
+    const all = store.snapshot?.() ?? store.all?.() ?? [];
+    const matching = Array.isArray(all)
+      ? all.filter((t: any) => t?.sourceMemoryId === "fact-structured")
+      : [];
+    assert.equal(matching.length, keys.length,
+      `emitted ${matching.length} tombstones, expected ${keys.length} (one per supersession key)`);
+    for (const t of matching) {
+      assert.equal(t.contentHash, "canonical-hash-abc",
+        "every per-key tombstone must carry the canonical contentHash (exact tier)");
+    }
+    const tombKeys = matching.map((t: any) => t.supersessionKey).sort();
+    assert.deepEqual(tombKeys, [...keys].sort(),
+      "the emitted supersession keys must cover every derived key");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1672 item 4: appendTombstoneFn falls back to a single tombstone when no keys are derived", async () => {
+  const { storage, cleanup } = await makeStorage();
+  try {
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+    const firstId = await appendTombstoneFn(wiring, "default", {
+      reason: "retraction",
+      sourceMemoryId: "fact-plain",
+      rawContent: "a plain unstructured fact",
+      contentHash: "plain-hash",
+    });
+    assert.ok(firstId, "a content-only tombstone must still be emitted");
+    const store = (storage as any).tombstoneStore ?? await (storage as any).getTombstoneStore();
+    const all = store.snapshot?.() ?? store.all?.() ?? [];
+    const matching = Array.isArray(all)
+      ? all.filter((t: any) => t?.sourceMemoryId === "fact-plain")
+      : [];
+    assert.equal(matching.length, 1, "exactly one tombstone when no supersession keys");
+    assert.equal(matching[0].contentHash, "plain-hash");
+  } finally {
+    await cleanup();
+  }
+});