@remnic/core 9.3.725 → 9.3.726

package/dist/{chunk-GZQXOQQ2.js → chunk-DCKNMLEQ.js}

@@ -19,14 +19,14 @@ import {
 import {
   LocalLlmClient
 } from "./chunk-24D66MMN.js";
-import {
-  delinearize
-} from "./chunk-VEWZZM3H.js";
 import {
   buildExtensionsFooterForSummary,
   formatDaySummaryMemories,
   loadDaySummaryPrompt
 } from "./chunk-EO5QWINU.js";
+import {
+  delinearize
+} from "./chunk-VEWZZM3H.js";
 import {
   applyWorkExtractionBoundary
 } from "./chunk-EI6V5UXY.js";
@@ -2422,4 +2422,4 @@ ${memoryList}` }
 export {
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-GZQXOQQ2.js.map
+//# sourceMappingURL=chunk-DCKNMLEQ.js.map

package/dist/{chunk-ZUDM75KG.js → chunk-DCWIQFNA.js}

@@ -1,3 +1,6 @@
+import {
+  failOpenFaissHealth
+} from "./chunk-XBZQRZ6G.js";
 import {
   rebuildConversationChunksFailOpen,
   upsertConversationChunksFailOpen
@@ -6,9 +9,6 @@ import {
   searchConversationIndex,
   searchConversationIndexFaissFailOpen
 } from "./chunk-SJHM6I4J.js";
-import {
-  failOpenFaissHealth
-} from "./chunk-XBZQRZ6G.js";
 
 // src/conversation-index/backend.ts
 function createConversationIndexBackend(options) {
@@ -235,4 +235,4 @@ function createFaissBackend(getFaiss) {
 export {
   createConversationIndexBackend
 };
-//# sourceMappingURL=chunk-ZUDM75KG.js.map
+//# sourceMappingURL=chunk-DCWIQFNA.js.map

package/dist/{chunk-VI5SGGXB.js → chunk-DQXPJ6HD.js}

@@ -21,16 +21,16 @@ import {
 } from "./chunk-T4WDJPEZ.js";
 import {
   defineOperation
-} from "./chunk-NT36GU6X.js";
+} from "./chunk-5OOA7SGX.js";
 import {
   EngramAccessInputError
-} from "./chunk-KGZF2VO3.js";
+} from "./chunk-Q6D75LVH.js";
 import {
   projectTagProjectId
 } from "./chunk-J6BH2OBA.js";
 import {
   validateBriefingFormat
-} from "./chunk-4WZ3J7M6.js";
+} from "./chunk-KJR66XOM.js";
 import {
   resolvePrincipal
 } from "./chunk-UZYLX7M6.js";
@@ -417,4 +417,4 @@ defineOperation({ name: "offline_sync_snapshot_stream", description: "SSE stream
 defineOperation({ name: "graph_events", description: "SSE graph events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
-//# sourceMappingURL=chunk-VI5SGGXB.js.map
+//# sourceMappingURL=chunk-DQXPJ6HD.js.map

package/dist/{chunk-YNDLCWXS.js → chunk-EZ25VE3G.js}

@@ -1,9 +1,9 @@
-import {
-  diffGraphSnapshots
-} from "./chunk-AUDJPF4N.js";
 import {
   graphSnapshotFromMemoryDir
 } from "./chunk-44442YCH.js";
+import {
+  diffGraphSnapshots
+} from "./chunk-AUDJPF4N.js";
 
 // src/dashboard-runtime.ts
 import { createHash, timingSafeEqual } from "crypto";
@@ -370,4 +370,4 @@ var GraphDashboardServer = class {
 export {
   GraphDashboardServer
 };
-//# sourceMappingURL=chunk-YNDLCWXS.js.map
+//# sourceMappingURL=chunk-EZ25VE3G.js.map

package/dist/{chunk-Z3FGC3QE.js → chunk-EZNDNMRH.js}

@@ -1,12 +1,21 @@
 import {
   enqueuePassiveCorrectionNotification
-} from "./chunk-4WZ3J7M6.js";
+} from "./chunk-KJR66XOM.js";
 import {
   stripAttributesSuffix
 } from "./chunk-SVOZFLIQ.js";
 import {
   serializeMutations
 } from "./chunk-LTJAMRGI.js";
+import {
+  supersessionKeysForFact
+} from "./chunk-TKZ3AL5V.js";
+import {
+  computeContentHash
+} from "./chunk-W5H6ZRPT.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
 import {
   log
 } from "./chunk-NU3CSQ4H.js";
@@ -79,22 +88,68 @@ function validateRedactionPattern(pattern) {
       `redaction_rule.pattern exceeds the ${REDACTION_PATTERN_MAX}-character bound.`
     );
   }
-  if (isRegexLike(trimmed) && isOverlyBroadRegex(trimmed)) {
+  if (isRegexLike(trimmed) && isUnsafeRedactionRegex(trimmed)) {
     throw new CorrectionContractError(
-      "redaction_rule.pattern is too broad \u2014 use a bounded literal or a more specific pattern."
+      "redaction_rule.pattern is unsafe \u2014 use a bounded literal or a regex without nested quantifiers / overlapping alternation."
     );
   }
+  if (isRegexLike(trimmed)) {
+    const regexBody = trimmed.slice(1, -1);
+    if (regexBody.length === 0) {
+      throw new CorrectionContractError("redaction_rule.pattern body is empty \u2014 use a non-empty regex.");
+    }
+    try {
+      if (new RegExp(regexBody).test("")) {
+        throw new CorrectionContractError(
+          "redaction_rule.pattern matches the empty string \u2014 it would withhold every fact."
+        );
+      }
+    } catch (e) {
+      if (e instanceof CorrectionContractError) throw e;
+    }
+  }
   return trimmed;
 }
 function isRegexLike(pattern) {
-  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2) return true;
-  return /[\\^$.|?*+()[\]{}]/.test(pattern);
+  return pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2;
 }
-function isOverlyBroadRegex(pattern) {
+function isUnsafeRedactionRegex(pattern) {
   const body = pattern.startsWith("/") && pattern.endsWith("/") ? pattern.slice(1, -1) : pattern;
   if (/(?:^|[^\\])\(\.\*\)|(?:^|[^\\])\.\*|(?:^|[^\\])\.\+|^\.([^*+]?)$/.test(body)) {
     return true;
   }
+  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;
 }
 function validateCorrectionAction(action) {
@@ -198,11 +253,13 @@ var CorrectionContractError = class extends Error {
 
 // src/correction/correction-access-wiring.ts
 import path2 from "path";
+import { createHash } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 
 // src/correction/correction-planner.ts
 import { mkdir, readFile, rename, unlink, readdir, writeFile } from "fs/promises";
 import path from "path";
+var REDACTED_REQUEST_TEXT = "[redacted \u2014 never-store/redaction correction text withheld from the pending-plan file]";
 var CorrectionPlanner = class {
   constructor(deps) {
     this.deps = deps;
@@ -386,10 +443,12 @@ var CorrectionPlanner = class {
   async persist(plan) {
     const dir = await this.pendingDir(plan.namespace);
     const target = path.join(dir, `${plan.planId}.json`);
+    const sensitive = plan.classification === "never_store" || plan.actions.some((a) => a.kind === "redaction_rule");
+    const persistedPlan = 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)}
+      await writeFile(tmp, `${JSON.stringify(persistedPlan)}
 `, "utf-8");
       await rename(tmp, target);
     });
@@ -451,6 +510,11 @@ var CorrectionPlanner = class {
       const plan = parsePlan(raw);
       if (!plan) return;
       plan.status = status;
+      if (status !== "applying") {
+        plan.actions = plan.actions.map(
+          (a) => a.kind === "redaction_rule" ? { ...a, pattern: "[redacted \u2014 pattern applied]" } : a
+        );
+      }
       const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
       await writeFile(tmp, `${JSON.stringify(plan)}
 `, "utf-8");
@@ -652,7 +716,7 @@ var CorrectionExecutor = class {
             continue;
           }
           const destId = await this.deps.rescopeMemory(namespace, action.memoryId, action.toNamespace);
-          results.push({ action, status: "applied", memoryId: action.memoryId });
+          results.push({ action, status: "applied", memoryId: destId });
           appliedTouched.push(action.memoryId);
           try {
             await this.deps.propagate(action.toNamespace, [destId]);
@@ -726,7 +790,14 @@ var CorrectionExecutor = class {
         sourceMemoryId: memoryId,
         rawContent: memory.rawContent,
         ...memory.entityRef ? { entityRef: memory.entityRef } : {},
-        ...memory.supersessionKey ? { supersessionKey: memory.supersessionKey } : {}
+        ...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",
@@ -745,9 +816,15 @@ var CorrectionExecutor = class {
     }
   }
 };
+var CORRECTION_ERROR_MAX = 500;
+function sanitizeErrorMessage(raw) {
+  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)}\u2026` : trimmed;
+}
 function errMsg(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
+  const raw = err instanceof Error ? err.message : String(err);
+  return sanitizeErrorMessage(raw);
 }
 
 // src/correction/correction-service.ts
@@ -868,7 +945,7 @@ async function searchMemories(wiring, text, namespaces, limit) {
     const storage = await wiring.orchestrator.getStorage(ns);
     const all = await storage.readAllMemories();
     for (const m of all) {
-      if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+      if (!isEligibleCorrectionCandidate(m)) continue;
       const hay = `${m.content} ${m.frontmatter.tags?.join(" ") ?? ""}`.toLowerCase();
       let hits = 0;
       for (const tok of tokens) {
@@ -1016,7 +1093,7 @@ async function expandEntityNeighbors(wiring, seedIds, namespaces, limit) {
     for (const m of all) {
       if (out.length >= limit) break;
       if (seen.has(m.frontmatter.id)) continue;
-      if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+      if (!isEligibleCorrectionCandidate(m)) continue;
       if (m.frontmatter.entityRef && seedRefs.has(m.frontmatter.entityRef)) {
         out.push(toCandidate(m, ns, 0.5));
         seen.add(m.frontmatter.id);
@@ -1107,9 +1184,13 @@ async function applyEditMemory(wiring, namespace, memoryId, patch) {
   const storage = await wiring.orchestrator.getStorage(namespace);
   const existing = await storage.getMemoryById(memoryId);
   if (!existing) throw new CorrectionContractError(`memory not found for edit: ${memoryId}`);
+  const contentHashForPatch = existing.frontmatter.category === "fact" ? computeContentHash(sanitizeMemoryContent(patch).text) : void 0;
   await storage.writeMemoryFrontmatter(
     { ...existing, content: patch },
-    { updated: (/* @__PURE__ */ new Date()).toISOString() }
+    {
+      updated: (/* @__PURE__ */ new Date()).toISOString(),
+      ...contentHashForPatch ? { contentHash: contentHashForPatch } : {}
+    }
   );
   return memoryId;
 }
@@ -1173,26 +1254,42 @@ async function rescopeMemoryFn(wiring, namespace, memoryId, toNamespace) {
 async function appendTombstoneFn(wiring, namespace, input) {
   const storage = await wiring.orchestrator.getStorage(namespace);
   const enabled = typeof storage.isTombstonesEnabled === "function" ? storage.isTombstonesEnabled() : true;
-  const result = await storage.appendTombstone({
-    reason: input.reason,
-    createdBy: "user_correction",
-    sourceMemoryId: input.sourceMemoryId,
-    rawContent: input.rawContent,
-    ...input.entityRef ? { entityRef: input.entityRef } : {},
-    ...input.supersessionKey ? { supersessionKey: input.supersessionKey } : {}
-  });
-  if (result === null && enabled) {
-    throw new CorrectionContractError(
-      `tombstone persistence failed for memory ${input.sourceMemoryId} (tombstones enabled but store returned null \u2014 I/O error swallowed)`
-    );
+  const keys = input.supersessionKeys && input.supersessionKeys.length > 0 ? input.supersessionKeys : input.supersessionKey ? [input.supersessionKey] : [void 0];
+  const writtenIds = [];
+  let firstId = null;
+  for (const key of keys) {
+    const result = await storage.appendTombstone({
+      reason: input.reason,
+      createdBy: "user_correction",
+      sourceMemoryId: input.sourceMemoryId,
+      rawContent: input.rawContent,
+      ...input.entityRef ? { entityRef: input.entityRef } : {},
+      ...key ? { supersessionKey: key } : {},
+      ...input.contentHash ? { contentHash: input.contentHash } : {}
+    });
+    if (result === null && enabled) {
+      for (const id of writtenIds) {
+        try {
+          await storage.revokeTombstone(id, "user_correction");
+        } catch {
+        }
+      }
+      throw new CorrectionContractError(
+        `tombstone persistence failed for memory ${input.sourceMemoryId} (tombstones enabled but store returned null \u2014 I/O error swallowed)`
+      );
+    }
+    if (firstId === null) firstId = result;
+    if (result) writtenIds.push(result);
   }
-  return result;
+  return firstId;
 }
 async function registerRedactionRuleFn(wiring, namespace, pattern) {
   const storage = await wiring.orchestrator.getStorage(namespace);
   const dir = path2.join(storage.dir, "state", "corrections", "redaction-rules");
   await mkdir2(dir, { recursive: true });
-  const slug = pattern.replace(/[^a-zA-Z0-9]+/g, "-").slice(0, 64) || "rule";
+  const slugBase = pattern.replace(/[^a-zA-Z0-9]+/g, "-").slice(0, 48) || "rule";
+  const patternHash = createHash("sha256").update(pattern).digest("hex").slice(0, 16);
+  const slug = `${slugBase}-${patternHash}`;
   await writeFile2(
     path2.join(dir, `${slug}.json`),
     `${JSON.stringify({ pattern, namespace, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
@@ -1252,15 +1349,27 @@ function toCandidate(m, namespace, score) {
     // candidate for diff rendering if needed.
   };
 }
+function isEligibleCorrectionCandidate(m) {
+  if (m.frontmatter.status && m.frontmatter.status !== "active") return false;
+  if (typeof m.frontmatter.archivedAt === "string" && m.frontmatter.archivedAt.length > 0) return false;
+  return true;
+}
 function toExecutorMemory(m) {
   const fm = m.frontmatter;
   const rawBody = fm.structuredAttributes ? stripAttributesSuffix(m.content) : m.content;
+  const supersessionKeys = supersessionKeysForFact({
+    entityRef: fm.entityRef,
+    structuredAttributes: fm.structuredAttributes
+  });
   return {
     memoryId: fm.id,
     content: m.content,
     category: fm.category,
     rawContent: rawBody,
-    ...fm.entityRef ? { entityRef: fm.entityRef } : {}
+    ...fm.entityRef ? { entityRef: fm.entityRef } : {},
+    ...supersessionKeys.length > 0 ? { supersessionKeys } : {},
+    ...supersessionKeys.length > 0 ? { supersessionKey: supersessionKeys[0] } : {},
+    ...typeof fm.contentHash === "string" && fm.contentHash.length > 0 ? { contentHash: fm.contentHash } : {}
   };
 }
 function isCorrectionFeatureEnabled(config) {
@@ -1685,4 +1794,4 @@ export {
   capturePassiveCorrections,
   clusterByKey
 };
-//# sourceMappingURL=chunk-Z3FGC3QE.js.map
+//# sourceMappingURL=chunk-EZNDNMRH.js.map