@remnic/core 9.69.52 → 9.69.54

package/dist/{chunk-UVZBDIJX.js → chunk-KGY6F4VJ.js}

@@ -112,6 +112,7 @@ import {
   normalizeEntitySchemas
 } from "./chunk-ZIKENA2C.js";
 import {
+  normalizeRecallTokenSet,
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
 import {
@@ -148,12 +149,15 @@ import {
   readEnvVar,
   resolveHomeDir
 } from "./chunk-P2QRMMVQ.js";
+import {
+  ALL_CATEGORY_DIRS
+} from "./chunk-VS2IYZRU.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
 
 // src/config.ts
-import path from "path";
+import path2 from "path";
 
 // src/procedural/maintenance-config.ts
 function parseProceduralMaintenanceConfig(raw) {
@@ -335,6 +339,415 @@ function parseSessionExperienceConfig(raw) {
   };
 }
 
+// src/dedup/index.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+// src/dedup/merge-provenance.ts
+var MERGE_DERIVED_VIA = "merge";
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+function assertIsoInstant(value, field) {
+  if (typeof value !== "string" || !ISO_TIMESTAMP.test(value)) {
+    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
+  }
+  const ms2 = Date.parse(value);
+  if (Number.isNaN(ms2)) {
+    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
+  }
+  if (!new Date(ms2).toISOString().startsWith(value.slice(0, 10))) {
+    throw new RangeError(`${field} is not a real calendar date: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function assertOffset(value, field) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${field} must be a non-negative integer when present, got ${String(value)}`);
+  }
+}
+function normalizeSource(source, index) {
+  const label = `sources[${index}]`;
+  for (const field of ["sessionKey", "quote"]) {
+    const value = source[field];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new RangeError(`${label}.${field} must be a non-blank string`);
+    }
+  }
+  assertIsoInstant(source.observedAt, `${label}.observedAt`);
+  if (source.turnId !== void 0 && (typeof source.turnId !== "string" || source.turnId.trim() === "")) {
+    throw new RangeError(`${label}.turnId must be a non-blank string when present`);
+  }
+  assertOffset(source.charStart, `${label}.charStart`);
+  assertOffset(source.charEnd, `${label}.charEnd`);
+  if (source.charStart !== void 0 && source.charEnd !== void 0 && source.charEnd < source.charStart) {
+    throw new RangeError(`${label}.charEnd must be >= charStart`);
+  }
+  const copy = {
+    sessionKey: source.sessionKey,
+    observedAt: source.observedAt,
+    quote: source.quote
+  };
+  if (source.turnId !== void 0) copy.turnId = source.turnId;
+  if (source.charStart !== void 0) copy.charStart = source.charStart;
+  if (source.charEnd !== void 0) copy.charEnd = source.charEnd;
+  return copy;
+}
+function sourceKey(source) {
+  return JSON.stringify([
+    source.sessionKey,
+    source.turnId ?? null,
+    source.observedAt,
+    source.quote,
+    source.charStart ?? null,
+    source.charEnd ?? null
+  ]);
+}
+function buildMergeFrontmatterUpdate(input) {
+  const updated = assertIsoInstant(input.nowIso, "nowIso");
+  const previous = input.targetReinforcementCount;
+  if (previous !== void 0 && (typeof previous !== "number" || !Number.isInteger(previous) || previous < 0)) {
+    throw new RangeError(
+      `reinforcement_count must be a non-negative integer when supplied, got ${String(previous)}`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  const append = (source, index) => {
+    const copy = normalizeSource(source, index);
+    const key = sourceKey(copy);
+    if (seen.has(key)) return;
+    seen.add(key);
+    sources.push(copy);
+  };
+  const target = input.targetSources ?? [];
+  target.forEach(append);
+  input.incomingSources.forEach((source, i) => append(source, target.length + i));
+  return {
+    updated,
+    derived_via: MERGE_DERIVED_VIA,
+    reinforcement_count: (previous ?? 0) + 1,
+    sources
+  };
+}
+
+// src/dedup/merge-content.ts
+var MERGE_CONTENT_LENGTH_FACTOR = 4;
+function requireString(value, field) {
+  if (typeof value !== "string") {
+    throw new RangeError(`merge ${field} must be a string`);
+  }
+  return value;
+}
+function checkMergedContent(input) {
+  const incoming = requireString(input.incomingContent, "incomingContent");
+  const target = requireString(input.targetContent, "targetContent");
+  const limit = MERGE_CONTENT_LENGTH_FACTOR * (incoming.length + target.length);
+  const merged = input.mergedContent;
+  if (typeof merged !== "string" || merged.trim() === "") {
+    return { ok: false, reason: "empty", limit };
+  }
+  if (!sanitizeMemoryContent(merged).clean) {
+    return { ok: false, reason: "unsafe", limit };
+  }
+  if (merged.length > limit) {
+    return { ok: false, reason: "oversized", limit };
+  }
+  return { ok: true, content: merged };
+}
+
+// src/dedup/index.ts
+var DEFAULT_DEDUP_THRESHOLD = 0.85;
+var DEFAULT_MAX_LOAD = 1e4;
+function normalizeThreshold(value, defaultValue) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : defaultValue;
+}
+function normalizeMaxLoad(value, defaultValue) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : defaultValue;
+}
+function findDuplicates(options) {
+  const startTime = Date.now();
+  const { memoryDir } = options;
+  const threshold = normalizeThreshold(options.threshold, DEFAULT_DEDUP_THRESHOLD);
+  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
+  const memories = loadMemories(memoryDir, options.categories, maxLoad);
+  const duplicates = [];
+  for (let i = 0; i < memories.length; i++) {
+    for (let j = i + 1; j < memories.length; j++) {
+      const sim = computeSimilarity(memories[i].content, memories[j].content);
+      if (sim >= threshold) {
+        duplicates.push({
+          left: memories[i],
+          right: memories[j],
+          similarity: sim,
+          action: sim >= 0.98 ? "merge" : sim >= 0.9 ? "keep_right" : "keep_left"
+        });
+      }
+    }
+  }
+  return {
+    scanned: memories.length,
+    duplicates,
+    durationMs: Date.now() - startTime
+  };
+}
+function findContradictions(options) {
+  const startTime = Date.now();
+  const { memoryDir } = options;
+  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
+  const memories = loadMemories(memoryDir, options.categories, maxLoad);
+  const contradictions = [];
+  for (let i = 0; i < memories.length; i++) {
+    for (let j = i + 1; j < memories.length; j++) {
+      const contra = detectContradiction(memories[i], memories[j]);
+      if (contra) {
+        contradictions.push(contra);
+      }
+    }
+  }
+  return {
+    scanned: memories.length,
+    contradictions,
+    durationMs: Date.now() - startTime
+  };
+}
+function computeSimilarity(a, b) {
+  const normA = normalize(a);
+  const normB = normalize(b);
+  const punctuationBoundariesA = embeddedPunctuationSignature(a);
+  const punctuationBoundariesB = embeddedPunctuationSignature(b);
+  if (punctuationBoundariesA !== punctuationBoundariesB) return 0;
+  if (normA === normB) return 1;
+  if (hashContent(normA) === hashContent(normB)) return 0.99;
+  if (normA.length > 50 && normB.length > 50) {
+    if (normA.includes(normB.slice(0, 40)) || normB.includes(normA.slice(0, 40))) {
+      return 0.9;
+    }
+  }
+  const wordsA = tokenizeForSimilarity(normA);
+  const wordsB = tokenizeForSimilarity(normB);
+  const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
+  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+  if (union.size === 0) return 0;
+  return intersection.size / union.size;
+}
+function embeddedPunctuationSignature(text) {
+  const chars = [...text.normalize("NFC")];
+  const significant = /[\p{L}\p{M}\p{N}]/u;
+  const ignored = /[\s']/u;
+  const boundaries = [];
+  let position = 0;
+  for (let index = 0; index < chars.length; ) {
+    const char = chars[index];
+    if (char === void 0) break;
+    if (significant.test(char)) {
+      position++;
+      index++;
+      continue;
+    }
+    if (ignored.test(char)) {
+      index++;
+      continue;
+    }
+    const start = index;
+    while (index < chars.length) {
+      const next = chars[index];
+      if (next === void 0 || significant.test(next) || ignored.test(next)) break;
+      index++;
+    }
+    const before = chars[start - 1];
+    const after = chars[index];
+    if (before && after && significant.test(before) && significant.test(after)) {
+      boundaries.push(`${position}:${chars.slice(start, index).join("")}`);
+    }
+  }
+  return boundaries.join("\0");
+}
+function normalize(text) {
+  return text.normalize("NFC").toLowerCase().replace(/[^\p{ASCII}\p{L}\p{M}\p{N}\s']/gu, " ").replace(/[^\p{L}\p{M}\p{N}\s']/gu, "").replace(/\s+/g, " ").trim();
+}
+function tokenizeForSimilarity(text) {
+  if (/\p{Script=Hangul}/u.test(text)) {
+    const tokens = normalizeRecallTokenSet(text);
+    for (const segment of text.match(/\p{Script=Hangul}+/gu) ?? []) {
+      const chars = [...segment];
+      for (const size of [1, 2, 3, 4]) {
+        for (let index = 0; index <= chars.length - size; index += 1) {
+          tokens.add(chars.slice(index, index + size).join(""));
+        }
+      }
+    }
+    return tokens;
+  }
+  if (/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(text)) {
+    return normalizeRecallTokenSet(text);
+  }
+  return text.length === 0 ? /* @__PURE__ */ new Set() : new Set(text.split(/\s+/));
+}
+var NEGATION_WORDS = /* @__PURE__ */ new Set([
+  "not",
+  "don't",
+  "doesn't",
+  "isn't",
+  "aren't",
+  "won't",
+  "can't",
+  "cannot",
+  "never",
+  "no",
+  "none",
+  "neither",
+  "nor",
+  "nothing",
+  "nowhere"
+]);
+function detectContradiction(a, b) {
+  const normA = normalize(a.content);
+  const normB = normalize(b.content);
+  const aHasNegation = containsNegation(normA);
+  const bHasNegation = containsNegation(normB);
+  if (aHasNegation === bHasNegation) return null;
+  const strippedA = stripNegation(normA);
+  const strippedB = stripNegation(normB);
+  const sim = computeSimilarity(strippedA, strippedB);
+  if (sim < 0.7) return null;
+  const oppQuantifiers = [
+    ["always", "never"],
+    ["all", "none"],
+    ["every", "no"],
+    ["must", "must not"],
+    ["should", "should not"],
+    ["can", "cannot"]
+  ];
+  for (const [pos, neg] of oppQuantifiers) {
+    if (a.content.toLowerCase().includes(pos) && b.content.toLowerCase().includes(neg) || a.content.toLowerCase().includes(neg) && b.content.toLowerCase().includes(pos)) {
+      return {
+        left: a,
+        right: b,
+        severity: "high",
+        reason: `Opposite quantifiers: "${pos}" vs "${neg}"`
+      };
+    }
+  }
+  return {
+    left: a,
+    right: b,
+    severity: sim >= 0.85 ? "high" : "medium",
+    reason: "Negated version of similar content"
+  };
+}
+function containsNegation(text) {
+  const words = text.split(/\s+/);
+  return words.some((w) => NEGATION_WORDS.has(w));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var stripNegationPattern = null;
+var stripNegationPatternSource = null;
+function stripNegationRegex() {
+  const alternation = [...NEGATION_WORDS].sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
+  if (stripNegationPattern === null || stripNegationPatternSource !== alternation) {
+    stripNegationPattern = new RegExp(`\\b(?:${alternation})\\b`, "gi");
+    stripNegationPatternSource = alternation;
+  }
+  return stripNegationPattern;
+}
+function stripNegation(text) {
+  return text.replace(stripNegationRegex(), "").replace(/\s+/g, " ").trim();
+}
+function loadMemories(memoryDir, categories, maxLoad = 1e4) {
+  const result = [];
+  const allCategories = categories ?? ALL_CATEGORY_DIRS;
+  if (!fs.existsSync(memoryDir)) return result;
+  const memoryRootReal = fs.realpathSync(memoryDir);
+  for (const category of allCategories) {
+    if (result.length >= maxLoad) break;
+    const dir = path.join(memoryDir, category);
+    if (!fs.existsSync(dir)) continue;
+    const categoryStat = fs.lstatSync(dir);
+    if (categoryStat.isSymbolicLink()) {
+      throw new Error(`Refusing to scan symlinked memory category directory: ${dir}`);
+    }
+    if (!categoryStat.isDirectory()) continue;
+    const categoryRootReal = fs.realpathSync(dir);
+    assertPathInsideRoot(memoryRootReal, categoryRootReal, dir);
+    walkMdFiles(dir, memoryRootReal, categoryRootReal, (filePath) => {
+      if (result.length >= maxLoad) return;
+      const content = readFileSafe(filePath, memoryRootReal, categoryRootReal);
+      if (!content) return;
+      const fm = parseFrontmatter(content);
+      const body = extractBody(content);
+      if (!fm?.id || !body) return;
+      result.push({
+        id: fm.id,
+        content: body,
+        category: fm.category ?? category.slice(0, -1),
+        filePath
+      });
+    });
+  }
+  return result;
+}
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function readFileSafe(filePath, memoryRootReal, categoryRootReal) {
+  try {
+    const fileStat = fs.lstatSync(filePath);
+    if (fileStat.isSymbolicLink()) {
+      throw new Error(`Refusing to read symlinked memory file: ${filePath}`);
+    }
+    const fileReal = fs.realpathSync(filePath);
+    assertPathInsideRoot(memoryRootReal, fileReal, filePath);
+    assertPathInsideRoot(categoryRootReal, fileReal, filePath);
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    fm[key] = value;
+  }
+  return fm;
+}
+function extractBody(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  return match ? match[1].trim() : content.trim();
+}
+function assertPathInsideRoot(rootReal, targetReal, sourcePath) {
+  const rel = path.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel)) {
+    return;
+  }
+  throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
+}
+function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    const entryStat = fs.lstatSync(fullPath);
+    if (entryStat.isSymbolicLink()) {
+      throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
+    }
+    const entryReal = fs.realpathSync(fullPath);
+    assertPathInsideRoot(memoryRootReal, entryReal, fullPath);
+    assertPathInsideRoot(categoryRootReal, entryReal, fullPath);
+    if (entryStat.isDirectory()) {
+      walkMdFiles(fullPath, memoryRootReal, categoryRootReal, callback);
+    } else if (entry.name.endsWith(".md")) {
+      callback(fullPath);
+    }
+  }
+}
+
 // src/lifecycle/seed-graduation.ts
 var SEED_GRADUATION_DEFAULTS = {
   enabled: false,
@@ -418,14 +831,29 @@ function isIndependentProvenance(seed, evidence) {
   return evidence.frontmatter.source !== seed.frontmatter.source;
 }
 function coverageOf(seedTokens, evidence) {
+  return tokenCoverageOf(
+    seedTokens,
+    new Set(normalizeRecallTokens(stripAttributesSuffix(evidence.content)))
+  );
+}
+function tokenCoverageOf(seedTokens, evidenceTokens) {
   if (seedTokens.size === 0) return 0;
-  const evidenceTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(evidence.content)));
   let matches = 0;
   for (const token of seedTokens) {
     if (evidenceTokens.has(token)) matches += 1;
   }
   return matches / seedTokens.size;
 }
+var NEGATION_WORD_SPLIT = /[^\p{L}\p{M}\p{N}']+/u;
+function hasNegationWord(text) {
+  for (const word of text.toLowerCase().split(NEGATION_WORD_SPLIT)) {
+    if (NEGATION_WORDS.has(word)) return true;
+  }
+  return false;
+}
+function stripNegationWords(text) {
+  return text.toLowerCase().split(NEGATION_WORD_SPLIT).filter((word) => !NEGATION_WORDS.has(word)).join(" ");
+}
 function evaluateSeedGraduation(seed, evidence, options = {}) {
   const config = options.config ?? SEED_GRADUATION_DEFAULTS;
   if (!config.enabled) {
@@ -433,22 +861,28 @@ function evaluateSeedGraduation(seed, evidence, options = {}) {
       decision: "hold",
       corroborationCount: 0,
       corroborating: [],
+      contradicting: [],
       echoSuppressedCount: 0,
       reasons: ["seed-graduation-disabled"]
     };
   }
-  const seedTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(seed.content)));
+  const seedText = stripAttributesSuffix(seed.content);
+  const seedTokens = new Set(normalizeRecallTokens(seedText));
   if (seedTokens.size < MIN_SEED_TOKENS) {
     return {
       decision: "hold",
       corroborationCount: 0,
       corroborating: [],
+      contradicting: [],
       echoSuppressedCount: 0,
       reasons: ["seed-too-short-for-deterministic-corroboration"]
     };
   }
+  const seedNegated = hasNegationWord(seedText);
+  const seedCoreTokens = new Set(normalizeRecallTokens(stripNegationWords(seedText)));
   const seedCreated = createdMs(seed);
   const corroborating = [];
+  const contradicting = [];
   const reasons = [];
   let echoSuppressedCount = 0;
   for (const candidate of evidence) {
@@ -457,6 +891,19 @@ function evaluateSeedGraduation(seed, evidence, options = {}) {
     if (!Number.isFinite(seedCreated) || !Number.isFinite(candidateCreated)) continue;
     if (candidateCreated <= seedCreated) continue;
     if (!isEvidenceStatus(candidate.frontmatter.status)) continue;
+    const candidateText = stripAttributesSuffix(candidate.content);
+    if (hasNegationWord(candidateText) !== seedNegated) {
+      if (seedCoreTokens.size >= MIN_SEED_TOKENS && isIndependentProvenance(seed, candidate)) {
+        const coreTokens = new Set(normalizeRecallTokens(stripNegationWords(candidateText)));
+        if (tokenCoverageOf(seedCoreTokens, coreTokens) >= SEED_CORROBORATION_COVERAGE) {
+          contradicting.push({
+            memoryId: candidate.frontmatter.id,
+            source: candidate.frontmatter.source
+          });
+        }
+      }
+      continue;
+    }
     if (coverageOf(seedTokens, candidate) < SEED_CORROBORATION_COVERAGE) continue;
     if (!isIndependentProvenance(seed, candidate)) {
       echoSuppressedCount += 1;
@@ -470,11 +917,23 @@ function evaluateSeedGraduation(seed, evidence, options = {}) {
     corroborating.push({ memoryId: candidate.frontmatter.id, source: candidate.frontmatter.source });
   }
   if (echoSuppressedCount > 0) reasons.push(`echo-suppressed:${echoSuppressedCount}`);
+  if (contradicting.length > 0) {
+    reasons.push(`contradiction-observed:${contradicting.length}`);
+    return {
+      decision: "hold",
+      corroborationCount: corroborating.length,
+      corroborating,
+      contradicting,
+      echoSuppressedCount,
+      reasons
+    };
+  }
   if (corroborating.length >= config.minCorroborations) {
     return {
       decision: "promote",
       corroborationCount: corroborating.length,
       corroborating,
+      contradicting,
       echoSuppressedCount,
       reasons
     };
@@ -484,6 +943,7 @@ function evaluateSeedGraduation(seed, evidence, options = {}) {
     decision: "hold",
     corroborationCount: corroborating.length,
     corroborating,
+    contradicting,
     echoSuppressedCount,
     reasons
   };
@@ -499,12 +959,13 @@ function graduationAttributes(evaluation) {
 async function runSeedGraduationPass(input) {
   const config = input.config ?? SEED_GRADUATION_DEFAULTS;
   if (!config.enabled) {
-    return { evaluated: 0, promoted: 0, held: 0, echoSuppressed: 0, disabled: true };
+    return { evaluated: 0, promoted: 0, held: 0, contradictionHeld: 0, echoSuppressed: 0, disabled: true };
   }
   const corpus = excludeSupportPassportPrivateMemories(input.memories);
   const evidencePool = corpus.filter((memory) => isEvidenceStatus(memory.frontmatter.status));
   let promoted = 0;
   let held = 0;
+  let contradictionHeld = 0;
   let echoSuppressed = 0;
   let evaluated = 0;
   for (const seed of corpus) {
@@ -518,6 +979,7 @@ async function runSeedGraduationPass(input) {
     echoSuppressed += evaluation.echoSuppressedCount;
     if (evaluation.decision === "hold") {
       held += 1;
+      if (evaluation.contradicting.length > 0) contradictionHeld += 1;
       continue;
     }
     const wrote = await input.storage.promoteWearableMemory(
@@ -527,7 +989,7 @@ async function runSeedGraduationPass(input) {
     if (wrote) promoted += 1;
     else held += 1;
   }
-  return { evaluated, promoted, held, echoSuppressed, disabled: false };
+  return { evaluated, promoted, held, contradictionHeld, echoSuppressed, disabled: false };
 }
 
 // src/dedup/connector-scope.ts
@@ -662,31 +1124,6 @@ var REFUSED_MERGE_CATEGORIES = [
   "correction"
 ];
 
-// src/dedup/merge-content.ts
-var MERGE_CONTENT_LENGTH_FACTOR = 4;
-function requireString(value, field) {
-  if (typeof value !== "string") {
-    throw new RangeError(`merge ${field} must be a string`);
-  }
-  return value;
-}
-function checkMergedContent(input) {
-  const incoming = requireString(input.incomingContent, "incomingContent");
-  const target = requireString(input.targetContent, "targetContent");
-  const limit = MERGE_CONTENT_LENGTH_FACTOR * (incoming.length + target.length);
-  const merged = input.mergedContent;
-  if (typeof merged !== "string" || merged.trim() === "") {
-    return { ok: false, reason: "empty", limit };
-  }
-  if (!sanitizeMemoryContent(merged).clean) {
-    return { ok: false, reason: "unsafe", limit };
-  }
-  if (merged.length > limit) {
-    return { ok: false, reason: "oversized", limit };
-  }
-  return { ok: true, content: merged };
-}
-
 // src/dedup/merge.ts
 function compareMergeCandidates(a, b) {
   if (a.similarity !== b.similarity) return b.similarity - a.similarity;
@@ -2220,14 +2657,14 @@ function validateScopeProfileTeamReferences(profiles, teams) {
 }
 
 // src/config.ts
-var DEFAULT_MEMORY_DIR = path.join(
+var DEFAULT_MEMORY_DIR = path2.join(
   resolveHomeDir(),
   ".openclaw",
   "workspace",
   "memory",
   "local"
 );
-var DEFAULT_WORKSPACE_DIR = path.join(
+var DEFAULT_WORKSPACE_DIR = path2.join(
   resolveHomeDir(),
   ".openclaw",
   "workspace"
@@ -3721,18 +4158,18 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     benchmarkBaselineSnapshotsEnabled: cfg.benchmarkBaselineSnapshotsEnabled === true,
     benchmarkDeltaReporterEnabled: cfg.benchmarkDeltaReporterEnabled === true,
     benchmarkStoredBaselineEnabled: cfg.benchmarkStoredBaselineEnabled === true,
-    evalStoreDir: typeof cfg.evalStoreDir === "string" && cfg.evalStoreDir.trim().length > 0 ? cfg.evalStoreDir.trim() : path.join(memoryDir, "state", "evals"),
+    evalStoreDir: typeof cfg.evalStoreDir === "string" && cfg.evalStoreDir.trim().length > 0 ? cfg.evalStoreDir.trim() : path2.join(memoryDir, "state", "evals"),
     objectiveStateMemoryEnabled: cfg.objectiveStateMemoryEnabled === true,
     objectiveStateSnapshotWritesEnabled: cfg.objectiveStateSnapshotWritesEnabled === true,
     objectiveStateRecallEnabled: cfg.objectiveStateRecallEnabled === true,
-    objectiveStateStoreDir: typeof cfg.objectiveStateStoreDir === "string" && cfg.objectiveStateStoreDir.trim().length > 0 ? cfg.objectiveStateStoreDir.trim() : path.join(memoryDir, "state", "objective-state"),
+    objectiveStateStoreDir: typeof cfg.objectiveStateStoreDir === "string" && cfg.objectiveStateStoreDir.trim().length > 0 ? cfg.objectiveStateStoreDir.trim() : path2.join(memoryDir, "state", "objective-state"),
     causalTrajectoryMemoryEnabled: cfg.causalTrajectoryMemoryEnabled === true,
-    causalTrajectoryStoreDir: typeof cfg.causalTrajectoryStoreDir === "string" && cfg.causalTrajectoryStoreDir.trim().length > 0 ? cfg.causalTrajectoryStoreDir.trim() : path.join(memoryDir, "state", "causal-trajectories"),
+    causalTrajectoryStoreDir: typeof cfg.causalTrajectoryStoreDir === "string" && cfg.causalTrajectoryStoreDir.trim().length > 0 ? cfg.causalTrajectoryStoreDir.trim() : path2.join(memoryDir, "state", "causal-trajectories"),
     causalTrajectoryRecallEnabled: cfg.causalTrajectoryRecallEnabled === true,
     actionGraphRecallEnabled: cfg.actionGraphRecallEnabled === true,
     trustZonesEnabled: cfg.trustZonesEnabled === true,
     quarantinePromotionEnabled: cfg.quarantinePromotionEnabled === true,
-    trustZoneStoreDir: typeof cfg.trustZoneStoreDir === "string" && cfg.trustZoneStoreDir.trim().length > 0 ? cfg.trustZoneStoreDir.trim() : path.join(memoryDir, "state", "trust-zones"),
+    trustZoneStoreDir: typeof cfg.trustZoneStoreDir === "string" && cfg.trustZoneStoreDir.trim().length > 0 ? cfg.trustZoneStoreDir.trim() : path2.join(memoryDir, "state", "trust-zones"),
     trustZoneRecallEnabled: cfg.trustZoneRecallEnabled === true,
     memoryPoisoningDefenseEnabled: cfg.memoryPoisoningDefenseEnabled === true,
     memoryRedTeamBenchEnabled: cfg.memoryRedTeamBenchEnabled === true,
@@ -3862,22 +4299,22 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     commitmentLedgerEnabled: cfg.commitmentLedgerEnabled === true,
     commitmentLifecycleEnabled: cfg.commitmentLifecycleEnabled === true,
     commitmentStaleDays: typeof cfg.commitmentStaleDays === "number" ? cfg.commitmentStaleDays : 14,
-    commitmentLedgerDir: typeof cfg.commitmentLedgerDir === "string" && cfg.commitmentLedgerDir.trim().length > 0 ? cfg.commitmentLedgerDir.trim() : path.join(memoryDir, "state", "commitment-ledger"),
+    commitmentLedgerDir: typeof cfg.commitmentLedgerDir === "string" && cfg.commitmentLedgerDir.trim().length > 0 ? cfg.commitmentLedgerDir.trim() : path2.join(memoryDir, "state", "commitment-ledger"),
     resumeBundlesEnabled: cfg.resumeBundlesEnabled === true,
-    resumeBundleDir: typeof cfg.resumeBundleDir === "string" && cfg.resumeBundleDir.trim().length > 0 ? cfg.resumeBundleDir.trim() : path.join(memoryDir, "state", "resume-bundles"),
+    resumeBundleDir: typeof cfg.resumeBundleDir === "string" && cfg.resumeBundleDir.trim().length > 0 ? cfg.resumeBundleDir.trim() : path2.join(memoryDir, "state", "resume-bundles"),
     workProductRecallEnabled: cfg.workProductRecallEnabled === true,
     workTasksEnabled: cfg.workTasksEnabled === true,
     workProjectsEnabled: cfg.workProjectsEnabled === true,
-    workTasksDir: typeof cfg.workTasksDir === "string" && cfg.workTasksDir.trim().length > 0 ? cfg.workTasksDir.trim() : path.join(memoryDir, "work", "tasks"),
-    workProjectsDir: typeof cfg.workProjectsDir === "string" && cfg.workProjectsDir.trim().length > 0 ? cfg.workProjectsDir.trim() : path.join(memoryDir, "work", "projects"),
+    workTasksDir: typeof cfg.workTasksDir === "string" && cfg.workTasksDir.trim().length > 0 ? cfg.workTasksDir.trim() : path2.join(memoryDir, "work", "tasks"),
+    workProjectsDir: typeof cfg.workProjectsDir === "string" && cfg.workProjectsDir.trim().length > 0 ? cfg.workProjectsDir.trim() : path2.join(memoryDir, "work", "projects"),
     workIndexEnabled: cfg.workIndexEnabled === true,
-    workIndexDir: typeof cfg.workIndexDir === "string" && cfg.workIndexDir.trim().length > 0 ? cfg.workIndexDir.trim() : path.join(memoryDir, "work", "index"),
+    workIndexDir: typeof cfg.workIndexDir === "string" && cfg.workIndexDir.trim().length > 0 ? cfg.workIndexDir.trim() : path2.join(memoryDir, "work", "index"),
     workTaskIndexEnabled: cfg.workTaskIndexEnabled === true,
     workProjectIndexEnabled: cfg.workProjectIndexEnabled === true,
     workIndexAutoRebuildEnabled: cfg.workIndexAutoRebuildEnabled === true,
     workIndexAutoRebuildDebounceMs: typeof cfg.workIndexAutoRebuildDebounceMs === "number" ? cfg.workIndexAutoRebuildDebounceMs : 1e3,
-    workProductLedgerDir: typeof cfg.workProductLedgerDir === "string" && cfg.workProductLedgerDir.trim().length > 0 ? cfg.workProductLedgerDir.trim() : path.join(memoryDir, "state", "work-product-ledger"),
-    abstractionNodeStoreDir: typeof cfg.abstractionNodeStoreDir === "string" && cfg.abstractionNodeStoreDir.trim().length > 0 ? cfg.abstractionNodeStoreDir.trim() : path.join(memoryDir, "state", "abstraction-nodes"),
+    workProductLedgerDir: typeof cfg.workProductLedgerDir === "string" && cfg.workProductLedgerDir.trim().length > 0 ? cfg.workProductLedgerDir.trim() : path2.join(memoryDir, "state", "work-product-ledger"),
+    abstractionNodeStoreDir: typeof cfg.abstractionNodeStoreDir === "string" && cfg.abstractionNodeStoreDir.trim().length > 0 ? cfg.abstractionNodeStoreDir.trim() : path2.join(memoryDir, "state", "abstraction-nodes"),
     ...parseLocalLlmConfig(cfg, localLlmApiKeyEnv, resolveEnvVars),
     // Observability (disabled by default to avoid log spam)
     slowLogEnabled: cfg.slowLogEnabled === true,
@@ -3886,7 +4323,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     traceRecallContent: cfg.traceRecallContent === true,
     // Performance profiling (opt-in, disabled by default)
     profilingEnabled: cfg.profilingEnabled === true,
-    profilingStorageDir: typeof cfg.profilingStorageDir === "string" && cfg.profilingStorageDir.length > 0 ? cfg.profilingStorageDir : path.join(memoryDir, "profiling"),
+    profilingStorageDir: typeof cfg.profilingStorageDir === "string" && cfg.profilingStorageDir.length > 0 ? cfg.profilingStorageDir : path2.join(memoryDir, "profiling"),
     profilingMaxTraces: typeof cfg.profilingMaxTraces === "number" && Number.isFinite(cfg.profilingMaxTraces) ? Math.max(0, cfg.profilingMaxTraces) : 100,
     // Extraction stability guards (P0/P1)
     extractionDedupeEnabled: cfg.extractionDedupeEnabled !== false,
@@ -4163,7 +4600,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     remoteSearchTimeoutMs: typeof cfg.remoteSearchTimeoutMs === "number" ? cfg.remoteSearchTimeoutMs : 3e4,
     // LanceDB backend
     lancedbEnabled: cfg.lancedbEnabled === true,
-    lanceDbPath: typeof cfg.lanceDbPath === "string" ? cfg.lanceDbPath : path.join(memoryDir, "lancedb"),
+    lanceDbPath: typeof cfg.lanceDbPath === "string" ? cfg.lanceDbPath : path2.join(memoryDir, "lancedb"),
     lanceEmbeddingDimension: typeof cfg.lanceEmbeddingDimension === "number" ? cfg.lanceEmbeddingDimension : 1536,
     // Meilisearch backend
     meilisearchEnabled: cfg.meilisearchEnabled === true,
@@ -4173,7 +4610,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     meilisearchAutoIndex: cfg.meilisearchAutoIndex === true,
     // Orama backend
     oramaEnabled: cfg.oramaEnabled === true,
-    oramaDbPath: typeof cfg.oramaDbPath === "string" ? cfg.oramaDbPath : path.join(memoryDir, "orama"),
+    oramaDbPath: typeof cfg.oramaDbPath === "string" ? cfg.oramaDbPath : path2.join(memoryDir, "orama"),
     oramaEmbeddingDimension: typeof cfg.oramaEmbeddingDimension === "number" ? cfg.oramaEmbeddingDimension : 1536,
     // CJK/Thai lexical segmentation (issue #2187) — default on; string forms
     // from CLI `--config` are coerced like neighboring boolean flags.
@@ -4343,7 +4780,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     graphRecallEntityHintsEnabled: cfg.graphRecallEntityHintsEnabled === true,
     graphRecallEntityHintMax: typeof cfg.graphRecallEntityHintMax === "number" ? cfg.graphRecallEntityHintMax : 3,
     graphRecallEntityHintMaxChars: typeof cfg.graphRecallEntityHintMaxChars === "number" ? cfg.graphRecallEntityHintMaxChars : 200,
-    graphRecallSnapshotDir: typeof cfg.graphRecallSnapshotDir === "string" && cfg.graphRecallSnapshotDir.trim().length > 0 ? cfg.graphRecallSnapshotDir.trim() : path.join(memoryDir, "state", "graph"),
+    graphRecallSnapshotDir: typeof cfg.graphRecallSnapshotDir === "string" && cfg.graphRecallSnapshotDir.trim().length > 0 ? cfg.graphRecallSnapshotDir.trim() : path2.join(memoryDir, "state", "graph"),
     graphRecallEnableTrace: cfg.graphRecallEnableTrace === true,
     graphRecallEnableDebug: cfg.graphRecallEnableDebug === true,
     graphExpandedIntentEnabled: cfg.graphExpandedIntentEnabled !== false,
@@ -5029,6 +5466,9 @@ function parseTrustScoreWeights(value) {
 export {
   DRIFT_DETECTION_DEFAULTS,
   parseDriftDetectionConfig,
+  buildMergeFrontmatterUpdate,
+  findDuplicates,
+  findContradictions,
   runSeedGraduationPass,
   normalizeConnectorScope,
   connectorMatchesScope,
@@ -5062,4 +5502,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-UVZBDIJX.js.map
+//# sourceMappingURL=chunk-KGY6F4VJ.js.map