@remnic/core 9.54.3 → 9.54.5

package/src/contradiction/contradiction.test.ts

@@ -970,6 +970,48 @@ test("runContradictionScan loads memories from namespace-scoped storage", async
   }
 });
 
+test("runContradictionScan excludes support passport private records", async () => {
+  const { dir, cleanup } = await makeTempDir();
+  try {
+    const visibleA = makeMemory("visible-a", "preference");
+    visibleA.frontmatter.entityRef = "entity:shared";
+    const visibleB = makeMemory("visible-b", "preference");
+    visibleB.frontmatter.entityRef = "entity:shared";
+    const passport = makeMemory("passport-card", "preference");
+    passport.frontmatter.entityRef = "entity:shared";
+    passport.frontmatter.tags = ["support-passport-card"];
+    passport.content = "Private support passport statement.";
+
+    const storage = makeScanStorage([visibleA, passport, visibleB]);
+    const config = parseConfig({
+      memoryDir: dir,
+      contradictionScan: {
+        enabled: true,
+        maxPairsPerRun: 10,
+        topicOverlapFloor: 0,
+        similarityFloor: 0,
+      },
+    });
+
+    const result = await runContradictionScan({
+      storage,
+      config,
+      memoryDir: dir,
+      localLlm: null,
+      fallbackLlm: null,
+    });
+
+    assert.equal(result.scanned, 2);
+    assert.equal(result.candidates, 1);
+    assert.deepEqual(listPairs(dir, { filter: "all" }).pairs[0]?.memoryIds, [
+      "visible-a",
+      "visible-b",
+    ]);
+  } finally {
+    await cleanup();
+  }
+});
+
 test("runContradictionScan caps candidates during generation and preserves strategy priority", async () => {
   const { dir, cleanup } = await makeTempDir();
   try {

package/src/correction/correction-access-wiring.ts

@@ -48,6 +48,7 @@ import {
 import { type ExecutorDeps, type ExecutorMemory } from "./correction-executor.js";
 import { CorrectionService, type CorrectionServiceDeps } from "./correction-service.js";
 import { resolveRecallAuxiliaryCapabilities } from "../capabilities.js";
+import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
 
 // ---------------------------------------------------------------------------
 // Public entry: build a fully-wired CorrectionService
@@ -223,7 +224,7 @@ async function resolveTargetMemories(
     for (const ns of namespaces) {
       const storage = await wiring.orchestrator.getStorage(ns);
       const m = await storage.getMemoryById(id);
-      if (m) {
+      if (m && isEligibleCorrectionCandidate(m)) {
         found = toCandidate(m, ns, 1);
         break;
       }
@@ -261,7 +262,11 @@ async function expandEntityNeighbors(
     const storage = await wiring.orchestrator.getStorage(ns);
     const all = await storage.readAllMemories();
     for (const m of all) {
-      if (seedIds.includes(m.frontmatter.id) && m.frontmatter.entityRef) {
+      if (
+        seedIds.includes(m.frontmatter.id) &&
+        m.frontmatter.entityRef &&
+        isEligibleCorrectionCandidate(m)
+      ) {
         seedRefs.add(m.frontmatter.entityRef);
       }
     }
@@ -859,6 +864,7 @@ function toCandidate(m: MemoryFile, namespace: string, score: number): PlannerCa
  * stays consistent with the rescope/retire apply-time guards.
  */
 function isEligibleCorrectionCandidate(m: MemoryFile): boolean {
+  if (isSupportPassportPrivateMemory(m)) return false;
   if (m.frontmatter.status && m.frontmatter.status !== "active") return false;
   if (typeof m.frontmatter.archivedAt === "string" && m.frontmatter.archivedAt.length > 0) return false;
   return true;

package/src/correction/correction-storage-integration.test.ts

@@ -86,6 +86,13 @@ test("#1672 item 2: isEligibleCorrectionCandidate rejects archived memory with n
   assert.equal(isEligibleCorrectionCandidate(m), false);
 });
 
+test("support passport records are not correction candidates", () => {
+  for (const tag of ["support-passport-card", "support-passport-audit"]) {
+    const memory = fakeMemoryFile({ id: tag, status: "active", tags: [tag] });
+    assert.equal(isEligibleCorrectionCandidate(memory), false);
+  }
+});
+
 // ---------------------------------------------------------------------------
 // item 3: contentHash recomputed on edit
 // ---------------------------------------------------------------------------

package/src/explicit-capture.test.ts

@@ -52,6 +52,7 @@ type StoredMemory = {
     category: string;
     status?: string;
     tags?: string[];
+    structuredAttributes?: Record<string, string>;
     sourceConnector?: string;
     blockedBy?: string;
   };
@@ -1147,3 +1148,26 @@ test("explicit capture scans active rows when the blocked index is unavailable",
   assert.equal(result.duplicateOf, "active-existing");
   assert.equal(probe.envelopes.length, 0);
 });
+
+test("explicit capture never deduplicates against private support-passport records", async () => {
+  const probe = createInlineCaptureProcessorProbe();
+  const candidate = validateExplicitCaptureInput({
+    content: "The same words can exist in an owner-controlled passport card.",
+    category: "preference",
+  });
+  probe.memories.push({
+    frontmatter: {
+      id: "private-passport-card",
+      category: "preference",
+      status: "active",
+      structuredAttributes: { "support-passport-owner": "private-owner" },
+    },
+    content: candidate.content,
+  });
+
+  const result = await persistExplicitCapture(probe.orchestrator, candidate, "memory_store");
+
+  assert.equal(result.duplicateOf, undefined);
+  assert.equal(probe.envelopes.length, 1);
+  assert.notEqual(result.id, "private-passport-card");
+});

package/src/explicit-capture.ts

@@ -12,6 +12,7 @@ import {
   normalizeExplicitCaptureContent,
 } from "./storage/tombstone-blocked-capture-index.js";
 import type { StorageManager } from "./storage.js";
+import { isSupportPassportPrivateMemory } from "./support-passport/card-projection.js";
 
 export type ExplicitCaptureInput = {
   content: string;
@@ -480,6 +481,7 @@ async function findDuplicateExplicitCapture(
   const existing = [...hotMemories, ...coldMemories];
   const normalizedCandidate = normalizeExplicitCaptureContent(candidate.content);
   const match = existing.find((memory) => {
+    if (isSupportPassportPrivateMemory(memory)) return false;
     const status = memory.frontmatter.status ?? "active";
     if (status !== "active" && (status !== "pending_review" || !memory.frontmatter.blockedBy)) {
       return false;

package/src/index.ts

@@ -48,6 +48,7 @@ export {
   defaultWorkspaceDir,
 } from "./orchestrator.js";
 export * from "./memory-projection-format.js";
+export { searchWithGenericExclusion } from "./access-memory-search-fanout.js";
 export * from "./model-registry.js";
 export * from "./contradiction/index.js";
 
@@ -404,6 +405,7 @@ export {
   type RemnicAdminModelOption,
 } from "./access-http.js";
 export { EngramMcpServer } from "./access-mcp.js";
+export * from "./support-passport/index.js";
 
 // Remnic Relay — host-agnostic mission evidence and receipt contract.
 export {
@@ -873,6 +875,7 @@ export {
   type OfflineSyncDeletionRevision,
   type OfflineSyncFileDeleteTarget,
   type OfflineSyncFileDigest,
+  type OfflineSyncExcludeFile,
   type OfflineSyncFileRecord,
   type OfflineSyncFileContentChunk,
   type OfflineSyncRecordDeletionRevision,

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

@@ -34,6 +34,7 @@ import {
   applyUtilityPromotionRuntimePolicy,
   loadUtilityRuntimeValues,
 } from "../utility-runtime.js";
+import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
 
 export const FIRST_START_DEMOTION_CAP = 50;
 export const LIFECYCLE_INIT_DONE_MARKER = ".lifecycle-init-done";
@@ -243,7 +244,7 @@ export async function runFirstStartMigration(
     return abortedResult();
   }
 
-  const hotMemories = await storage.readAllMemories();
+  const hotMemories = excludeSupportPassportPrivateMemories(await storage.readAllMemories());
   if (signal?.aborted) {
     return abortedResult();
   }

package/src/maintenance/memory-governance.test.ts

@@ -51,3 +51,28 @@ test("governance restore manifest pre-marks actions applied before mutation", as
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("governance excludes support-passport private records", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-governance-passport-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    const { id } = await storage.writeMemory("preference", "Give me advance notice.", {
+      source: "support-passport",
+      tags: ["support-passport-card"],
+      confidence: 0.9,
+    });
+    await storage.updateMemoryFrontmatter(id, { verificationState: "disputed" });
+
+    const result = await runMemoryGovernance({
+      memoryDir,
+      mode: "apply",
+      now: new Date("2026-08-13T12:00:00.000Z"),
+    });
+
+    assert.equal(result.summary.scannedMemories, 0);
+    assert.deepEqual(result.proposedActions, []);
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.status, "active");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/maintenance/memory-governance.ts

@@ -7,6 +7,7 @@ import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import { bumpMemoryCorpusVersionForDir } from "../memory-corpus-version.js";
 import { assertPathInsideRoot } from "../utils/path-containment.js";
 import { requestEntityCanonicalIdReconcile } from "../storage/entity-canonical-id-references.js";
+import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
 
 export type MemoryGovernanceMode = "shadow" | "apply";
 export type MemoryGovernanceReasonCode =
@@ -830,7 +831,9 @@ export async function runMemoryGovernance(
         updatedAfter,
       })
     : undefined;
-  const memories = memoryWindow?.memories ?? await storage.readAllMemories();
+  const memories = excludeSupportPassportPrivateMemories(
+    memoryWindow?.memories ?? await storage.readAllMemories(),
+  );
   const reviewQueue = await buildReviewQueue(options.memoryDir, storage, memories, now, {
     malformedCandidateFiles: memoryWindow?.filePaths,
   });

package/src/maintenance/pattern-reinforcement.test.ts

@@ -328,6 +328,26 @@ test("runPatternReinforcement: skips out-of-scope categories", async () => {
   assert.equal(writes.length, 0);
 });
 
+test("runPatternReinforcement: excludes support-passport private records", async () => {
+  const content = "Give me advance notice before plans change.";
+  const passport = makeMemory({
+    id: "passport-card",
+    content,
+    tags: ["support-passport-card"],
+  });
+  const publicPreference = makeMemory({ id: "public-preference", content });
+  const { stub, writes } = makeStorageStub([passport, publicPreference]);
+
+  const result = await runPatternReinforcement(stub, {
+    categories: ["preference"],
+    minCount: 2,
+    now: frozenNow,
+  });
+
+  assert.equal(result.clustersFound, 0);
+  assert.deepEqual(writes, []);
+});
+
 test("runPatternReinforcement: counts both active and already-superseded members; only writes to active duplicates", async () => {
   const dupContent = "mixed status cluster";
   const memories = [

package/src/maintenance/pattern-reinforcement.ts

@@ -35,6 +35,7 @@
 import { clusterByKey } from "../procedural/reinforcement-core.js";
 import { buildRetiredFactTombstoneInputs, type TombstoneReason, type TombstoneCreatedBy } from "../lifecycle/tombstones.js";
 import { supersessionKeysForFact } from "../temporal-supersession.js";
+import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
 import type {
   MemoryFile,
   MemoryFrontmatter,
@@ -225,7 +226,7 @@ export async function runPatternReinforcement(
     return emptyResult();
   }
 
-  const memories = await storage.readAllMemories();
+  const memories = excludeSupportPassportPrivateMemories(await storage.readAllMemories());
 
   // Cluster across BOTH active and already-superseded memories so a
   // canonical that has previously absorbed duplicates still gets

package/src/maintenance/rebuild-memory-projection.ts

@@ -44,6 +44,7 @@ import {
 } from "../memory-projection-format.js";
 import { openBetterSqlite3 } from "../runtime/better-sqlite.js";
 import { commitPreparedFileAtomically } from "./atomic-file.js";
+import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
 
 export interface RebuildMemoryProjectionOptions {
   memoryDir: string;
@@ -204,6 +205,7 @@ function toCurrentStateRow(memoryDir: string, memory: MemoryFile): MemoryProject
     lastAccessed: memory.frontmatter.lastAccessed,
     tags: normalizeProjectionTags(memory.frontmatter.tags),
     preview: normalizeProjectionPreview(memory.content),
+    privateRecord: isSupportPassportPrivateMemory(memory),
   };
 }
 
@@ -406,6 +408,7 @@ function serializeCurrentStateRow(row: MemoryProjectionCurrentState): string {
     lastAccessed: row.lastAccessed ?? null,
     tags: row.tags ?? [],
     preview: row.preview ?? "",
+    privateRecord: row.privateRecord === true,
   });
 }
 
@@ -691,8 +694,7 @@ function readProjectedCurrentRows(
           memory_kind,
           access_count,
           last_accessed,
-          ${selectExpressions.tagsJson},
-          ${selectExpressions.previewText}
+          ${selectExpressions.tagsJson}, ${selectExpressions.previewText}, ${selectExpressions.privateRecord}
         FROM memory_current
       `).all() as Array<Record<string, unknown>>;
 
@@ -788,9 +790,8 @@ function writeProjectionDb(
         memory_kind,
         access_count,
         last_accessed,
-        tags_json,
-        preview_text
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        tags_json, preview_text, private_record
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     const insertTimeline = db.prepare(`
@@ -899,9 +900,8 @@ function writeProjectionDb(
           row.confidenceTier,
           row.memoryKind ?? null,
           row.accessCount ?? null,
-          row.lastAccessed ?? null,
-          JSON.stringify(row.tags ?? []),
-          row.preview ?? "",
+          row.lastAccessed ?? null, JSON.stringify(row.tags ?? []), row.preview ?? "",
+          row.privateRecord === true ? 1 : 0,
         );
       }
 

package/src/memory-projection-store.ts

@@ -20,12 +20,11 @@ import {
   type BetterSqlite3Database,
 } from "./runtime/better-sqlite.js";
 
-export const MEMORY_PROJECTION_SCHEMA_VERSION = 3;
+export const MEMORY_PROJECTION_SCHEMA_VERSION = 4;
 
 export interface ProjectedMemoryBrowseOptions {
-  query?: string;
-  status?: string;
-  category?: string;
+  query?: string; status?: string; category?: string;
+  excludeTags?: readonly string[]; excludePrivateRecords?: boolean;
   sort?: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
   limit: number;
   offset: number;
@@ -154,15 +153,15 @@ function migrateProjectionSchemaIfNeeded(memoryDir: string): void {
 }
 
 export function memoryCurrentSelectExpressions(db: BetterSqlite3Database): {
-  tagsJson: string;
-  previewText: string;
-  hasPathValid: boolean;
+  tagsJson: string; previewText: string; hasPathValid: boolean;
+  privateRecord: string; hasPrivateRecord: boolean;
 } {
   const columns = listTableColumns(db, "memory_current");
   return {
     tagsJson: columns.has("tags_json") ? "tags_json" : `'[]' AS tags_json`,
-    previewText: columns.has("preview_text") ? "preview_text" : `'' AS preview_text`,
-    hasPathValid: columns.has("path_valid"),
+    previewText: columns.has("preview_text") ? "preview_text" : `'' AS preview_text`, hasPathValid: columns.has("path_valid"),
+    privateRecord: columns.has("private_record") ? "private_record" : "0 AS private_record",
+    hasPrivateRecord: columns.has("private_record"),
   };
 }
 
@@ -192,7 +191,8 @@ export function initializeMemoryProjectionDb(db: BetterSqlite3Database): void {
       access_count INTEGER,
       last_accessed TEXT,
       tags_json TEXT NOT NULL DEFAULT '[]',
-      preview_text TEXT NOT NULL DEFAULT ''
+      preview_text TEXT NOT NULL DEFAULT '',
+      private_record INTEGER NOT NULL DEFAULT 0 CHECK (private_record IN (0, 1))
     );
 
     CREATE INDEX IF NOT EXISTS idx_memory_current_status
@@ -428,6 +428,7 @@ const REQUIRED_MEMORY_CURRENT_COLUMNS = [
   "created_at",
   "updated_at",
   "entity_ref",
+  "private_record",
 ] as const;
 
 function assertProjectionSchemaReadable(db: BetterSqlite3Database): void {
@@ -698,6 +699,7 @@ export function parseCurrentRow(
     lastAccessed: typeof row.last_accessed === "string" ? row.last_accessed : undefined,
     tags: parseStringArray(row.tags_json),
     preview: typeof row.preview_text === "string" ? row.preview_text : "",
+    privateRecord: row.private_record === 1,
   };
 }
 
@@ -760,7 +762,8 @@ export function readProjectedMemoryState(
             access_count,
             last_accessed,
             ${currentSelect.tagsJson},
-            ${currentSelect.previewText}
+            ${currentSelect.previewText},
+            ${currentSelect.privateRecord}
           FROM memory_current
           WHERE memory_id = ?
         `,
@@ -820,38 +823,33 @@ export function readProjectedMemoryBrowse(
 ): ProjectedMemoryBrowsePage | null {
   return withProjectionReadonly(memoryDir, (db) => {
     const normalizedQuery = options.query?.trim().toLowerCase() ?? "";
-
     const currentSelect = memoryCurrentSelectExpressions(db);
+    if ((options.excludeTags?.length ?? 0) > 0 && currentSelect.tagsJson.startsWith("'[]'"))
+      throw new Error("tag exclusions require tags_json");
+    if (options.excludePrivateRecords && !currentSelect.hasPrivateRecord)
+      throw new Error("private-record exclusions require private_record");
     const whereClauses: string[] = [];
     const params: unknown[] = [];
-
-    if (options.status) {
-      whereClauses.push("status = ?");
-      params.push(options.status);
+    if (options.status) { whereClauses.push("status = ?"); params.push(options.status); }
+    if (options.category) { whereClauses.push("category = ?"); params.push(options.category); }
+    for (const tag of options.excludeTags ?? []) {
+      whereClauses.push("NOT EXISTS (SELECT 1 FROM json_each(memory_current.tags_json) WHERE value = ?)");
+      params.push(tag);
     }
-    if (options.category) {
-      whereClauses.push("category = ?");
-      params.push(options.category);
-    }
-    const sort = options.sort ?? "updated_desc";
+    if (options.excludePrivateRecords) whereClauses.push("private_record = 0");
     const orderBySql = (() => {
-      switch (sort) {
+      switch (options.sort ?? "updated_desc") {
         case "updated_asc":
           return "updated_at ASC, created_at ASC, memory_id ASC";
         case "created_desc":
           return "created_at DESC, updated_at DESC, memory_id ASC";
         case "created_asc":
           return "created_at ASC, updated_at ASC, memory_id ASC";
-        case "updated_desc":
         default:
           return "updated_at DESC, created_at DESC, memory_id ASC";
       }
     })();
-    const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-
     if (normalizedQuery) {
-      // Full-content search still examines every eligible row so totals and
-      // matches stay exact, but iteration keeps memory use proportional to the page.
       const queryWhereClauses = currentSelect.hasPathValid
         ? [...whereClauses, ...projectedBrowsePathSqlClauses(), "path_valid = 1"]
         : whereClauses;

package/src/offline-sync-file-io.ts

@@ -0,0 +1,68 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { open } from "node:fs/promises";
+import { MAGIC_HEADER_SIZE, isEncryptedFile } from "./secure-store/secure-fs.js";
+
+export interface OfflineSyncFileTarget {
+  root: string;
+  path: string;
+  filePath: string;
+}
+
+export type OfflineSyncExcludeFile = (target: OfflineSyncFileTarget) => boolean | Promise<boolean>;
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) throw new Error("offline sync request aborted");
+}
+
+export async function shouldExcludeOfflineSyncFile(
+  excludeFile: OfflineSyncExcludeFile | undefined,
+  target: OfflineSyncFileTarget
+): Promise<boolean> {
+  return excludeFile ? await excludeFile(target) : false;
+}
+
+export async function sha256OfflineSyncFile(
+  filePath: string,
+  signal?: AbortSignal
+): Promise<{ sha256: string; bytes: number }> {
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    throwIfAborted(signal);
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    hash.update(buffer);
+    bytes += buffer.length;
+  }
+  throwIfAborted(signal);
+  return { sha256: hash.digest("hex"), bytes };
+}
+
+export async function isEncryptedOfflineSyncFile(filePath: string): Promise<boolean> {
+  const handle = await open(filePath, "r");
+  try {
+    const header = Buffer.alloc(MAGIC_HEADER_SIZE);
+    const { bytesRead } = await handle.read(header, 0, header.length, 0);
+    return bytesRead >= MAGIC_HEADER_SIZE && isEncryptedFile(header);
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function readPlainOfflineSyncFileChunk(options: {
+  filePath: string;
+  offset: number;
+  length: number;
+  bytes: number;
+}): Promise<Buffer> {
+  const chunkBytes = Math.min(options.length, options.bytes - options.offset);
+  const chunk = Buffer.alloc(chunkBytes);
+  if (chunkBytes === 0) return chunk;
+  const handle = await open(options.filePath, "r");
+  try {
+    const { bytesRead } = await handle.read(chunk, 0, chunk.length, options.offset);
+    return bytesRead === chunk.length ? chunk : chunk.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}