@remnic/plugin-openclaw 1.0.7 → 1.0.9

package/dist/{chunk-QHMR3D7U.js → chunk-S2ISS4AH.js}

@@ -1,6 +1,11 @@
 import {
-  StorageManager
-} from "./chunk-KPMXWORS.js";
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-7TENHBV2.js";
+import {
+  StorageManager,
+  isConsolidationOperator
+} from "./chunk-JJSNPSCD.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
@@ -422,10 +427,9 @@ function validateMemoryMd(content) {
 }
 function resolveCodexHome(override) {
   if (override && override.trim().length > 0) return override;
-  const fromEnv = process.env.CODEX_HOME;
+  const fromEnv = readEnvVar("CODEX_HOME");
   if (fromEnv && fromEnv.trim().length > 0) return fromEnv;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path.join(home, ".codex");
+  return path.join(resolveHomeDir(), ".codex");
 }
 function readSentinel(sentinelPath) {
   if (!existsSync(sentinelPath)) return null;
@@ -936,6 +940,109 @@ Write ONLY the consolidated memory content (no metadata, no explanation, no prea
 function parseConsolidationResponse(response) {
   return response.trim();
 }
+function chooseConsolidationOperator(cluster) {
+  if (cluster.memories.length <= 1) return "update";
+  return "merge";
+}
+function buildOperatorAwareConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Pick exactly ONE consolidation operator for this cluster and return a JSON object.
+
+Operator vocabulary:
+  - "merge"  \u2014 multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).
+  - "update" \u2014 one source memory carries a stale value that a newer source supersedes within the same logical fact.
+  - "split"  \u2014 a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body \u2014 the write path will chunk it later).
+
+Output JSON ONLY, no prose before or after.  The "operator" key MUST be set to exactly one of the three strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder like "merge|update|split".  Example shape:
+  {
+    "operator": "merge",
+    "output": "<the canonical memory text>"
+  }
+
+The "output" value must:
+1. Preserve ALL unique information from every source memory
+2. Remove redundancy and repetition
+3. Use clear, concise language
+4. Match the "${cluster.category}" category and tone
+5. NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Return ONLY the JSON object:`;
+}
+function parseOperatorAwareConsolidationResponse(response, cluster) {
+  const fallback = {
+    operator: chooseConsolidationOperator(cluster),
+    output: response.trim()
+  };
+  const trimmed = response.trim();
+  if (trimmed.length === 0) return fallback;
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
+  const payload = fenced ? fenced[1].trim() : trimmed;
+  const parsed = findLastJsonObjectWithOperator(payload);
+  if (parsed === void 0) return fallback;
+  if (typeof parsed !== "object" || parsed === null) return fallback;
+  const obj = parsed;
+  const rawOperator = typeof obj.operator === "string" ? obj.operator.trim().toLowerCase() : "";
+  const rawOutput = typeof obj.output === "string" ? obj.output : "";
+  const operator = isConsolidationOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
+  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
+  return { operator, output };
+}
+function findLastJsonObjectWithOperator(text) {
+  let searchFrom = 0;
+  let last = void 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start < 0) return last;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let closed = false;
+    let endIdx = -1;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closed = true;
+          endIdx = i;
+          break;
+        }
+      }
+    }
+    if (!closed) return last;
+    const slice = text.slice(start, endIdx + 1);
+    try {
+      const parsed = JSON.parse(slice);
+      if (typeof parsed === "object" && parsed !== null && "operator" in parsed) {
+        last = parsed;
+      }
+    } catch {
+    }
+    searchFrom = endIdx + 1;
+  }
+  return last;
+}
 async function buildExtensionsBlockForConsolidation(config) {
   if (!config.memoryExtensionsEnabled) return "";
   const root = resolveExtensionsRoot(config);
@@ -955,6 +1062,9 @@ export {
   findSimilarClusters,
   buildConsolidationPrompt,
   parseConsolidationResponse,
+  chooseConsolidationOperator,
+  buildOperatorAwareConsolidationPrompt,
+  parseOperatorAwareConsolidationResponse,
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };

package/dist/consolidation-undo-5ZSX4MWO.js

@@ -0,0 +1,426 @@
+import {
+  getVersion
+} from "./chunk-6OJAU466.js";
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/consolidation-undo.ts
+import path from "path";
+import { mkdir, writeFile, access, realpath, lstat } from "fs/promises";
+import { constants as fsConstants } from "fs";
+var DERIVED_FROM_ENTRY_RE = /^(.+):(\d+)$/;
+function parseEntry(entry) {
+  if (typeof entry !== "string") return null;
+  const match = entry.match(DERIVED_FROM_ENTRY_RE);
+  if (!match) return null;
+  return { pagePath: match[1], versionId: match[2] };
+}
+function isInsideDirectory(candidate, root) {
+  const normRoot = path.resolve(root);
+  const normCandidate = path.resolve(candidate);
+  const rel = path.relative(normRoot, normCandidate);
+  if (rel.length === 0) return true;
+  if (rel.startsWith("..")) return false;
+  if (path.isAbsolute(rel)) return false;
+  return true;
+}
+async function isInsideDirectoryRealpath(candidate, root) {
+  if (!isInsideDirectory(candidate, root)) return false;
+  const rawSegments = candidate.replace(/\\/g, "/").split("/");
+  if (rawSegments.some((s) => s === "..")) return false;
+  let resolvedRoot;
+  try {
+    resolvedRoot = await realpath(path.resolve(root));
+  } catch {
+    return false;
+  }
+  const normCandidate = path.resolve(candidate);
+  const normRoot = path.resolve(root);
+  const relFromRoot = path.relative(normRoot, normCandidate);
+  const segments = relFromRoot.length > 0 ? relFromRoot.split(path.sep) : [];
+  for (let i = 0; i <= segments.length; i++) {
+    const probe = i === 0 ? normRoot : path.join(normRoot, ...segments.slice(0, i));
+    try {
+      const st = await lstat(probe);
+      if (st.isSymbolicLink() && probe !== normRoot) {
+        let target;
+        try {
+          target = await realpath(probe);
+        } catch {
+          return false;
+        }
+        const rel = path.relative(resolvedRoot, target);
+        if (rel.length === 0) continue;
+        if (rel.startsWith("..") || path.isAbsolute(rel)) return false;
+      }
+    } catch {
+    }
+  }
+  const parts = normCandidate.split(path.sep);
+  for (let i = parts.length; i > 0; i--) {
+    const probe = parts.slice(0, i).join(path.sep) || path.sep;
+    try {
+      const resolved = await realpath(probe);
+      const trailing = parts.slice(i).join(path.sep);
+      const final = trailing.length > 0 ? path.join(resolved, trailing) : resolved;
+      const rel = path.relative(resolvedRoot, final);
+      if (rel.length === 0) return true;
+      if (rel.startsWith("..")) return false;
+      if (path.isAbsolute(rel)) return false;
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+var NON_ACTIVE_PREFIXES = ["archive/", "state/"];
+function normalizeRelativePath(p) {
+  const parts = p.replace(/\\/g, "/").split("/");
+  const resolved = [];
+  for (const seg of parts) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (resolved.length > 0) resolved.pop();
+    } else {
+      resolved.push(seg);
+    }
+  }
+  return resolved.join("/");
+}
+function isActiveMemoryRelativePath(pagePath, sidecarDir) {
+  const normalized = normalizeRelativePath(pagePath);
+  const prefixes = [...NON_ACTIVE_PREFIXES];
+  if (sidecarDir) {
+    const normSidecar = normalizeRelativePath(sidecarDir);
+    prefixes.push(normSidecar + "/");
+  }
+  for (const prefix of prefixes) {
+    if (normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function isRegularFile(p) {
+  try {
+    const st = await lstat(p);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(p) {
+  try {
+    await access(p, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runConsolidationUndo(options) {
+  const { storage, memoryDir, targetPath, versioning } = options;
+  const dryRun = options.dryRun === true;
+  const result = {
+    targetPath,
+    targetArchived: false,
+    restores: [],
+    dryRun
+  };
+  if (!await isInsideDirectoryRealpath(targetPath, memoryDir)) {
+    result.error = `target path ${targetPath} is outside memory directory ${memoryDir}`;
+    return result;
+  }
+  const targetRel = path.relative(memoryDir, targetPath);
+  if (!isActiveMemoryRelativePath(targetRel, versioning.sidecarDir)) {
+    result.error = `target path "${targetRel}" is inside a non-active directory \u2014 refusing to operate`;
+    return result;
+  }
+  const target = await storage.readMemoryByPath(targetPath);
+  if (!target) {
+    result.error = `could not load target memory at ${targetPath}`;
+    return result;
+  }
+  const derivedFrom = target.frontmatter.derived_from;
+  if (!Array.isArray(derivedFrom) || derivedFrom.length === 0) {
+    result.error = "target memory has no derived_from entries \u2014 nothing to undo";
+    return result;
+  }
+  const plans = [];
+  for (const rawEntry of derivedFrom) {
+    const entry = typeof rawEntry === "string" ? rawEntry : String(rawEntry);
+    const parsed = parseEntry(rawEntry);
+    if (!parsed) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath: "",
+          outcome: "skipped_malformed_entry",
+          detail: `expected "<path>:<version>" shape`
+        }
+      });
+      continue;
+    }
+    if (path.isAbsolute(parsed.pagePath)) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath: parsed.pagePath,
+          outcome: "skipped_malformed_entry",
+          detail: `derived_from path must be relative, got absolute: "${parsed.pagePath}"`
+        }
+      });
+      continue;
+    }
+    const sourcePath = path.join(memoryDir, parsed.pagePath);
+    if (!await isInsideDirectoryRealpath(sourcePath, memoryDir)) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath,
+          outcome: "skipped_outside_memory_dir",
+          detail: `resolved path escapes memory directory ${memoryDir}`
+        }
+      });
+      continue;
+    }
+    let resolvedRelative = parsed.pagePath;
+    try {
+      const realBase = await realpath(memoryDir);
+      try {
+        const realSource = await realpath(sourcePath);
+        const rel = path.relative(realBase, realSource);
+        if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+          resolvedRelative = rel.replace(/\\/g, "/");
+        }
+      } catch {
+        const parentDir = path.dirname(sourcePath);
+        try {
+          const realParent = await realpath(parentDir);
+          const parentRel = path.relative(realBase, realParent);
+          if (!parentRel.startsWith("..") && !path.isAbsolute(parentRel)) {
+            const leafName = path.basename(sourcePath);
+            resolvedRelative = path.join(parentRel, leafName).replace(/\\/g, "/");
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (!isActiveMemoryRelativePath(parsed.pagePath, versioning.sidecarDir) || !isActiveMemoryRelativePath(resolvedRelative, versioning.sidecarDir)) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath,
+          outcome: "skipped_non_active_path",
+          detail: `source path "${parsed.pagePath}" is inside a non-active directory (archive/state/versions)`
+        }
+      });
+      continue;
+    }
+    if (path.resolve(sourcePath) === path.resolve(targetPath)) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath,
+          outcome: "skipped_self_referential",
+          detail: `derived_from entry "${entry}" resolves to the same file as the target \u2014 refusing to count as recovered`
+        }
+      });
+      continue;
+    }
+    if (await isRegularFile(sourcePath)) {
+      plans.push({ kind: "recovered_existing", entry, sourcePath });
+      continue;
+    }
+    if (await fileExists(sourcePath)) {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath,
+          outcome: "skipped_non_regular_file",
+          detail: "source path is occupied by a non-regular-file; refusing to proceed"
+        }
+      });
+      continue;
+    }
+    let snapshotContent;
+    try {
+      snapshotContent = await getVersion(
+        sourcePath,
+        parsed.versionId,
+        versioning,
+        memoryDir
+      );
+    } catch {
+      plans.push({
+        kind: "skip",
+        restore: {
+          entry,
+          sourcePath,
+          outcome: "skipped_snapshot_missing",
+          detail: `no snapshot for version ${parsed.versionId}`
+        }
+      });
+      continue;
+    }
+    plans.push({ kind: "write", entry, sourcePath, content: snapshotContent });
+  }
+  const skipped = plans.filter((p) => p.kind === "skip");
+  if (skipped.length > 0) {
+    for (const p of plans) {
+      if (p.kind === "skip") {
+        result.restores.push(p.restore);
+      } else if (p.kind === "write") {
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: dryRun ? "skipped_dry_run" : "skipped_blocked_by_other_failures",
+          detail: dryRun ? "would restore from snapshot (blocked by other failures)" : "snapshot available but undo aborted due to other failures"
+        });
+      } else {
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "skipped_file_exists",
+          detail: "source file already exists; no restore needed"
+        });
+      }
+    }
+    const recovered = result.restores.filter(
+      (r) => r.outcome === "restored" || r.outcome === "skipped_file_exists"
+    ).length;
+    if (recovered === 0) {
+      result.error = "no sources could be recovered (all snapshots missing or paths unsafe); target not archived to preserve data";
+    } else {
+      result.error = `${skipped.length} of ${plans.length} sources could not be recovered; target not archived (undo is all-or-nothing)`;
+    }
+    return result;
+  }
+  const seenSourcePaths = /* @__PURE__ */ new Set();
+  const dedupedPlans = [];
+  for (const p of plans) {
+    if (p.kind === "write" || p.kind === "recovered_existing") {
+      if (seenSourcePaths.has(p.sourcePath)) {
+        dedupedPlans.push({
+          kind: "skip",
+          restore: {
+            entry: p.kind === "write" ? p.entry : p.entry,
+            sourcePath: p.sourcePath,
+            outcome: "skipped_file_exists",
+            detail: "duplicate derived_from entry \u2014 source already processed"
+          }
+        });
+        continue;
+      }
+      seenSourcePaths.add(p.sourcePath);
+    }
+    dedupedPlans.push(p);
+  }
+  if (dryRun) {
+    for (const p of dedupedPlans) {
+      if (p.kind === "write") {
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "skipped_dry_run",
+          detail: "would restore from snapshot"
+        });
+      } else if (p.kind === "recovered_existing") {
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "skipped_file_exists",
+          detail: "source file already exists; no restore needed"
+        });
+      } else if (p.kind === "skip" && p.restore) {
+        result.restores.push(p.restore);
+      }
+    }
+    return result;
+  }
+  let writeFailed = false;
+  for (const p of dedupedPlans) {
+    if (p.kind === "skip") {
+      if (p.restore) result.restores.push(p.restore);
+      continue;
+    }
+    if (p.kind === "recovered_existing") {
+      result.restores.push({
+        entry: p.entry,
+        sourcePath: p.sourcePath,
+        outcome: "skipped_file_exists",
+        detail: "source file already exists; no restore needed"
+      });
+      continue;
+    }
+    if (p.kind === "write") {
+      if (writeFailed) {
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "skipped_blocked_by_other_failures",
+          detail: "a prior source write failed; skipping remaining writes to honor all-or-nothing contract"
+        });
+        continue;
+      }
+      try {
+        await mkdir(path.dirname(p.sourcePath), { recursive: true });
+        await writeFile(p.sourcePath, p.content, { encoding: "utf-8", flag: "wx" });
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "restored"
+        });
+      } catch (err) {
+        writeFailed = true;
+        result.restores.push({
+          entry: p.entry,
+          sourcePath: p.sourcePath,
+          outcome: "skipped_write_failed",
+          detail: `write failed: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  if (writeFailed) {
+    result.error = "one or more source writes failed mid-restore; target not archived to preserve data";
+    return result;
+  }
+  const archivedAt = await storage.archiveMemory(target, {
+    actor: "consolidate-undo",
+    reasonCode: "consolidation-undo"
+  });
+  result.targetArchived = archivedAt !== null;
+  if (!result.targetArchived) {
+    result.error = "sources restored successfully but archiving the consolidated target failed; inspect storage for manual cleanup";
+  }
+  return result;
+}
+function formatConsolidationUndoResult(result) {
+  const lines = [];
+  lines.push(`consolidate undo ${result.dryRun ? "(dry run) " : ""}\u2192 ${result.targetPath}`);
+  for (const r of result.restores) {
+    lines.push(`  - ${r.entry} \u2192 ${r.outcome}${r.detail ? ` (${r.detail})` : ""}`);
+  }
+  if (result.error) {
+    lines.push(`  ERROR: ${result.error}`);
+    return lines.join("\n");
+  }
+  lines.push(
+    result.dryRun ? "  (dry run \u2014 no files were modified, target not archived)" : `  target archived: ${result.targetArchived ? "yes" : "no"}`
+  );
+  return lines.join("\n");
+}
+export {
+  formatConsolidationUndoResult,
+  isActiveMemoryRelativePath,
+  isInsideDirectory,
+  isInsideDirectoryRealpath,
+  runConsolidationUndo
+};

package/dist/{contradiction-scan-LRRLWUOS.js → contradiction-scan-U3QKHWQN.js}

@@ -33,7 +33,7 @@ IMPORTANT:
 - Two memories about the same entity/topic are NOT necessarily contradictory.
 - Temporal changes ("Joshua uses pnpm" vs "Joshua switched to npm") ARE contradictions.
 - Different aspects of the same entity ("Joshua uses pnpm" vs "Joshua works on Remnic") are "independent".`;
-var verdictCache = /* @__PURE__ */ new Map();
+var defaultVerdictCache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 1e4;
 function pairKey(idA, idB) {
   const sorted = [idA, idB].sort();
@@ -50,7 +50,7 @@ function contentHash(a) {
 async function judgeContradictionPairs(pairs, config, localLlm, fallbackLlm, cache) {
   const startTime = Date.now();
   const results = /* @__PURE__ */ new Map();
-  const activeCache = cache ?? verdictCache;
+  const activeCache = cache ?? defaultVerdictCache;
   let cached = 0;
   let judged = 0;
   const toJudge = [];
@@ -208,8 +208,9 @@ var SCAN_CATEGORIES = /* @__PURE__ */ new Set([
 ]);
 async function runContradictionScan(deps) {
   const startTime = Date.now();
-  const { storage, config, memoryDir, embeddingLookup, localLlm, fallbackLlm, namespace } = deps;
+  const { storage, config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm, namespace } = deps;
   const scanConfig = config.contradictionScan;
+  const scopedEmbeddingLookup = embeddingLookupFactory ? embeddingLookupFactory(storage) : embeddingLookup;
   if (!scanConfig.enabled) {
     log.info("[contradiction-scan] disabled by config");
     return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };
@@ -224,7 +225,7 @@ async function runContradictionScan(deps) {
   for (const p of existingPairs) {
     existingMap.set(p.pairId, p);
   }
-  const candidates = generatePairs(memories, existingMap, scanConfig, embeddingLookup);
+  const candidates = await generatePairs(memories, existingMap, scanConfig, scopedEmbeddingLookup);
   const cooledDown = candidates.skipped;
   log.info("[contradiction-scan] generated %d candidates (%d cooled down)", candidates.pairs.length, cooledDown);
   if (candidates.pairs.length === 0) {
@@ -246,7 +247,8 @@ async function runContradictionScan(deps) {
     categoryA: pair.categoryA,
     categoryB: pair.categoryB
   }));
-  const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm);
+  const scanCache = /* @__PURE__ */ new Map();
+  const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm, scanCache);
   log.info("[contradiction-scan] judge completed: %d judged, %d cached in %dms", judgeResult.judged, judgeResult.cached, judgeResult.elapsed);
   const queueEntries = [];
   for (const [key, result] of judgeResult.results) {
@@ -273,8 +275,9 @@ async function runContradictionScan(deps) {
     elapsedMs: elapsed
   };
 }
-function generatePairs(memories, existingPairs, scanConfig, embeddingLookup) {
+async function generatePairs(memories, existingPairs, scanConfig, embeddingLookup) {
   const pairs = [];
+  const embeddingPairs = [];
   let skipped = 0;
   const seen = /* @__PURE__ */ new Set();
   const byEntity = /* @__PURE__ */ new Map();
@@ -339,6 +342,39 @@ function generatePairs(memories, existingPairs, scanConfig, embeddingLookup) {
       });
     }
   }
+  if (embeddingLookup) {
+    const memoryById = new Map(memories.map((m) => [m.frontmatter.id, m]));
+    for (const mem of memories) {
+      const id = mem.frontmatter.id;
+      try {
+        const hits = await embeddingLookup(mem.content, 20);
+        for (const hit of hits) {
+          if (hit.score < scanConfig.similarityFloor) continue;
+          if (hit.id === id) continue;
+          const peer = memoryById.get(hit.id);
+          if (!peer) continue;
+          const pairId = computePairId(id, hit.id);
+          if (seen.has(pairId)) continue;
+          seen.add(pairId);
+          const existing = existingPairs.get(pairId);
+          if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {
+            skipped++;
+            continue;
+          }
+          embeddingPairs.push({
+            idA: id,
+            idB: hit.id,
+            textA: mem.content,
+            textB: peer.content,
+            categoryA: mem.frontmatter.category,
+            categoryB: peer.frontmatter.category
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  pairs.push(...embeddingPairs);
   return { pairs, skipped };
 }
 async function loadEligibleMemories(storage, namespace) {

package/dist/{engine-WGNTTFYE.js → engine-65C2J63X.js}

@@ -1,8 +1,9 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-SVGN3ACY.js";
-import "./chunk-KPMXWORS.js";
+} from "./chunk-HCFFXBLV.js";
+import "./chunk-JJSNPSCD.js";
+import "./chunk-6OJAU466.js";
 import "./chunk-UFU5GGGA.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/extraction-judge-telemetry-GHOTVYMP.js

@@ -0,0 +1,14 @@
+import {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  judgeTelemetryPath,
+  readJudgeVerdictStats,
+  recordJudgeVerdict
+} from "./chunk-5ZW5XJQ6.js";
+import "./chunk-UFU5GGGA.js";
+import "./chunk-MLKGABMK.js";
+export {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  judgeTelemetryPath,
+  readJudgeVerdictStats,
+  recordJudgeVerdict
+};