@remnic/core 9.54.4 → 9.54.5

package/src/access-http.test.ts

@@ -4361,6 +4361,7 @@ test("HTTP memory search excludes artifacts and tops up to a full page", async (
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit ?? -1);
       return corpus.slice(0, limit);
@@ -4385,6 +4386,7 @@ test("HTTP memory search stops topping up when the corpus is exhausted", async (
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit ?? -1);
       return [{ path: "facts/only.md", score: 0.5, snippet: "only" }];
@@ -4407,6 +4409,7 @@ test("HTTP memory search omits maxResults when the caller named no budget", asyn
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const corpus = [
@@ -4448,6 +4451,7 @@ test("HTTP memory search keeps topping up past four excluded pages", async () =>
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       return corpus.slice(0, limit);
@@ -4470,6 +4474,7 @@ test("HTTP memory search stops at the candidate ceiling", async () => {
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: () => true,
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       return Array.from({ length: limit ?? 0 }, (_, index) => ({
@@ -4500,6 +4505,7 @@ test("HTTP memory search scales its ceiling above a large requested budget", asy
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath === "artifacts/a.md",
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 0;
@@ -4531,6 +4537,7 @@ test("HTTP memory search keeps the backend page size when no limit is named", as
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: () => false,
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 6;
@@ -4558,6 +4565,7 @@ test("HTTP memory search still tops up a thinned default page", async () => {
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 6;
@@ -4605,6 +4613,7 @@ test("search keeps archived memories but still excludes the dedicated surfaces",
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => isSearchExcludedPath(memoryPath),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async () => [
       { path: "archive/2026-01/fact-1.md", score: 0.9, snippet: "archived" },
       { path: "artifacts/report.md", score: 0.8, snippet: "artifact" },
@@ -4709,6 +4718,7 @@ test("search keeps paging while the backend page is full of excluded hits", asyn
       limits.push(limit);
       return corpus.slice(0, limit ?? corpus.length);
     },
+    filterPrivate: async (hits) => hits,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
   });
   assert.equal(results.length, 50, "the memories behind the excluded block are returned");
@@ -4719,6 +4729,26 @@ test("search keeps paging while the backend page is full of excluded hits", asyn
   );
 });
 
+test("search removes excluded paths before private-memory resolution", async () => {
+  const { searchWithGenericExclusion } = await import("./access-memory-search-fanout.js");
+  const resolved: string[] = [];
+  const results = await searchWithGenericExclusion({
+    budget: 1,
+    sendInitialLimit: true,
+    search: async () => [
+      { path: "artifacts/private.md" },
+      { path: "facts/visible.md" },
+    ],
+    filterPrivate: async (hits) => {
+      resolved.push(...hits.map((hit) => hit.path));
+      return hits;
+    },
+    isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+  });
+  assert.deepEqual(resolved, ["facts/visible.md"]);
+  assert.deepEqual(results, [{ path: "facts/visible.md" }]);
+});
+
 test("a budget above the backend cap still gets the rows it asked for", async () => {
   // The cap protects the backend from an unbounded walk; it must never sit
   // BELOW an explicit request, or a large search returns a short page for a
@@ -4732,6 +4762,7 @@ test("a budget above the backend cap still gets the rows it asked for", async ()
     budget: 30_000,
     sendInitialLimit: true,
     search: async (limit) => corpus.slice(0, limit ?? corpus.length),
+    filterPrivate: async (hits) => hits,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
   });
   assert.equal(results.length, 30_000, "the excluded hit was replaced, not subtracted");

package/src/access-memory-search-fanout.ts

@@ -299,6 +299,7 @@ export async function searchWithGenericExclusion<TResult extends { path: string
    */
   sendInitialLimit: boolean;
   search(limit: number | undefined): Promise<TResult[]>;
+  filterPrivate(results: TResult[]): Promise<TResult[]>;
   isExcluded(memoryPath: string): boolean;
 }): Promise<TResult[]> {
   const { budget } = options;
@@ -313,7 +314,8 @@ export async function searchWithGenericExclusion<TResult extends { path: string
   let firstPage = true;
   for (;;) {
     const raw = await options.search(limit);
-    results = raw.filter((hit) => !options.isExcluded(hit.path));
+    const eligible = raw.filter((hit) => !options.isExcluded(hit.path));
+    results = await options.filterPrivate(eligible);
     if (firstPage) {
       firstPage = false;
       if (!options.sendInitialLimit) target = Math.min(budget, raw.length);
@@ -358,6 +360,9 @@ export async function runScopedMemorySearch(options: {
   mode?: "search" | "hybrid" | "bm25" | "vector";
   namespacesEnabled: boolean;
   isExcluded(memoryPath: string): boolean;
+  filterPrivate(
+    results: Array<{ path: string; score: number; snippet?: string }>,
+  ): Promise<Array<{ path: string; score: number; snippet?: string }>>;
   flatCorpus(
     limit: number | undefined,
   ): Promise<Array<{ path: string; score: number; snippet?: string }>>;
@@ -370,6 +375,7 @@ export async function runScopedMemorySearch(options: {
     budget: options.budget,
     sendInitialLimit: options.sendInitialLimit,
     isExcluded: options.isExcluded,
+    filterPrivate: options.filterPrivate,
     search: (limit) =>
       options.namespacesEnabled ? options.namespaced(limit) : options.flatCorpus(limit),
   });
@@ -384,7 +390,14 @@ export async function runScopedMemorySearch(options: {
 export interface ScopedMemorySearchDeps {
   namespacesEnabled: boolean;
   defaultBudget: number;
+  memoryCollections: readonly string[];
   isExcluded(memoryPath: string): boolean;
+  filterPrivate(
+    results: Array<{ path: string; score: number; snippet?: string }>,
+    namespaces: readonly string[],
+    preserveUnresolved?: boolean,
+    visibilityCache?: Map<string, boolean>,
+  ): Promise<Array<{ path: string; score: number; snippet?: string }>>;
   /** Flat-corpus authorization; throws when the namespace is unreadable. */
   authorizeFlatCorpus(namespace: string | undefined, principal: string | undefined): void;
   /** Namespace-aware authorization; throws, else returns the search fan-out. */
@@ -437,10 +450,20 @@ export async function memorySearchThroughScope(
     throw new EngramAccessInputError("collection must be a non-empty string");
   }
   let searchNamespaces: string[] = [];
+  const privateVisibilityCache = new Map<string, boolean>();
   const results = await runScopedMemorySearch({
     query, collection, mode,
     namespacesEnabled: deps.namespacesEnabled,
     isExcluded: deps.isExcluded,
+    filterPrivate: (results) => deps.filterPrivate(
+      results,
+      searchNamespaces,
+      !deps.namespacesEnabled &&
+        collection !== undefined &&
+        collection !== "global" &&
+        !deps.memoryCollections.includes(collection),
+      privateVisibilityCache,
+    ),
     budget: maxResults ?? deps.defaultBudget,
     sendInitialLimit: maxResults !== undefined,
     authorizeScope: async () => {

package/src/access-offline-manifest.ts

@@ -10,6 +10,7 @@ import {
   type ReconcileManifestFile,
   type ReconcileMemoryParser,
 } from "./reconcile/manifest.js";
+import { isSupportPassportPrivateMemory } from "./support-passport/card-projection.js";
 
 export interface OfflineSyncManifestRequest {
   includeTranscripts?: boolean;
@@ -36,6 +37,10 @@ export async function createOfflineSyncManifestStream(
     readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
     signal: options.signal,
     userExcludeRegexps,
+    excludeFile: async ({ filePath }) => {
+      const memory = await storage.readMemoryByPath(filePath);
+      return memory ? isSupportPassportPrivateMemory(memory) : false;
+    },
   });
   return {
     namespace,

package/src/access-service-namespace.test.ts

@@ -71,6 +71,9 @@ function makeService(): {
         maxResults?: number;
         mode?: string;
       }): Promise<unknown[]>;
+      filterPrivateSearchResults(
+        results: Array<{ path: string; score: number; snippet?: string }>,
+      ): Promise<Array<{ path: string; score: number; snippet?: string }>>;
     };
   }).orchestrator = {
     config: makeConfig(),
@@ -92,6 +95,9 @@ function makeService(): {
     async searchAcrossNamespaces() {
       return [];
     },
+    async filterPrivateSearchResults(results) {
+      return results;
+    },
   };
 
   return { service, storage, getStorageCalls };
@@ -1343,6 +1349,9 @@ test("offlineSyncSnapshot does not trust client base capture time for server fas
       async readDeletionRevisions() {
         return new Map<string, number>();
       },
+      async readMemoryByPath() {
+        return null;
+      },
       async readOfflineSyncFile(targetPath: string) {
         return readFile(targetPath);
       },
@@ -1410,6 +1419,9 @@ test("offlineSyncSnapshot drains pending recall-impression spills so a recorded
       async readDeletionRevisions() {
         return new Map<string, number>();
       },
+      async readMemoryByPath() {
+        return null;
+      },
       async readOfflineSyncFile(targetPath: string) {
         return readFile(targetPath);
       },
@@ -1688,6 +1700,7 @@ function makeServiceWithConfig(config: PluginConfig): {
       mode?: string;
       execution?: unknown;
     }): Promise<unknown[]>;
+    filterPrivateSearchResults(results: unknown[]): Promise<unknown[]>;
   };
   const orchestrator: OrchLike = {
     config,
@@ -1701,6 +1714,7 @@ function makeServiceWithConfig(config: PluginConfig): {
       captured.execution = params.execution;
       return [];
     },
+    async filterPrivateSearchResults(results) { return results; },
   };
   (service as unknown as { orchestrator: OrchLike }).orchestrator = orchestrator;
   return { service, captured };

package/src/access-service-observe-scope.test.ts

@@ -1140,6 +1140,7 @@ test("#1501 implicit memorySearch honors active scope profile readOrder", async
     config,
     qmd: { isAvailable: () => true },
     getStorage: async () => ({ dir: config.memoryDir } as StorageManager),
+    filterPrivateSearchResults: async (results: unknown[]) => results,
     searchAcrossNamespaces: async (options: { namespaces: string[] }) => {
       searchedNamespaces = options.namespaces;
       return [];
@@ -1193,6 +1194,7 @@ test("#1501 memorySearch collection names stay constrained to active scope profi
     config,
     qmd: { isAvailable: () => true },
     getStorage: async () => ({ dir: config.memoryDir } as StorageManager),
+    filterPrivateSearchResults: async (results: unknown[]) => results,
     searchAcrossNamespaces: async (options: { namespaces: string[] }) => {
       searchedNamespaces = options.namespaces;
       return [];

package/src/access-service-offline-file-content.test.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -85,6 +86,24 @@ function memoryFile(options: {
   ].join("\n");
 }
 
+function supportPassportFile(options: { id: string; includeTag?: boolean }): string {
+  return [
+    "---",
+    `id: ${options.id}`,
+    "category: preference",
+    ...(options.includeTag === false ? [] : ["tags: [support-passport-card]"]),
+    `structuredAttributes: ${JSON.stringify({ "support-passport-owner": "a".repeat(64) })}`,
+    "created: 2026-08-13T00:00:00.000Z",
+    "updated: 2026-08-13T00:00:00.000Z",
+    "---",
+    "Private support statement",
+  ].join("\n");
+}
+
+function sha256(content: Buffer): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
 function createManifestService(options: {
   root: string;
   storage: StorageManager;
@@ -304,6 +323,198 @@ test("offline file-transfer endpoints reject internal Remnic state paths", async
   }
 });
 
+test("offline read surfaces exclude support-passport private records", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-private-sync-"));
+  try {
+    const storage = new StorageManager(root);
+    await storage.ensureDirectories();
+    const privatePath = path.join(root, "preferences", "2026-08-13", "passport.md");
+    const publicPath = path.join(root, "facts", "2026-08-13", "public.md");
+    const localStatePath = path.join(root, "state", "lcm.sqlite");
+    await mkdir(path.dirname(privatePath), { recursive: true });
+    await mkdir(path.dirname(publicPath), { recursive: true });
+    await mkdir(path.dirname(localStatePath), { recursive: true });
+    await writeFile(privatePath, supportPassportFile({ id: "passport" }));
+    await writeFile(publicPath, memoryFile({ id: "public", body: "Public fact", status: "active" }));
+    await writeFile(localStatePath, "node-local state");
+    const { service } = createManifestService({ root, storage });
+
+    const snapshot = await service.offlineSyncSnapshot({ includeContent: true });
+    assert.equal(snapshot.files.some((file) => file.path === "facts/2026-08-13/public.md"), true);
+    assert.equal(snapshot.files.some((file) => file.path.includes("passport.md")), false);
+    const stream = await service.offlineSyncSnapshotStream({ includeContent: true });
+    const streamed = [];
+    for await (const file of stream.files) streamed.push(file.path);
+    assert.equal(streamed.includes("facts/2026-08-13/public.md"), true);
+    assert.equal(streamed.some((file) => file.includes("passport.md")), false);
+    const manifest = await service.offlineSyncManifestStream();
+    const manifested = [];
+    for await (const file of manifest.files) manifested.push(file.path);
+    assert.equal(manifested.includes("facts/2026-08-13/public.md"), true);
+    assert.equal(manifested.some((file) => file.includes("passport.md")), false);
+    await assert.rejects(
+      () => service.offlineSyncFiles({ paths: ["preferences/2026-08-13/passport.md"] }),
+      (error) => error instanceof EngramAccessInputError && /path is excluded/.test(error.message),
+    );
+    await assert.rejects(
+      () => service.offlineSyncFileContent({
+        path: "preferences/2026-08-13/passport.md",
+        offset: 0,
+        length: 10,
+      }),
+      (error) => error instanceof EngramAccessInputError && /path is excluded/.test(error.message),
+    );
+    const applyResult = await service.offlineSyncApply({
+      changeset: {
+        format: OFFLINE_SYNC_CHANGESET_FORMAT,
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        sourceId: "peer",
+        includeTranscripts: true,
+        changes: [],
+      },
+    });
+    assert.equal(applyResult.currentFiles.some((file) => file.path === "facts/2026-08-13/public.md"), true);
+    assert.equal(applyResult.currentFiles.some((file) => file.path === "state/lcm.sqlite"), true);
+    assert.equal(applyResult.currentFiles.some((file) => file.path.includes("passport.md")), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline apply routes reject existing support-passport private records", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-private-apply-target-"));
+  try {
+    const storage = new StorageManager(root);
+    await storage.ensureDirectories();
+    const relativePath = "preferences/2026-08-13/passport.md";
+    const targetPath = path.join(root, relativePath);
+    const original = Buffer.from(supportPassportFile({ id: "passport", includeTag: false }));
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, original);
+    const { service } = createManifestService({ root, storage });
+    const replacement = Buffer.from(memoryFile({ id: "public", body: "Replacement", status: "active" }));
+
+    await assert.rejects(
+      () => service.offlineSyncApplyFileContent({
+        sourceId: "peer",
+        path: relativePath,
+        sha256: sha256(replacement),
+        bytes: replacement.length,
+        mtimeMs: 0,
+        offset: 0,
+        baseSha256: sha256(original),
+        content: replacement,
+      }),
+      (error) => error instanceof EngramAccessInputError && /private support-passport record/.test(error.message),
+    );
+    await assert.rejects(
+      () => service.offlineSyncApply({
+        returnCurrentFiles: false,
+        changeset: {
+          format: OFFLINE_SYNC_CHANGESET_FORMAT,
+          schemaVersion: 1,
+          createdAt: new Date().toISOString(),
+          sourceId: "peer",
+          includeTranscripts: true,
+          changes: [{
+            type: "delete",
+            path: relativePath,
+            baseSha256: sha256(original),
+          }],
+        },
+      }),
+      (error) => error instanceof EngramAccessInputError && /private support-passport record/.test(error.message),
+    );
+    assert.deepEqual(await readFile(targetPath), original);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline apply routes reject forged support-passport metadata and allow public records", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-private-apply-content-"));
+  try {
+    const storage = new StorageManager(root);
+    await storage.ensureDirectories();
+    const { service } = createManifestService({ root, storage });
+    const forgedPath = "preferences/2026-08-13/forged.md";
+    const forged = Buffer.from(supportPassportFile({ id: "forged", includeTag: false }));
+    const splitAt = forged.indexOf("support-passport-owner") + 8;
+
+    const first = await service.offlineSyncApplyFileContent({
+      sourceId: "peer",
+      path: forgedPath,
+      sha256: sha256(forged),
+      bytes: forged.length,
+      mtimeMs: 0,
+      offset: 0,
+      content: forged.subarray(0, splitAt),
+    });
+    assert.equal(first.applied, false);
+    assert.equal(first.done, false);
+    await assert.rejects(
+      () => service.offlineSyncApplyFileContent({
+        sourceId: "peer",
+        path: forgedPath,
+        sha256: sha256(forged),
+        bytes: forged.length,
+        mtimeMs: 0,
+        offset: splitAt,
+        content: forged.subarray(splitAt),
+      }),
+      (error) => error instanceof EngramAccessInputError && /private support-passport record/.test(error.message),
+    );
+    await assert.rejects(() => readFile(path.join(root, forgedPath)));
+
+    const changesetPath = "preferences/2026-08-13/forged-changeset.md";
+    await assert.rejects(
+      () => service.offlineSyncApply({
+        returnCurrentFiles: false,
+        changeset: {
+          format: OFFLINE_SYNC_CHANGESET_FORMAT,
+          schemaVersion: 1,
+          createdAt: new Date().toISOString(),
+          sourceId: "peer",
+          includeTranscripts: true,
+          changes: [{
+            type: "upsert",
+            path: changesetPath,
+            file: {
+              path: changesetPath,
+              sha256: sha256(forged),
+              bytes: forged.length,
+              mtimeMs: 0,
+              contentBase64: forged.toString("base64"),
+            },
+          }],
+        },
+      }),
+      (error) => error instanceof EngramAccessInputError && /private support-passport record/.test(error.message),
+    );
+
+    const publicPath = "facts/2026-08-13/public-sync.md";
+    const publicContent = Buffer.from(memoryFile({
+      id: "public-sync",
+      body: "The body can mention support-passport-owner without becoming private.",
+      status: "active",
+    }));
+    const publicResult = await service.offlineSyncApplyFileContent({
+      sourceId: "peer",
+      path: publicPath,
+      sha256: sha256(publicContent),
+      bytes: publicContent.length,
+      mtimeMs: 0,
+      offset: 0,
+      content: publicContent,
+    });
+    assert.equal(publicResult.applied, true);
+    assert.deepEqual(await storage.readOfflineSyncFile(path.join(root, publicPath)), publicContent);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline apply-file-content reports invalid metadata as input errors", async () => {
   const service = createOfflineService();
   await assert.rejects(