@remnic/core 9.3.665 → 9.3.667

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/orchestrator.ts

@@ -245,6 +245,7 @@ import {
   type TrustZoneSearchResult,
 } from "./trust-zones.js";
 import { tryDirectAnswer, type DirectAnswerSources } from "./direct-answer-wiring.js";
+import { resolveCapabilities, type CapabilitySet } from "./capabilities.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/index.js";
 import {
   searchHarmonicRetrieval,
@@ -1376,6 +1377,13 @@ export function resolveRecallModeDecision(options: RecallModeGraphOptions): Reca
 export async function resolveRecallModeDecisionAsync(
   options: RecallModeGraphOptions & {
     config: PluginConfig;
+    /**
+     * Recall-operation capability gates (issue #1523). OPTIONAL and additive:
+     * the recall orchestrator passes a resolved set, but existing callers that
+     * only pass `config` + planner flags stay backward-compatible — the LLM
+     * planner gate falls back to `config.recallPlannerLlmEnabled` when omitted.
+     */
+    caps?: CapabilitySet;
     hints?: string[];
     llm?: FallbackLlmClient;
     signal?: AbortSignal;
@@ -1384,7 +1392,11 @@ export async function resolveRecallModeDecisionAsync(
   const heuristicDecision = resolveRecallModeDecision(options);
 
   // Planner globally off, or LLM planning not opted into → heuristic only.
-  if (!options.plannerEnabled || !options.config.recallPlannerLlmEnabled) {
+  // Prefer the resolved capability when supplied; otherwise fall back to the
+  // config flag so callers on the old option shape get identical gating.
+  const plannerLlmEnabled =
+    options.caps?.recallPlannerLlm ?? options.config.recallPlannerLlmEnabled;
+  if (!options.plannerEnabled || !plannerLlmEnabled) {
     return heuristicDecision;
   }
 
@@ -1395,6 +1407,7 @@ export async function resolveRecallModeDecisionAsync(
     options.config,
     options.llm,
     options.signal,
+    options.caps,
   );
 
   // Shadow mode: record what the LLM would have chosen but keep the heuristic
@@ -5738,6 +5751,10 @@ export class Orchestrator {
     sessionKey?: string,
     options: RecallInvocationOptions = {},
   ): Promise<string> {
+    // Resolve the recall-operation capability gates ONCE, at the operation
+    // entry, and thread the frozen set down (issue #1523). Never re-read the
+    // migrated flags off `this.config` mid-operation.
+    const caps = resolveCapabilities(this.config);
     const abortController = new AbortController();
     const onAbort = () => {
       abortController.abort();
@@ -5813,7 +5830,7 @@ export class Orchestrator {
       const recallPromise = this.recallInternal(prompt, sessionKey, {
         ...options,
         abortSignal: abortController.signal,
-      });
+      }, caps);
       const RECALL_TIMEOUT_MS = this.config.recallOuterTimeoutMs ?? 75_000;
       if (RECALL_TIMEOUT_MS <= 0) {
         return await recallPromise;
@@ -5837,13 +5854,14 @@ export class Orchestrator {
       // Observation-mode direct-answer tier (issue #518 slice 3c).
       // Runs after the user's recall already succeeded, fire-and-forget,
       // so annotation latency can never delay the caller's response.
-      if (this.config.recallDirectAnswerEnabled && sessionKey) {
+      if (caps.recallDirectAnswer && sessionKey) {
         try {
           this.enqueueDirectAnswerObservation(
             prompt,
             sessionKey,
             options.namespace?.trim() || undefined,
             options.principalOverride,
+            caps,
           );
         } catch (err) {
           log.debug(`direct-answer observation setup failed: ${err}`);
@@ -5912,6 +5930,7 @@ export class Orchestrator {
     sessionKey: string,
     namespaceOverride: string | undefined,
     principalOverride: string | undefined,
+    caps: CapabilitySet,
   ): void {
     const expectedSnapshot = this.lastRecall.get(sessionKey);
     if (expectedSnapshot === null) return;
@@ -5992,6 +6011,7 @@ export class Orchestrator {
             sessionKey,
             observationNamespaces,
             expectedIdentity,
+            caps,
             undefined,
           );
         } catch (err) {
@@ -6007,6 +6027,7 @@ export class Orchestrator {
     expectedIdentity:
       | { writeNonce?: string; traceId?: string; recordedAt?: string }
       | undefined,
+    caps: CapabilitySet,
     _parentAbortSignal?: AbortSignal,
   ): Promise<void> {
     const tierStart = Date.now();
@@ -6091,6 +6112,7 @@ export class Orchestrator {
           query: prompt,
           namespace: ns,
           config: this.config,
+          enabled: caps.recallDirectAnswer,
           sources,
         });
         if (r.eligible && r.winner) {
@@ -7273,10 +7295,22 @@ export class Orchestrator {
     };
   }
 
+  /**
+   * Clock source for the shared post-retrieval assembly/enrichment budget. The
+   * deadline is set from this value and every expiry check reads it back, so a
+   * test can drive the budget deterministically instead of racing the few-ms
+   * wall-clock window that made the "skips … after budget expires" tests flaky.
+   * Production behavior is unchanged — it returns the wall clock.
+   */
+  protected recallAssemblyClockMs(): number {
+    return Date.now();
+  }
+
   private async recallInternal(
     prompt: string,
     sessionKey?: string,
     options: RecallInvocationOptions = {},
+    caps: CapabilitySet = resolveCapabilities(this.config),
   ): Promise<string> {
     const recallStart = Date.now();
     // Backend degradations observed by this recall's QMD searches (#1536):
@@ -7436,11 +7470,10 @@ export class Orchestrator {
     let identityInjectionTruncated = false;
     timings.queryPolicy = `${queryPolicy.promptShape}/${queryPolicy.retrievalBudgetMode}${queryPolicy.skipConversationRecall ? "/skip-conv" : ""}`;
     const recallModeDecisionOptions = {
-      plannerEnabled: this.config.recallPlannerEnabled,
-      graphRecallEnabled: this.config.graphRecallEnabled,
+      plannerEnabled: caps.recallPlanner,
+      graphRecallEnabled: caps.graphRecall,
       multiGraphMemoryEnabled: this.config.multiGraphMemoryEnabled,
-      graphExpandedIntentEnabled:
-        this.config.graphExpandedIntentEnabled === true,
+      graphExpandedIntentEnabled: caps.graphExpandedIntent,
       prompt,
     };
     const requestedMode = options.mode;
@@ -7454,6 +7487,7 @@ export class Orchestrator {
         : await resolveRecallModeDecisionAsync({
             ...recallModeDecisionOptions,
             config: this.config,
+            caps,
             signal: options.abortSignal,
           });
     if (
@@ -7779,7 +7813,7 @@ export class Orchestrator {
       promptLength: prompt.length,
       retrievalQueryHash,
       retrievalQueryLength: retrievalQuery.length,
-      plannerEnabled: this.config.recallPlannerEnabled,
+      plannerEnabled: caps.recallPlanner,
       plannedMode: requestedMode ?? recallDecision.plannedMode,
       effectiveMode: recallMode,
       recallResultLimit,
@@ -7790,7 +7824,7 @@ export class Orchestrator {
         reason: graphDecisionReason,
         shadowMode: graphDecisionShadowMode,
         qmdAvailable,
-        graphRecallEnabled: this.config.graphRecallEnabled,
+        graphRecallEnabled: caps.graphRecall,
         multiGraphMemoryEnabled: this.config.multiGraphMemoryEnabled,
       },
     });
@@ -10238,7 +10272,7 @@ export class Orchestrator {
 
     const enrichmentAssemblyDeadlineAtMs =
       enrichmentSectionDeadlineMs > 0
-        ? Date.now() + enrichmentSectionDeadlineMs
+        ? this.recallAssemblyClockMs() + enrichmentSectionDeadlineMs
         : null;
 
     const awaitEnrichmentSection = async <T>(
@@ -10280,7 +10314,7 @@ export class Orchestrator {
       const timeoutMs =
         enrichmentAssemblyDeadlineAtMs === null
           ? null
-          : Math.max(0, enrichmentAssemblyDeadlineAtMs - Date.now());
+          : Math.max(0, enrichmentAssemblyDeadlineAtMs - this.recallAssemblyClockMs());
       if (timeoutMs === 0) {
         const settledOutcome = promise.getSettledOutcome();
         if (settledOutcome) {
@@ -10326,7 +10360,7 @@ export class Orchestrator {
     const remainingEnrichmentAssemblyMs = (): number | null =>
       enrichmentAssemblyDeadlineAtMs === null
         ? null
-        : Math.max(0, enrichmentAssemblyDeadlineAtMs - Date.now());
+        : Math.max(0, enrichmentAssemblyDeadlineAtMs - this.recallAssemblyClockMs());
 
     const awaitAssemblyStep = async <T>(
       name: string,
@@ -11012,7 +11046,7 @@ export class Orchestrator {
 
       const isFullModeGraphAssist =
         this.config.multiGraphMemoryEnabled &&
-        this.config.graphAssistInFullModeEnabled !== false &&
+        caps.graphAssistInFullMode &&
         recallMode === "full" &&
         memoryResults.length >=
           Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
@@ -11192,7 +11226,7 @@ export class Orchestrator {
           timeoutMs: this.config.rerankTimeoutMs,
           maxCandidates: this.config.rerankMaxCandidates,
           cache: this.rerankCache,
-          cacheEnabled: this.config.rerankCacheEnabled,
+          cacheEnabled: caps.rerankCache,
           cacheTtlMs: this.config.rerankCacheTtlMs,
         });
         if (ranked && ranked.length > 0) {
@@ -11222,7 +11256,7 @@ export class Orchestrator {
       // flips the default once bench shows tie-or-win. Fail-open: any
       // lookup error leaves the original scores untouched rather than
       // breaking recall for the whole namespace.
-      if (this.config.recallMemoryWorthFilterEnabled && memoryResults.length > 0) {
+      if (caps.recallMemoryWorthFilter && memoryResults.length > 0) {
         try {
           memoryResults = await this.applyMemoryWorthRerank(memoryResults, recallNamespaces);
         } catch (err) {
@@ -11260,7 +11294,7 @@ export class Orchestrator {
         memoryResults.length,
       );
       let confidenceGateRejected = false;
-      if (this.config.recallConfidenceGateEnabled && effectiveGateScore > 0) {
+      if (caps.recallConfidenceGate && effectiveGateScore > 0) {
         if (effectiveGateScore < this.config.recallConfidenceGateThreshold) {
           log.debug(
             `recall: confidence gate rejected ${memoryResults.length} results (effective score ${effectiveGateScore.toFixed(3)} below ${this.config.recallConfidenceGateThreshold})`,
@@ -11278,6 +11312,7 @@ export class Orchestrator {
         memoryResults,
         recallResultLimit,
         retrievalQuery,
+        caps,
       );
 
       // E-Mem-inspired memory reconstruction: fill gaps for referenced entities
@@ -11394,6 +11429,7 @@ export class Orchestrator {
               boostedScoped,
               recallResultLimit,
               retrievalQuery,
+              caps,
             );
           },
           [] as QmdSearchResult[],
@@ -11431,6 +11467,7 @@ export class Orchestrator {
             recallNamespaces,
             recallResultLimit,
             recallMode,
+            caps,
             queryAwarePrefilter,
             abortSignal: options.abortSignal,
             onDegradation: (degradation) => {
@@ -11551,6 +11588,7 @@ export class Orchestrator {
               boostedScoped,
               recallResultLimit,
               retrievalQuery,
+              caps,
             );
           },
           [] as QmdSearchResult[],
@@ -11656,6 +11694,7 @@ export class Orchestrator {
               recallNamespaces,
               recallResultLimit,
               recallMode,
+              caps,
               queryAwarePrefilter,
               abortSignal: options.abortSignal,
               onDegradation: (degradation) => {
@@ -11730,6 +11769,7 @@ export class Orchestrator {
                   boostedRecent,
                   recallResultLimit,
                   retrievalQuery,
+                  caps,
                 );
               },
               [] as QmdSearchResult[],
@@ -11768,6 +11808,7 @@ export class Orchestrator {
                 recallNamespaces,
                 recallResultLimit,
                 recallMode,
+                caps,
                 queryAwarePrefilter,
                 abortSignal: options.abortSignal,
                 onDegradation: (degradation) => {
@@ -11815,6 +11856,7 @@ export class Orchestrator {
             recallNamespaces,
             recallResultLimit,
             recallMode,
+            caps,
             queryAwarePrefilter,
             abortSignal: options.abortSignal,
             onDegradation: (degradation) => {
@@ -18361,6 +18403,11 @@ export class Orchestrator {
     results: QmdSearchResult[],
     limit: number,
     retrievalQuery?: string,
+    // `caps` is additive AND last (issue #1523) so the positional call shape
+    // stays backward-compatible: the recall pipeline threads a resolved set,
+    // but callers that omit it (e.g. direct unit-test invocations) get an
+    // equivalent set derived from the same config — behavior-preserving.
+    caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
     const safeLimit =
       typeof limit === "number" && Number.isFinite(limit)
@@ -18377,13 +18424,13 @@ export class Orchestrator {
     // facts/decisions before MMR picks the final section. No-op when the
     // flag is off or the query is not a problem-solving ask.
     const boosted =
-      this.config.recallReasoningTraceBoostEnabled && typeof retrievalQuery === "string"
+      caps.recallReasoningTraceBoost && typeof retrievalQuery === "string"
         ? applyReasoningTraceBoost(results, {
             enabled: true,
             query: retrievalQuery,
           })
         : results;
-    const diversified = this.applyMmrToQmdResults(sectionId, boosted);
+    const diversified = this.applyMmrToQmdResults(sectionId, boosted, caps);
     return diversified.slice(0, safeLimit);
   }
 
@@ -18398,8 +18445,11 @@ export class Orchestrator {
   private applyMmrToQmdResults(
     sectionId: string,
     results: QmdSearchResult[],
+    // Additive `caps` (issue #1523); defaults to a config-derived set so direct
+    // callers that omit it behave identically to the threaded recall path.
+    caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
-    if (this.config.recallMmrEnabled === false) return results;
+    if (!caps.recallMmr) return results;
     if (!Array.isArray(results) || results.length < 2) return results;
 
     // Config is runtime API (see AGENTS.md §4): preserve `0` as a true zero
@@ -18698,6 +18748,13 @@ export class Orchestrator {
     recallNamespaces: string[];
     recallResultLimit: number;
     recallMode: RecallPlanMode;
+    /**
+     * Recall-operation capability gates resolved once at recall entry (#1523).
+     * OPTIONAL and additive: the recall pipeline threads a resolved set, but
+     * callers that omit it (e.g. direct unit-test invocations) get an
+     * equivalent config-derived set — behavior-preserving.
+     */
+    caps?: CapabilitySet;
     queryAwarePrefilter?: QueryAwarePrefilter;
     abortSignal?: AbortSignal;
     /** Backend degradation observer — cold-tier QMD must report like hot (#1536). */
@@ -18717,6 +18774,9 @@ export class Orchestrator {
     /** Issue #681 — when true, bypass graphTraversalConfidenceFloor. */
     includeLowConfidence?: boolean;
   }): Promise<QmdSearchResult[]> {
+    // Prefer the threaded set; fall back to a config-derived set so direct
+    // callers (unit tests) behave identically to the recall pipeline (#1523).
+    const caps = options.caps ?? resolveCapabilities(this.config);
     if (options.queryAwarePrefilter?.candidatePaths?.size === 0) {
       if (options.xrayPoolSizeSink) options.xrayPoolSizeSink.size = 0;
       return [];
@@ -18932,7 +18992,7 @@ export class Orchestrator {
     const isFullModeGraphAssist =
       this.config.qmdTierParityGraphEnabled &&
       this.config.multiGraphMemoryEnabled &&
-      this.config.graphAssistInFullModeEnabled !== false &&
+      caps.graphAssistInFullMode &&
       options.recallMode === "full" &&
       results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
     const shouldRunGraphExpansion =
@@ -19028,7 +19088,7 @@ export class Orchestrator {
         timeoutMs: this.config.rerankTimeoutMs,
         maxCandidates: this.config.rerankMaxCandidates,
         cache: this.rerankCache,
-        cacheEnabled: this.config.rerankCacheEnabled,
+        cacheEnabled: caps.rerankCache,
         cacheTtlMs: this.config.rerankCacheTtlMs,
       });
       if (ranked && ranked.length > 0) {
@@ -19054,7 +19114,7 @@ export class Orchestrator {
     // Memory Worth filter — must fire on the cold fallback path too, or the
     // feature flag produces divergent behavior by retrieval path (CLAUDE.md
     // rule 39). Fail-open on lookup errors.
-    if (this.config.recallMemoryWorthFilterEnabled && results.length > 0) {
+    if (caps.recallMemoryWorthFilter && results.length > 0) {
       try {
         results = await this.applyMemoryWorthRerank(results, options.recallNamespaces);
       } catch (err) {
@@ -19079,6 +19139,7 @@ export class Orchestrator {
       results,
       options.recallResultLimit,
       options.prompt,
+      caps,
     );
   }