@remnic/core 9.54.4 → 9.54.6

package/src/orchestration/qmd-result-resolver.ts

@@ -27,13 +27,37 @@
  */
 
 import path from "node:path";
+import { resolveNamespaceCapabilities } from "../capabilities.js";
+import type { StorageManager } from "../index.js";
 import { log } from "../logger.js";
-import { isPathInsideStorageRoot } from "../storage-paths.js";
 import { namespaceIdentityFromToken } from "../namespaces/identity.js";
-import { resolveNamespaceCapabilities } from "../capabilities.js";
+import { normalizeQmdResultPath } from "../namespaces/search.js";
 import { SecureStoreLockedError } from "../secure-store/index.js";
-import type { PluginConfig, QmdSearchResult, MemoryFile } from "../types.js";
-import type { StorageManager } from "../index.js";
+import { isPathInsideStorageRoot } from "../storage-paths.js";
+import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "../types.js";
+import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
+
+const INTERNAL_QMD_ROOTS = new Set([
+  ...ALL_CATEGORY_DIRS,
+  "activity",
+  "archive",
+  "artifacts",
+  "cold",
+  "config",
+  "entities",
+  "identity",
+  "meetings",
+  "namespaces",
+  "state",
+  "summaries",
+  "transcripts",
+  "wearables",
+  "work",
+  "workspace",
+]);
+
+const PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 
 /**
  * Split a relative QMD result path into its collection prefix and the
@@ -45,6 +69,18 @@ export function qmdCollectionPathParts(resultPath: string): {
   relativePath: string;
 } | null {
   if (!resultPath || path.isAbsolute(resultPath)) return null;
+  if (resultPath.trim().startsWith("qmd://")) {
+    try {
+      const parsed = new URL(resultPath.trim());
+      if (parsed.protocol !== "qmd:" || !parsed.hostname) return null;
+      const collection = parsed.hostname;
+      const relativePath = normalizeQmdResultPath(resultPath, collection).replace(/\\/g, "/").replace(/^\/+/, "");
+      if (!relativePath) return null;
+      return { collection, relativePath };
+    } catch {
+      return null;
+    }
+  }
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -61,10 +97,7 @@ export function qmdCollectionPathParts(resultPath: string): {
  * constrained to the storage root so a result path can never escape the
  * namespace directory.
  */
-export function qmdResultPathCandidates(
-  storageDir: string,
-  resultPath: string,
-): string[] {
+export function qmdResultPathCandidates(storageDir: string, resultPath: string): string[] {
   const candidates = new Set<string>();
   const storageRoot = path.resolve(storageDir);
   const addCandidate = (candidate: string) => {
@@ -122,25 +155,20 @@ export class QmdResultResolver {
   private readonly getConfig: () => PluginConfig;
   private readonly storageFor: (namespace: string) => Promise<StorageManager>;
   private readonly storageDirNamespace: (storageDir: string) => string;
-  private readonly qmdCollectionNamespaceFromPrefix: (
-    collectionPrefix: string,
-  ) => string | null;
+  private readonly qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
   private readonly namespaceFromPath: (p: string) => string;
 
   constructor(options: {
     getConfig: () => PluginConfig;
     storageFor: (namespace: string) => Promise<StorageManager>;
     storageDirNamespace: (storageDir: string) => string;
-    qmdCollectionNamespaceFromPrefix: (
-      collectionPrefix: string,
-    ) => string | null;
+    qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
     namespaceFromPath: (p: string) => string;
   }) {
     this.getConfig = options.getConfig;
     this.storageFor = options.storageFor;
     this.storageDirNamespace = options.storageDirNamespace;
-    this.qmdCollectionNamespaceFromPrefix =
-      options.qmdCollectionNamespaceFromPrefix;
+    this.qmdCollectionNamespaceFromPrefix = options.qmdCollectionNamespaceFromPrefix;
     this.namespaceFromPath = options.namespaceFromPath;
   }
 
@@ -148,29 +176,29 @@ export class QmdResultResolver {
     resultPath: string,
     fallbackStorage: StorageManager,
     recallNamespaces: readonly string[] = [],
-    preferredNamespace?: string,
+    preferredNamespace?: string
   ): Promise<MemoryFile | null> {
     const parts = qmdCollectionPathParts(resultPath);
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const config = this.getConfig();
     const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    const fallbackResultPath =
+      resultPath.trim().startsWith("qmd://") && parts?.collection === config.qmdCollection
+        ? parts.relativePath
+        : resultPath;
     if (parts && parts.collection === coldCollection) {
       const storages: StorageManager[] = [];
       const seenStorageDirs = new Set<string>();
       const addStorage = (storage: StorageManager): void => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir
-          ? path.resolve(storageDir)
-          : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
       };
 
       const fallbackNamespace =
-        fallbackStorageDir !== null
-          ? this.storageDirNamespace(fallbackStorageDir)
-          : config.defaultNamespace;
+        fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
       if (
         recallNamespaces.length === 0 ||
         !resolveNamespaceCapabilities(config).namespaces ||
@@ -202,10 +230,7 @@ export class QmdResultResolver {
         }
         try {
           const coldRoot = path.join(storageDir, "cold");
-          for (const candidate of qmdResultPathCandidates(
-            coldRoot,
-            parts.relativePath,
-          )) {
+          for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
           }
@@ -220,17 +245,12 @@ export class QmdResultResolver {
       }
       return null;
     }
-    const collectionNamespace = parts
-      ? this.qmdCollectionNamespaceFromPrefix(parts.collection)
-      : null;
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
 
     if (parts && collectionNamespace) {
       try {
         const collectionStorage = await this.storageFor(collectionNamespace);
-        for (const candidate of qmdResultPathCandidates(
-          collectionStorage.dir,
-          parts.relativePath,
-        )) {
+        for (const candidate of qmdResultPathCandidates(collectionStorage.dir, parts.relativePath)) {
           const memory = await collectionStorage.readMemoryByPath(candidate);
           if (memory) return memory;
         }
@@ -249,10 +269,7 @@ export class QmdResultResolver {
     if (preferredNamespace) {
       try {
         const preferredStorage = await this.storageFor(preferredNamespace);
-        for (const candidate of qmdResultPathCandidates(
-          preferredStorage.dir,
-          resultPath,
-        )) {
+        for (const candidate of qmdResultPathCandidates(preferredStorage.dir, fallbackResultPath)) {
           const memory = await preferredStorage.readMemoryByPath(candidate);
           if (memory) return memory;
         }
@@ -269,22 +286,19 @@ export class QmdResultResolver {
       // is stale/deleted — do NOT fall through to the default store and validate
       // a same-relative-path memory from the wrong namespace (#2020). Absolute
       // paths still fall through: the absolute branch resolves the true owner.
-      if (!path.isAbsolute(resultPath)) return null;
+      if (!path.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path.isAbsolute(resultPath)) {
+    if (path.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
-        return await fallbackStorage.readMemoryByPath(resultPath);
+        return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        resultPath,
+        fallbackResultPath,
         fallbackStorage,
-        recallNamespaces,
+        recallNamespaces
       );
       if (!ownerStorage) return null;
-      for (const candidate of qmdResultPathCandidates(
-        ownerStorage.dir,
-        resultPath,
-      )) {
+      for (const candidate of qmdResultPathCandidates(ownerStorage.dir, fallbackResultPath)) {
         const memory = await ownerStorage.storage.readMemoryByPath(candidate);
         if (memory) return memory;
       }
@@ -292,46 +306,101 @@ export class QmdResultResolver {
     }
 
     if (!fallbackStorageDir) {
-      return await fallbackStorage.readMemoryByPath(resultPath);
+      return await fallbackStorage.readMemoryByPath(fallbackResultPath);
     }
-    for (const candidate of qmdResultPathCandidates(
-      fallbackStorageDir,
-      resultPath,
-    )) {
+    for (const candidate of qmdResultPathCandidates(fallbackStorageDir, fallbackResultPath)) {
       const memory = await fallbackStorage.readMemoryByPath(candidate);
       if (memory) return memory;
     }
     return null;
   }
 
+  async filterPrivateSearchResults(
+    results: QmdSearchResult[],
+    fallbackStorage: StorageManager,
+    namespaces: readonly string[] = [],
+    preserveUnresolved = false,
+    visibilityCache = new Map<string, boolean>()
+  ): Promise<QmdSearchResult[]> {
+    const namespaceKey = namespaces.join("\0");
+    const entries = results
+      .filter((result) => Boolean(result.path))
+      .map((result) => ({
+        result,
+        cacheKey: `${namespaceKey}\0${preserveUnresolved ? "1" : "0"}\0${result.namespace ?? ""}\0${result.path}`,
+      }));
+    const pending = new Map<string, QmdSearchResult>();
+    for (const { result, cacheKey } of entries) {
+      if (!visibilityCache.has(cacheKey)) pending.set(cacheKey, result);
+    }
+    const unresolved = [...pending];
+    for (let offset = 0; offset < unresolved.length; offset += PRIVATE_RESULT_RESOLUTION_CONCURRENCY) {
+      await Promise.all(
+        unresolved.slice(offset, offset + PRIVATE_RESULT_RESOLUTION_CONCURRENCY).map(async ([cacheKey, result]) => {
+          visibilityCache.set(
+            cacheKey,
+            await this.isVisibleSearchResult(result, fallbackStorage, namespaces, preserveUnresolved)
+          );
+        })
+      );
+    }
+    return entries.filter(({ cacheKey }) => visibilityCache.get(cacheKey) === true).map(({ result }) => result);
+  }
+
+  private async isVisibleSearchResult(
+    result: QmdSearchResult,
+    fallbackStorage: StorageManager,
+    namespaces: readonly string[],
+    preserveUnresolved: boolean
+  ): Promise<boolean> {
+    const parts = qmdCollectionPathParts(result.path);
+    const config = this.getConfig();
+    const collectionIsKnownInternal = parts !== null && INTERNAL_QMD_ROOTS.has(parts.collection);
+    const collectionIsConfigured =
+      parts !== null &&
+      (parts.collection === config.qmdCollection ||
+        parts.collection === (config.qmdColdCollection ?? "openclaw-engram-cold") ||
+        this.qmdCollectionNamespaceFromPrefix(parts.collection) !== null);
+    let memory = await this.readQmdResultMemory(result.path, fallbackStorage, namespaces, result.namespace);
+    if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
+      memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
+    }
+    const absoluteInsideMemoryRoot =
+      path.isAbsolute(result.path) &&
+      isPathInsideStorageRoot(path.resolve(config.memoryDir), path.resolve(result.path));
+    const hasExplicitQmdCollection = result.path.trim().startsWith("qmd://");
+    const unresolvedInternalPath =
+      !memory &&
+      (absoluteInsideMemoryRoot ||
+        (collectionIsKnownInternal && (!preserveUnresolved || hasExplicitQmdCollection)) ||
+        (hasExplicitQmdCollection && collectionIsConfigured));
+    const unresolvedExternalCollection =
+      !memory &&
+      ((parts !== null && !collectionIsKnownInternal && !collectionIsConfigured) ||
+        (path.isAbsolute(result.path) &&
+          !isPathInsideStorageRoot(path.resolve(config.memoryDir), path.resolve(result.path))));
+    return (
+      (memory !== null && !isSupportPassportPrivateMemory(memory)) ||
+      (!memory && !unresolvedInternalPath && (preserveUnresolved || unresolvedExternalCollection))
+    );
+  }
+
   async resolveColdQmdResultForRecall(
     result: QmdSearchResult,
     fallbackStorage: StorageManager,
-    recallNamespaces: readonly string[] = [],
+    recallNamespaces: readonly string[] = []
   ): Promise<{ namespace: string; result: QmdSearchResult } | null> {
-    const memory = await this.readQmdResultMemory(
-      result.path,
-      fallbackStorage,
-      recallNamespaces,
-      result.namespace,
-    );
+    const memory = await this.readQmdResultMemory(result.path, fallbackStorage, recallNamespaces, result.namespace);
     if (!memory) return null;
 
     let ownerNamespace: string | null = null;
     if (path.isAbsolute(memory.path)) {
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        memory.path,
-        fallbackStorage,
-        recallNamespaces,
-      );
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
     }
     ownerNamespace ??= this.namespaceFromPath(memory.path);
-    if (
-      recallNamespaces.length > 0 &&
-      !recallNamespaces.includes(ownerNamespace)
-    ) {
+    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
       return null;
     }
 
@@ -349,7 +418,7 @@ export class QmdResultResolver {
   async storageForAbsoluteQmdResultPath(
     resultPath: string,
     fallbackStorage: StorageManager,
-    recallNamespaces: readonly string[] = [],
+    recallNamespaces: readonly string[] = []
   ): Promise<{ storage: StorageManager; dir: string; namespace: string } | null> {
     const resolvedPath = path.resolve(resultPath);
     const config = this.getConfig();
@@ -365,10 +434,7 @@ export class QmdResultResolver {
       const candidateRoot = path.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
-      if (
-        candidateRoot === memoryRoot &&
-        isPathInsideStorageRoot(namespacesRoot, resolvedPath)
-      ) {
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
         return;
       }
       seenDirs.add(candidateRoot);
@@ -376,9 +442,7 @@ export class QmdResultResolver {
     };
 
     const fallbackNamespace =
-      fallbackStorageDir !== null
-        ? this.storageDirNamespace(fallbackStorageDir)
-        : config.defaultNamespace;
+      fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
     maybeAddStorage(fallbackStorage, fallbackNamespace);
 
     const candidateNamespaces = new Set<string>();
@@ -391,9 +455,7 @@ export class QmdResultResolver {
       const relativeToNamespaces = path.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
-        candidateNamespaces.add(
-          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment,
-        );
+        candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
       }
     }
     for (const policy of config.namespacePolicies ?? []) {
@@ -404,9 +466,7 @@ export class QmdResultResolver {
       if (!ns) continue;
       try {
         maybeAddStorage(await this.storageFor(ns), ns);
-      } catch {
-        continue;
-      }
+      } catch {}
     }
 
     matches.sort((a, b) => b.dir.length - a.dir.length);

package/src/orchestration/recall-search-pipeline.test.ts

@@ -108,6 +108,47 @@ test("recall safety derives sourceConnector exclusively from the hydrated memory
   }
 });
 
+test("recall safety keeps support passport records out of generic recall", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-passport-recall-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const card = {
+      path: "preferences/support-card.md",
+      content: "Give me time to answer.",
+      frontmatter: {
+        status: "active",
+        tags: ["support-passport-card"],
+        created: "2026-07-19T00:00:00.000Z",
+        updated: "2026-07-19T00:00:00.000Z",
+      },
+    } as unknown as MemoryFile;
+    const audit = {
+      path: "corrections/support-card-audit.md",
+      content: "Superseded: Give me time to answer.",
+      frontmatter: {
+        status: "active",
+        tags: ["support-passport-audit"],
+        created: "2026-07-19T00:00:00.000Z",
+        updated: "2026-07-19T00:00:00.000Z",
+      },
+    } as unknown as MemoryFile;
+    const candidates = [result("default", card.path), result("default", audit.path)];
+    const memoryByPath = new Map([
+      [`default\0${card.path}`, card],
+      [`default\0${audit.path}`, audit],
+    ]);
+
+    assert.deepEqual(coordinator.filterSearchResultsByRecallSafety(candidates, memoryByPath), []);
+    assert.deepEqual(
+      coordinator.filterSearchResultsByRecallSafety(candidates, memoryByPath, { allowDedicatedSurface: true }),
+      [],
+      "a generic-recall override must not disclose owner-controlled support records",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("recall safety partitions tool-scoped memories by requesting connector", async () => {
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-connector-partition-"));
   try {

package/src/orchestration/recall-search-pipeline.ts

@@ -70,6 +70,7 @@ import {
 } from "../orchestrator.js";
 import { isActivityDigestPath } from "./orchestrator-helpers.js";
 import { isGenericRecallExcludedPath, isTopLevelArchivePath } from "./generic-recall-paths.js";
+import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
 
 export interface RecallSearchPipelineDeps {
   applyMemoryWorthRerank(
@@ -1091,6 +1092,7 @@ export class RecallSearchPipelineCoordinator {
     let forgottenFilteredCount = 0;
     let blockedPathFilteredCount = 0;
     let connectorPartitionFilteredCount = 0;
+    let supportPassportFilteredCount = 0;
     const filtered: QmdSearchResult[] = [];
     for (const r of results) {
       if (options?.blockedPaths && resultHasKey(options.blockedPaths, r)) {
@@ -1127,6 +1129,11 @@ export class RecallSearchPipelineCoordinator {
           continue;
         }
 
+        if (isSupportPassportPrivateMemory(memory)) {
+          supportPassportFilteredCount += 1;
+          continue;
+        }
+
         if (
           options?.allowLifecycleFiltered !== true &&
           shouldFilterLifecycleRecallCandidate(memory.frontmatter, {
@@ -1223,6 +1230,11 @@ export class RecallSearchPipelineCoordinator {
         `connector partition filter removed ${connectorPartitionFilteredCount} tool-scoped candidates from recall`,
       );
     }
+    if (supportPassportFilteredCount > 0) {
+      log.debug(
+        `support passport filter removed ${supportPassportFilteredCount} owner-controlled records from generic recall`,
+      );
+    }
     if (lifecycleFilteredCount > 0) {
       log.debug(
         `lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`,

package/src/orchestration/semantic-consolidation-coordinator.ts

@@ -51,6 +51,7 @@ import type { PluginConfig, MemoryFile, AgentPersonaModelConfig } from "../types
 import { log } from "../logger.js";
 import { composeMemoryEnvelope } from "../write-envelope.js";
 import { resolveConversationContextCapabilities } from "../capabilities.js";
+import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
 
 /** Dependencies injected by the orchestrator. All stable references or
  *  live accessors. */
@@ -110,7 +111,7 @@ export class SemanticConsolidationCoordinator {
 
     log.info("[semantic-consolidation] starting run");
 
-    const allMemories = await targetStorage.readAllMemories();
+    const allMemories = excludeSupportPassportPrivateMemories(await targetStorage.readAllMemories());
     if (allMemories.length < 10) {
       log.debug("[semantic-consolidation] too few memories, skipping");
       return result;

package/src/orchestration/tier-migration-coordinator.ts

@@ -19,28 +19,22 @@
 
 import path from "node:path";
 
+import { resolveQmdCapabilities } from "../capabilities.js";
+import { type CompoundingEngine, defaultTierMigrationCycleBudget } from "../compounding/engine.js";
 // StorageManager type comes from the package barrel (type-only) so this
 // module does not add a direct storage.ts import (#1533 ratchet).
 import type { StorageManager } from "../index.js";
-import type { SearchBackend } from "../search/port.js";
-import { TierMigrationExecutor } from "../tier-migration.js";
-import { decideTierTransition, type MemoryTier } from "../tier-routing.js";
-import {
+import { log } from "../logger.js";
+import type {
+  TierMigrationCycleSummary,
+  TierMigrationStatusSnapshot,
   TierMigrationStatusStore,
-  type TierMigrationCycleSummary,
-  type TierMigrationStatusSnapshot,
 } from "../recall-state.js";
-import {
-  type CompoundingEngine,
-  defaultTierMigrationCycleBudget,
-} from "../compounding/engine.js";
-import {
-  applyUtilityPromotionRuntimePolicy,
-  type UtilityRuntimeValues,
-} from "../utility-runtime.js";
-import type { PluginConfig, MemoryFile } from "../types.js";
-import { log } from "../logger.js";
-import { resolveQmdCapabilities } from "../capabilities.js";
+import type { SearchBackend } from "../search/port.js";
+import { TierMigrationExecutor } from "../tier-migration.js";
+import { type MemoryTier, decideTierTransition } from "../tier-routing.js";
+import type { MemoryFile, PluginConfig } from "../types.js";
+import { type UtilityRuntimeValues, applyUtilityPromotionRuntimePolicy } from "../utility-runtime.js";
 
 /** Dependencies injected by the orchestrator. All stable references or live
  *  accessors (the orchestrator reassigns `qmd` to NoopSearchBackend and
@@ -91,7 +85,7 @@ export class TierMigrationCoordinator {
       dryRun?: boolean;
       limitOverride?: number;
       force?: boolean;
-    },
+    }
   ): Promise<TierMigrationCycleSummary> {
     const { config, tierMigrationStatus } = this.deps;
     const dryRun = options?.dryRun === true;
@@ -110,11 +104,7 @@ export class TierMigrationCoordinator {
       if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
       return skipped;
     }
-    if (
-      trigger === "maintenance" &&
-      !resolveQmdCapabilities(config).qmdTierAutoBackfill &&
-      options?.force !== true
-    ) {
+    if (trigger === "maintenance" && !resolveQmdCapabilities(config).qmdTierAutoBackfill && options?.force !== true) {
       const skipped: TierMigrationCycleSummary = {
         trigger,
         scanned: 0,
@@ -147,15 +137,9 @@ export class TierMigrationCoordinator {
     const budget =
       this.deps.getCompounding()?.tierMigrationCycleBudget(budgetTrigger) ??
       defaultTierMigrationCycleBudget(config, budgetTrigger);
-    const limit =
-      options?.limitOverride !== undefined
-        ? Math.max(0, Math.floor(options.limitOverride))
-        : budget.limit;
+    const limit = options?.limitOverride !== undefined ? Math.max(0, Math.floor(options.limitOverride)) : budget.limit;
     const nowMs = Date.now();
-    if (
-      options?.force !== true &&
-      nowMs - this.lastRunAtMs < budget.minIntervalMs
-    ) {
+    if (options?.force !== true && nowMs - this.lastRunAtMs < budget.minIntervalMs) {
       const skipped: TierMigrationCycleSummary = {
         trigger,
         scanned: 0,
@@ -177,28 +161,17 @@ export class TierMigrationCoordinator {
         demotionValueThreshold: config.qmdTierDemotionValueThreshold,
         promotionValueThreshold: config.qmdTierPromotionValueThreshold,
       },
-      this.deps.getUtilityRuntimeValues(),
+      this.deps.getUtilityRuntimeValues()
     );
 
     this.inFlight = true;
     try {
-      const coldStorage = this.deps.createColdStorage(
-        path.join(storage.dir, "cold"),
-      );
-      const [hotMemories, coldMemories] = await Promise.all([
-        storage.readAllMemories(),
-        coldStorage.readAllMemories(),
-      ]);
+      const coldStorage = this.deps.createColdStorage(path.join(storage.dir, "cold"));
+      const [hotMemories, coldMemories] = await Promise.all([storage.readAllMemories(), coldStorage.readAllMemories()]);
       const now = new Date();
       const scanLimit = Math.max(0, Math.floor(budget.scanLimit));
-      const hotScanLimit = Math.min(
-        hotMemories.length,
-        Math.ceil(scanLimit * 0.75),
-      );
-      const coldScanLimit = Math.min(
-        coldMemories.length,
-        Math.max(0, scanLimit - hotScanLimit),
-      );
+      const hotScanLimit = Math.min(hotMemories.length, Math.ceil(scanLimit * 0.75));
+      const coldScanLimit = Math.min(coldMemories.length, Math.max(0, scanLimit - hotScanLimit));
       const toTimestamp = (memory: MemoryFile): number =>
         Date.parse(memory.frontmatter.updated ?? memory.frontmatter.created);
       const hotCandidates = hotMemories
@@ -215,8 +188,7 @@ export class TierMigrationCoordinator {
         storage,
         qmd: this.deps.getQmd(),
         hotCollection: config.qmdCollection,
-        coldCollection:
-          config.qmdColdCollection ?? `${config.qmdCollection}-cold`,
+        coldCollection: config.qmdColdCollection ?? `${config.qmdCollection}-cold`,
         autoEmbed: resolveQmdCapabilities(config).qmdAutoEmbed,
       });
 
@@ -225,12 +197,7 @@ export class TierMigrationCoordinator {
       let demoted = 0;
       for (const candidate of candidates) {
         if (migrated >= limit) break;
-        const decision = decideTierTransition(
-          candidate.memory,
-          candidate.tier,
-          policy,
-          now,
-        );
+        const decision = decideTierTransition(candidate.memory, candidate.tier, policy, now);
         if (!decision.changed) continue;
 
         if (!dryRun) {
@@ -249,7 +216,7 @@ export class TierMigrationCoordinator {
 
       if (!dryRun) this.lastRunAtMs = Date.now();
       log.debug(
-        `tier migration cycle completed: trigger=${trigger} scanned=${candidates.length} migrated=${migrated} limit=${limit}${dryRun ? " dryRun=true" : ""}`,
+        `tier migration cycle completed: trigger=${trigger} scanned=${candidates.length} migrated=${migrated} limit=${limit}${dryRun ? " dryRun=true" : ""}`
       );
       const summary: TierMigrationCycleSummary = {
         trigger,

package/src/orchestration/workspace-ops.test.ts

@@ -1,9 +1,46 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { StorageManager } from "../storage.js";
 import { WorkspaceOpsCoordinator, type WorkspaceOpsDeps } from "./workspace-ops.js";
 import type { AccessTrackingEntry, PluginConfig } from "../types.js";
 
+test("gatherTodayFacts excludes support passport cards from day-summary input", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-workspace-passport-"));
+  try {
+    await mkdir(root, { recursive: true });
+    const storage = new StorageManager(root);
+    await storage.writeMemory("preference", "Private support statement", {
+      tags: ["support-passport-card"],
+      source: "support-passport",
+    });
+    await storage.writeMemory("fact", "Public project update", {
+      source: "test",
+    });
+    const coordinator = new WorkspaceOpsCoordinator({
+      config: {
+        defaultNamespace: "default",
+        daySummaryTimezone: "UTC",
+      } as unknown as PluginConfig,
+      storageRouter: {
+        storageFor: async () => storage,
+      },
+    } as unknown as WorkspaceOpsDeps);
+
+    const gathered = await coordinator.gatherTodayFacts(undefined, {
+      now: new Date(),
+      timeZone: "UTC",
+    });
+
+    assert.equal(gathered.includes("Private support statement"), false);
+    assert.equal(gathered.includes("Public project update"), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("flushAccessTracking keeps duplicate memory IDs scoped by memory path", async () => {
   const defaultPath = path.join("/memory", "namespaces", "default", "facts", "same-id.md");
   const sharedPath = path.join("/memory", "namespaces", "shared", "facts", "same-id.md");