@remnic/core 9.3.733 → 9.3.734

package/src/capabilities.ts

@@ -404,3 +404,200 @@ export function resolveCreationMemoryCapabilities(
     commitmentLifecycle: config.commitmentLifecycleEnabled,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Namespace capability set (issue #1523 batch 5).
+//
+// `namespacesEnabled` is the single most-scattered config flag in the codebase
+// (101 read sites outside config.ts across 18 files — orchestrator, access-service,
+// namespace modules, maintenance, CLI, admin). It gates whether the multi-namespace
+// system is active at all: every namespace resolution, storage path, recall budget,
+// and maintenance fanout checks it. Like the other projections above it gets its own
+// resolver invoked ONCE per operation entry rather than re-derived at each site.
+//
+// The field is a non-optional boolean in PluginConfig, so no coercion is needed.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of namespace feature gates (issue #1523 batch 5).
+ *
+ * Every field is `readonly boolean`. Composition lives ONLY in
+ * {@link resolveNamespaceCapabilities}.
+ */
+export interface NamespaceCapabilitySet {
+  /** `namespacesEnabled` — multi-namespace system master switch. */
+  readonly namespaces: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveNamespaceCapabilities}.
+ */
+export type NamespaceConfigProjection = Pick<PluginConfig, "namespacesEnabled">;
+
+/**
+ * Resolve the {@link NamespaceCapabilitySet} from parsed config.
+ *
+ * Call this ONCE at operation entry and thread the result down. The flag is a
+ * non-optional boolean so the projection is a pure pass-through.
+ */
+export function resolveNamespaceCapabilities(
+  config: NamespaceConfigProjection,
+): NamespaceCapabilitySet {
+  return Object.freeze({
+    namespaces: config.namespacesEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// QMD capability set (issue #1523 batch 6).
+//
+// The twelve QMD (query-managed database) flags are the largest remaining
+// scattered cluster after batch 5. They gate every aspect of the tiered
+// memory system: master switch, tier migration, cold tier, daemon, auto-embed,
+// maintenance, query rerank, intent hints, explain, auto-upgrade, and parity
+// graph. Read sites span orchestrator, operator-toolkit, access-service, and
+// search/factory. All flags are non-optional booleans on PluginConfig (defaults
+// resolved at the parse boundary), so the projection is pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of QMD feature gates (issue #1523 batch 6).
+ *
+ * Every field is `readonly boolean`. Composition lives ONLY in
+ * {@link resolveQmdCapabilities}.
+ */
+export interface QmdCapabilitySet {
+  /** `qmdEnabled` — QMD tiered-memory master switch. */
+  readonly qmd: boolean;
+  /** `qmdTierMigrationEnabled` — automatic tier promotion/demotion. */
+  readonly qmdTierMigration: boolean;
+  /** `qmdTierAutoBackfillEnabled` — backfill stale tier entries. */
+  readonly qmdTierAutoBackfill: boolean;
+  /** `qmdAutoEmbedEnabled` — auto-embed documents on write. */
+  readonly qmdAutoEmbed: boolean;
+  /** `qmdMaintenanceEnabled` — QMD maintenance pass runner. */
+  readonly qmdMaintenance: boolean;
+  /** `qmdColdTierEnabled` — cold-tier storage. */
+  readonly qmdColdTier: boolean;
+  /** `qmdDaemonEnabled` — background QMD daemon. */
+  readonly qmdDaemon: boolean;
+  /** `qmdTierParityGraphEnabled` — tier parity graph. */
+  readonly qmdTierParityGraph: boolean;
+  /** `qmdQueryRerankEnabled` — QMD query reranking. */
+  readonly qmdQueryRerank: boolean;
+  /** `qmdIntentHintsEnabled` — QMD intent hint extraction. */
+  readonly qmdIntentHints: boolean;
+  /** `qmdExplainEnabled` — QMD explain output. */
+  readonly qmdExplain: boolean;
+  /** `qmdAutoUpgradeEnabled` — QMD auto-upgrade tiers. */
+  readonly qmdAutoUpgrade: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveQmdCapabilities}.
+ */
+export type QmdConfigProjection = Pick<
+  PluginConfig,
+  | "qmdEnabled"
+  | "qmdTierMigrationEnabled"
+  | "qmdTierAutoBackfillEnabled"
+  | "qmdAutoEmbedEnabled"
+  | "qmdMaintenanceEnabled"
+  | "qmdColdTierEnabled"
+  | "qmdDaemonEnabled"
+  | "qmdTierParityGraphEnabled"
+  | "qmdQueryRerankEnabled"
+  | "qmdIntentHintsEnabled"
+  | "qmdExplainEnabled"
+  | "qmdAutoUpgradeEnabled"
+>;
+
+/**
+ * Resolve the {@link QmdCapabilitySet} from parsed config.
+ *
+ * Call this ONCE at operation entry and thread the result down. Eleven flags
+ * are non-optional booleans (pure pass-through); `qmdColdTierEnabled` is
+ * optional and coerced with `=== true` (matching the pre-migration call sites).
+ */
+export function resolveQmdCapabilities(config: QmdConfigProjection): QmdCapabilitySet {
+  return Object.freeze({
+    qmd: config.qmdEnabled,
+    qmdTierMigration: config.qmdTierMigrationEnabled,
+    qmdTierAutoBackfill: config.qmdTierAutoBackfillEnabled,
+    qmdAutoEmbed: config.qmdAutoEmbedEnabled,
+    qmdMaintenance: config.qmdMaintenanceEnabled,
+    qmdColdTier: config.qmdColdTierEnabled === true,
+    qmdDaemon: config.qmdDaemonEnabled,
+    qmdTierParityGraph: config.qmdTierParityGraphEnabled,
+    qmdQueryRerank: config.qmdQueryRerankEnabled,
+    qmdIntentHints: config.qmdIntentHintsEnabled,
+    qmdExplain: config.qmdExplainEnabled,
+    qmdAutoUpgrade: config.qmdAutoUpgradeEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Identity-continuity capability set (issue #1523 batch 6).
+//
+// `identityContinuityEnabled` gates the identity/continuity system (agent
+// identity tracking, continuity incident logging). Its 13 read sites span
+// orchestrator, access-service, and CLI. The flag is a non-optional boolean
+// on PluginConfig, so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of identity-continuity feature gates (issue #1523 batch 6).
+ */
+export interface IdentityContinuityCapabilitySet {
+  /** `identityContinuityEnabled` — identity-continuity master switch. */
+  readonly identityContinuity: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveIdentityContinuityCapabilities}.
+ */
+export type IdentityContinuityConfigProjection = Pick<PluginConfig, "identityContinuityEnabled">;
+
+/**
+ * Resolve the {@link IdentityContinuityCapabilitySet} from parsed config.
+ */
+export function resolveIdentityContinuityCapabilities(
+  config: IdentityContinuityConfigProjection,
+): IdentityContinuityCapabilitySet {
+  return Object.freeze({
+    identityContinuity: config.identityContinuityEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Local-LLM capability set (issue #1523 batch 6).
+//
+// `localLlmEnabled` gates whether a local (on-device) LLM is used for
+// summarization, embedding fallback, extraction, and search. Its 11 read
+// sites span orchestrator, extraction, embedding-fallback, local-llm,
+// search/embed-helper, and summarizer. The flag is a non-optional boolean.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of local-LLM feature gates (issue #1523 batch 6).
+ */
+export interface LocalLlmCapabilitySet {
+  /** `localLlmEnabled` — local (on-device) LLM master switch. */
+  readonly localLlm: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveLocalLlmCapabilities}.
+ */
+export type LocalLlmConfigProjection = Pick<PluginConfig, "localLlmEnabled">;
+
+/**
+ * Resolve the {@link LocalLlmCapabilitySet} from parsed config.
+ */
+export function resolveLocalLlmCapabilities(
+  config: LocalLlmConfigProjection,
+): LocalLlmCapabilitySet {
+  return Object.freeze({
+    localLlm: config.localLlmEnabled,
+  });
+}

package/src/cli.ts

@@ -4,7 +4,11 @@ import { access, lstat, readFile, readdir, realpath, unlink } from "node:fs/prom
 import { createHash } from "node:crypto";
 import type { Readable, Writable } from "node:stream";
 import type { Orchestrator } from "./orchestrator.js";
-import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
+import {
+  resolveNamespaceCapabilities,
+  resolveMemoryLifecycleCapabilities,
+  resolveIdentityContinuityCapabilities,
+} from "./capabilities.js";
 import { ThreadingManager } from "./threading.js";
 import { utcDayRange } from "./transcript.js";
 import { runWearablesCliCommand } from "./wearables/cli.js";
@@ -2361,7 +2365,7 @@ export function hasDestructivePurgeFailures(
 
 function resolvePolicySignalNamespaces(orchestrator: PolicyTuningCliOrchestrator): string[] {
   const names = new Set<string>([orchestrator.config.defaultNamespace]);
-  if (orchestrator.config.namespacesEnabled) {
+  if (resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     names.add(orchestrator.config.sharedNamespace);
     for (const policy of orchestrator.config.namespacePolicies) {
       if (policy?.name) names.add(policy.name);
@@ -2520,7 +2524,7 @@ function resolveAuditNamespaces(
   }
 
   const names = new Set<string>([orchestrator.config.defaultNamespace]);
-  if (orchestrator.config.namespacesEnabled) {
+  if (resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     names.add(orchestrator.config.sharedNamespace);
     for (const policy of orchestrator.config.namespacePolicies) {
       if (policy?.name) names.add(policy.name);
@@ -3319,7 +3323,7 @@ export async function resolveMemoryDirForNamespace(
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   assertSafeNamespaceSegment(ns);
-  if (!orchestrator.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     if (options?.rejectUnsupportedOverride && ns !== orchestrator.config.defaultNamespace) {
       throw new Error(`namespaces are disabled; cannot target namespace: ${ns}`);
     }
@@ -7858,7 +7862,7 @@ export function registerCli(
         .option("--state <state>", "Filter by state: open|closed|all", "open")
         .option("--limit <number>", "Maximum incidents to list", "25")
         .action(async (...args: unknown[]) => {
-          if (!orchestrator.config.identityContinuityEnabled) {
+          if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
             console.log("Identity continuity is disabled.");
             return;
           }
@@ -7886,7 +7890,7 @@ export function registerCli(
         .option("--trigger-window <window>", "Optional incident trigger window")
         .option("--suspected-cause <text>", "Optional suspected cause")
         .action(async (...args: unknown[]) => {
-          if (!orchestrator.config.identityContinuityEnabled) {
+          if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
             console.log("Identity continuity is disabled.");
             return;
           }
@@ -7917,7 +7921,7 @@ export function registerCli(
         .option("--verification-result <text>", "Required verification result")
         .option("--preventive-rule <text>", "Optional preventive rule")
         .action(async (...args: unknown[]) => {
-          if (!orchestrator.config.identityContinuityEnabled) {
+          if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
             console.log("Identity continuity is disabled.");
             return;
           }
@@ -8507,7 +8511,7 @@ export function registerCli(
             mergedContent: cmdOpts.mergedContent,
             storageForNamespace: (namespace) => {
               const requested = namespace?.trim();
-              if (!orchestrator.config.namespacesEnabled) {
+              if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
                 if (requested && requested !== orchestrator.config.defaultNamespace) {
                   throw new Error(`unsupported namespace: ${requested}`);
                 }
@@ -8554,7 +8558,7 @@ export function registerCli(
             storageForNamespace: async (namespace) => {
               const resolvedNamespace =
                 namespace?.trim() ||
-                (orchestrator.config.namespacesEnabled ? orchestrator.config.defaultNamespace : undefined);
+                (resolveNamespaceCapabilities(orchestrator.config).namespaces ? orchestrator.config.defaultNamespace : undefined);
               const storage = await orchestrator.getStorageForNamespace(resolvedNamespace);
               return { storage, namespace: resolvedNamespace };
             },

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,
+} from "../capabilities.js";
 import type { StorageManager } from "../storage.js";
 import type { PluginConfig } from "../types.js";
 import {
@@ -135,7 +138,7 @@ 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,
@@ -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 } from "../capabilities.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   loadUtilityRuntimeValues,
@@ -82,7 +83,7 @@ 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,

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);