@remnic/core 9.35.2 → 9.35.3

package/dist/{chunk-FHYGLITW.js → chunk-AKELMJO2.js}

@@ -16,7 +16,7 @@ import {
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-IZXTZ7BF.js";
+} from "./chunk-JYLN6KHH.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-XWDZQIYU.js";
+} from "./chunk-IJAQCBGV.js";
 import {
   SharedContextManager
 } from "./chunk-AS7YMSL6.js";
@@ -198,7 +198,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-Y6OWJ3V5.js";
+} from "./chunk-RY2XZTFN.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -214,7 +214,7 @@ import {
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors
-} from "./chunk-HEVWWPTL.js";
+} from "./chunk-LH3KXIBJ.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -224,14 +224,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-EO7X2LDK.js";
+} from "./chunk-4TAD3B56.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-7ZHGPX56.js";
+} from "./chunk-PRP3M5Y3.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -244,11 +244,11 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-TJLLYV2X.js";
+} from "./chunk-IMEXE4XS.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-TCIWHK3N.js";
+} from "./chunk-6D5D5A4M.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -283,7 +283,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-AEPYA55F.js";
+} from "./chunk-FE7MUX7M.js";
 import {
   buildBehaviorSignalsForMemory,
   dedupeBehaviorSignalsByMemoryAndHash
@@ -322,7 +322,7 @@ import {
 } from "./chunk-LBJBNWS2.js";
 import {
   MeetingsInputError
-} from "./chunk-SLPLPGJQ.js";
+} from "./chunk-WL2S2UBB.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -340,10 +340,10 @@ import {
   capturePassiveCorrections,
   clusterByKey,
   detectPassiveCorrections
-} from "./chunk-5HTAJCTO.js";
+} from "./chunk-ZB3YODID.js";
 import {
   importCapsule
-} from "./chunk-65ZPVYTA.js";
+} from "./chunk-3CE77VAP.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
@@ -385,7 +385,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-PH3ZWL3W.js";
+} from "./chunk-Q53RLEW7.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
@@ -399,7 +399,7 @@ import {
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-Y2ZD2RVG.js";
+} from "./chunk-PYTUBWAS.js";
 import {
   writeConversationChunks
 } from "./chunk-72A4L5JJ.js";
@@ -462,7 +462,7 @@ import {
 } from "./chunk-NRV4Y3PM.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-BIXWNHIL.js";
+} from "./chunk-6TF4M2LB.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -481,7 +481,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-4TGZCYHH.js";
+} from "./chunk-Q3CVY7LV.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -494,17 +494,7 @@ import {
 } from "./chunk-UHVXE24Y.js";
 import {
   buildRetiredFactTombstoneInputs
-} from "./chunk-QNWXCJ76.js";
-import {
-  applyTemporalSupersession,
-  normalizeSupersessionKey,
-  shouldFilterSupersededFromRecall,
-  supersessionKeysForFact
-} from "./chunk-DNHVPZOD.js";
-import {
-  isValidAsOf,
-  isValidityExpiredNow
-} from "./chunk-6CIAGZ6X.js";
+} from "./chunk-ENTCVTQR.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -531,7 +521,7 @@ import {
 } from "./chunk-DM2T26WE.js";
 import {
   ContentHashIndex
-} from "./chunk-FBUE6PD3.js";
+} from "./chunk-BEQOZOYZ.js";
 import {
   TAG_LIMITS,
   composeMemoryEnvelope,
@@ -552,6 +542,26 @@ import {
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-IJ7HK452.js";
+import {
+  HistoricalEntityCanonicalIdCache,
+  canonicalizeEntityRefFrontmatter,
+  classifyEntityRefWritePath,
+  readEntityRefFromFrontmatter,
+  repairContentAfterJournalMove,
+  repairContentAfterJournalMoveSync,
+  requestEntityCanonicalIdReconcile,
+  requestEntityCanonicalIdReconcileSync
+} from "./chunk-4J7G5SY4.js";
+import {
+  applyTemporalSupersession,
+  normalizeSupersessionKey,
+  shouldFilterSupersededFromRecall,
+  supersessionKeysForFact
+} from "./chunk-DNHVPZOD.js";
+import {
+  isValidAsOf,
+  isValidityExpiredNow
+} from "./chunk-6CIAGZ6X.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -19092,6 +19102,7 @@ function emptyManifest() {
 import fsp4 from "fs/promises";
 import path20 from "path";
 import crypto3 from "crypto";
+var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
   const rel = path20.relative(memoryDir, mdPath);
   if (rel.startsWith("..") || path20.isAbsolute(rel)) return false;
@@ -19290,7 +19301,34 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     let writeFailCount = 0;
     for (const update of updates) {
       try {
-        await writeMarkdownFile(update.mdPath, update.content);
+        const stateDir = path20.join(memoryDir, "state");
+        const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
+        if (kind === "memory") {
+          const idsAtWrite = historicalIdCache.get(stateDir);
+          const written = canonicalizeEntityRefFrontmatter(update.content, idsAtWrite);
+          const originalBytes = await readMarkdownFile(update.mdPath).catch(() => null);
+          await writeMarkdownFile(update.mdPath, written);
+          try {
+            await repairContentAfterJournalMove({
+              stateDir,
+              cache: historicalIdCache,
+              idsAtWrite,
+              rawContent: update.content,
+              lastWritten: written,
+              rewrite: (next) => writeMarkdownFile(update.mdPath, next)
+            });
+          } catch (err) {
+            if (originalBytes !== null) {
+              await writeMarkdownFile(update.mdPath, originalBytes).catch(() => void 0);
+            }
+            throw err;
+          }
+        } else {
+          await writeMarkdownFile(update.mdPath, update.content);
+          if (kind === "entity") {
+            await requestEntityCanonicalIdReconcile(stateDir);
+          }
+        }
         if (isRecallCorpusMarkdown(update.mdPath, memoryDir)) {
           bumpMemoryCorpusVersionForDir(memoryDir);
         }
@@ -20512,6 +20550,7 @@ function loadExistingMemories(memoryDir) {
   }
   return result;
 }
+var historicalIdCache2 = new HistoricalEntityCanonicalIdCache();
 function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
@@ -20520,7 +20559,8 @@ function writeStatement(stmt, memoryDir) {
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
   const filePath = path23.join(dir, fileName);
-  const frontmatter = [
+  const historicalIds = historicalIdCache2.get(path23.join(memoryDir, "state"));
+  const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
     `category: ${stmt.category}`,
@@ -20534,12 +20574,28 @@ function writeStatement(stmt, memoryDir) {
     `provenanceFile: ${stmt.provenance.relativePath}`,
     `provenanceHash: ${stmt.provenance.sourceFileHash}`,
     "---"
-  ].filter(Boolean).join("\n");
-  const body = `${frontmatter}
+  ].filter(Boolean).join("\n")}
 
 ${stmt.content}
 `;
+  const body = canonicalizeEntityRefFrontmatter(rawBody, historicalIds);
   fs3.writeFileSync(filePath, body);
+  try {
+    repairContentAfterJournalMoveSync({
+      stateDir: path23.join(memoryDir, "state"),
+      cache: historicalIdCache2,
+      idsAtWrite: historicalIds,
+      rawContent: rawBody,
+      lastWritten: body,
+      rewrite: (next) => fs3.writeFileSync(filePath, next)
+    });
+  } catch (err) {
+    try {
+      fs3.unlinkSync(filePath);
+    } catch {
+    }
+    throw err;
+  }
   bumpMemoryCorpusVersionForDir(memoryDir);
   return filePath;
 }
@@ -20828,6 +20884,39 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 // src/review/index.ts
 import fs5 from "fs";
 import path25 from "path";
+var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
+function writeReviewFileCanonicalized(memoryDir, filePath, content) {
+  const stateDir = path25.join(memoryDir, "state");
+  const idsAtWrite = historicalIdCache3.get(stateDir);
+  let originalBytes = null;
+  try {
+    originalBytes = fs5.readFileSync(filePath, "utf8");
+  } catch {
+    originalBytes = null;
+  }
+  const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
+  fs5.writeFileSync(filePath, written, "utf8");
+  try {
+    repairContentAfterJournalMoveSync({
+      stateDir,
+      cache: historicalIdCache3,
+      idsAtWrite,
+      rawContent: content,
+      lastWritten: written,
+      rewrite: (next) => fs5.writeFileSync(filePath, next, "utf8")
+    });
+  } catch (err) {
+    try {
+      if (originalBytes === null) {
+        fs5.unlinkSync(filePath);
+      } else {
+        fs5.writeFileSync(filePath, originalBytes, "utf8");
+      }
+    } catch {
+    }
+    throw err;
+  }
+}
 var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
 function realMemoryRoot(memoryDir) {
   try {
@@ -20976,7 +21065,8 @@ function approveItem(memoryDir, itemId, options) {
   const fm = parseFrontmatter4(content);
   if (!fm) return { itemId, action: "approve", message: "Could not parse frontmatter" };
   const blockedBy = typeof fm.blockedBy === "string" ? fm.blockedBy : null;
-  if (blockedBy && options.onApproveBlockedMemory) {
+  const fireBlockedRevocation = () => {
+    if (!blockedBy || !options.onApproveBlockedMemory) return;
     try {
       const maybe = options.onApproveBlockedMemory(blockedBy, itemId);
       if (maybe && typeof maybe.then === "function") {
@@ -20984,7 +21074,7 @@ function approveItem(memoryDir, itemId, options) {
       }
     } catch {
     }
-  }
+  };
   const updatedContent = updateFrontmatterFields(content, {
     confidence: "0.9",
     confidenceTier: "high",
@@ -20996,7 +21086,8 @@ function approveItem(memoryDir, itemId, options) {
     ...blockedBy ? { blockedBy: null, tombstoneBlockTier: null, status: "active" } : {}
   });
   if (found.location === "category") {
-    fs5.writeFileSync(found.filePath, updatedContent, "utf8");
+    writeReviewFileCanonicalized(memoryDir, found.filePath, updatedContent);
+    fireBlockedRevocation();
     return {
       itemId,
       action: "approve",
@@ -21011,8 +21102,28 @@ function approveItem(memoryDir, itemId, options) {
   ensureSafeDirectory(rootReal, targetDir);
   const outputPath = path25.join(targetDir, dateDir, path25.basename(found.filePath));
   ensureSafeDirectory(rootReal, path25.dirname(outputPath));
-  const promotedPath = writeFileWithoutClobber(outputPath, updatedContent, itemId);
+  const reviewStateDir = path25.join(memoryDir, "state");
+  const idsAtWrite = historicalIdCache3.get(reviewStateDir);
+  const promotedWritten = canonicalizeEntityRefFrontmatter(updatedContent, idsAtWrite);
+  const promotedPath = writeFileWithoutClobber(outputPath, promotedWritten, itemId);
+  try {
+    repairContentAfterJournalMoveSync({
+      stateDir: reviewStateDir,
+      cache: historicalIdCache3,
+      idsAtWrite,
+      rawContent: updatedContent,
+      lastWritten: promotedWritten,
+      rewrite: (next) => fs5.writeFileSync(promotedPath, next, "utf8")
+    });
+  } catch (err) {
+    try {
+      fs5.unlinkSync(promotedPath);
+    } catch {
+    }
+    throw err;
+  }
   fs5.unlinkSync(found.filePath);
+  fireBlockedRevocation();
   return {
     itemId,
     action: "approve",
@@ -21031,13 +21142,13 @@ function dismissItem(memoryDir, itemId, options) {
     return { itemId, action: "dismiss", message: "Dismissed and removed" };
   }
   const content = fs5.readFileSync(found.filePath, "utf8");
-  fs5.writeFileSync(
+  writeReviewFileCanonicalized(
+    memoryDir,
     found.filePath,
     updateFrontmatterFields(content, {
       reviewDismissed: "true",
       reviewDismissedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }),
-    "utf8"
+    })
   );
   return {
     itemId,
@@ -21056,7 +21167,7 @@ function flagItem(memoryDir, itemId, options) {
     flagged: "true",
     flaggedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  fs5.writeFileSync(found.filePath, fixed);
+  writeReviewFileCanonicalized(memoryDir, found.filePath, fixed);
   return {
     itemId,
     action: "flag",
@@ -21426,6 +21537,7 @@ import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
 import path27 from "path";
+var historicalIdCache4 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
@@ -21999,6 +22111,17 @@ function copyMemories(sourceDir, targetDir, options) {
   fs7.mkdirSync(targetDir, { recursive: true });
   const targetRoot = fs7.realpathSync(targetDir);
   const sourceFiles = walkMd2(sourceRoot);
+  const sourceEntityIds = new Set(
+    sourceFiles.filter((p) => {
+      const rp = safeRealpath(p);
+      if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
+      const rel = path27.relative(sourceRoot, rp);
+      const mapped = path27.resolve(targetRoot, rel);
+      if (!isPathInsideRoot(mapped, targetRoot)) return false;
+      return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
+    }).map((p) => path27.basename(p, ".md"))
+  );
+  let reconcileNeeded = false;
   for (const sourcePath of sourceFiles) {
     const sourceRealPath = safeRealpath(sourcePath);
     if (!sourceRealPath || !isPathInsideRoot(sourceRealPath, sourceRoot)) {
@@ -22017,6 +22140,11 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
+    const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
+    const idsAtCompare = historicalIdCache4.get(path27.join(targetRoot, "state"));
+    const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
+    const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
+    const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
     const sourceHash = hashContent4(content);
     if (options?.filterIds?.length) {
       const fm = parseSimpleFrontmatter(content);
@@ -22040,7 +22168,11 @@ function copyMemories(sourceDir, targetDir, options) {
     if (fs7.existsSync(targetPath) && !options?.force) {
       const targetContent = fs7.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (sourceHash !== targetHash) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path27.join(targetRoot, "state")) === idsAtCompare) {
+        skipped++;
+        continue;
+      }
+      if (hashContent4(canonicalContent) !== targetHash && sourceHash !== targetHash) {
         conflicts.push({
           memoryId: parseSimpleFrontmatter(content)?.id ?? relativePath,
           sourcePath,
@@ -22051,8 +22183,6 @@ function copyMemories(sourceDir, targetDir, options) {
         });
         continue;
       }
-      skipped++;
-      continue;
     }
     fs7.mkdirSync(path27.dirname(targetPath), { recursive: true });
     const targetParentRealPath = safeRealpath(path27.dirname(targetPath));
@@ -22060,10 +22190,52 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs7.writeFileSync(targetPath, content);
+    const stateDir = path27.join(targetRoot, "state");
+    if (targetKind === "memory" && !refHasSourceClaimant) {
+      const idsAtWrite = historicalIdCache4.get(stateDir);
+      const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
+      let priorTarget = null;
+      try {
+        priorTarget = fs7.readFileSync(targetPath, "utf8");
+      } catch {
+        priorTarget = null;
+      }
+      fs7.writeFileSync(targetPath, written);
+      try {
+        repairContentAfterJournalMoveSync({
+          stateDir,
+          cache: historicalIdCache4,
+          idsAtWrite,
+          rawContent: content,
+          lastWritten: written,
+          rewrite: (next) => fs7.writeFileSync(targetPath, next)
+        });
+      } catch (err) {
+        try {
+          if (priorTarget === null) {
+            fs7.unlinkSync(targetPath);
+          } else {
+            fs7.writeFileSync(targetPath, priorTarget);
+          }
+        } catch {
+        }
+        throw err;
+      }
+    } else if (targetKind === "memory") {
+      fs7.writeFileSync(targetPath, content);
+      reconcileNeeded = true;
+    } else {
+      fs7.writeFileSync(targetPath, content);
+      if (targetKind === "entity") {
+        reconcileNeeded = true;
+      }
+    }
     merged++;
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
+  if (reconcileNeeded) {
+    requestEntityCanonicalIdReconcileSync(path27.join(targetRoot, "state"));
+  }
   return { merged, conflicts, skipped };
 }
 function hashContent4(content) {
@@ -23751,4 +23923,4 @@ export {
   filterRecallCandidates,
   Orchestrator
 };
-//# sourceMappingURL=chunk-FHYGLITW.js.map
+//# sourceMappingURL=chunk-AKELMJO2.js.map