@remnic/core 9.3.733 → 9.3.735

package/src/compounding/engine.ts

@@ -7,6 +7,7 @@ import { StorageManager } from "../storage.js";
 import type { ContinuityIncidentRecord, PluginConfig } from "../types.js";
 import { resolveSharedContextDir, SharedFeedbackEntrySchema, type SharedFeedbackEntry } from "../shared-context/manager.js";
 import { parseContinuityImprovementLoops } from "../identity-continuity.js";
+import { resolveQmdCapabilities, type QmdConfigProjection } from "../capabilities.js";
 
 type MistakesFile = {
   version?: number;
@@ -369,7 +370,7 @@ export interface TierMigrationCycleBudget {
 }
 
 export function defaultTierMigrationCycleBudget(
-  config: Pick<PluginConfig, "qmdTierAutoBackfillEnabled">,
+  config: QmdConfigProjection,
   trigger: TierMigrationCycleTrigger,
 ): TierMigrationCycleBudget {
   if (trigger === "extraction") {
@@ -380,11 +381,11 @@ export function defaultTierMigrationCycleBudget(
       minIntervalMs: 60_000,
     };
   }
-  const limit = config.qmdTierAutoBackfillEnabled ? 200 : 50;
+  const limit = resolveQmdCapabilities(config).qmdTierAutoBackfill ? 200 : 50;
   return {
     limit,
     scanLimit: limit * 4,
-    minIntervalMs: config.qmdTierAutoBackfillEnabled ? 120_000 : 300_000,
+    minIntervalMs: resolveQmdCapabilities(config).qmdTierAutoBackfill ? 120_000 : 300_000,
   };
 }
 

package/src/contradiction/contradiction-scan.ts

@@ -14,6 +14,7 @@
  *   4. Cap per-run work at maxPairsPerRun.
  */
 
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import type { StorageManager } from "../storage.js";
 import type { PluginConfig, MemoryFile, MemoryStatus } from "../types.js";
 import type { SemanticDedupLookup } from "../dedup/semantic.js";
@@ -107,7 +108,7 @@ export async function runContradictionScan(deps: ScanDependencies): Promise<Scan
   }
 
   const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);
-  if (config.namespacesEnabled && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {
+  if (resolveNamespaceCapabilities(config).namespaces && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {
     const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });
     if (migrated > 0) {
       log.info("[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s", migrated, namespace);
@@ -382,7 +383,7 @@ async function resolveScanStorage(
   deps: ScanDependencies,
   namespace: string | undefined,
 ): Promise<ScanStorageResolution> {
-  if (!deps.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(deps.config).namespaces) {
     const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);
     if (namespace && namespace !== defaultNamespace) {
       throw new Error(`unsupported namespace: ${namespace}`);
@@ -427,7 +428,7 @@ function isStorageManagerLike(value: unknown): value is StorageManager {
 
 function fallbackResolvedNamespace(deps: ScanDependencies, namespace: string | undefined): string | undefined {
   if (namespace) return namespace;
-  return deps.config.namespacesEnabled ? deps.config.defaultNamespace : undefined;
+  return resolveNamespaceCapabilities(deps.config).namespaces ? deps.config.defaultNamespace : undefined;
 }
 
 function isDefaultNamespaceScan(

package/src/embedding-fallback.ts

@@ -1,7 +1,10 @@
 import path from "node:path";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { log } from "./logger.js";
-import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
+import {
+  resolveMemoryLifecycleCapabilities,
+  resolveLocalLlmCapabilities,
+} from "./capabilities.js";
 import { readEnvVar } from "./runtime/env.js";
 import type { PluginConfig } from "./types.js";
 import {
@@ -461,7 +464,7 @@ export class EmbeddingFallback {
   }
 
   private createLocalProvider(): ProviderConfig | null {
-    if (!this.config.localLlmEnabled || !this.config.localLlmUrl) return null;
+    if (!resolveLocalLlmCapabilities(this.config).localLlm || !this.config.localLlmUrl) return null;
     const base = this.config.localLlmUrl.replace(/\/$/, "");
     const endpoint = /\/v1$/i.test(base) ? `${base}/embeddings` : `${base}/v1/embeddings`;
     const headers: Record<string, string> = {

package/src/entity-retrieval.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { createHash } from "node:crypto";
 import { sanitizeMemoryContent } from "./sanitize.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -329,7 +330,7 @@ async function readNativeChunks(
     workspaceDir: config.workspaceDir,
     memoryDir: config.memoryDir,
     config: config.nativeKnowledge,
-    recallNamespaces: config.namespacesEnabled ? recallNamespaces : undefined,
+    recallNamespaces: resolveNamespaceCapabilities(config).namespaces ? recallNamespaces : undefined,
     defaultNamespace: config.defaultNamespace,
   }).catch(() => []);
 }
@@ -341,7 +342,7 @@ async function resolveEntityIndexStorages(
   namespaceStorage?: (namespace: string) => Promise<StorageManager>,
 ): Promise<StorageManager[]> {
   if (
-    !config.namespacesEnabled ||
+    !resolveNamespaceCapabilities(config).namespaces ||
     !namespaceStorage ||
     !recallNamespaces ||
     recallNamespaces.length === 0

package/src/explicit-capture.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { randomUUID } from "node:crypto";
 import type { Orchestrator } from "./orchestrator.js";
 import { isSafeRouteNamespace } from "./routing/engine.js";
@@ -175,7 +176,7 @@ function resolveExplicitCaptureNamespace(
 ): string | undefined {
   const normalized = asTrimmed(namespace);
   if (!normalized) return undefined;
-  if (!orchestrator.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     if (normalized !== orchestrator.config.defaultNamespace) {
       throw new Error(`unsupported namespace: ${normalized}`);
     }

package/src/extraction.ts

@@ -38,7 +38,10 @@ import { normalizeProcedureSteps } from "./procedural/procedure-types.js";
 import { normalizeReasoningTrace } from "./reasoning-trace-types.js";
 import { looksLikeMechanicalTelemetryTranscript } from "./telemetry-transcript.js";
 import { buildFactProvenance, type ProvenanceTurnInput } from "./provenance.js";
-import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
+import {
+  resolveMemoryLifecycleCapabilities,
+  resolveLocalLlmCapabilities,
+} from "./capabilities.js";
 
 type ExtractionQuestion = ExtractionResult["questions"][number];
 type ExtractedFactResult = ExtractionResult["facts"][number];
@@ -152,7 +155,7 @@ export class ExtractionEngine {
    * Disabled when gateway model source is active (gateway chain replaces local).
    */
   private get shouldUseLocalLlm(): boolean {
-    return this.config.localLlmEnabled && !this.useGatewayModelSource;
+    return resolveLocalLlmCapabilities(this.config).localLlm && !this.useGatewayModelSource;
   }
 
   /**
@@ -1114,7 +1117,7 @@ export class ExtractionEngine {
     // --- profiling instrumentation ---
     const extractionTraceId = this.profiler.startTrace("extraction", undefined, {
       model: this.config.model,
-      localLlm: this.config.localLlmEnabled,
+      localLlm: resolveLocalLlmCapabilities(this.config).localLlm,
     });
     this.profiler.startSpan("total", extractionTraceId);
 

package/src/local-llm.ts

@@ -5,6 +5,7 @@ import os from "node:os";
 import type { ModelRegistry } from "./model-registry.js";
 import { launchProcessSync } from "./runtime/child-process.js";
 import { mergeEnv, readEnvVar } from "./runtime/env.js";
+import { resolveLocalLlmCapabilities } from "./capabilities.js";
 
 /** Trim trailing slash characters without backtracking regex. */
 function trimTrailingSlashes(s: string): string {
@@ -934,7 +935,7 @@ export class LocalLlmClient {
     queueMeta?: { priority: LocalLlmRequestPriority; enqueuedAtMs: number },
   ): Promise<LocalLlmChatCompletionResult | null> {
     log.debug(
-      `local LLM chatCompletion: localLlmEnabled=${this.config.localLlmEnabled}, model=${this.config.localLlmModel}`,
+      `local LLM chatCompletion: localLlmEnabled=${resolveLocalLlmCapabilities(this.config).localLlm}, model=${this.config.localLlmModel}`,
     );
 
     const operation = options.operation ?? "unspecified";
@@ -1389,7 +1390,7 @@ export class LocalLlmClient {
     messages: Array<{ role: string; content: string }>,
     options: LocalLlmChatCompletionOptions = {},
   ): Promise<LocalLlmChatCompletionResult | null> {
-    if (!this.config.localLlmEnabled) {
+    if (!resolveLocalLlmCapabilities(this.config).localLlm) {
       log.debug("local LLM: disabled, returning null");
       return null;
     }
@@ -1444,7 +1445,7 @@ export class LocalLlmClient {
     operationName: string
   ): Promise<T> {
     // Try local LLM first if enabled
-    if (this.config.localLlmEnabled) {
+    if (resolveLocalLlmCapabilities(this.config).localLlm) {
       const localResult = await localOperation();
       if (localResult !== null) {
         log.debug(`${operationName}: used local LLM`);

package/src/maintenance/first-start-migration.ts

@@ -18,7 +18,10 @@
 
 import path from "node:path";
 import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { resolveMemoryLifecycleCapabilities } from "../capabilities.js";
+import {
+  resolveMemoryLifecycleCapabilities,
+  resolveQmdCapabilities,
+  resolveUtilityLearningCapabilities} from "../capabilities.js";
 import type { StorageManager } from "../storage.js";
 import type { PluginConfig } from "../types.js";
 import {
@@ -135,15 +138,15 @@ async function clearQmdRefreshPending(memoryDir: string): Promise<void> {
 
 async function buildTierRoutingPolicy(config: PluginConfig): Promise<TierRoutingPolicy> {
   const basePolicy: TierRoutingPolicy = {
-    enabled: config.qmdTierMigrationEnabled,
+    enabled: resolveQmdCapabilities(config).qmdTierMigration,
     demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
     demotionValueThreshold: config.qmdTierDemotionValueThreshold,
     promotionValueThreshold: config.qmdTierPromotionValueThreshold,
   };
   const runtime = await loadUtilityRuntimeValues({
     memoryDir: config.memoryDir,
-    memoryUtilityLearningEnabled: config.memoryUtilityLearningEnabled,
-    promotionByOutcomeEnabled: config.promotionByOutcomeEnabled,
+    memoryUtilityLearningEnabled: resolveUtilityLearningCapabilities(config).memoryUtilityLearning,
+    promotionByOutcomeEnabled: resolveUtilityLearningCapabilities(config).promotionByOutcome,
   });
   return applyUtilityPromotionRuntimePolicy(basePolicy, runtime);
 }
@@ -207,7 +210,7 @@ export async function runFirstStartMigration(
     };
   }
 
-  if (!config.qmdTierMigrationEnabled) {
+  if (!resolveQmdCapabilities(config).qmdTierMigration) {
     return {
       skipped: true,
       skipReason: "qmdTierMigrationEnabled is false",

package/src/maintenance/namespace-maintenance-fanout.ts

@@ -24,6 +24,7 @@
  * - Per-namespace locks prevent duplicate concurrent runs (planner-provided).
  */
 
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import type { NamespaceCatalog } from "../namespaces/catalog.js";
 import type { PluginConfig } from "../types.js";
 import {
@@ -262,7 +263,7 @@ export async function summarizeNamespaceMaintenanceHealth(
   return {
     generatedAt,
     fanoutEnabled: config.maintenanceNamespaceFanoutEnabled !== false,
-    namespacesEnabled: config.namespacesEnabled,
+    namespacesEnabled: resolveNamespaceCapabilities(config).namespaces,
     maxNamespacesPerCycle: config.maintenanceMaxNamespacesPerCycle,
     jobs,
     totalRan,

package/src/maintenance/namespace-planner.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import { createHash, randomUUID } from "node:crypto";
 import type { Dirent } from "node:fs";
 import { lstat, mkdir, open, readFile, readdir, rename, rm, rmdir, stat, utimes, writeFile } from "node:fs/promises";
@@ -211,7 +212,7 @@ export async function planNamespaceMaintenance(
   // policies) would make a mutating maintenance job process the SAME corpus
   // once per configured name. The #1500 contract is "namespaces disabled:
   // maintain the current default storage only," so collapse to the default.
-  const configured = config.namespacesEnabled
+  const configured = resolveNamespaceCapabilities(config).namespaces
     ? getConfiguredNamespaces(config)
     : [config.defaultNamespace.trim()].filter(Boolean);
   const byNamespace = new Map<string, NamespaceMaintenanceCandidate>();
@@ -226,7 +227,7 @@ export async function planNamespaceMaintenance(
     });
   }
 
-  if (config.namespacesEnabled && config.maintenanceNamespaceFanoutEnabled !== false) {
+  if (resolveNamespaceCapabilities(config).namespaces && config.maintenanceNamespaceFanoutEnabled !== false) {
     const configuredSet = new Set(configured);
     try {
       const records = options.catalog?.enabled ? await options.catalog.listNamespaces() : [];
@@ -267,7 +268,7 @@ export async function planNamespaceMaintenance(
         detail: error instanceof Error ? error.message : String(error),
       });
     }
-  } else if (config.namespacesEnabled) {
+  } else if (resolveNamespaceCapabilities(config).namespaces) {
     skipped.push({
       namespace: "*",
       reason: "fanout_disabled",

package/src/maintenance/tier-stats.ts

@@ -25,6 +25,7 @@ import {
   type TierRoutingPolicy,
   type TierTransitionDecision,
 } from "../tier-routing.js";
+import { resolveQmdCapabilities, resolveUtilityLearningCapabilities} from "../capabilities.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   loadUtilityRuntimeValues,
@@ -82,15 +83,15 @@ async function tierRoutingPolicyFromConfig(
   config: PluginConfig,
 ): Promise<TierRoutingPolicy> {
   const basePolicy: TierRoutingPolicy = {
-    enabled: config.qmdTierMigrationEnabled,
+    enabled: resolveQmdCapabilities(config).qmdTierMigration,
     demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
     demotionValueThreshold: config.qmdTierDemotionValueThreshold,
     promotionValueThreshold: config.qmdTierPromotionValueThreshold,
   };
   const runtime = await loadUtilityRuntimeValues({
     memoryDir: config.memoryDir,
-    memoryUtilityLearningEnabled: config.memoryUtilityLearningEnabled,
-    promotionByOutcomeEnabled: config.promotionByOutcomeEnabled,
+    memoryUtilityLearningEnabled: resolveUtilityLearningCapabilities(config).memoryUtilityLearning,
+    promotionByOutcomeEnabled: resolveUtilityLearningCapabilities(config).promotionByOutcome,
   });
   return applyUtilityPromotionRuntimePolicy(basePolicy, runtime);
 }

package/src/namespaces/catalog.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import path from "node:path";
 import type { Dirent } from "node:fs";
 import {
@@ -181,7 +182,7 @@ const MEMORY_DATA_CHILDREN = [
 function isCatalogEnabled(config: PluginConfig): boolean {
   // Inert unless namespaces are enabled. namespaceCatalogEnabled defaults to
   // true (undefined => enabled) but is only honored when namespacesEnabled.
-  if (config.namespacesEnabled !== true) return false;
+  if (resolveNamespaceCapabilities(config).namespaces !== true) return false;
   return (config as { namespaceCatalogEnabled?: boolean }).namespaceCatalogEnabled !== false;
 }
 

package/src/namespaces/migrate.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import path from "node:path";
 import { access, lstat, mkdir, readdir, realpath, rename, rmdir } from "node:fs/promises";
 import type { PluginConfig } from "../types.js";
@@ -146,7 +147,7 @@ export async function runNamespaceMigration(options: {
   dryRun?: boolean;
   renameFn?: typeof rename;
 }): Promise<NamespaceMigrationReport> {
-  if (!options.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(options.config).namespaces) {
     throw new Error("Namespaces are disabled.");
   }
 

package/src/namespaces/principal.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import type { PluginConfig } from "../types.js";
 import { isLikelyUnsafeRegex } from "../routing/engine.js";
 
@@ -13,7 +14,7 @@ function compileSafePrincipalRegex(pattern: string): RegExp | null {
 }
 
 export function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string | undefined {
-  if (!config.namespacesEnabled) return "default";
+  if (!resolveNamespaceCapabilities(config).namespaces) return "default";
   const sk = typeof sessionKey === "string" && sessionKey.trim().length > 0
     ? sessionKey
     : "";
@@ -51,7 +52,7 @@ export function resolvePrincipal(sessionKey: string | undefined, config: PluginC
 }
 
 export function canReadNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {
-  if (!config.namespacesEnabled) return true;
+  if (!resolveNamespaceCapabilities(config).namespaces) return true;
   if (!principal) return false;
   const policy = config.namespacePolicies.find((p) => p.name === namespace);
   if (!policy) return namespace === config.defaultNamespace || namespace === config.sharedNamespace;
@@ -59,7 +60,7 @@ export function canReadNamespace(principal: string | undefined, namespace: strin
 }
 
 export function canWriteNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {
-  if (!config.namespacesEnabled) return true;
+  if (!resolveNamespaceCapabilities(config).namespaces) return true;
   if (!principal) return false;
   const policy = config.namespacePolicies.find((p) => p.name === namespace);
   if (!policy) return namespace === config.defaultNamespace;
@@ -74,7 +75,7 @@ export function canWriteNamespace(principal: string | undefined, namespace: stri
  * - Otherwise use config.defaultNamespace.
  */
 export function defaultNamespaceForPrincipal(principal: string | undefined, config: PluginConfig): string {
-  if (!config.namespacesEnabled) return config.defaultNamespace;
+  if (!resolveNamespaceCapabilities(config).namespaces) return config.defaultNamespace;
   if (!principal) return config.defaultNamespace;
   const exists = config.namespacePolicies.some((p) => p.name === principal);
   return exists ? principal : config.defaultNamespace;
@@ -82,7 +83,7 @@ export function defaultNamespaceForPrincipal(principal: string | undefined, conf
 
 export function recallNamespacesForPrincipal(principal: string | undefined, config: PluginConfig): string[] {
   const out: string[] = [];
-  if (!config.namespacesEnabled) return [config.defaultNamespace];
+  if (!resolveNamespaceCapabilities(config).namespaces) return [config.defaultNamespace];
   if (!principal) return out;
 
   const selfNs = defaultNamespaceForPrincipal(principal, config);

package/src/namespaces/scope-profiles.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import { createHash } from "node:crypto";
 
 import { combineNamespaces, type CodingNamespaceOverlay } from "../coding/coding-namespace.js";
@@ -326,7 +327,7 @@ export function resolveScopeProfilePlan(
   options: ResolveScopeProfilePlanOptions,
 ): ResolvedScopeProfilePlan | null {
   const active = activeScopeProfile(options.config);
-  if (!active || !options.config.namespacesEnabled) return null;
+  if (!active || !resolveNamespaceCapabilities(options.config).namespaces) return null;
 
   const baseNamespace = scopeProfileSelfNamespace(options.principal, options.config);
   const layerIds = Array.from(

package/src/namespaces/search.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import path from "node:path";
 import type { PluginConfig, QmdSearchResult } from "../types.js";
 import type {
@@ -350,7 +351,7 @@ export class NamespaceSearchRouter {
     const useLegacyDefaultCollection =
       key === this.config.defaultNamespace && storage.dir === this.config.memoryDir;
     const filtersNestedNamespaces =
-      this.config.namespacesEnabled === true && useLegacyDefaultCollection;
+      resolveNamespaceCapabilities(this.config).namespaces === true && useLegacyDefaultCollection;
     const rootHostEmbeddingScope =
       (this.config as NamespaceScopedSearchConfig).hostEmbeddingProviderScope ??
       this.config.memoryDir;

package/src/namespaces/storage.ts

@@ -1,3 +1,4 @@
+import { resolveNamespaceCapabilities } from "../capabilities.js";
 import path from "node:path";
 import { access, lstat, readdir } from "node:fs/promises";
 import { isSafeRouteNamespace } from "../routing/engine.js";
@@ -139,7 +140,7 @@ export interface NamespaceStorageRouterHooks {
  * the default migrate into that tokenized/legacy-named dir.
  */
 export async function resolveDefaultNamespaceRoot(config: PluginConfig): Promise<string> {
-  if (!config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(config).namespaces) {
     return config.memoryDir;
   }
 
@@ -183,7 +184,7 @@ export async function resolveNamespaceStorageRoot(
   config: PluginConfig,
   namespace: string,
 ): Promise<string> {
-  if (!config.namespacesEnabled) return config.memoryDir;
+  if (!resolveNamespaceCapabilities(config).namespaces) return config.memoryDir;
   // Compare on NORMALIZED identity so a whitespace-padded configured default name
   // still routes to the default root rather than a tokenized non-default dir
   // (NH-FH). The catalog keys records by the same normalized identity.
@@ -257,7 +258,7 @@ export class NamespaceStorageRouter {
 
   private async namespaceRoot(namespace: string): Promise<string> {
     // NOTE: only used after defaultNamespaceRoot() resolution.
-    if (!this.config.namespacesEnabled) return this.config.memoryDir;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.memoryDir;
     if (normalizeNamespaceIdentity(namespace) === this.defaultNamespaceIdentity) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }

package/src/operator-toolkit.ts

@@ -28,7 +28,8 @@ import {
   resolveAccessSetupCapabilities,
   resolveCapabilities,
   resolveGraphConstructionCapabilities,
-} from "./capabilities.js";
+  resolveQmdCapabilities,
+  resolveEvalCapabilities} from "./capabilities.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -742,7 +743,7 @@ export async function runOperatorSetup(options: OperatorSetupOptions): Promise<O
   await mkdir(options.orchestrator.config.workspaceDir, { recursive: true });
 
   const qmdAvailable = await options.orchestrator.qmd.probe();
-  const collectionState = options.orchestrator.config.qmdEnabled
+  const collectionState = resolveQmdCapabilities(options.orchestrator.config).qmd
     ? await options.orchestrator.qmd.ensureCollection(
         options.orchestrator.config.memoryDir,
         options.orchestrator.config.qmdCollection,
@@ -813,7 +814,7 @@ export async function runOperatorSetup(options: OperatorSetupOptions): Promise<O
     workspaceDir: options.orchestrator.config.workspaceDir,
     directories,
     qmd: {
-      enabled: options.orchestrator.config.qmdEnabled,
+      enabled: resolveQmdCapabilities(options.orchestrator.config).qmd,
       available: qmdAvailable,
       collectionState,
       debugStatus: options.orchestrator.qmd.debugStatus(),
@@ -949,12 +950,12 @@ async function buildOperatorConfigReviewReport(input: {
     }));
   }
 
-  if (config.qmdEnabled && config.qmdDaemonEnabled === false) {
+  if (resolveQmdCapabilities(config).qmd && resolveQmdCapabilities(config).qmdDaemon === false) {
     findings.push(buildConfigReviewFinding({
       key: "qmd_daemon",
       status: "recommend",
       setting: "qmdDaemonEnabled",
-      currentValue: config.qmdDaemonEnabled,
+      currentValue: resolveQmdCapabilities(config).qmdDaemon,
       defaultValue: true,
       recommendedValue: true,
       summary: "Enable the QMD daemon path when QMD powers recall.",
@@ -991,12 +992,12 @@ async function buildOperatorConfigReviewReport(input: {
     }));
   }
 
-  if (searchBackend === "qmd" && config.qmdEnabled === false) {
+  if (searchBackend === "qmd" && resolveQmdCapabilities(config).qmd === false) {
     findings.push(buildConfigReviewFinding({
       key: "qmd_search_backend_disabled",
       status: "problem",
       setting: "qmdEnabled",
-      currentValue: config.qmdEnabled,
+      currentValue: resolveQmdCapabilities(config).qmd,
       defaultValue: true,
       recommendedValue: true,
       summary: "QMD search is selected but QMD is disabled.",
@@ -1005,12 +1006,12 @@ async function buildOperatorConfigReviewReport(input: {
     }));
   }
 
-  if (config.qmdColdTierEnabled === true && config.qmdEnabled === false) {
+  if (resolveQmdCapabilities(config).qmdColdTier === true && resolveQmdCapabilities(config).qmd === false) {
     findings.push(buildConfigReviewFinding({
       key: "qmd_cold_tier_requires_qmd",
       status: "problem",
       setting: "qmdEnabled",
-      currentValue: config.qmdEnabled,
+      currentValue: resolveQmdCapabilities(config).qmd,
       defaultValue: true,
       recommendedValue: true,
       summary: "Cold-tier QMD recall is enabled while QMD itself is disabled.",
@@ -1019,12 +1020,12 @@ async function buildOperatorConfigReviewReport(input: {
     }));
   }
 
-  if (config.qmdTierMigrationEnabled && config.qmdColdTierEnabled !== true) {
+  if (resolveQmdCapabilities(config).qmdTierMigration && resolveQmdCapabilities(config).qmdColdTier !== true) {
     findings.push(buildConfigReviewFinding({
       key: "qmd_tier_migration_requires_cold_tier",
       status: "problem",
       setting: "qmdColdTierEnabled",
-      currentValue: config.qmdColdTierEnabled,
+      currentValue: resolveQmdCapabilities(config).qmdColdTier,
       defaultValue: false,
       recommendedValue: true,
       summary: "Hot/cold tier migration is enabled without the cold tier itself.",
@@ -1033,12 +1034,12 @@ async function buildOperatorConfigReviewReport(input: {
     }));
   }
 
-  if (resolveIndexingCapabilities(config).conversationIndex && config.conversationIndexBackend === "qmd" && config.qmdEnabled === false) {
+  if (resolveIndexingCapabilities(config).conversationIndex && config.conversationIndexBackend === "qmd" && resolveQmdCapabilities(config).qmd === false) {
     findings.push(buildConfigReviewFinding({
       key: "conversation_index_qmd_requires_qmd",
       status: "problem",
       setting: "qmdEnabled",
-      currentValue: config.qmdEnabled,
+      currentValue: resolveQmdCapabilities(config).qmd,
       defaultValue: true,
       recommendedValue: true,
       summary: "The conversation index is configured for QMD while QMD is disabled.",
@@ -1063,8 +1064,8 @@ async function buildOperatorConfigReviewReport(input: {
     profile: {
       memoryOsPreset: config.memoryOsPreset,
       searchBackend,
-      qmdEnabled: config.qmdEnabled,
-      qmdDaemonEnabled: config.qmdDaemonEnabled,
+      qmdEnabled: resolveQmdCapabilities(config).qmd,
+      qmdDaemonEnabled: resolveQmdCapabilities(config).qmdDaemon,
       nativeKnowledgeEnabled: config.nativeKnowledge?.enabled === true,
       fileHygieneEnabled: config.fileHygiene?.enabled === true,
       conversationIndexEnabled: resolveIndexingCapabilities(config).conversationIndex,
@@ -1145,12 +1146,12 @@ export async function runOperatorDoctor(options: OperatorDoctorOptions): Promise
   });
 
   const qmdAvailable = await options.orchestrator.qmd.probe();
-  const collectionState = config.qmdEnabled
+  const collectionState = resolveQmdCapabilities(config).qmd
     ? await options.orchestrator.qmd.ensureCollection(config.memoryDir, config.qmdCollection)
     : "skipped";
   checks.push({
     key: "qmd",
-    status: !config.qmdEnabled
+    status: !resolveQmdCapabilities(config).qmd
       ? "warn"
       : !qmdAvailable
       ? "error"
@@ -1159,12 +1160,12 @@ export async function runOperatorDoctor(options: OperatorDoctorOptions): Promise
       : collectionState === "missing"
       ? "error"
       : "warn",
-    summary: !config.qmdEnabled
+    summary: !resolveQmdCapabilities(config).qmd
       ? "QMD is disabled in config."
       : qmdAvailable
       ? `QMD is reachable (${collectionState}).`
       : "QMD is not currently reachable.",
-    remediation: !config.qmdEnabled
+    remediation: !resolveQmdCapabilities(config).qmd
       ? "Enable `qmdEnabled` if you expect hybrid search."
       : !qmdAvailable
       ? "Ensure the `qmd` binary is installed and on PATH, or set `qmdPath`."
@@ -2262,17 +2263,17 @@ export async function runBenchmarkRecall(options: BenchmarkRecallOptions): Promi
   const status = await getEvalHarnessStatus({
     memoryDir: options.config.memoryDir,
     evalStoreDir: options.config.evalStoreDir,
-    enabled: options.config.evalHarnessEnabled,
-    shadowModeEnabled: options.config.evalShadowModeEnabled,
-    baselineSnapshotsEnabled: options.config.benchmarkBaselineSnapshotsEnabled,
-    memoryRedTeamBenchEnabled: options.config.memoryRedTeamBenchEnabled,
+    enabled: resolveEvalCapabilities(options.config).evalHarness,
+    shadowModeEnabled: resolveEvalCapabilities(options.config).evalShadowMode,
+    baselineSnapshotsEnabled: resolveEvalCapabilities(options.config).benchmarkBaselineSnapshots,
+    memoryRedTeamBenchEnabled: resolveEvalCapabilities(options.config).memoryRedTeamBench,
   });
 
   if (options.createSnapshot && options.snapshotId) {
     const snapshot = await createEvalBaselineSnapshot({
       memoryDir: options.config.memoryDir,
       evalStoreDir: options.config.evalStoreDir,
-      baselineSnapshotsEnabled: options.config.benchmarkBaselineSnapshotsEnabled,
+      baselineSnapshotsEnabled: resolveEvalCapabilities(options.config).benchmarkBaselineSnapshots,
       snapshotId: options.snapshotId,
       notes: options.snapshotNotes,
       gitRef: options.gitRef,
@@ -2308,7 +2309,7 @@ export async function runBenchmarkRecall(options: BenchmarkRecallOptions): Promi
     const baselineReport = await runEvalBaselineDeltaReport({
       memoryDir: options.config.memoryDir,
       evalStoreDir: options.config.evalStoreDir,
-      benchmarkDeltaReporterEnabled: options.config.benchmarkDeltaReporterEnabled,
+      benchmarkDeltaReporterEnabled: resolveEvalCapabilities(options.config).benchmarkDeltaReporter,
       snapshotId: options.snapshotId,
     });
     return {
@@ -2322,7 +2323,7 @@ export async function runBenchmarkRecall(options: BenchmarkRecallOptions): Promi
 
   if (options.validatePath) {
     const validate = await validateEvalBenchmarkPack(options.validatePath, {
-      memoryRedTeamBenchEnabled: options.config.memoryRedTeamBenchEnabled,
+      memoryRedTeamBenchEnabled: resolveEvalCapabilities(options.config).memoryRedTeamBench,
     });
     return {
       schemaVersion: 1,