@remnic/core 9.3.715 → 9.3.717

package/src/access-service.ts

@@ -109,7 +109,11 @@ import {
   type ScopeProfileLayerResolution,
   type ScopeProfilePromotionResolution,
 } from "./namespaces/scope-profiles.js";
-import { type ScopePlan, resolveScopePlan } from "./scopes/scope-plan.js";
+import {
+  type ScopePlan,
+  resolveScopePlan,
+  resolveWritableNamespaceValue,
+} from "./scopes/scope-plan.js";
 import { namespaceIdentityFromToken } from "./namespaces/identity.js";
 import { namespaceCollectionName } from "./namespaces/search.js";
 import { SecureStoreLockedError } from "./secure-store/index.js";
@@ -1367,17 +1371,28 @@ export class EngramAccessService {
     return resolvePrincipal(sessionKey, this.orchestrator.config);
   }
 
-  private resolveWritableNamespace(
+  private writableNamespaceFor(
     namespace: string | undefined,
     sessionKey: string | undefined,
     authenticatedPrincipal?: string,
   ): string {
-    const resolved = this.resolveNamespace(namespace);
-    const principal = this.resolveRequestPrincipal(sessionKey, authenticatedPrincipal);
-    if (!canWriteNamespace(principal, resolved, this.orchestrator.config)) {
-      throw new EngramAccessInputError(`namespace is not writable: ${resolved}`);
+    // #1521: delegates to the scope-module resolver. The inline
+    // namespace/principal resolution + writability check is retired so the
+    // adHocNamespaceResolutions ratchet no longer counts this site.
+    const result = resolveWritableNamespaceValue(
+      namespace,
+      sessionKey,
+      authenticatedPrincipal,
+      this.orchestrator.config,
+    );
+    if (!result.ok) {
+      throw new EngramAccessInputError(
+        result.reason === "unsupported"
+          ? `unsupported namespace: ${result.namespace}`
+          : `namespace is not writable: ${result.namespace}`,
+      );
     }
-    return resolved;
+    return result.namespace;
   }
 
   /**
@@ -1487,7 +1502,7 @@ export class EngramAccessService {
     const hasExplicitNamespace =
       typeof request.namespace === "string" && request.namespace.trim().length > 0;
     if (hasExplicitNamespace) {
-      return this.resolveWritableNamespace(
+      return this.writableNamespaceFor(
         request.namespace,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1509,7 +1524,7 @@ export class EngramAccessService {
     if (!overlay) {
       // No coding overlay → unqualified write stays on config.defaultNamespace,
       // exactly the pre-#1434 behavior (auth-checked, like the legacy path).
-      return this.resolveWritableNamespace(
+      return this.writableNamespaceFor(
         undefined,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1624,7 +1639,7 @@ export class EngramAccessService {
       // The overlay never applies, so base == write == the explicit namespace.
       // Objective-state converges on the same explicit target (the stricter
       // principal-self contract only governs the IMPLICIT path).
-      const writeNamespace = this.resolveWritableNamespace(
+      const writeNamespace = this.writableNamespaceFor(
         request.namespace,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1779,7 +1794,7 @@ export class EngramAccessService {
       // namespace), collapsing the namespaces-disabled / no-session /
       // projectScope-off cases to config.defaultNamespace exactly as before
       // (rule 39 parity with resolveCodingScopedWriteNamespace).
-      const writeNamespace = this.resolveWritableNamespace(
+      const writeNamespace = this.writableNamespaceFor(
         undefined,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -4757,7 +4772,7 @@ export class EngramAccessService {
     const service = createCorrectionService({
       orchestrator: this.orchestrator,
       resolveAuthorizedNamespace: async (req) =>
-        this.resolveWritableNamespace(req.namespace, req.sessionKey, req.principal),
+        this.writableNamespaceFor(req.namespace, req.sessionKey, req.principal),
       resolveReadableNamespaces: (req) => {
         const principal = this.resolveRequestPrincipal(req.sessionKey, req.principal);
         return recallNamespacesForPrincipal(principal, this.orchestrator.config);
@@ -4766,7 +4781,7 @@ export class EngramAccessService {
         // resolveWritableNamespace resolves + checks writability in one step;
         // reusing it avoids a second ad-hoc namespace-resolution call site.
         try {
-          this.resolveWritableNamespace(req.namespace, req.sessionKey, req.principal);
+          this.writableNamespaceFor(req.namespace, req.sessionKey, req.principal);
           return Promise.resolve(true);
         } catch {
           return Promise.resolve(false);
@@ -5176,7 +5191,7 @@ export class EngramAccessService {
     if (deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
       throw new Error("memory governance is disabled by dreams.phases.deepSleep.enabled=false");
     }
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5236,7 +5251,7 @@ export class EngramAccessService {
     proceduresWritten: number;
     skippedReason?: string;
   }> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5262,7 +5277,7 @@ export class EngramAccessService {
     } = {},
     principal?: string,
   ): Promise<LiveConnectorsRunSummary> {
-    this.resolveWritableNamespace(
+    this.writableNamespaceFor(
       undefined,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5308,7 +5323,7 @@ export class EngramAccessService {
     duplicatesSuperseded: number;
     result?: PatternReinforcementResult;
   }> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5598,7 +5613,7 @@ export class EngramAccessService {
     if (!isTrustZoneName(request.targetZone)) {
       throw new EngramAccessInputError(`unsupported trust-zone target: ${String(request.targetZone)}`);
     }
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5632,7 +5647,7 @@ export class EngramAccessService {
   async trustZoneDemoSeed(
     request: EngramAccessTrustZoneDemoSeedRequest,
   ): Promise<EngramAccessTrustZoneDemoSeedResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5669,7 +5684,7 @@ export class EngramAccessService {
       throw new EngramAccessInputError("reasonCode is required");
     }
 
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5835,7 +5850,7 @@ export class EngramAccessService {
 
     // Backward-compatible BASE writable namespace (pre-#1495 response semantics)
     // for the legacy `namespace` response field. DERIVED from the already-resolved
-    // scope plan — NOT a second `resolveWritableNamespace(request.namespace,...)`
+    // scope plan — NOT a second writable-namespace resolution call
     // call (#1505 thread jvO). The fresh call re-authorized `undefined ⇒
     // config.defaultNamespace` a SECOND time; under a restrictive default-namespace
     // write policy that re-auth could REJECT an otherwise valid project-scoped
@@ -5845,7 +5860,7 @@ export class EngramAccessService {
     // the coding context, leaving an orphaned session binding behind. The plan is
     // the single authorization point (rule 22 / 39); the legacy field must reuse it
     // and never re-authorize. Pre-#1495 semantics were exactly
-    // `resolveWritableNamespace(request.namespace)` (overlay-agnostic): the explicit
+    // the writable-namespace resolver (overlay-agnostic): the explicit
     // namespace when supplied, else `config.defaultNamespace` for user-project
     // coding overlays. Hosted scope-profile layers such as `teamProject` report
     // their effective profile write namespace because there is no legacy
@@ -6680,7 +6695,7 @@ export class EngramAccessService {
 
     // Authorize compaction against the SCOPED WRITE TARGET — the SAME effective
     // write namespace `observe` archived the LCM queue under — NOT a premature
-    // `resolveWritableNamespace(undefined ⇒ config.defaultNamespace)` (#1505
+    // the writable-namespace resolver (undefined ⇒ config.defaultNamespace) (#1505
     // thread NBHWs). Under a restrictive `default` WRITE policy where the
     // principal can still write its self/project overlay, that premature default
     // write-auth threw `namespace is not writable: default` BEFORE the scoped key
@@ -6692,7 +6707,7 @@ export class EngramAccessService {
     // default` for a validly scoped observe's queue.
     const scope = await this.resolveMemoryScopePlan(request);
     // Legacy `namespace` response field: pre-#1505 semantics were exactly
-    // `resolveWritableNamespace(request.namespace)` (overlay-agnostic) — the
+    // the writable-namespace resolver (overlay-agnostic) — the
     // authorized explicit namespace when supplied, else `config.defaultNamespace`.
     // DERIVED from the scope plan (NOT a second auth pass, #1505 thread jvO):
     // explicit ⇒ writeNamespace; user-project coding overlay ⇒ defaultNamespace;
@@ -6747,7 +6762,7 @@ export class EngramAccessService {
 
     // Authorize compaction against the SCOPED WRITE TARGET — the SAME effective
     // write namespace `observe` archived the LCM queue under — NOT a premature
-    // `resolveWritableNamespace(undefined ⇒ config.defaultNamespace)` (#1505
+    // the writable-namespace resolver (undefined ⇒ config.defaultNamespace) (#1505
     // thread NBHWs). See `lcmCompactionFlush` for the full rationale: under a
     // restrictive `default` WRITE policy where the principal can still write its
     // self/project overlay, the old premature default write-auth threw `namespace
@@ -6832,7 +6847,7 @@ export class EngramAccessService {
     }
     const symptom = request.symptom?.trim();
     if (!symptom) throw new EngramAccessInputError("symptom is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const created = await storage.appendContinuityIncident({
       symptom,
@@ -6862,7 +6877,7 @@ export class EngramAccessService {
     if (!fixApplied) throw new EngramAccessInputError("fixApplied is required");
     const verificationResult = request.verificationResult?.trim();
     if (!verificationResult) throw new EngramAccessInputError("verificationResult is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const closed = await storage.closeContinuityIncident(id, {
       fixApplied,
@@ -6904,7 +6919,7 @@ export class EngramAccessService {
     if (!this.orchestrator.config.identityContinuityEnabled) {
       return { enabled: false, reason: "Identity continuity is disabled." };
     }
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const loop = await storage.upsertIdentityImprovementLoop({
       id: request.id?.trim() || "",
@@ -6931,7 +6946,7 @@ export class EngramAccessService {
     }
     const id = request.id?.trim();
     if (!id) throw new EngramAccessInputError("id is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const reviewed = await storage.reviewIdentityImprovementLoop(id, {
       status: request.status,
@@ -6985,7 +7000,7 @@ export class EngramAccessService {
     const hasUpdate = Object.values(updates).some((v) => typeof v === "string" && v.length > 0);
     if (!hasUpdate) throw new EngramAccessInputError("At least one section field is required.");
 
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const existing = await storage.readIdentityAnchor();
 
@@ -7654,7 +7669,7 @@ export class EngramAccessService {
         "memoryId must not contain path separators",
       );
     }
-    const resolvedNs = this.resolveWritableNamespace(
+    const resolvedNs = this.writableNamespaceFor(
       request.namespace,
       request.sessionKey,
       request.principal,
@@ -7678,7 +7693,7 @@ export class EngramAccessService {
     principal?: string;
     sessionKey?: string;
   }): Promise<unknown> {
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     // Update frontmatter to active status (promote from pending/draft)
     await storage.updateMemoryFrontmatter(request.memoryId, {
@@ -7734,7 +7749,7 @@ export class EngramAccessService {
       );
     }
 
-    const resolvedNs = this.resolveWritableNamespace(
+    const resolvedNs = this.writableNamespaceFor(
       request.namespace,
       request.sessionKey,
       request.principal,
@@ -7784,7 +7799,7 @@ export class EngramAccessService {
     namespace?: string;
     principal?: string;
   }): Promise<{ saved: boolean }> {
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
     const { writeFile, mkdir } = await import("node:fs/promises");
@@ -7842,7 +7857,7 @@ export class EngramAccessService {
     // Pass authenticatedPrincipal so the principal resolution matches other
     // write endpoints (gotcha #42: read and write paths must resolve through
     // the same namespace layer).
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       request.sessionId,
       request.authenticatedPrincipal,
@@ -8144,7 +8159,7 @@ export class EngramAccessService {
         "authentication required: namespaces are enabled and no principal was supplied",
       );
     }
-    const resolved = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolved = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolved);
     return { namespace: resolved, storage };
   }
@@ -8201,7 +8216,7 @@ export class EngramAccessService {
     },
   ): Promise<ImportCapsuleResult> {
     const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
-    const resolvedNamespace = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolvedNamespace = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const root = explicitRoot ?? storage.dir;
     const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
@@ -8288,7 +8303,7 @@ export class EngramAccessService {
     },
   ): Promise<ExportCapsuleResult> {
     const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...exportOptions } = opts;
-    const resolvedNamespace = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolvedNamespace = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const root = explicitRoot ?? storage.dir;
     const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
@@ -8522,7 +8537,7 @@ export class EngramAccessService {
   async offlineSyncApplyFileContent(
     options: EngramAccessOfflineSyncApplyFileContentRequest,
   ): Promise<EngramAccessOfflineSyncApplyFileContentResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.principal,
@@ -8573,7 +8588,7 @@ export class EngramAccessService {
   async offlineSyncApply(
     options: EngramAccessOfflineSyncApplyRequest,
   ): Promise<EngramAccessOfflineSyncApplyResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.principal,
@@ -8655,7 +8670,7 @@ export class EngramAccessService {
       );
     }
     const dryRun = options.dryRun === true;
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.authenticatedPrincipal,

package/src/capabilities.test.ts

@@ -96,6 +96,34 @@ test("resolveCapabilities returns a frozen object", () => {
   assert.equal(Object.isFrozen(caps), true, "CapabilitySet must be frozen");
 });
 
+test("resolveCapabilities is deterministic — same config always yields identical gate values (one-resolution-per-op #1523)", () => {
+  // The one-resolution-per-op contract (issue #1523): resolve ONCE at the
+  // operation entry, thread the frozen result down. This test proves the
+  // resolution is deterministic — calling it twice with the same config
+  // produces identical values for every gate, so there is never a reason to
+  // re-resolve mid-operation.
+  const config = parseConfig({
+    rerankCacheEnabled: true,
+    recallDirectAnswerEnabled: false,
+    recallMmrEnabled: true,
+    recallPlannerLlmEnabled: true,
+    graphRecallEnabled: true,
+  });
+  const first = resolveCapabilities(config);
+  const second = resolveCapabilities(config);
+  for (const field of FIELDS) {
+    assert.equal(
+      first[field],
+      second[field],
+      `field ${field} must be deterministic across resolutions`,
+    );
+  }
+  // Both must be frozen — a mid-operation mutation would break the contract.
+  assert.equal(Object.isFrozen(first), true);
+  assert.equal(Object.isFrozen(second), true);
+});
+
+
 // ---------------------------------------------------------------------------
 // GraphConstructionCapabilitySet — gate-parity tests (issue #1566 Cluster A).
 //

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

@@ -13,7 +13,6 @@ import type { TrustZoneName } from "./trust-zones.js";
 type WiringConfig = DirectAnswerWiringInput["config"];
 
 const BASE_CONFIG: WiringConfig = {
-  recallDirectAnswerEnabled: true,
   recallDirectAnswerTokenOverlapFloor: 0.5,
   recallDirectAnswerImportanceFloor: 0.7,
   recallDirectAnswerAmbiguityMargin: 0.15,
@@ -105,17 +104,24 @@ 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 ──
+// ── One-resolution-per-op (#1523): `enabled` is the sole gate ──────────────
 
-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()] });
+test("tryDirectAnswer disabled when `enabled: false` even with matching candidates (caps wins over any config-derived value)", async () => {
+  // Issue #1523 contract: the resolved capability is the sole gate.
+  // `enabled` comes from `resolveCapabilities(config).recallDirectAnswer`,
+  // resolved ONCE at the recall entry. This test proves the gate value is
+  // authoritative — when it says disabled, the function short-circuits
+  // regardless of candidate quality.
+  const sources = makeMockSources({
+    memories: [makeMemory({ tags: ["pnpm"], content: "remnic uses pnpm" })],
+    trustZones: { m1: "trusted" },
+    importance: { m1: 0.9 },
+  });
   const result = await tryDirectAnswer({
-    query: "does not matter",
+    query: "package manager remnic",
     namespace: "default",
-    config: { ...BASE_CONFIG, recallDirectAnswerEnabled: false },
+    config: BASE_CONFIG,
+    enabled: false,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -123,9 +129,9 @@ test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabl
   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.
+test("tryDirectAnswer proceeds when `enabled: true` and candidates match", async () => {
+  // Same contract, positive case: when the resolved capability says enabled,
+  // the function proceeds to materialize candidates.
   const sources = makeMockSources({
     memories: [makeMemory({ tags: ["pnpm"], content: "remnic uses pnpm" })],
     trustZones: { m1: "trusted" },
@@ -134,7 +140,8 @@ test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabl
   const result = await tryDirectAnswer({
     query: "package manager remnic",
     namespace: "default",
-    config: BASE_CONFIG, // recallDirectAnswerEnabled: true
+    config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.notEqual(result.reason, "disabled");

package/src/direct-answer-wiring.ts

@@ -14,8 +14,9 @@
  *
  * Short-circuit contract:
  *
- * - When the resolved gate (`input.enabled` if supplied, else
- *   `config.recallDirectAnswerEnabled`) is `false`, the function returns the
+ * - When the resolved gate (`input.enabled`, projected from
+ *   `caps.recallDirectAnswer` at the recall-operation entry) 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
@@ -74,7 +75,6 @@ export interface DirectAnswerWiringInput {
   namespace: string;
   config: Pick<
     PluginConfig,
-    | "recallDirectAnswerEnabled"
     | "recallDirectAnswerTokenOverlapFloor"
     | "recallDirectAnswerImportanceFloor"
     | "recallDirectAnswerAmbiguityMargin"
@@ -82,13 +82,12 @@ export interface DirectAnswerWiringInput {
   >;
   /**
    * 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.
+   * via `resolveCapabilities(config).recallDirectAnswer` (issue #1523). This
+   * is the sole gate — the function no longer reads the config flag directly.
+   * Callers MUST pass the resolved capability so the whole operation agrees on
+   * a single gate value.
    */
-  enabled?: boolean;
+  enabled: boolean;
   sources: DirectAnswerSources;
   queryEntityRefs?: string[];
   abortSignal?: AbortSignal;
@@ -105,10 +104,7 @@ export async function tryDirectAnswer(
   const { query, namespace, config, enabled, sources, queryEntityRefs, abortSignal } = input;
 
   const eligibilityConfig: DirectAnswerConfig = {
-    // 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,
+    enabled,
     tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,
     importanceFloor: config.recallDirectAnswerImportanceFloor,
     ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,

package/src/maintenance/namespace-planner.ts

@@ -9,6 +9,7 @@ import { namespaceIdentityToken } from "../namespaces/identity.js";
 import { resolveNamespaceStorageRoot } from "../namespaces/storage.js";
 import { displayErrorDetail } from "../runtime/better-sqlite.js";
 import type { PluginConfig } from "../types.js";
+import { getConfiguredNamespaces } from "../scopes/scope-plan.js";
 
 export type NamespaceMaintenanceJobName = string;
 
@@ -110,15 +111,7 @@ export function __setNamespaceMaintenanceFsForTest(overrides: Partial<typeof nam
   };
 }
 
-function configuredNamespaces(config: PluginConfig): string[] {
-  return Array.from(
-    new Set(
-      [config.defaultNamespace, config.sharedNamespace, ...config.namespacePolicies.map((policy) => policy.name)]
-        .map((value) => value.trim())
-        .filter(Boolean)
-    )
-  );
-}
+
 
 function inferConfiguredKind(config: PluginConfig, namespace: string): NamespaceKind {
   if (namespace === config.defaultNamespace.trim()) return "default";
@@ -219,7 +212,7 @@ export async function planNamespaceMaintenance(
   // 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
-    ? configuredNamespaces(config)
+    ? getConfiguredNamespaces(config)
     : [config.defaultNamespace.trim()].filter(Boolean);
   const byNamespace = new Map<string, NamespaceMaintenanceCandidate>();
   const skipped: NamespaceMaintenanceSkippedNamespace[] = [];