@remnic/core 9.3.737 → 9.3.739

package/src/capabilities.test.ts

@@ -14,6 +14,9 @@ import {
   resolveUtilityLearningCapabilities,
   resolveObjectiveStateCapabilities,
   resolveCompressionCapabilities,
+  resolvePresentationCapabilities,
+  resolveConsolidationCapabilities,
+  resolveRecallAuxiliaryCapabilities,
   type CapabilitySet,
   type AccessSetupCapabilitySet,
   type NamespaceCapabilitySet,
@@ -25,6 +28,9 @@ import {
   type UtilityLearningCapabilitySet,
   type ObjectiveStateCapabilitySet,
   type CompressionCapabilitySet,
+  type PresentationCapabilitySet,
+  type ConsolidationCapabilitySet,
+  type RecallAuxiliaryCapabilitySet,
 } from "./capabilities.js";
 
 /**
@@ -1021,3 +1027,134 @@ test("resolveCompressionCapabilities returns a frozen object", () => {
   const caps = resolveCompressionCapabilities(parseConfig({}));
   assert.equal(Object.isFrozen(caps), true, "CompressionCapabilitySet must be frozen");
 });
+
+// ---------------------------------------------------------------------------
+// PresentationCapabilitySet — gate-parity tests (issue #1523 batch 8).
+// ---------------------------------------------------------------------------
+
+const PRESENTATION_FIELD_TO_FLAG: Record<keyof PresentationCapabilitySet, string> = {
+  verbatimArtifacts: "verbatimArtifactsEnabled",
+  memoryBoxes: "memoryBoxesEnabled",
+  bufferSurpriseTrigger: "bufferSurpriseTriggerEnabled",
+  threading: "threadingEnabled",
+  episodeNoteMode: "episodeNoteModeEnabled",
+  transcript: "transcriptEnabled",
+  entitySummary: "entitySummaryEnabled",
+};
+
+const PRESENTATION_FIELDS = Object.keys(PRESENTATION_FIELD_TO_FLAG) as Array<keyof PresentationCapabilitySet>;
+
+test("resolvePresentationCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(PRESENTATION_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolvePresentationCapabilities(config);
+  for (const field of PRESENTATION_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolvePresentationCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(PRESENTATION_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolvePresentationCapabilities(config);
+  for (const field of PRESENTATION_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolvePresentationCapabilities returns a frozen object", () => {
+  const caps = resolvePresentationCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "PresentationCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// ConsolidationCapabilitySet — gate-parity tests (issue #1523 batch 8).
+// ---------------------------------------------------------------------------
+
+const CONSOLIDATION_FIELD_TO_FLAG: Record<keyof ConsolidationCapabilitySet, string> = {
+  compoundingSemantic: "compoundingSemanticEnabled",
+  abstractionAnchors: "abstractionAnchorsEnabled",
+  compounding: "compoundingEnabled",
+  calibration: "calibrationEnabled",
+  semanticConsolidation: "semanticConsolidationEnabled",
+  patternReinforcement: "patternReinforcementEnabled",
+  continuityAudit: "continuityAuditEnabled",
+  graphEdgeDecay: "graphEdgeDecayEnabled",
+};
+
+const CONSOLIDATION_FIELDS = Object.keys(CONSOLIDATION_FIELD_TO_FLAG) as Array<keyof ConsolidationCapabilitySet>;
+
+test("resolveConsolidationCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CONSOLIDATION_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveConsolidationCapabilities(config);
+  for (const field of CONSOLIDATION_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveConsolidationCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CONSOLIDATION_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveConsolidationCapabilities(config);
+  for (const field of CONSOLIDATION_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveConsolidationCapabilities returns a frozen object", () => {
+  const caps = resolveConsolidationCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "ConsolidationCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// RecallAuxiliaryCapabilitySet — gate-parity tests (issue #1523 batch 8).
+// ---------------------------------------------------------------------------
+
+const RECALL_AUX_FIELD_TO_FLAG: Record<keyof RecallAuxiliaryCapabilitySet, string> = {
+  causalRuleExtraction: "causalRuleExtractionEnabled",
+  correction: "correctionEnabled",
+  continuityIncidentLogging: "continuityIncidentLoggingEnabled",
+  daySummary: "daySummaryEnabled",
+  versioning: "versioningEnabled",
+  verifiedRecall: "verifiedRecallEnabled",
+  semanticRuleVerification: "semanticRuleVerificationEnabled",
+  workProductRecall: "workProductRecallEnabled",
+  secureStore: "secureStoreEnabled",
+  knowledgeIndex: "knowledgeIndexEnabled",
+  factDeduplication: "factDeduplicationEnabled",
+  compactionReset: "compactionResetEnabled",
+  entityRetrieval: "entityRetrievalEnabled",
+  cronRecallPolicy: "cronRecallPolicyEnabled",
+};
+
+const RECALL_AUX_FIELDS = Object.keys(RECALL_AUX_FIELD_TO_FLAG) as Array<keyof RecallAuxiliaryCapabilitySet>;
+
+test("resolveRecallAuxiliaryCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(RECALL_AUX_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveRecallAuxiliaryCapabilities(config);
+  for (const field of RECALL_AUX_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveRecallAuxiliaryCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(RECALL_AUX_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveRecallAuxiliaryCapabilities(config);
+  for (const field of RECALL_AUX_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveRecallAuxiliaryCapabilities returns a frozen object", () => {
+  const caps = resolveRecallAuxiliaryCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "RecallAuxiliaryCapabilitySet must be frozen");
+});

package/src/capabilities.ts

@@ -807,3 +807,212 @@ export function resolveCompressionCapabilities(config: CompressionConfigProjecti
     contextCompressionActions: config.contextCompressionActionsEnabled,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Presentation capability set (issue #1523 batch 8).
+//
+// These flags gate output formatting and presentation across the orchestrator, extraction
+// pipeline, consolidation engine, and related modules. Resolved ONCE per
+// operation entry rather than re-derived from raw config at each read site.
+// All flags are non-optional booleans on PluginConfig (defaults applied at
+// the parse boundary), so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of output formatting and presentation feature gates (issue #1523 batch 8).
+ */
+export interface PresentationCapabilitySet {
+  /** `verbatimArtifactsEnabled` — verbatim-artifact rendering in recall output. */
+  readonly verbatimArtifacts: boolean;
+  /** `memoryBoxesEnabled` — memory-box rendering in recall output. */
+  readonly memoryBoxes: boolean;
+  /** `bufferSurpriseTriggerEnabled` — buffer surprise-detection trigger. */
+  readonly bufferSurpriseTrigger: boolean;
+  /** `threadingEnabled` — conversation threading in output. */
+  readonly threading: boolean;
+  /** `episodeNoteModeEnabled` — episode note-mode formatting. */
+  readonly episodeNoteMode: boolean;
+  /** `transcriptEnabled` — transcript-mode output. */
+  readonly transcript: boolean;
+  /** `entitySummaryEnabled` — entity summary generation. */
+  readonly entitySummary: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolvePresentationCapabilities}.
+ */
+export type PresentationConfigProjection = Pick<
+  PluginConfig,
+  "verbatimArtifactsEnabled" |
+  "memoryBoxesEnabled" |
+  "bufferSurpriseTriggerEnabled" |
+  "threadingEnabled" |
+  "episodeNoteModeEnabled" |
+  "transcriptEnabled" |
+  "entitySummaryEnabled"
+>;
+
+/**
+ * Resolve the {@link PresentationCapabilitySet} from parsed config.
+ */
+export function resolvePresentationCapabilities(config: PresentationConfigProjection): PresentationCapabilitySet {
+  return Object.freeze({
+    verbatimArtifacts: config.verbatimArtifactsEnabled,
+    memoryBoxes: config.memoryBoxesEnabled,
+    bufferSurpriseTrigger: config.bufferSurpriseTriggerEnabled,
+    threading: config.threadingEnabled,
+    episodeNoteMode: config.episodeNoteModeEnabled,
+    transcript: config.transcriptEnabled,
+    entitySummary: config.entitySummaryEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Consolidation capability set (issue #1523 batch 8).
+//
+// These flags gate memory consolidation, compounding, and abstraction across the orchestrator, extraction
+// pipeline, consolidation engine, and related modules. Resolved ONCE per
+// operation entry rather than re-derived from raw config at each read site.
+// All flags are non-optional booleans on PluginConfig (defaults applied at
+// the parse boundary), so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of memory consolidation, compounding, and abstraction feature gates (issue #1523 batch 8).
+ */
+export interface ConsolidationCapabilitySet {
+  /** `compoundingSemanticEnabled` — semantic compounding of memories. */
+  readonly compoundingSemantic: boolean;
+  /** `abstractionAnchorsEnabled` — abstraction-anchor extraction. */
+  readonly abstractionAnchors: boolean;
+  /** `compoundingEnabled` — master compounding switch. */
+  readonly compounding: boolean;
+  /** `calibrationEnabled` — memory calibration pass. */
+  readonly calibration: boolean;
+  /** `semanticConsolidationEnabled` — semantic consolidation pass. */
+  readonly semanticConsolidation: boolean;
+  /** `patternReinforcementEnabled` — pattern reinforcement in consolidation. */
+  readonly patternReinforcement: boolean;
+  /** `continuityAuditEnabled` — continuity audit during consolidation. */
+  readonly continuityAudit: boolean;
+  /** `graphEdgeDecayEnabled` — graph edge decay in maintenance. */
+  readonly graphEdgeDecay: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveConsolidationCapabilities}.
+ */
+export type ConsolidationConfigProjection = Pick<
+  PluginConfig,
+  "compoundingSemanticEnabled" |
+  "abstractionAnchorsEnabled" |
+  "compoundingEnabled" |
+  "calibrationEnabled" |
+  "semanticConsolidationEnabled" |
+  "patternReinforcementEnabled" |
+  "continuityAuditEnabled" |
+  "graphEdgeDecayEnabled"
+>;
+
+/**
+ * Resolve the {@link ConsolidationCapabilitySet} from parsed config.
+ */
+export function resolveConsolidationCapabilities(config: ConsolidationConfigProjection): ConsolidationCapabilitySet {
+  return Object.freeze({
+    compoundingSemantic: config.compoundingSemanticEnabled,
+    abstractionAnchors: config.abstractionAnchorsEnabled,
+    compounding: config.compoundingEnabled,
+    calibration: config.calibrationEnabled,
+    semanticConsolidation: config.semanticConsolidationEnabled,
+    patternReinforcement: config.patternReinforcementEnabled,
+    continuityAudit: config.continuityAuditEnabled,
+    graphEdgeDecay: config.graphEdgeDecayEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// RecallAuxiliary capability set (issue #1523 batch 8).
+//
+// These flags gate extraction pipeline details and auxiliary recall enrichment across the orchestrator, extraction
+// pipeline, consolidation engine, and related modules. Resolved ONCE per
+// operation entry rather than re-derived from raw config at each read site.
+// All flags are non-optional booleans on PluginConfig (defaults applied at
+// the parse boundary), so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of extraction pipeline details and auxiliary recall enrichment feature gates (issue #1523 batch 8).
+ */
+export interface RecallAuxiliaryCapabilitySet {
+  /** `causalRuleExtractionEnabled` — causal-rule extraction in pipeline. */
+  readonly causalRuleExtraction: boolean;
+  /** `correctionEnabled` — memory correction subsystem. */
+  readonly correction: boolean;
+  /** `continuityIncidentLoggingEnabled` — continuity incident logging. */
+  readonly continuityIncidentLogging: boolean;
+  /** `daySummaryEnabled` — day-summary generation. */
+  readonly daySummary: boolean;
+  /** `versioningEnabled` — memory versioning. */
+  readonly versioning: boolean;
+  /** `verifiedRecallEnabled` — verified-recall tier. */
+  readonly verifiedRecall: boolean;
+  /** `semanticRuleVerificationEnabled` — semantic-rule verification. */
+  readonly semanticRuleVerification: boolean;
+  /** `workProductRecallEnabled` — work-product recall tier. */
+  readonly workProductRecall: boolean;
+  /** `secureStoreEnabled` — secure storage mode. */
+  readonly secureStore: boolean;
+  /** `knowledgeIndexEnabled` — knowledge index in recall. */
+  readonly knowledgeIndex: boolean;
+  /** `factDeduplicationEnabled` — fact deduplication in recall. */
+  readonly factDeduplication: boolean;
+  /** `compactionResetEnabled` — compaction reset on re-ingest. */
+  readonly compactionReset: boolean;
+  /** `entityRetrievalEnabled` — entity retrieval tier. */
+  readonly entityRetrieval: boolean;
+  /** `cronRecallPolicyEnabled` — cron-based recall policy. */
+  readonly cronRecallPolicy: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveRecallAuxiliaryCapabilities}.
+ */
+export type RecallAuxiliaryConfigProjection = Pick<
+  PluginConfig,
+  "causalRuleExtractionEnabled" |
+  "correctionEnabled" |
+  "continuityIncidentLoggingEnabled" |
+  "daySummaryEnabled" |
+  "versioningEnabled" |
+  "verifiedRecallEnabled" |
+  "semanticRuleVerificationEnabled" |
+  "workProductRecallEnabled" |
+  "secureStoreEnabled" |
+  "knowledgeIndexEnabled" |
+  "factDeduplicationEnabled" |
+  "compactionResetEnabled" |
+  "entityRetrievalEnabled" |
+  "cronRecallPolicyEnabled"
+>;
+
+/**
+ * Resolve the {@link RecallAuxiliaryCapabilitySet} from parsed config.
+ */
+export function resolveRecallAuxiliaryCapabilities(config: RecallAuxiliaryConfigProjection): RecallAuxiliaryCapabilitySet {
+  return Object.freeze({
+    causalRuleExtraction: config.causalRuleExtractionEnabled,
+    correction: config.correctionEnabled,
+    continuityIncidentLogging: config.continuityIncidentLoggingEnabled,
+    daySummary: config.daySummaryEnabled,
+    versioning: config.versioningEnabled,
+    verifiedRecall: config.verifiedRecallEnabled,
+    semanticRuleVerification: config.semanticRuleVerificationEnabled,
+    workProductRecall: config.workProductRecallEnabled,
+    secureStore: config.secureStoreEnabled,
+    knowledgeIndex: config.knowledgeIndexEnabled,
+    factDeduplication: config.factDeduplicationEnabled,
+    compactionReset: config.compactionResetEnabled,
+    entityRetrieval: config.entityRetrievalEnabled,
+    cronRecallPolicy: config.cronRecallPolicyEnabled,
+  });
+}

package/src/cli/creation-ledger-commands.ts

@@ -20,7 +20,7 @@ import type { CliCommand } from "../cli.js";
 import type { CommitmentLedgerEntry } from "../commitment-ledger.js";
 import type { WorkProductLedgerEntry } from "../work-product-ledger.js";
 import type { ResumeBundle } from "../resume-bundles.js";
-import { resolveCreationMemoryCapabilities, resolveObjectiveStateCapabilities} from "../capabilities.js";
+import { resolveCreationMemoryCapabilities, resolveObjectiveStateCapabilities, resolvePresentationCapabilities, resolveRecallAuxiliaryCapabilities } from "../capabilities.js";
 import {
   runResumeBundleStatusCliCommand,
   runResumeBundleRecordCliCommand,
@@ -130,7 +130,7 @@ cmd
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
       creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
       resumeBundlesEnabled: resolveCreationMemoryCapabilities(orchestrator.config).resumeBundles,
-      transcriptEnabled: orchestrator.config.transcriptEnabled,
+      transcriptEnabled: resolvePresentationCapabilities(orchestrator.config).transcript,
       objectiveStateMemoryEnabled: resolveObjectiveStateCapabilities(orchestrator.config).objectiveStateMemory,
       commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
       bundleId: String(options.bundleId ?? ""),
@@ -336,7 +336,7 @@ cmd
       memoryDir: orchestrator.config.memoryDir,
       workProductLedgerDir: orchestrator.config.workProductLedgerDir,
       creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
-      workProductRecallEnabled: orchestrator.config.workProductRecallEnabled,
+      workProductRecallEnabled: resolveRecallAuxiliaryCapabilities(orchestrator.config).workProductRecall,
       query,
       maxResults: Number.isFinite(maxResults) ? maxResults : 3,
       sessionKey: typeof options.sessionKey === "string" ? options.sessionKey : undefined,

package/src/cli/research-status-commands.ts

@@ -18,7 +18,7 @@
  */
 
 import type { Orchestrator } from "../orchestrator.js";
-import { resolveCapabilities, resolveSecurityCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities} from "../capabilities.js";
+import { resolveCapabilities, resolveSecurityCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveConsolidationCapabilities } from "../capabilities.js";
 import type { CliCommand } from "../cli.js";
 import type { UtilityTelemetryEvent } from "../utility-telemetry.js";
 import {
@@ -116,7 +116,7 @@ cmd
       memoryDir: orchestrator.config.memoryDir,
       abstractionNodeStoreDir: orchestrator.config.abstractionNodeStoreDir,
       harmonicRetrievalEnabled: caps.harmonicRetrieval,
-      abstractionAnchorsEnabled: orchestrator.config.abstractionAnchorsEnabled,
+      abstractionAnchorsEnabled: resolveConsolidationCapabilities(orchestrator.config).abstractionAnchors,
     });
     console.log(JSON.stringify(status, null, 2));
     console.log("OK");
@@ -130,7 +130,7 @@ cmd
       memoryDir: orchestrator.config.memoryDir,
       abstractionNodeStoreDir: orchestrator.config.abstractionNodeStoreDir,
       harmonicRetrievalEnabled: caps.harmonicRetrieval,
-      abstractionAnchorsEnabled: orchestrator.config.abstractionAnchorsEnabled,
+      abstractionAnchorsEnabled: resolveConsolidationCapabilities(orchestrator.config).abstractionAnchors,
     });
     console.log(JSON.stringify(status, null, 2));
     console.log("OK");
@@ -152,7 +152,7 @@ cmd
       memoryDir: orchestrator.config.memoryDir,
       abstractionNodeStoreDir: orchestrator.config.abstractionNodeStoreDir,
       harmonicRetrievalEnabled: caps.harmonicRetrieval,
-      abstractionAnchorsEnabled: orchestrator.config.abstractionAnchorsEnabled,
+      abstractionAnchorsEnabled: resolveConsolidationCapabilities(orchestrator.config).abstractionAnchors,
       query,
       maxResults: Number.isFinite(maxResults) ? maxResults : 3,
       sessionKey: typeof options.sessionKey === "string" ? options.sessionKey : undefined,

package/src/cli.ts

@@ -4,11 +4,10 @@ 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 {
-  resolveNamespaceCapabilities,
+import { resolveNamespaceCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolveIdentityContinuityCapabilities,
-  resolveSecurityCapabilities, resolveEvalCapabilities} from "./capabilities.js";
+  resolveSecurityCapabilities, resolveEvalCapabilities, resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 import { ThreadingManager } from "./threading.js";
 import { utcDayRange } from "./transcript.js";
 import { runWearablesCliCommand } from "./wearables/cli.js";
@@ -6259,7 +6258,7 @@ export function registerCli(
             : 3;
           const results = await runVerifiedRecallSearchCliCommand({
             memoryDir: orchestrator.config.memoryDir,
-            verifiedRecallEnabled: orchestrator.config.verifiedRecallEnabled,
+            verifiedRecallEnabled: resolveRecallAuxiliaryCapabilities(orchestrator.config).verifiedRecall,
             query,
             maxResults: Number.isFinite(maxResults) ? maxResults : 3,
             boxRecallDays: orchestrator.config.boxRecallDays,
@@ -6295,8 +6294,8 @@ export function registerCli(
           const options = (args[0] ?? {}) as Record<string, unknown>;
           const result = await runCompoundingPromoteCliCommand({
             memoryDir: orchestrator.config.memoryDir,
-            compoundingEnabled: orchestrator.config.compoundingEnabled,
-            compoundingSemanticEnabled: orchestrator.config.compoundingSemanticEnabled,
+            compoundingEnabled: resolveConsolidationCapabilities(orchestrator.config).compounding,
+            compoundingSemanticEnabled: resolveConsolidationCapabilities(orchestrator.config).compoundingSemantic,
             weekId: String(options.weekId ?? ""),
             candidateId: String(options.candidateId ?? ""),
             dryRun: options.dryRun === true,
@@ -6318,7 +6317,7 @@ export function registerCli(
             : 3;
           const results = await runSemanticRuleVerifyCliCommand({
             memoryDir: orchestrator.config.memoryDir,
-            semanticRuleVerificationEnabled: orchestrator.config.semanticRuleVerificationEnabled,
+            semanticRuleVerificationEnabled: resolveRecallAuxiliaryCapabilities(orchestrator.config).semanticRuleVerification,
             query,
             maxResults: Number.isFinite(maxResults) ? maxResults : 3,
           });
@@ -7805,7 +7804,7 @@ export function registerCli(
             memoryDir: orchestrator.config.memoryDir,
             targetPath,
             versioning: {
-              enabled: orchestrator.config.versioningEnabled,
+              enabled: resolveRecallAuxiliaryCapabilities(orchestrator.config).versioning,
               maxVersionsPerPage: orchestrator.config.versioningMaxPerPage,
               sidecarDir: orchestrator.config.versioningSidecarDir,
             },
@@ -7894,7 +7893,7 @@ export function registerCli(
             console.log("Identity continuity is disabled.");
             return;
           }
-          if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          if (!resolveRecallAuxiliaryCapabilities(orchestrator.config).continuityIncidentLogging) {
             console.log("Continuity incident logging is disabled.");
             return;
           }
@@ -7925,7 +7924,7 @@ export function registerCli(
             console.log("Identity continuity is disabled.");
             return;
           }
-          if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          if (!resolveRecallAuxiliaryCapabilities(orchestrator.config).continuityIncidentLogging) {
             console.log("Continuity incident logging is disabled.");
             return;
           }

package/src/compounding/engine.ts

@@ -7,7 +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";
+import { resolveQmdCapabilities, type QmdConfigProjection, resolveConsolidationCapabilities } from "../capabilities.js";
 
 type MistakesFile = {
   version?: number;
@@ -493,7 +493,7 @@ export class CompoundingEngine {
     const previousMistakes = await this.readMistakes();
     const mistakes = this.buildMistakes(entries, actionPatterns, weekId, previousMistakes?.registry ?? []);
     const rubrics = this.buildRubricSnapshot(entries, outcomeSummary);
-    let promotionCandidates = this.config.compoundingSemanticEnabled
+    let promotionCandidates = resolveConsolidationCapabilities(this.config).compoundingSemantic
       ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics)
       : [];
     if (this.config.cmcConsolidationEnabled) {
@@ -540,7 +540,7 @@ export class CompoundingEngine {
       }
     }
     // PEDC: Run calibration consolidation during weekly synthesis
-    if (this.config.calibrationEnabled) {
+    if (resolveConsolidationCapabilities(this.config).calibration) {
       try {
         const { runCalibrationConsolidation } = await import("../calibration.js");
         const calRules = await runCalibrationConsolidation({
@@ -555,7 +555,7 @@ export class CompoundingEngine {
         log.warn(`[calibration] weekly consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
       }
     }
-    const continuity = this.config.continuityAuditEnabled
+    const continuity = resolveConsolidationCapabilities(this.config).continuityAudit
       ? await this.readContinuityAuditReferences(weekId)
       : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
 
@@ -641,7 +641,7 @@ export class CompoundingEngine {
     storage?: StorageManager;
   }): Promise<CompoundingPromotionReport> {
     const report: CompoundingPromotionReport = {
-      enabled: this.config.compoundingEnabled === true && this.config.compoundingSemanticEnabled === true,
+      enabled: resolveConsolidationCapabilities(this.config).compounding === true && resolveConsolidationCapabilities(this.config).compoundingSemantic === true,
       dryRun: opts.dryRun === true,
       weekId: opts.weekId,
       promoted: [],
@@ -1384,7 +1384,7 @@ export class CompoundingEngine {
     }
     lines.push("");
 
-    if (this.config.compoundingSemanticEnabled) {
+    if (resolveConsolidationCapabilities(this.config).compoundingSemantic) {
       lines.push("## Promotion Candidates (Advisory)");
       if (promotionCandidates.length === 0) {
         lines.push("- (no advisory promotion candidates this week)");
@@ -1403,7 +1403,7 @@ export class CompoundingEngine {
       lines.push("");
     }
 
-    if (this.config.continuityAuditEnabled) {
+    if (resolveConsolidationCapabilities(this.config).continuityAudit) {
       lines.push("## Continuity Audits");
       if (continuity.weeklyPath) {
         lines.push(`- weekly: ${continuity.weeklyPath}`);

package/src/correction/correction-access-wiring.ts

@@ -43,6 +43,7 @@ import {
 } from "./correction-planner.js";
 import { type ExecutorDeps, type ExecutorMemory } from "./correction-executor.js";
 import { CorrectionService, type CorrectionServiceDeps } from "./correction-service.js";
+import { resolveRecallAuxiliaryCapabilities } from "../capabilities.js";
 
 // ---------------------------------------------------------------------------
 // Public entry: build a fully-wired CorrectionService
@@ -810,11 +811,11 @@ function toExecutorMemory(m: MemoryFile): ExecutorMemory {
  * Nested wins when present; both default to `true` (plan is read-only, safe on).
  */
 export function isCorrectionFeatureEnabled(config: PluginConfig): boolean {
-  // parseConfig now resolves this into `config.correctionEnabled` (review
+  // parseConfig now resolves this into `resolveRecallAuxiliaryCapabilities(config).correction` (review
   // thread Txp) — prefer the parsed boolean so operator config actually takes
   // effect. The loose nested/flat read stays as a fallback for PluginConfig-
   // shaped objects built without parseConfig (unit tests).
-  if (typeof config.correctionEnabled === "boolean") return config.correctionEnabled;
+  if (typeof resolveRecallAuxiliaryCapabilities(config).correction === "boolean") return resolveRecallAuxiliaryCapabilities(config).correction;
   const nested = (config as unknown as Record<string, unknown>).correction as
     | Record<string, unknown>
     | undefined;

package/src/extraction.ts

@@ -38,10 +38,8 @@ 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,
-  resolveLocalLlmCapabilities,
-} from "./capabilities.js";
+import { resolveMemoryLifecycleCapabilities,
+  resolveLocalLlmCapabilities,resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 
 type ExtractionQuestion = ExtractionResult["questions"][number];
 type ExtractedFactResult = ExtractionResult["facts"][number];
@@ -1664,7 +1662,7 @@ Memory categories:
 - principle: Durable rules, values, or operating beliefs (e.g., "never use Chat Completions API")
 - commitment: Promises, obligations, or deadlines (e.g., "deploy by Friday", "call accountant Monday")
 - moment: Emotionally significant events or milestones (e.g., "first successful deployment of engram")
-- skill: Capabilities the user or agent has demonstrated (e.g., "user is proficient with Kubernetes")${this.config.causalRuleExtractionEnabled ? `
+- skill: Capabilities the user or agent has demonstrated (e.g., "user is proficient with Kubernetes")${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? `
 - rule: Causal rules discovered through experience (format: "IF <condition> THEN <action/outcome>", e.g., "IF Shopify API returns 401 THEN the admin token is missing read_products scope")` : ""}
 - procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to "procedure". Use "content" for a short title that includes explicit trigger phrasing (e.g. "When you deploy to production…", "Whenever you ship a release…"). Add "procedureSteps": an array of at least two objects {"order": number, "intent": "concrete step description"} in execution order. Optional per-step "toolCall": {"kind": "…", "signature": "…"}, "expectedOutcome", "optional": true.
 - reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. "Here's how I debugged the latency spike: first I checked…, then I…, finally I…"). Set category to "reasoning_trace". Use "content" for a short title summarising the problem (e.g. "How I debugged the staging latency spike"). Add "reasoningTrace": {"steps": [{"order": number, "description": "what happened at this step"}, …], "finalAnswer": "the conclusion or answer", "observedOutcome": "optional confirmation of how it played out"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning — not for ordinary decisions (use "decision") or reusable workflows (use "procedure").
@@ -1672,7 +1670,7 @@ Memory categories:
 Rules:
 - Only extract genuinely NEW information worth remembering across sessions
 - Skip transient task details (file paths being edited, current errors, etc.)
-- Priority: corrections > principles${this.config.causalRuleExtractionEnabled ? " > rules" : ""} > preferences > commitments > decisions > relationships > entities > moments > skills > facts
+- Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? " > rules" : ""} > preferences > commitments > decisions > relationships > entities > moments > skills > facts
 - Corrections (user saying "actually, don't do X" or "I prefer Y") get highest confidence
 - Each fact should be a standalone, self-contained statement
 - Lines labelled [context user] or [context assistant] are reference context only. Use them to resolve pronouns and adjacent question/answer pairs, but do not extract a memory stated only in context lines unless a normal [user] or [assistant] line confirms or completes it.
@@ -1800,7 +1798,7 @@ Actions:
 
 Also:
 - Suggest profile updates based on patterns across memories
-- Identify entity updates for entity tracking${this.config.causalRuleExtractionEnabled ? `
+- Identify entity updates for entity tracking${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? `
 - When merging or updating memories, look for IF→THEN causal patterns. If a memory describes "X failed/succeeded because Y" or "doing X led to Y", rewrite its content to make the causal rule explicit in the form "IF <condition> THEN <action/outcome>".` : ""}`,
         },
         {
@@ -1846,7 +1844,7 @@ Actions:
 
 Also:
 - Suggest profile updates based on patterns across memories
-- Identify entity updates for entity tracking${this.config.causalRuleExtractionEnabled ? `
+- Identify entity updates for entity tracking${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? `
 - When merging or updating memories, look for IF→THEN causal patterns. If a memory describes "X failed/succeeded because Y" or "doing X led to Y", rewrite its content to make the causal rule explicit in the form "IF <condition> THEN <action/outcome>".` : ""}
 
 Current behavioral profile:
@@ -1944,7 +1942,7 @@ Actions:
 
 Also:
 - Suggest profile updates based on patterns across memories
-- Identify entity updates for entity tracking${this.config.causalRuleExtractionEnabled ? `
+- Identify entity updates for entity tracking${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? `
 - When merging or updating memories, look for IF→THEN causal patterns. If a memory describes "X failed/succeeded because Y" or "doing X led to Y", rewrite its content to make the causal rule explicit in the form "IF <condition> THEN <action/outcome>".` : ""}
 
 Current behavioral profile:
@@ -2689,7 +2687,7 @@ Respond with valid JSON matching this schema:
   }
 
   async generateDaySummary(memories: string | MemoryFile[]): Promise<DaySummaryResultShape | null> {
-    if (!this.config.daySummaryEnabled) {
+    if (!resolveRecallAuxiliaryCapabilities(this.config).daySummary) {
       log.warn("day summary skipped — disabled by config");
       return null;
     }