@remnic/core 9.45.3 → 9.45.5

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

@@ -27,6 +27,7 @@ import { log } from "../logger.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
 import { NegativeExampleStore } from "../negative.js";
 import { qmdCollectionPathParts } from "./qmd-result-resolver.js";
+import type { RecallRerankCoordinator, RecallResultPartitionSink } from "./recall-rerank-coordinator.js";
 import type { GraphRecallExpandedEntry } from "../recall-state.js";
 import { RelevanceStore } from "../relevance.js";
 import { RerankCache, rerankLocalOrNoop, reorderByRankedKeys } from "../rerank.js";
@@ -90,6 +91,7 @@ export interface RecallSearchPipelineDeps {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]>;
   buildConfiguredQmdSearchOptions(
@@ -100,6 +102,7 @@ export interface RecallSearchPipelineDeps {
     recallNamespaces: string[],
   ): Promise<QueryAwarePrefilter>;
   readonly config: PluginConfig;
+  readonly recallRerankCoordinator: Pick<RecallRerankCoordinator, "diversifyRecallResultsWithHeadroom">;
   diversifyAndLimitRecallResults(
     sectionId: string,
     results: QmdSearchResult[],
@@ -152,6 +155,7 @@ export interface RecallSearchPipelineDeps {
       allowDedicatedSurface?: boolean;
       asOfMs?: number;
       blockedPaths?: Set<string>;
+      requestingConnector?: string;
     },
   ): QmdSearchResult[];
   filterSearchResultsForRecall(
@@ -165,6 +169,7 @@ export interface RecallSearchPipelineDeps {
       abortSignal?: AbortSignal;
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
+      requestingConnector?: string;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }>;
   loadSearchResultMemoryMap(
@@ -719,6 +724,7 @@ export class RecallSearchPipelineCoordinator {
     onDegradation?: (degradation: SearchDegradation) => void;
     /** Issue #680 — historical recall point in ms-since-epoch. */
     asOfMs?: number;
+    requestingConnector?: string;
     /**
      * Optional out-parameter that receives the pre-MMR / pre-truncation
      * pool size captured inside the pipeline (issue #570 PR 1).  The
@@ -728,6 +734,7 @@ export class RecallSearchPipelineCoordinator {
      * Unset by default so existing call sites are unaffected.
      */
     xrayPoolSizeSink?: { size: number };
+    resultPartitionSink?: RecallResultPartitionSink;
     /**
      * Issue #1577 — out-parameter that receives the TrustScore stage's
      * per-path trust map (admitted + quarantined) when the cold path runs
@@ -983,6 +990,7 @@ export class RecallSearchPipelineCoordinator {
         abortSignal: options.abortSignal,
         dropUnresolved: true,
         recallNamespaces: options.recallNamespaces,
+        requestingConnector: options.requestingConnector,
       },
     );
     results = boostInput.results;
@@ -1000,7 +1008,11 @@ export class RecallSearchPipelineCoordinator {
                 options.recallNamespaces,
                 options.prompt,
                 boostInput.memoryByPath,
-                { allowLifecycleFiltered: true, asOfMs: options.asOfMs },
+                {
+                  allowLifecycleFiltered: true,
+                  asOfMs: options.asOfMs,
+                  requestingConnector: options.requestingConnector,
+                },
               ),
               new Promise<{ status: "timed_out" }>((resolve) => {
                 timeoutHandle = setTimeout(
@@ -1014,7 +1026,11 @@ export class RecallSearchPipelineCoordinator {
               options.recallNamespaces,
               options.prompt,
               boostInput.memoryByPath,
-              { allowLifecycleFiltered: true, asOfMs: options.asOfMs },
+              {
+                allowLifecycleFiltered: true,
+                asOfMs: options.asOfMs,
+                requestingConnector: options.requestingConnector,
+              },
             ));
         if (
           typeof boosted === "object" &&
@@ -1066,10 +1082,6 @@ export class RecallSearchPipelineCoordinator {
       );
     }
 
-    // Trust-reweighting — must fire on the cold fallback path too, or the
-    // feature flag produces divergent behavior by retrieval path (rule 39).
-    // TrustScore subsumes the Memory Worth multiplier; run exactly one.
-    // Fail-open on lookup errors.
     if (caps.recallTrustScore && results.length > 0) {
       try {
         const trustOutcome = await this.deps.applyTrustScoreRerank(results, options.recallNamespaces, boostInput.memoryByPath);
@@ -1090,16 +1102,23 @@ export class RecallSearchPipelineCoordinator {
       }
     }
 
-    // Apply MMR before final truncation so the cold fallback path mirrors
-    // the diversification policy applied in the hot QMD/embedding/recent
-    // paths. Running MMR post-slice would be unable to promote diverse
-    // candidates sitting just below the cutoff.
     if (options.xrayPoolSizeSink) {
       options.xrayPoolSizeSink.size = Math.max(
         options.xrayPoolSizeSink.size,
         results.length,
       );
     }
+    if (options.resultPartitionSink) {
+      const partition = this.deps.recallRerankCoordinator.diversifyRecallResultsWithHeadroom(
+        "memories",
+        results,
+        options.recallResultLimit,
+        options.prompt,
+        caps,
+      );
+      options.resultPartitionSink.partition = partition;
+      return partition.appliedResults;
+    }
     return this.deps.diversifyAndLimitRecallResults(
       "memories",
       results,
@@ -1225,6 +1244,7 @@ export class RecallSearchPipelineCoordinator {
       allowDedicatedSurface?: boolean;
       asOfMs?: number;
       blockedPaths?: Set<string>;
+      requestingConnector?: string;
     },
   ): QmdSearchResult[] {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.deps.config);
@@ -1234,6 +1254,7 @@ export class RecallSearchPipelineCoordinator {
     let dedicatedSurfaceFilteredCount = 0;
     let forgottenFilteredCount = 0;
     let blockedPathFilteredCount = 0;
+    let connectorPartitionFilteredCount = 0;
     const filtered: QmdSearchResult[] = [];
     for (const r of results) {
       if (options?.blockedPaths && resultHasKey(options.blockedPaths, r)) {
@@ -1242,6 +1263,18 @@ export class RecallSearchPipelineCoordinator {
       }
       const memory = memoryForResult(memoryByPath, r);
       if (memory) {
+        const memoryConnector = memory.frontmatter.sourceConnector?.trim();
+        const requestingConnector = options?.requestingConnector?.trim();
+        if (
+          lifecycleCaps.extractionScopeClassification &&
+          memory.frontmatter.toolScoped === true &&
+          memoryConnector &&
+          requestingConnector &&
+          memoryConnector !== requestingConnector
+        ) {
+          connectorPartitionFilteredCount += 1;
+          continue;
+        }
         // Review-lifecycle statuses never enter active recall injection
         // (forgotten, pending_review, rejected, quarantined). Superseded and
         // archived have dedicated filters below. #1576: the faithfulness gate
@@ -1349,6 +1382,11 @@ export class RecallSearchPipelineCoordinator {
         sourceConnector: memory ? memory.frontmatter.sourceConnector : undefined,
       });
     }
+    if (connectorPartitionFilteredCount > 0) {
+      log.debug(
+        `connector partition filter removed ${connectorPartitionFilteredCount} tool-scoped candidates from recall`,
+      );
+    }
     if (lifecycleFilteredCount > 0) {
       log.debug(
         `lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`,
@@ -1393,6 +1431,7 @@ export class RecallSearchPipelineCoordinator {
       abortSignal?: AbortSignal;
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
+      requestingConnector?: string;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }> {
     if (results.length === 0) {
@@ -1455,6 +1494,7 @@ export class RecallSearchPipelineCoordinator {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]> {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.deps.config);

package/src/orchestrator-convergence-refresh.test.ts

@@ -27,7 +27,7 @@ test("refreshNamespacesAfterConvergence runs one strict QMD batch and rebuilds e
     const storageCalls: string[] = [];
     const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
     const internals = orchestrator as unknown as {
-      config: { defaultNamespace: string };
+      config: { defaultNamespace: string; qmdEnabled: boolean };
       namespaceSearchRouter: {
         updateNamespacesDetailed(
           namespaces: string[],
@@ -37,7 +37,7 @@ test("refreshNamespacesAfterConvergence runs one strict QMD batch and rebuilds e
       };
       getStorage(namespace: string): Promise<StorageManager>;
     };
-    internals.config = { defaultNamespace: "default" };
+    internals.config = { defaultNamespace: "default", qmdEnabled: true };
     internals.namespaceSearchRouter = {
       async updateNamespacesDetailed(namespaces, _execution, options) {
         qmdCalls.push({ namespaces, options });
@@ -85,6 +85,7 @@ test("refreshNamespacesAfterConvergence rebuilds projection when search is disab
     });
     const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
     const internals = orchestrator as unknown as {
+      config: { qmdEnabled: boolean; searchBackend: "qmd" };
       namespaceSearchRouter: {
         updateNamespacesDetailed(
           namespaces: string[],
@@ -94,6 +95,7 @@ test("refreshNamespacesAfterConvergence rebuilds projection when search is disab
       };
       getStorage(namespace: string): Promise<StorageManager>;
     };
+    internals.config = { qmdEnabled: false, searchBackend: "qmd" };
     internals.namespaceSearchRouter = {
       async updateNamespacesDetailed() {
         return { backendCount: 0, eligibleNamespaces: [] };
@@ -112,3 +114,35 @@ test("refreshNamespacesAfterConvergence rebuilds projection when search is disab
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("refreshNamespacesAfterConvergence rejects skipped namespaces when search is enabled", async () => {
+  const storageCalls: string[] = [];
+  const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
+  const internals = orchestrator as unknown as {
+    config: { qmdEnabled: boolean };
+    namespaceSearchRouter: {
+      updateNamespacesDetailed(
+        namespaces: string[],
+        execution?: unknown,
+        options?: { strict?: boolean },
+      ): Promise<{ backendCount: number; eligibleNamespaces: string[] }>;
+    };
+    getStorage(namespace: string): Promise<StorageManager>;
+  };
+  internals.config = { qmdEnabled: true };
+  internals.namespaceSearchRouter = {
+    async updateNamespacesDetailed() {
+      return { backendCount: 1, eligibleNamespaces: ["default"] };
+    },
+  };
+  internals.getStorage = async (namespace) => {
+    storageCalls.push(namespace);
+    throw new Error("projection rebuild must not run after incomplete search refresh");
+  };
+
+  await assert.rejects(
+    () => orchestrator.refreshNamespacesAfterConvergence(["default", "team"]),
+    /search refresh skipped namespaces: team/,
+  );
+  assert.deepEqual(storageCalls, []);
+});

package/src/orchestrator.ts

@@ -76,6 +76,7 @@ import type {
 import {
   createSearchBackend,
   createConversationIndexRuntime,
+  isSearchBackendEnabled,
 } from "./search/factory.js";
 import { NoopSearchBackend } from "./search/noop-backend.js";
 import {
@@ -102,7 +103,7 @@ import { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coo
 import { EntitySynthesisCoordinator } from "./orchestration/entity-synthesis-coordinator.js";
 import { RecallResultFormatter } from "./orchestration/recall-result-formatter.js";
 import { ConversationIndexCoordinator } from "./orchestration/conversation-index-coordinator.js";
-import { RecallRerankCoordinator } from "./orchestration/recall-rerank-coordinator.js";
+import { RecallRerankCoordinator, type RecallResultPartitionSink } from "./orchestration/recall-rerank-coordinator.js";
 import {
   RecallSectionCoordinator,
   type RecallSectionAppendOptions,
@@ -1280,7 +1281,12 @@ export class Orchestrator {
   }
 
   async refreshNamespacesAfterConvergence(namespaces: readonly string[]): Promise<void> {
-    return refreshConvergedNamespaces(namespaces, this.namespaceSearchRouter, this.getStorage.bind(this));
+    return refreshConvergedNamespaces(
+      namespaces,
+      this.namespaceSearchRouter,
+      this.getStorage.bind(this),
+      isSearchBackendEnabled(this.config),
+    );
   }
 
 
@@ -3506,7 +3512,6 @@ export class Orchestrator {
       abortSignal,
     );
   }
-
   private diversifyAndLimitRecallResults(
     sectionId: string,
     results: QmdSearchResult[],
@@ -3634,6 +3639,7 @@ export class Orchestrator {
     onDegradation?: (degradation: SearchDegradation) => void;
     /** Issue #680 — historical recall point in ms-since-epoch. */
     asOfMs?: number;
+    requestingConnector?: string;
     /**
      * Optional out-parameter that receives the pre-MMR / pre-truncation
      * pool size captured inside the pipeline (issue #570 PR 1).  The
@@ -3643,6 +3649,7 @@ export class Orchestrator {
      * Unset by default so existing call sites are unaffected.
      */
     xrayPoolSizeSink?: { size: number };
+    resultPartitionSink?: RecallResultPartitionSink;
     /**
      * Issue #1577 — out-parameter that receives the TrustScore stage's
      * per-path trust map (admitted + quarantined) when the cold path runs
@@ -3713,6 +3720,7 @@ export class Orchestrator {
       allowDedicatedSurface?: boolean;
       asOfMs?: number;
       blockedPaths?: Set<string>;
+      requestingConnector?: string;
     },
   ): QmdSearchResult[] {
     return this.recallSearchPipelineCoordinator.filterSearchResultsByRecallSafety(
@@ -3733,6 +3741,7 @@ export class Orchestrator {
       abortSignal?: AbortSignal;
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
+      requestingConnector?: string;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }> {
     return this.recallSearchPipelineCoordinator.filterSearchResultsForRecall(
@@ -3758,6 +3767,7 @@ export class Orchestrator {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]> {
     return this.recallSearchPipelineCoordinator.boostSearchResults(

package/src/page-versioning.ts

@@ -31,6 +31,7 @@ import {
   pathMayCarryEntityRefs,
   requestEntityCanonicalIdReconcile,
 } from "./storage/entity-canonical-id-references.js";
+import { withRawEntityPageMutation } from "./storage/entity-canonical-id-lock.js";
 
 // ---------------------------------------------------------------------------
 // Public interfaces
@@ -335,28 +336,13 @@ export async function revertToVersion(
     resolvedMemoryDir,
   );
 
-  // Write the reverted content to the actual page
-  await writeFile(pagePath, targetContent, "utf-8");
-  // A revert overwrites a memory file out-of-band (not via a StorageManager
-  // mutation), so bump the corpus sentinel when the reverted page lives under a
-  // recall category dir — forcing a warm hot-memories cache to rescan on its
-  // next read (issue #1902, Codex P1). Non-recall pages (entities/artifacts/
-  // profiles) are not in the corpus scan, so they need no bump.
-  // The hot-memories corpus covers the RECALL corpus, which excludes the
-  // non-memory queue dirs (questions/). Use RECALL_FALLBACK_DIRS — a revert of a
-  // questions/ page must NOT bump the recall corpus sentinel and force a rescan.
+  await withRawEntityPageMutation(resolvedMemoryDir, pagePath, async () => {
+    await writeFile(pagePath, targetContent, "utf-8");
+  });
   const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];
-  const inRecallTier = (RECALL_FALLBACK_DIRS as readonly string[]).includes(revertedTop);
-  if (inRecallTier) {
+  if ((RECALL_FALLBACK_DIRS as readonly string[]).includes(revertedTop)) {
     bumpMemoryCorpusVersionForDir(resolvedMemoryDir);
   }
-  // A pre-migration snapshot can reintroduce a legacy entityRef — or, under
-  // entities/, a legacy relationship target rewriteRelationshipTargets had
-  // migrated — that the target's completed journal already renamed (issue
-  // #2213); the revert keeps the snapshot bytes faithful, so request one
-  // bounded reconcile pass instead. pathMayCarryEntityRefs is the migration's
-  // own scan scope (hot recall + cold + archive + entities), which is wider
-  // than the corpus bump above on purpose.
   if (pathMayCarryEntityRefs(resolvedMemoryDir, pagePath)) {
     await requestEntityCanonicalIdReconcile(path.join(resolvedMemoryDir, "state"));
   }

package/src/procedural/procedure-recall.ts

@@ -6,6 +6,7 @@ import type { MemoryFile, PluginConfig } from "../types.js";
 import type { StorageManager } from "../storage.js";
 import { inferIntentFromText, intentCompatibilityScore, isTaskInitiationIntent } from "../intent.js";
 import { isActiveMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
+import { canRecallToolScopedMemory } from "../tool-scoped-memory.js";
 
 function tokenOverlapScore(prompt: string, memoryText: string): number {
   const norm = (s: string) =>
@@ -44,6 +45,7 @@ export async function buildProcedureRecallSection(
   storage: StorageManager,
   prompt: string,
   config: PluginConfig,
+  options?: { partitionToolScoped?: boolean; requestingConnector?: string },
 ): Promise<string | null> {
   if (config.procedural?.enabled !== true) return null;
   const trimmed = typeof prompt === "string" ? prompt.trim() : "";
@@ -72,7 +74,9 @@ export async function buildProcedureRecallSection(
     .filter(
       (m) =>
         m.frontmatter.category === "procedure" &&
-        isActiveMemoryStatus(m.frontmatter.status),
+        isActiveMemoryStatus(m.frontmatter.status) &&
+        (options?.partitionToolScoped !== true ||
+          canRecallToolScopedMemory(m.frontmatter, options.requestingConnector)),
     )
     .map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent) }))
     .filter((x) => x.score > 0.04)

package/src/provenance-surfaces.test.ts

@@ -44,6 +44,9 @@ function snapshotWithSourceSpan(): RecallXraySnapshot {
     snapshotId: "22222222-2222-2222-2222-222222222222",
     tierExplain: null,
     results: [resultWithSourceSpan()],
+    appliedResultLimit: 0,
+    appliedResults: [],
+    headroomResults: [],
     filters: [{ name: "recall-result-limit", considered: 1, admitted: 1 }],
     budget: { chars: 4096, used: 100 },
   };

package/src/qmd-client.test.ts

@@ -13,11 +13,7 @@ test("QmdClient rechecks daemon availability before returning unavailable", asyn
     available: boolean;
     daemonAvailable: boolean;
     probeDaemon: () => Promise<boolean>;
-    searchViaDaemon: (
-      query: string,
-      collection: string | undefined,
-      maxResults: number,
-    ) => Promise<QmdSearchResult[]>;
+    searchViaDaemon: (query: string, collection: string | undefined, maxResults: number) => Promise<QmdSearchResult[]>;
   };
   let probeCount = 0;
   internals.available = false;
@@ -49,13 +45,9 @@ type SubprocessInternals = {
   runQmdCommand: (
     args: string[],
     timeoutMs?: number,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ) => Promise<{ stdout: string; stderr: string }>;
-  searchViaSubprocess: (
-    query: string,
-    collection: string,
-    maxResults: number,
-  ) => Promise<QmdSearchResult[]>;
+  searchViaSubprocess: (query: string, collection: string, maxResults: number) => Promise<QmdSearchResult[]>;
   searchGlobalViaSubprocess: (query: string, maxResults: number) => Promise<QmdSearchResult[]>;
 };
 
@@ -79,7 +71,7 @@ test("updateStrict respects QMD update min-interval throttles", async () => {
     await client.updateStrict();
     await assert.rejects(
       () => client.updateStrict(),
-      /QMD update skipped by min-interval gate|QMD update skipped by global min-interval gate/,
+      /QMD update skipped by min-interval gate|QMD update skipped by global min-interval gate/
     );
   } finally {
     client.resetUpdateThrottles();
@@ -100,10 +92,7 @@ test("embedCollectionStrict rejects QMD embed subprocess failures", async () =>
   };
 
   try {
-    await assert.rejects(
-      () => client.embedCollectionStrict("memories--project"),
-      /embed subprocess failed/,
-    );
+    await assert.rejects(() => client.embedCollectionStrict("memories--project"), /embed subprocess failed/);
   } finally {
     client.resetUpdateThrottles();
   }
@@ -120,7 +109,7 @@ test("embedCollectionStrict respects QMD embed min-interval throttles", async ()
     await client.embedCollectionStrict("memories--project");
     await assert.rejects(
       () => client.embedCollectionStrict("memories--project"),
-      /QMD embed skipped by per-collection min-interval gate/,
+      /QMD embed skipped by per-collection min-interval gate/
     );
   } finally {
     client.resetUpdateThrottles();
@@ -198,6 +187,78 @@ test("ensureCollection rechecks collection state after auto-create failure", asy
   ]);
 });
 
+test("QmdClient advertises isolated additional collection support", () => {
+  const client = new QmdClient("memories", 3, {});
+
+  assert.equal(client.supportsAdditionalCollections(), true);
+});
+
+test("QmdClient excludes a dedicated collection from global search", async () => {
+  const client = new QmdClient("memories", 3, {});
+  const calls = captureSubprocessArgs(client);
+  const controller = new AbortController();
+
+  await client.excludeCollectionFromGlobalSearch("external-wiki-reading", {
+    signal: controller.signal,
+  });
+
+  assert.deepEqual(calls, [["collection", "exclude", "external-wiki-reading"]]);
+});
+
+test("QmdClient reports status for a named collection", async () => {
+  const client = new QmdClient("memories", 3, {});
+  const internals = client as unknown as SubprocessInternals & {
+    qmdCapabilities: { safeStatusDeviceProbe: boolean };
+  };
+  const calls: string[][] = [];
+  internals.available = true;
+  internals.qmdCapabilities = { safeStatusDeviceProbe: true };
+  internals.runQmdCommand = async (args) => {
+    calls.push(args);
+    return { stdout: "Total: 12\nVectors: 10\nPending: 2", stderr: "" };
+  };
+
+  const status = await client.collectionStatus("external-wiki-reading");
+
+  assert.equal(status.totalFiles, 12);
+  assert.deepEqual(calls, [["status", "-c", "external-wiki-reading"]]);
+});
+
+test("QmdClient reports the configured root for a named collection", async () => {
+  const client = new QmdClient("memories", 3, {});
+  const internals = client as unknown as SubprocessInternals;
+  const calls: string[][] = [];
+  internals.available = true;
+  internals.runQmdCommand = async (args) => {
+    calls.push(args);
+    return {
+      stdout: [
+        "Collection: external-wiki-reading",
+        "  Path:     /srv/reading/wiki",
+        "  Pattern:  **/*.md",
+        "  Include:  no",
+      ].join("\n"),
+      stderr: "",
+    };
+  };
+
+  const root = await client.collectionRoot("external-wiki-reading");
+
+  assert.equal(root, "/srv/reading/wiki");
+  assert.deepEqual(calls, [["collection", "show", "external-wiki-reading"]]);
+});
+
+test("QmdClient removes a dedicated collection but refuses its primary collection", async () => {
+  const client = new QmdClient("memories", 3, {});
+  const calls = captureSubprocessArgs(client);
+
+  await assert.rejects(() => client.deleteCollection("memories"), /primary QMD collection/i);
+  const removed = await client.deleteCollection("external-wiki-reading");
+
+  assert.equal(removed, true);
+  assert.deepEqual(calls, [["collection", "remove", "external-wiki-reading"]]);
+});
+
 test("subprocess fallback defaults to `qmd query` for scoped and global recall", async () => {
   const client = new QmdClient("memories", 3, {});
   const calls = captureSubprocessArgs(client);

package/src/qmd.test.ts

@@ -12,6 +12,7 @@ import {
   parseQmdVersion,
   parseQmdExplain,
   resolveQmdCapabilities,
+  QmdClient,
   shouldAutoUpgradeQmd,
 } from "./qmd.js";
 
@@ -183,6 +184,29 @@ test("QmdClient preserves configured qmdPath diagnostics when all probes fail",
   }
 });
 
+test("QmdClient strict configured path never probes PATH or fallback binaries", async () => {
+  const configuredPath = "/explicit/benchmark/qmd";
+  const probedPaths: string[] = [];
+  const client = new QmdClient("test-collection", 10, {
+    qmdPath: configuredPath,
+    qmdFallbackPaths: ["/implicit/fallback/qmd"],
+    qmdStrictPath: true,
+  });
+  const internals = client as unknown as {
+    runVersionProbe: (qmdPath: string) => Promise<{ stdout: string; stderr: string }>;
+  };
+  internals.runVersionProbe = async (qmdPath: string) => {
+    probedPaths.push(qmdPath);
+    if (qmdPath === configuredPath) {
+      throw Object.assign(new Error("configured binary missing"), { code: "ENOENT" });
+    }
+    return { stdout: "qmd 2.5.3", stderr: "" };
+  };
+
+  assert.equal(await client.probe(), false);
+  assert.deepEqual(probedPaths, [configuredPath]);
+});
+
 test("QmdClient read-only availability failures preserve operational state", async () => {
   const { QmdClient } = await import("./qmd.js");
   const originalPath = process.env.PATH;