@remnic/core 9.45.3 → 9.45.5

package/src/maintenance/first-start-migration.ts

@@ -278,7 +278,7 @@ export async function runFirstStartMigration(
         qmd,
         hotCollection: options.hotCollection ?? config.qmdCollection ?? "openclaw-engram",
         coldCollection: options.coldCollection ?? config.qmdColdCollection ?? "openclaw-engram-cold",
-    })
+      })
     : null;
   const coldCollection = options.coldCollection ?? config.qmdColdCollection ?? "openclaw-engram-cold";
 
@@ -287,17 +287,17 @@ export async function runFirstStartMigration(
       return abortedResult(candidateCount, demotedCount, failureCount);
     }
     try {
-      if (executor) {
-        await executor.migrateMemory({
-          memory,
-          fromTier: "hot",
-          toTier: "cold",
-          reason: "first-start-lifecycle-migration",
-        });
-      } else {
-        await storage.migrateMemoryToTier(memory, "cold");
+      const result = executor
+        ? await executor.migrateMemory({
+            memory,
+            fromTier: "hot",
+            toTier: "cold",
+            reason: "first-start-lifecycle-migration",
+          })
+        : await storage.migrateMemoryToTier(memory, "cold");
+      if (result.changed) {
+        demotedCount += 1;
       }
-      demotedCount += 1;
     } catch {
       const targetPath = storage.buildTierMemoryPath(memory, "cold");
       const [targetExists, sourceExists] = await Promise.all([

package/src/mcp-read-only-tools.ts

@@ -35,6 +35,7 @@ export const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {
   identity_anchor_get: true,
   memory_identity: true,
   memory_search: true,
+  external_wiki_search: true,
   memory_profile: true,
   memory_entities_list: true,
   memory_questions: true,

package/src/memory-snapshot.ts

@@ -0,0 +1,15 @@
+import type { MemoryFile } from "./types.js";
+
+function sortSnapshotObject(_key: string, candidate: unknown): unknown {
+  if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) return candidate;
+  return Object.keys(candidate)
+    .sort()
+    .reduce<Record<string, unknown>>((sorted, key) => {
+      sorted[key] = (candidate as Record<string, unknown>)[key];
+      return sorted;
+    }, {});
+}
+
+export function createMemorySnapshot(memory: MemoryFile): string {
+  return JSON.stringify([memory.frontmatter, memory.content], sortSnapshotObject);
+}

package/src/offline-sync.test.ts

@@ -16,7 +16,10 @@ import {
   buildOfflineSyncSnapshotForPaths,
   compileOfflineSyncExcludeGlobs,
   globToRegExp,
+  isInternalRemnicStatePath,
   OFFLINE_SYNC_MAX_MTIME_MS,
+  normalizeOfflineSyncSnapshot,
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
   readOfflineSyncFileContentChunk,
   shouldPreferIncomingOfflineRuntimeFile,
   summarizeOfflineSyncPendingChanges,
@@ -106,6 +109,197 @@ test("offline snapshot captures source-of-truth files and excludes private/inter
     await rm(root, { recursive: true, force: true });
   }
 });
+test("offline snapshots preserve actual deletion revisions and never use capture time", async () => {
+  const root = await tempDir("remnic-offline-deletion-census");
+  try {
+    const deletion = { path: "facts/deleted.md", mtimeMs: 2000 };
+    const snapshot = await buildOfflineSyncSnapshot({
+      root,
+      sourceId: "local",
+      now: new Date(4000),
+      deletions: [deletion],
+    });
+    assert.deepEqual(snapshot.deletions, [deletion]);
+    assert.equal(snapshot.createdAt, new Date(4000).toISOString());
+
+    await write(root, deletion.path, "recreated");
+    const recreated = await buildOfflineSyncSnapshot({
+      root,
+      sourceId: "local",
+      now: new Date(5000),
+      deletions: [deletion],
+    });
+    assert.deepEqual(recreated.deletions, []);
+
+    const legacy = normalizeOfflineSyncSnapshot({
+      format: "remnic.offline-sync.snapshot.v1",
+      schemaVersion: 1,
+      createdAt: new Date(6000).toISOString(),
+      sourceId: "legacy",
+      includeTranscripts: false,
+      files: [],
+    });
+    assert.equal(legacy.deletions, undefined);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline delete changes propagate the originating deletion revision", async () => {
+  const root = await tempDir("remnic-offline-delete-revision");
+  try {
+    const relativePath = "facts/deleted.md";
+    const content = Buffer.from("delete me");
+    const sha256 = createHash("sha256").update(content).digest("hex");
+    await write(root, relativePath, content);
+    let receivedMtimeMs: number | undefined;
+
+    const result = await applyOfflineSyncChangeset({
+      root,
+      currentFiles: [{ path: relativePath, sha256, bytes: content.length, mtimeMs: 1000 }],
+      changeset: {
+        format: "remnic.offline-sync.changeset.v1",
+        schemaVersion: 1,
+        createdAt: new Date(4000).toISOString(),
+        sourceId: "peer",
+        includeTranscripts: false,
+        changes: [{ type: "delete", path: relativePath, baseSha256: sha256, mtimeMs: 2000 }],
+      },
+      deleteFile: async ({ filePath, mtimeMs }) => {
+        receivedMtimeMs = mtimeMs;
+        await rm(filePath);
+      },
+    });
+
+    assert.equal(result.appliedDeletes, 1);
+    assert.equal(receivedMtimeMs, 2000);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline apply relays known deletion metadata when the target is already absent", async () => {
+  const root = await tempDir("remnic-offline-delete-relay");
+  try {
+    const relativePath = "facts/deleted.md";
+    const sha256 = "a".repeat(64);
+    let receivedRevision: { path: string; mtimeMs: number } | undefined;
+
+    const result = await applyOfflineSyncChangeset({
+      root,
+      currentFiles: [],
+      changeset: {
+        format: "remnic.offline-sync.changeset.v1",
+        schemaVersion: 1,
+        createdAt: new Date(4000).toISOString(),
+        sourceId: "peer",
+        includeTranscripts: false,
+        changes: [{ type: "delete", path: relativePath, baseSha256: sha256, mtimeMs: 2000 }],
+      },
+      recordDeletionRevision: async ({ path, mtimeMs }) => {
+        receivedRevision = { path, mtimeMs };
+      },
+    });
+
+    assert.equal(result.skipped, 1);
+    assert.deepEqual(receivedRevision, { path: relativePath, mtimeMs: 2000 });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test("offline sync excludes the internal Remnic tree from snapshots and file transfer", async () => {
+  const root = await tempDir("remnic-offline-internal-state");
+  const internalPaths = [
+    ".remnic/state/converge-cursors/peer.json",
+    ".remnic/state/converge.lock",
+    ".remnic/state/converge.tmp-123",
+    ".remnic/state/conflicts/fact.remote",
+  ];
+  const corpusPath = "Facts/.remnic-notes/MixedCase.md";
+  try {
+    for (const relPath of internalPaths) await write(root, relPath, relPath);
+    await write(root, corpusPath, "corpus");
+
+    assert.equal(isInternalRemnicStatePath(".remnic"), true);
+    assert.equal(isInternalRemnicStatePath(internalPaths[0]!), true);
+    assert.equal(isInternalRemnicStatePath(".Remnic/state/cursor.json"), false);
+    assert.equal(isInternalRemnicStatePath("facts/.remnic/note.md"), true);
+    assert.equal(isInternalRemnicStatePath("facts\\.remnic\\note.md"), true);
+
+    const snapshot = await buildOfflineSyncSnapshot({
+      root,
+      sourceId: "local",
+      includeContent: false,
+    });
+    assert.deepEqual(snapshot.files.map((file) => file.path), [corpusPath]);
+
+    await assert.rejects(
+      () => buildOfflineSyncSnapshotForPaths({
+        root,
+        sourceId: "local",
+        paths: [internalPaths[0]!],
+      }),
+      /offline sync snapshot path is excluded/,
+    );
+    await assert.rejects(
+      () => readOfflineSyncFileContentChunk({
+        root,
+        path: internalPaths[0]!,
+      }),
+      /offline sync file content path is excluded/,
+    );
+
+    const cursorContent = Buffer.from(internalPaths[0]!);
+    await assert.rejects(
+      () => applyOfflineSyncFileContentChunk({
+        root,
+        sourceId: "peer",
+        path: internalPaths[0]!,
+        sha256: createHash("sha256").update(cursorContent).digest("hex"),
+        bytes: cursorContent.length,
+        mtimeMs: Date.now(),
+        offset: 0,
+        content: cursorContent,
+      }),
+      /offline sync file content path is excluded/,
+    );
+    const writes: string[] = [];
+    const applyResult = await applyOfflineSyncSnapshot({
+      root,
+      snapshot: {
+        format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        sourceId: "peer",
+        includeTranscripts: true,
+        files: [{
+          path: internalPaths[0]!,
+          sha256: createHash("sha256").update(cursorContent).digest("hex"),
+          bytes: cursorContent.length,
+          mtimeMs: Date.now(),
+          contentBase64: cursorContent.toString("base64"),
+        }],
+      },
+      baseFiles: [],
+      currentFiles: [],
+      writeFile: async ({ path: relPath }) => {
+        writes.push(relPath);
+      },
+      deleteFile: async ({ path: relPath }) => {
+        writes.push(relPath);
+      },
+    });
+    assert.deepEqual(writes, []);
+    assert.equal(applyResult.upserted, 0);
+    assert.equal(applyResult.deleted, 0);
+
+    assert.equal(await readUtf8(root, internalPaths[0]!), internalPaths[0]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
 
 test("offline snapshot abort signal stops filesystem snapshot work", async () => {
   const root = await tempDir("remnic-offline-snapshot-abort");