@remnic/core 9.69.70 → 9.69.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.70",
+  "version": "9.69.72",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3317,7 +3317,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.70"
+    "@remnic/coding-graph": "^9.69.72"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/deep-recall-seeds.test.ts

@@ -51,3 +51,38 @@ test("seed search forwards the cancellation signal and the capped limit to the r
   assert.equal(captured?.execution?.signal, controller.signal, "the transport signal reaches the search router");
   assert.equal(resolverCalls, 2, "each returned hit is resolved per hit");
 });
+
+test("resolve-miss drops the hit instead of admitting the bare docid (issue #3087)", async () => {
+  const resolvedPaths: string[] = [];
+  const router: DeepRecallSeedRouter = {
+    async searchAcrossNamespaces() {
+      return [
+        { path: "entities/company-x.md", docid: "foreign-doc-42", score: 0.7 },
+        { path: "facts/2026-09-12/fact-good.md", docid: "doc-good", score: 0.6 },
+        { path: "", docid: "doc-nopath", score: 0.5 },
+      ];
+    },
+  };
+  const searchSeed = createDeepRecallSeedSearch({
+    namespace: "ns_3087",
+    storage: { dir: "/synthetic/ns_3087", readMemoryByPath: async () => null },
+    router,
+    resolver: {
+      async readQmdResultMemory(resultPath) {
+        resolvedPaths.push(resultPath);
+        return resultPath === "facts/2026-09-12/fact-good.md"
+          ? { frontmatter: { id: "fact-good-123" } }
+          : null;
+      },
+    },
+  });
+
+  const seeds = await searchSeed("company x", 3);
+
+  assert.deepEqual(
+    seeds,
+    [{ memoryId: "fact-good-123", score: 0.6 }],
+    "a hit the resolver cannot resolve is dropped, never admitted by its bare docid",
+  );
+  assert.ok(!resolvedPaths.includes(""), "an empty path is skipped before the resolver");
+});

package/src/deep-recall-seeds.ts

@@ -15,7 +15,9 @@
  * and the two forms it cannot decode (`qmd:///`, a leading `/`) are stripped
  * for one retry. A hit with no path is dropped: its namespace membership
  * cannot be verified, and a bare docid from a foreign collection must never
- * enter the working set as a resolved memory.
+ * enter the working set as a resolved memory. A hit with a path that still
+ * fails to resolve is dropped for the same reason: the resolver miss leaves
+ * the docid as the only identity, and a docid is not a memory id.
  *
  * An unavailable namespace backend (or a missing collection) contributes an
  * empty result set and reports itself only through `execution.onDegradation`,
@@ -127,9 +129,8 @@ export function createDeepRecallSeedSearch(deps: {
     const seeds: DeepRecallSeedHit[] = [];
     for (const hit of hits) {
       if (typeof hit.path !== "string" || hit.path.length === 0) continue;
-      const memoryId =
-        (await resolveSeedMemoryId(deps.resolver, deps.storage, deps.namespace, hit.path)) ?? hit.docid;
-      if (typeof memoryId !== "string" || memoryId.length === 0) continue;
+      const memoryId = await resolveSeedMemoryId(deps.resolver, deps.storage, deps.namespace, hit.path);
+      if (memoryId === null) continue;
       seeds.push({
         memoryId,
         score: typeof hit.score === "number" && Number.isFinite(hit.score) ? hit.score : 0,

package/src/deep-recall-surface.test.ts

@@ -870,8 +870,8 @@ test("deep recall seeds resolve collection-qualified paths when namespaces are d
           path: rawPath,
           score: 0.5 + index / 10,
         })),
-        // A foreign-collection hit stays unresolvable: it keeps its docid and
-        // still seeds the working set, but never hydrates into the graph.
+        // A foreign-collection hit is unresolvable: skip it. Admitting the
+        // bare docid would violate the foreign-collection guard (#3087).
         { docid: "hash-doc-foreign", path: "foreign-coll/facts/2026-08-01/fact-1.md", score: 0.9 },
       ],
     };
@@ -885,15 +885,12 @@ test("deep recall seeds resolve collection-qualified paths when namespaces are d
 
     assert.deepEqual(
       seeds.map((seed) => seed.memoryId),
-      [
-        ...rawPaths.map(() => "mem-seed-1"),
-        "hash-doc-foreign",
-      ],
-      "every collection-qualified raw path form must resolve to the frontmatter id; only a foreign collection keeps its docid",
+      rawPaths.map(() => "mem-seed-1"),
+      "every collection-qualified raw path form must resolve to the frontmatter id; a foreign collection is dropped",
     );
     assert.deepEqual(
       seeds.map((seed) => seed.score),
-      [0.5, 0.6, 0.7, 0.8, 0.9],
+      [0.5, 0.6, 0.7, 0.8],
       "resolution must not disturb the hit scores",
     );
   } finally {

package/src/support-passport/grant-service.test.ts

@@ -29,6 +29,7 @@ import {
   readPrivateFileNoFollow,
   removePrivateFilesNoFollow,
   requirePrivateFileDescriptorRoot,
+  withPrivateDirectoryNoFollow,
   writePrivateFileAtomicallyNoFollow,
 } from "./private-file.js";
 
@@ -2865,15 +2866,7 @@ test("the grant store rejects a symlinked grant directory", async () => {
   }
 });
 
-test("private file operations select supported directory access strategies", () => {
-  assert.throws(
-    () =>
-      requirePrivateFileDescriptorRoot(
-        "win32",
-        "private file directory cannot be pinned",
-      ),
-    /private file directory cannot be pinned/,
-  );
+test("private file operations select supported directory access strategies", async () => {
   assert.equal(
     requirePrivateFileDescriptorRoot("linux", "unreachable"),
     "/proc/self/fd",
@@ -2882,6 +2875,28 @@ test("private file operations select supported directory access strategies", ()
     requirePrivateFileDescriptorRoot("darwin", "unreachable"),
     "/dev/fd",
   );
+  assert.throws(
+    () => requirePrivateFileDescriptorRoot("sunos", "unreachable"),
+    /unreachable/,
+  );
+
+  // win32 has no POSIX directory-fd root; pinning degrades to the resolved
+  // stable path while the no-follow ancestor walk and containment asserts stay.
+  const root = await mkdtemp(path.join(tmpdir(), "remnic-support-private-win32-"));
+  try {
+    const target = path.join(root, "state", "memory");
+    await mkdir(target, { recursive: true });
+    const pinned = await withPrivateDirectoryNoFollow(
+      root,
+      target,
+      "private file directory cannot be pinned",
+      async (pinnedDirectory) => pinnedDirectory,
+      "win32",
+    );
+    assert.equal(pinned, path.resolve(target));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
 });
 
 test("private directory creation syncs every verified parent entry", async () => {
@@ -3105,25 +3120,35 @@ test("the grant store rejects a symlink alias in the configured memory root", as
   }
 });
 
-test("Windows private-file operations fail before mutation", async () => {
+test("Windows private-file operations pin without a POSIX descriptor root", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "remnic-support-private-win32-"));
   try {
     const directory = path.join(root, "state", "support-passport", "grants");
-    const filePath = path.join(directory, "grant.json");
     const errorMessage = "private Windows file operation failed";
+    await ensurePrivateDirectoryNoFollow(root, directory, errorMessage, undefined, true, "win32");
+    assert.equal((await lstat(directory)).isDirectory(), true);
+
+    const liveParent = path.join(root, "live");
+    const parkedParent = path.join(root, "parked");
+    const outside = path.join(root, "outside");
+    await mkdir(liveParent);
+    await mkdir(path.join(outside, "memory"), { recursive: true });
+    await renameSync(liveParent, parkedParent);
+    await symlink(outside, liveParent, "dir");
+
     await assert.rejects(
-      ensurePrivateDirectoryNoFollow(root, directory, errorMessage, undefined, true, "win32"),
-      new RegExp(errorMessage)
-    );
-    assert.equal(
-      await lstat(directory).then(
-        () => true,
-        () => false
+      ensurePrivateDirectoryNoFollow(
+        root,
+        path.join(liveParent, "memory"),
+        errorMessage,
+        undefined,
+        true,
+        "win32",
       ),
-      false
+      new RegExp(errorMessage),
     );
     assert.equal(
-      await lstat(filePath).then(
+      await lstat(path.join(outside, "memory", "state")).then(
         () => true,
         () => false
       ),

package/src/support-passport/private-file.test.ts

@@ -30,16 +30,21 @@ test("private append cannot escape its pinned directory", async (context) => {
   await assert.rejects(readFile(outsidePath, "utf8"), { code: "ENOENT" });
 });
 
-test("private append fails before mutation when descriptor pinning is unavailable", async (context) => {
+test("private append writes through a path-pinned directory on win32", async (context) => {
   const root = await mkdtemp(path.join(os.tmpdir(), "remnic-private-append-win32-"));
   context.after(async () => await rm(root, { recursive: true, force: true }));
   const privateDirectory = path.join(root, "private");
+  await mkdir(privateDirectory);
   const auditPath = path.join(privateDirectory, "audit.jsonl");
-  await assert.rejects(
-    ensurePrivateDirectoryNoFollow(root, privateDirectory, "private path escaped", undefined, true, "win32"),
-    /private path escaped/
+  await appendPrivateFileNoFollow(
+    privateDirectory,
+    auditPath,
+    "private\n",
+    "private path escaped",
+    root,
+    "win32",
   );
-  await assert.rejects(readFile(auditPath, "utf8"), { code: "ENOENT" });
+  assert.equal(await readFile(auditPath, "utf8"), "private\n");
 });
 
 test("private append rejects a renamed target after opening it", async (context) => {

package/src/support-passport/private-file.ts

@@ -104,6 +104,7 @@ export async function resolvePrivateDirectoryPath(
   errorMessage: string,
   platform: NodeJS.Platform = process.platform
 ): Promise<string> {
+  if (pinsDirectoriesByPath(platform)) return path.resolve(directory);
   const descriptorRoot = requirePrivateFileDescriptorRoot(platform, errorMessage);
   const pinnedPath = path.join(descriptorRoot, String(handle.fd));
   const metadata = await stat(pinnedPath);
@@ -125,6 +126,10 @@ export function requirePrivateFileDescriptorRoot(platform: NodeJS.Platform, erro
   throw new Error(errorMessage);
 }
 
+function pinsDirectoriesByPath(platform: NodeJS.Platform): boolean {
+  return platform === "win32";
+}
+
 async function openStableDirectoryFromRoot(
   trustedRoot: string,
   directory: string,
@@ -140,7 +145,7 @@ async function openStableDirectoryFromRoot(
   const root = path.resolve(trustedRoot);
   const target = path.resolve(directory);
   assertContainedPath(root, target, errorMessage);
-  requirePrivateFileDescriptorRoot(platform, errorMessage);
+  if (!pinsDirectoriesByPath(platform)) requirePrivateFileDescriptorRoot(platform, errorMessage);
   const relative = path.relative(root, target);
   const components = relative === "" ? [] : relative.split(path.sep);
   const handles: FileHandle[] = [];
@@ -149,7 +154,7 @@ async function openStableDirectoryFromRoot(
     let current = await openDirectoryNoFollow(root, errorMessage);
     handles.push(current.handle);
     for (const component of components) {
-      const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage);
+      const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage, platform);
       const child = await openDirectoryNoFollow(path.join(pinnedParent, component), errorMessage);
       handles.push(child.handle);
       assertStableDirectory(current.before, current.opened, await lstat(currentPath), errorMessage);
@@ -186,7 +191,7 @@ export async function ensurePrivateDirectoryNoFollow(
   const target = path.resolve(directory);
   assertContainedPath(root, target, errorMessage);
   const relative = path.relative(root, target);
-  requirePrivateFileDescriptorRoot(platform, errorMessage);
+  if (!pinsDirectoriesByPath(platform)) requirePrivateFileDescriptorRoot(platform, errorMessage);
   const components = relative === "" ? [] : relative.split(path.sep);
   const handles: FileHandle[] = [];
   let currentPath = root;
@@ -194,7 +199,7 @@ export async function ensurePrivateDirectoryNoFollow(
     let current = await openDirectoryNoFollow(root, errorMessage);
     handles.push(current.handle);
     for (const component of components) {
-      const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage);
+      const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage, platform);
       const childPath = path.join(pinnedParent, component);
       let created = false;
       try {
@@ -393,10 +398,12 @@ export async function appendPrivateFileInPinnedDirectory(
   errorMessage: string,
   platform: NodeJS.Platform = process.platform
 ): Promise<void> {
-  const descriptorRoot = requirePrivateFileDescriptorRoot(platform, errorMessage);
   const resolvedDirectory = path.resolve(pinnedDirectory);
-  const descriptor = path.relative(descriptorRoot, resolvedDirectory);
-  if (!/^\d+$/.test(descriptor)) throw new Error(errorMessage);
+  if (!pinsDirectoriesByPath(platform)) {
+    const descriptorRoot = requirePrivateFileDescriptorRoot(platform, errorMessage);
+    const descriptor = path.relative(descriptorRoot, resolvedDirectory);
+    if (!/^\d+$/.test(descriptor)) throw new Error(errorMessage);
+  }
   const before = await stat(resolvedDirectory);
   if (!before.isDirectory()) throw new Error(errorMessage);
   let directoryHandle: FileHandle | undefined;

package/dist/chunk-AJBWVDRV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/deep-recall-seeds.ts"],"sourcesContent":["/**\n * Deep-recall seed retrieval (issue #2332 review).\n *\n * Seeds route through the SAME namespace search router the rest of the read\n * path uses, so a non-default caller searches its own suffixed collection\n * instead of the base (default-namespace) collection — read and write resolve\n * through one resolver, never two (§30).\n *\n * Each hit is resolved to a real memory id through the shared QMD result\n * resolver (`QmdResultResolver.readQmdResultMemory`), per hit and bounded by\n * the requested limit, instead of pre-scanning the whole namespace corpus to\n * build a path index. With namespaces disabled the fanout queries the QMD\n * backend directly, so hits keep the indexer's raw path forms; the resolver\n * decodes `qmd://<collection>/` URIs and `<collection>/`-prefixed relatives,\n * and the two forms it cannot decode (`qmd:///`, a leading `/`) are stripped\n * for one retry. A hit with no path is dropped: its namespace membership\n * cannot be verified, and a bare docid from a foreign collection must never\n * enter the working set as a resolved memory.\n *\n * An unavailable namespace backend (or a missing collection) contributes an\n * empty result set and reports itself only through `execution.onDegradation`,\n * so the observer is REQUIRED here: without it a dead index is indistinguishable\n * from a healthy empty one and deep recall would answer `ok: true` with zero\n * entries instead of the advertised `backend_unavailable` failure.\n */\n\nimport type { DeepRecallSeedHit } from \"./deep-recall.js\";\nimport type { SearchDegradation } from \"./search/port.js\";\n\n/** Namespace-scoped search entrypoint (satisfied by `Orchestrator.searchAcrossNamespaces`). */\nexport interface DeepRecallSeedRouter {\n  searchAcrossNamespaces(options: {\n    query: string;\n    namespaces: string[];\n    maxResults?: number;\n    execution?: {\n      signal?: AbortSignal;\n      onDegradation?: (degradation: SearchDegradation) => void;\n    };\n  }): Promise<ReadonlyArray<{ path?: string; docid?: string; score?: number }>>;\n}\n\n/** Namespace-scoped storage read (satisfied by `StorageManager`). */\nexport interface DeepRecallSeedStorage {\n  readonly dir: string;\n  readMemoryByPath(filePath: string): Promise<{ frontmatter: { id?: string } } | null>;\n}\n\n/** Full QMD hit -> memory resolver (satisfied by `QmdResultResolver#readQmdResultMemory`). */\nexport interface DeepRecallSeedResultResolver {\n  readQmdResultMemory(\n    resultPath: string,\n    fallbackStorage: DeepRecallSeedStorage,\n    recallNamespaces?: readonly string[],\n    preferredNamespace?: string,\n  ): Promise<{ frontmatter: { id?: string } } | null>;\n}\n\n/**\n * Strip the collection-qualified forms the indexer can emit but\n * `readQmdResultMemory` cannot decode: the empty-hostname `qmd:///` URI and\n * the root-relative `/` path both reach its fallback probe still prefixed and\n * miss. Returns `null` when the path carries no such prefix — including a\n * decodable `qmd://<collection>/` or `<collection>/` form, which the resolver\n * owns, and a foreign collection prefix, which must stay a miss.\n */\nfunction collectionPrefixStrippedPath(resultPath: string): string | null {\n  const trimmed = resultPath.trim();\n  if (trimmed.startsWith(\"qmd:///\")) {\n    const relative = trimmed.slice(\"qmd:///\".length).replace(/^\\/+/, \"\");\n    return relative.length > 0 ? relative : null;\n  }\n  if (trimmed.startsWith(\"/\")) {\n    const relative = trimmed.replace(/^\\/+/, \"\");\n    return relative.length > 0 ? relative : null;\n  }\n  return null;\n}\n\nasync function resolveSeedMemoryId(\n  resolver: DeepRecallSeedResultResolver,\n  storage: DeepRecallSeedStorage,\n  namespace: string,\n  resultPath: string | undefined,\n): Promise<string | null> {\n  if (typeof resultPath !== \"string\" || resultPath.length === 0) return null;\n  const attempts = [resultPath];\n  const stripped = collectionPrefixStrippedPath(resultPath);\n  if (stripped !== null) attempts.push(stripped);\n  for (const attempt of attempts) {\n    const memory = await resolver.readQmdResultMemory(attempt, storage, [namespace]);\n    const id = memory?.frontmatter?.id;\n    if (typeof id === \"string\" && id.length > 0) return id;\n  }\n  return null;\n}\n\nexport function createDeepRecallSeedSearch(deps: {\n  namespace: string;\n  storage: DeepRecallSeedStorage;\n  router: DeepRecallSeedRouter;\n  resolver: DeepRecallSeedResultResolver;\n  /** Transport cancellation (issue #2915); forwarded to the search router. */\n  signal?: AbortSignal;\n}): (query: string, limit: number) => Promise<DeepRecallSeedHit[]> {\n  return async (query, limit) => {\n    if (limit <= 0) return [];\n    const unavailable: SearchDegradation[] = [];\n    const hits = await deps.router.searchAcrossNamespaces({\n      query,\n      namespaces: [deps.namespace],\n      maxResults: limit,\n      execution: {\n        ...(deps.signal ? { signal: deps.signal } : {}),\n        onDegradation: (degradation) => {\n          if (degradation.code === \"backend_unavailable\") unavailable.push(degradation);\n        },\n      },\n    });\n    // The requested namespace has no usable index: a seed-search failure, which\n    // is the one condition deep recall reports as `backend_unavailable`.\n    if (unavailable.length > 0) {\n      throw new Error(\n        `deep recall seed search unavailable: ${unavailable.map((d) => d.detail ?? d.code).join(\"; \")}`,\n      );\n    }\n    const seeds: DeepRecallSeedHit[] = [];\n    for (const hit of hits) {\n      if (typeof hit.path !== \"string\" || hit.path.length === 0) continue;\n      const memoryId =\n        (await resolveSeedMemoryId(deps.resolver, deps.storage, deps.namespace, hit.path)) ?? hit.docid;\n      if (typeof memoryId !== \"string\" || memoryId.length === 0) continue;\n      seeds.push({\n        memoryId,\n        score: typeof hit.score === \"number\" && Number.isFinite(hit.score) ? hit.score : 0,\n      });\n    }\n    return seeds;\n  };\n}\n"],"mappings":";AAkEA,SAAS,6BAA6B,YAAmC;AACvE,QAAM,UAAU,WAAW,KAAK;AAChC,MAAI,QAAQ,WAAW,SAAS,GAAG;AACjC,UAAM,WAAW,QAAQ,MAAM,UAAU,MAAM,EAAE,QAAQ,QAAQ,EAAE;AACnE,WAAO,SAAS,SAAS,IAAI,WAAW;AAAA,EAC1C;AACA,MAAI,QAAQ,WAAW,GAAG,GAAG;AAC3B,UAAM,WAAW,QAAQ,QAAQ,QAAQ,EAAE;AAC3C,WAAO,SAAS,SAAS,IAAI,WAAW;AAAA,EAC1C;AACA,SAAO;AACT;AAEA,eAAe,oBACb,UACA,SACA,WACA,YACwB;AACxB,MAAI,OAAO,eAAe,YAAY,WAAW,WAAW,EAAG,QAAO;AACtE,QAAM,WAAW,CAAC,UAAU;AAC5B,QAAM,WAAW,6BAA6B,UAAU;AACxD,MAAI,aAAa,KAAM,UAAS,KAAK,QAAQ;AAC7C,aAAW,WAAW,UAAU;AAC9B,UAAM,SAAS,MAAM,SAAS,oBAAoB,SAAS,SAAS,CAAC,SAAS,CAAC;AAC/E,UAAM,KAAK,QAAQ,aAAa;AAChC,QAAI,OAAO,OAAO,YAAY,GAAG,SAAS,EAAG,QAAO;AAAA,EACtD;AACA,SAAO;AACT;AAEO,SAAS,2BAA2B,MAOwB;AACjE,SAAO,OAAO,OAAO,UAAU;AAC7B,QAAI,SAAS,EAAG,QAAO,CAAC;AACxB,UAAM,cAAmC,CAAC;AAC1C,UAAM,OAAO,MAAM,KAAK,OAAO,uBAAuB;AAAA,MACpD;AAAA,MACA,YAAY,CAAC,KAAK,SAAS;AAAA,MAC3B,YAAY;AAAA,MACZ,WAAW;AAAA,QACT,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;AAAA,QAC7C,eAAe,CAAC,gBAAgB;AAC9B,cAAI,YAAY,SAAS,sBAAuB,aAAY,KAAK,WAAW;AAAA,QAC9E;AAAA,MACF;AAAA,IACF,CAAC;AAGD,QAAI,YAAY,SAAS,GAAG;AAC1B,YAAM,IAAI;AAAA,QACR,wCAAwC,YAAY,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;AAAA,MAC/F;AAAA,IACF;AACA,UAAM,QAA6B,CAAC;AACpC,eAAW,OAAO,MAAM;AACtB,UAAI,OAAO,IAAI,SAAS,YAAY,IAAI,KAAK,WAAW,EAAG;AAC3D,YAAM,WACH,MAAM,oBAAoB,KAAK,UAAU,KAAK,SAAS,KAAK,WAAW,IAAI,IAAI,KAAM,IAAI;AAC5F,UAAI,OAAO,aAAa,YAAY,SAAS,WAAW,EAAG;AAC3D,YAAM,KAAK;AAAA,QACT;AAAA,QACA,OAAO,OAAO,IAAI,UAAU,YAAY,OAAO,SAAS,IAAI,KAAK,IAAI,IAAI,QAAQ;AAAA,MACnF,CAAC;AAAA,IACH;AACA,WAAO;AAAA,EACT;AACF;","names":[]}