@remnic/core 9.3.737 → 9.3.738

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.737",
+  "version": "9.3.738",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.737"
+    "@remnic/coding-graph": "^9.3.738"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-service.ts

@@ -5,12 +5,11 @@ import { readdirSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
-import {
-  resolveNamespaceCapabilities,
+import { resolveNamespaceCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolveQmdCapabilities,
   resolveIdentityContinuityCapabilities,
-  resolveSecurityCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities} from "./capabilities.js";
+  resolveSecurityCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities, resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 import { AccessAuditAdapter, type AccessAuditConfig, type AccessAuditResult } from "./access-audit.js";
 import type { AnomalyDetectorResult } from "./recall-audit-anomaly.js";
 import { resolveGitContext } from "./coding/git-context.js";
@@ -2984,7 +2983,7 @@ export class EngramAccessService {
   async daySummary(
     request: EngramAccessDaySummaryRequest,
   ): Promise<import("./types.js").DaySummaryResult | null> {
-    if (!this.orchestrator.config.daySummaryEnabled) {
+    if (!resolveRecallAuxiliaryCapabilities(this.orchestrator.config).daySummary) {
       throw new EngramAccessInputError("day summary is disabled");
     }
 
@@ -6832,7 +6831,7 @@ export class EngramAccessService {
     if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
       return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
     }
-    if (!this.orchestrator.config.continuityAuditEnabled) {
+    if (!resolveConsolidationCapabilities(this.orchestrator.config).continuityAudit) {
       return { enabled: false, reason: "Continuity audits are disabled. Enable `continuityAuditEnabled: true`." };
     }
     if (!this.orchestrator.compounding) {
@@ -6854,7 +6853,7 @@ export class EngramAccessService {
     if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
       return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
     }
-    if (!this.orchestrator.config.continuityIncidentLoggingEnabled) {
+    if (!resolveRecallAuxiliaryCapabilities(this.orchestrator.config).continuityIncidentLogging) {
       return { enabled: false, reason: "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true`." };
     }
     const symptom = request.symptom?.trim();
@@ -6880,7 +6879,7 @@ export class EngramAccessService {
     if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
       return { enabled: false, reason: "Identity continuity is disabled." };
     }
-    if (!this.orchestrator.config.continuityIncidentLoggingEnabled) {
+    if (!resolveRecallAuxiliaryCapabilities(this.orchestrator.config).continuityIncidentLogging) {
       return { enabled: false, reason: "Continuity incident logging is disabled." };
     }
     const id = request.id?.trim();
@@ -8234,7 +8233,7 @@ export class EngramAccessService {
     const root = explicitRoot ?? storage.dir;
     const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
     const versioning = importOptions.versioning ?? {
-      enabled: this.orchestrator.config.versioningEnabled,
+      enabled: resolveRecallAuxiliaryCapabilities(this.orchestrator.config).versioning,
       maxVersionsPerPage: this.orchestrator.config.versioningMaxPerPage,
       sidecarDir: this.orchestrator.config.versioningSidecarDir,
     };

package/src/buffer.ts

@@ -9,6 +9,7 @@ import type {
   PluginConfig,
   SignalLevel,
 } from "./types.js";
+import { resolvePresentationCapabilities } from "./capabilities.js";
 
 export type TriggerDecision = "extract_now" | "extract_batch" | "keep_buffering";
 
@@ -286,7 +287,7 @@ export class SmartBuffer {
     // *reduce* extraction frequency.
     if (
       decision === "keep_buffering" &&
-      this.config.bufferSurpriseTriggerEnabled &&
+      resolvePresentationCapabilities(this.config).bufferSurpriseTrigger &&
       this.surpriseProbe !== null &&
       // Matching the existing "smart" branch: surprise is a lower-tier
       // novelty signal that should not second-guess a high-signal hit

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,