@remnic/core 9.3.664 → 9.3.666

package/src/direct-answer-wiring.test.ts

@@ -7,7 +7,7 @@ import {
   type DirectAnswerWiringInput,
 } from "./direct-answer-wiring.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/default-taxonomy.js";
-import type { MemoryFile, PluginConfig } from "./types.js";
+import type { MemoryFile } from "./types.js";
 import type { TrustZoneName } from "./trust-zones.js";
 
 type WiringConfig = DirectAnswerWiringInput["config"];
@@ -94,7 +94,8 @@ test("tryDirectAnswer disabled-path does not call any source accessor", async ()
   const result = await tryDirectAnswer({
     query: "does not matter",
     namespace: "default",
-    config: { ...BASE_CONFIG, recallDirectAnswerEnabled: false },
+    config: BASE_CONFIG,
+    enabled: false,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -104,6 +105,42 @@ test("tryDirectAnswer disabled-path does not call any source accessor", async ()
   assert.deepEqual(sources.calls.importance, []);
 });
 
+// ── Backward-compat (#1523): omit top-level `enabled`, fall back to config ──
+
+test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabled` is omitted (disabled)", async () => {
+  // Old input shape: config carries recallDirectAnswerEnabled: false and no
+  // top-level `enabled`. Must short-circuit as "disabled" (identical to the
+  // pre-#1523 behavior) rather than treating undefined as enabled.
+  const sources = makeMockSources({ memories: [makeMemory()] });
+  const result = await tryDirectAnswer({
+    query: "does not matter",
+    namespace: "default",
+    config: { ...BASE_CONFIG, recallDirectAnswerEnabled: false },
+    sources,
+  });
+  assert.equal(result.eligible, false);
+  assert.equal(result.reason, "disabled");
+  assert.equal(sources.calls.listCandidates, 0);
+});
+
+test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabled` is omitted (enabled)", async () => {
+  // Old input shape with recallDirectAnswerEnabled: true and no `enabled` must
+  // NOT short-circuit — it proceeds to materialize candidates.
+  const sources = makeMockSources({
+    memories: [makeMemory({ tags: ["pnpm"], content: "remnic uses pnpm" })],
+    trustZones: { m1: "trusted" },
+    importance: { m1: 0.9 },
+  });
+  const result = await tryDirectAnswer({
+    query: "package manager remnic",
+    namespace: "default",
+    config: BASE_CONFIG, // recallDirectAnswerEnabled: true
+    sources,
+  });
+  assert.notEqual(result.reason, "disabled");
+  assert.equal(sources.calls.listCandidates, 1);
+});
+
 // ── Empty-query short-circuit: no I/O ───────────────────────────────────────
 
 test("tryDirectAnswer skips all I/O when query normalizes to zero searchable tokens", async () => {
@@ -119,6 +156,7 @@ test("tryDirectAnswer skips all I/O when query normalizes to zero searchable tok
     query: "? !!!  ",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.reason, "empty-query");
@@ -135,6 +173,7 @@ test("tryDirectAnswer with empty memory list returns no-candidates", async () =>
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.reason, "no-candidates");
@@ -158,6 +197,7 @@ test("tryDirectAnswer skips importance resolution for non-trusted memories", asy
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -182,6 +222,7 @@ test("tryDirectAnswer skips importance for quarantine-zone memories", async () =
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -203,6 +244,7 @@ test("tryDirectAnswer skips importance when trust zone is missing (null)", async
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -229,6 +271,7 @@ test("tryDirectAnswer skips importance when taxonomy bucket is not eligible", as
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -254,6 +297,7 @@ test("tryDirectAnswer returns eligible for a single trusted user-confirmed decis
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, true);
@@ -284,6 +328,7 @@ test("tryDirectAnswer defers to hybrid when two trusted candidates are within am
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -327,6 +372,7 @@ test("tryDirectAnswer throws AbortError when signal aborts mid-loop", async () =
         query: "package manager remnic",
         namespace: "default",
         config: BASE_CONFIG,
+        enabled: true,
         sources,
         abortSignal: controller.signal,
       }),
@@ -363,6 +409,7 @@ test("tryDirectAnswer throws when abort lands during trustZoneFor on the only me
         query: "package manager remnic",
         namespace: "default",
         config: BASE_CONFIG,
+        enabled: true,
         sources,
         abortSignal: controller.signal,
       }),
@@ -391,6 +438,7 @@ test("tryDirectAnswer throws when abort lands during trustZoneFor on the last of
         query: "package manager remnic",
         namespace: "default",
         config: BASE_CONFIG,
+        enabled: true,
         sources,
         abortSignal: controller.signal,
       }),
@@ -408,6 +456,7 @@ test("tryDirectAnswer throws when signal is already aborted before I/O", async (
         query: "anything",
         namespace: "default",
         config: BASE_CONFIG,
+        enabled: true,
         sources,
         abortSignal: controller.signal,
       }),
@@ -434,6 +483,7 @@ test("tryDirectAnswer passes the requested namespace to listCandidateMemories",
     query: "anything",
     namespace: "project-x",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.equal(observedNamespace, "project-x");
@@ -465,6 +515,7 @@ test("tryDirectAnswer forwards queryEntityRefs to the eligibility gate", async (
     query: "package manager remnic",
     namespace: "default",
     config: BASE_CONFIG,
+    enabled: true,
     sources,
     queryEntityRefs: ["remnic"],
   });

package/src/direct-answer-wiring.ts

@@ -14,9 +14,10 @@
  *
  * Short-circuit contract:
  *
- * - When `config.recallDirectAnswerEnabled === false`, the function
- *   returns the eligibility verdict with reason `"disabled"` without
- *   touching any source accessor.  This is the documented default.
+ * - When the resolved gate (`input.enabled` if supplied, else
+ *   `config.recallDirectAnswerEnabled`) is `false`, the function returns the
+ *   eligibility verdict with reason `"disabled"` without touching any source
+ *   accessor.  This is the documented default.
  * - When enabled, the wiring cheaply drops non-trusted-zone memories
  *   and ineligible taxonomy buckets before computing importance, so
  *   the eligibility module sees a pre-filtered candidate set.  The
@@ -79,6 +80,15 @@ export interface DirectAnswerWiringInput {
     | "recallDirectAnswerAmbiguityMargin"
     | "recallDirectAnswerEligibleTaxonomyBuckets"
   >;
+  /**
+   * Direct-answer capability gate, resolved once at the recall-operation entry
+   * (issue #1523: `caps.recallDirectAnswer`). OPTIONAL and additive: when the
+   * caller supplies it, this module and the orchestrator agree on a single
+   * resolved gate value for the whole operation. When omitted, we fall back to
+   * `config.recallDirectAnswerEnabled` so existing callers on the old input
+   * shape keep identical behavior.
+   */
+  enabled?: boolean;
   sources: DirectAnswerSources;
   queryEntityRefs?: string[];
   abortSignal?: AbortSignal;
@@ -92,10 +102,13 @@ export interface DirectAnswerWiringInput {
 export async function tryDirectAnswer(
   input: DirectAnswerWiringInput,
 ): Promise<DirectAnswerResult> {
-  const { query, namespace, config, sources, queryEntityRefs, abortSignal } = input;
+  const { query, namespace, config, enabled, sources, queryEntityRefs, abortSignal } = input;
 
   const eligibilityConfig: DirectAnswerConfig = {
-    enabled: config.recallDirectAnswerEnabled,
+    // Prefer the resolved capability when supplied; fall back to the config
+    // flag so callers on the old input shape (config-only, no `enabled`) get
+    // identical gating (issue #1523 backward-compat).
+    enabled: enabled ?? config.recallDirectAnswerEnabled,
     tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,
     importanceFloor: config.recallDirectAnswerImportanceFloor,
     ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,

package/src/namespaces/catalog.test.ts

@@ -487,13 +487,13 @@ test("StorageRouter integration: catalog registers namespace on storageFor", asy
     const config = makeConfig(memoryDir);
     const catalog = new NamespaceCatalog(config);
     const router = new NamespaceStorageRouter(config, {
-      onResolve: (namespace, storageDir) => {
-        void catalog.registerResolved(namespace, storageDir);
-      },
+      // Return the registration promise so the router tracks it as in-flight and
+      // `whenResolveHooksSettled()` can await it deterministically (no timer race).
+      onResolve: (namespace, storageDir) => catalog.registerResolved(namespace, storageDir),
     });
     await router.storageFor("project-origin-abc123");
-    // allow the fire-and-forget registration to settle
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the fire-and-forget registration instead of sleeping.
+    await router.whenResolveHooksSettled();
 
     const record = await catalog.getNamespaceRecord("project-origin-abc123");
     assert.ok(record, "storageFor should have registered the namespace");
@@ -2523,8 +2523,8 @@ test("an async onResolve hook rejection does not crash storage resolution", asyn
     // Must not throw or produce an unhandled rejection that fails the test.
     const sm = await router.storageFor("default");
     assert.ok(sm, "storage resolution succeeds despite a rejecting async hook");
-    // Give the swallowed rejection a tick to settle.
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the swallowed rejection instead of sleeping.
+    await router.whenResolveHooksSettled();
     assert.ok(called >= 1, "the async hook was invoked");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2564,7 +2564,7 @@ test("concurrent storageFor() for one namespace fires the resolve hook ONCE whil
     // Let the in-flight registration settle, then a steady-state cache hit must
     // still be a catalog no-op (now deduped via notifiedResolved).
     release();
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     await router.storageFor("project-origin-inflight");
     assert.equal(calls, 1, "a steady-state cache hit after settle must not re-fire the hook");
   } finally {
@@ -2589,20 +2589,20 @@ test("a dropped resolve registration (hook returns false) is retried on a later
     });
 
     await router.storageFor("project-origin-retry");
-    // Give the async hook a tick to settle and clear the in-flight marker.
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the async hook so the in-flight marker is cleared.
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 1, "the hook fired once for the dropped registration");
 
     // Now the registration will succeed; a later resolve must RETRY (not be
     // suppressed by a stale in-flight/notified marker from the dropped attempt).
     result = undefined; // success (legacy void)
     await router.storageFor("project-origin-retry");
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 2, "a dropped registration must be retried on the next storageFor()");
 
     // After a SUCCESSFUL registration, further cache hits are deduped (no retry).
     await router.storageFor("project-origin-retry");
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 2, "a successful registration is not re-fired on subsequent cache hits");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });

package/src/namespaces/storage.ts

@@ -223,6 +223,11 @@ export class NamespaceStorageRouter {
   // entry is always removed when the promise settles, so the map cannot grow
   // unbounded (one transient entry per concurrently-resolving namespace).
   private readonly inFlightResolved = new Map<string, string>();
+  // Tracks every in-flight resolve-hook promise so callers can deterministically
+  // await the fire-and-forget registrations that `storageFor()` kicks off (see
+  // `whenResolveHooksSettled`). Entries are removed as each hook settles, so the
+  // set holds at most one promise per concurrently-resolving namespace.
+  private readonly pendingResolveHooks = new Set<Promise<unknown>>();
 
   // Normalized (trimmed) default namespace identity (NH-FH). `storageFor`
   // normalizes its input, so default-namespace branches must compare against the
@@ -325,7 +330,10 @@ export class NamespaceStorageRouter {
       // the map holds at most one transient entry per concurrently-resolving
       // namespace and cannot grow unbounded.
       this.inFlightResolved.set(namespace, storageDir);
-      Promise.resolve(hook(namespace, storageDir)).then(
+      const hookResult = Promise.resolve(hook(namespace, storageDir));
+      // Track the in-flight promise so `whenResolveHooksSettled()` can await it.
+      this.pendingResolveHooks.add(hookResult);
+      hookResult.then(
         (persisted) => {
           // Clear the in-flight marker ONLY if it is still ours (a newer resolve
           // for a different dir may have replaced it).
@@ -338,6 +346,7 @@ export class NamespaceStorageRouter {
           // On `false` (dropped touch) we intentionally do NOT mark notified, so
           // a later `storageFor()` retries the registration. Clearing the
           // in-flight marker above is what re-enables that retry.
+          this.pendingResolveHooks.delete(hookResult);
         },
         () => {
           // Registration failed — clear in-flight AND do NOT mark as notified, so
@@ -348,6 +357,7 @@ export class NamespaceStorageRouter {
           if (this.notifiedResolved.get(namespace) === storageDir) {
             this.notifiedResolved.delete(namespace);
           }
+          this.pendingResolveHooks.delete(hookResult);
         },
       );
     } catch {
@@ -358,4 +368,21 @@ export class NamespaceStorageRouter {
       }
     }
   }
+
+  /**
+   * Resolve once every in-flight `onResolve` registration has settled.
+   *
+   * `storageFor()` fires the resolve hook fire-and-forget, so its catalog side
+   * effect (e.g. `registerResolved(...)`) is not observable the moment
+   * `storageFor()` returns. Callers that must act on that side effect — notably
+   * tests asserting the catalog was updated — should await this instead of
+   * racing a timer. Resolves immediately when no hook is registered or nothing
+   * is in flight. The loop re-checks because a settling hook could, in
+   * principle, trigger a follow-on resolution.
+   */
+  async whenResolveHooksSettled(): Promise<void> {
+    while (this.pendingResolveHooks.size > 0) {
+      await Promise.allSettled([...this.pendingResolveHooks]);
+    }
+  }
 }