@remnic/core 9.3.738 → 9.3.740

package/dist/{tier-stats-QID73BBB.js → tier-stats-CSKL7BDG.js}

@@ -14,7 +14,7 @@ import {
 import {
   resolveQmdCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-RJBW4EOU.js";
+} from "./chunk-G7Q4D2G3.js";
 import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
 import "./chunk-PZ5AY32C.js";
@@ -153,4 +153,4 @@ export {
   formatTierSummaryText,
   summarizeTiers
 };
-//# sourceMappingURL=tier-stats-QID73BBB.js.map
+//# sourceMappingURL=tier-stats-CSKL7BDG.js.map

package/dist/verified-recall.js

@@ -1,10 +1,10 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-WDJCZQB4.js";
+} from "./chunk-UGFPGWJB.js";
 import "./chunk-7FL4CNPV.js";
 import "./chunk-ZBJMUXZH.js";
-import "./chunk-Q6BAA57B.js";
+import "./chunk-JFCS6PQU.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.738",
+  "version": "9.3.740",
   "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.738"
+    "@remnic/coding-graph": "^9.3.740"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-service.ts

@@ -249,6 +249,7 @@ import {
 } from "./action-confidence.js";
 import { formatProfileTraceAscii } from "./profiling.js";
 import { resolveAccessSetupCapabilities, resolveGraphConstructionCapabilities, resolveIndexingCapabilities } from "./capabilities.js";
+import { resolveRecallEnhancementCapabilities } from "./capabilities.js";
 
 export class EngramAccessInputError extends Error {}
 
@@ -7639,7 +7640,7 @@ export class EngramAccessService {
     vote: "up" | "down";
     note?: string;
   }): Promise<{ recorded: boolean; enabled?: boolean; reason?: string }> {
-    if (!this.orchestrator.config.feedbackEnabled) {
+    if (!resolveRecallEnhancementCapabilities(this.orchestrator.config).feedback) {
       return {
         recorded: false,
         enabled: false,

package/src/capabilities.test.ts

@@ -17,6 +17,9 @@ import {
   resolvePresentationCapabilities,
   resolveConsolidationCapabilities,
   resolveRecallAuxiliaryCapabilities,
+  resolveRecallEnhancementCapabilities,
+  resolvePipelineProcessingCapabilities,
+  resolveConversationContextCapabilities,
   type CapabilitySet,
   type AccessSetupCapabilitySet,
   type NamespaceCapabilitySet,
@@ -31,6 +34,9 @@ import {
   type PresentationCapabilitySet,
   type ConsolidationCapabilitySet,
   type RecallAuxiliaryCapabilitySet,
+  type RecallEnhancementCapabilitySet,
+  type PipelineProcessingCapabilitySet,
+  type ConversationContextCapabilitySet,
 } from "./capabilities.js";
 
 /**
@@ -1158,3 +1164,163 @@ test("resolveRecallAuxiliaryCapabilities returns a frozen object", () => {
   const caps = resolveRecallAuxiliaryCapabilities(parseConfig({}));
   assert.equal(Object.isFrozen(caps), true, "RecallAuxiliaryCapabilitySet must be frozen");
 });
+
+
+// ---------------------------------------------------------------------------
+// RecallEnhancementCapabilitySet — gate-parity tests (issue #1523 batch 9).
+// ---------------------------------------------------------------------------
+
+const RECALL_ENH_FIELD_TO_FLAG: Record<keyof RecallEnhancementCapabilitySet, string> = {
+  explicitCueRecall: "explicitCueRecallEnabled",
+  targetedFactRecall: "targetedFactRecallEnabled",
+  focusedListRecall: "focusedListRecallEnabled",
+  responseGuidanceRecall: "responseGuidanceRecallEnabled",
+  eventOrderRecall: "eventOrderRecallEnabled",
+  reinforcementRecallBoost: "reinforcementRecallBoostEnabled",
+  recallPlannerTelemetry: "recallPlannerTelemetryEnabled",
+  peerProfileRecall: "peerProfileRecallEnabled",
+  graphAssistShadowEval: "graphAssistShadowEvalEnabled",
+  memoryReconstruction: "memoryReconstructionEnabled",
+  memoryLinking: "memoryLinkingEnabled",
+  causalTrajectoryRecall: "causalTrajectoryRecallEnabled",
+  causalTrajectoryMemory: "causalTrajectoryMemoryEnabled",
+  cmcRetrieval: "cmcRetrievalEnabled",
+  contradictionDetection: "contradictionDetectionEnabled",
+  factArchival: "factArchivalEnabled",
+  entityRelationships: "entityRelationshipsEnabled",
+  entityActivityLog: "entityActivityLogEnabled",
+  compoundingInject: "compoundingInjectEnabled",
+  accessTracking: "accessTrackingEnabled",
+  autoPromoteToShared: "autoPromoteToSharedEnabled",
+  recallGraph: "recallGraphEnabled",
+  feedback: "feedbackEnabled",
+  identity: "identityEnabled",
+};
+
+const RECALL_ENH_FIELDS = Object.keys(RECALL_ENH_FIELD_TO_FLAG) as Array<keyof RecallEnhancementCapabilitySet>;
+
+test("resolveRecallEnhancementCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(RECALL_ENH_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveRecallEnhancementCapabilities(config);
+  for (const field of RECALL_ENH_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveRecallEnhancementCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(RECALL_ENH_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveRecallEnhancementCapabilities(config);
+  for (const field of RECALL_ENH_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveRecallEnhancementCapabilities returns a frozen object", () => {
+  const caps = resolveRecallEnhancementCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "RecallEnhancementCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// PipelineProcessingCapabilitySet — gate-parity tests (issue #1523 batch 9).
+// ---------------------------------------------------------------------------
+
+const PIPELINE_FIELD_TO_FLAG: Record<keyof PipelineProcessingCapabilitySet, string> = {
+  chunking: "chunkingEnabled",
+  semanticChunking: "semanticChunkingEnabled",
+  semanticDedup: "semanticDedupEnabled",
+  summarization: "summarizationEnabled",
+  topicExtraction: "topicExtractionEnabled",
+  sessionObserver: "sessionObserverEnabled",
+  profiling: "profilingEnabled",
+  checkpoint: "checkpointEnabled",
+  traceWeaver: "traceWeaverEnabled",
+  routingRules: "routingRulesEnabled",
+  inlineSourceAttribution: "inlineSourceAttributionEnabled",
+  negativeExamples: "negativeExamplesEnabled",
+  hourlySummaries: "hourlySummariesEnabled",
+  lcm: "lcmEnabled",
+  localLlmFast: "localLlmFastEnabled",
+  proactiveExtraction: "proactiveExtractionEnabled",
+  delinearize: "delinearizeEnabled",
+  slowLog: "slowLogEnabled",
+  hostEmbeddingProvider: "hostEmbeddingProviderEnabled",
+  memoryExtensions: "memoryExtensionsEnabled",
+  hourlySummariesExtended: "hourlySummariesExtendedEnabled",
+};
+
+const PIPELINE_FIELDS = Object.keys(PIPELINE_FIELD_TO_FLAG) as Array<keyof PipelineProcessingCapabilitySet>;
+
+test("resolvePipelineProcessingCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(PIPELINE_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolvePipelineProcessingCapabilities(config);
+  for (const field of PIPELINE_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolvePipelineProcessingCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(PIPELINE_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolvePipelineProcessingCapabilities(config);
+  for (const field of PIPELINE_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolvePipelineProcessingCapabilities returns a frozen object", () => {
+  const caps = resolvePipelineProcessingCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "PipelineProcessingCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// ConversationContextCapabilitySet — gate-parity tests (issue #1523 batch 9).
+// ---------------------------------------------------------------------------
+
+const CONV_CTX_FIELD_TO_FLAG: Record<keyof ConversationContextCapabilitySet, string> = {
+  sharedContext: "sharedContextEnabled",
+  intentRouting: "intentRoutingEnabled",
+  crossSignalsSemantic: "crossSignalsSemanticEnabled",
+  sharedCrossSignalSemantic: "sharedCrossSignalSemanticEnabled",
+  operatorAwareConsolidation: "operatorAwareConsolidationEnabled",
+  peerProfileReasoner: "peerProfileReasonerEnabled",
+  cmcConsolidation: "cmcConsolidationEnabled",
+  maintenanceNamespaceFanout: "maintenanceNamespaceFanoutEnabled",
+  citations: "citationsEnabled",
+  behaviorLoopAutoTune: "behaviorLoopAutoTuneEnabled",
+  semanticRulePromotion: "semanticRulePromotionEnabled",
+  codexMarketplace: "codexMarketplaceEnabled",
+};
+
+const CONV_CTX_FIELDS = Object.keys(CONV_CTX_FIELD_TO_FLAG) as Array<keyof ConversationContextCapabilitySet>;
+
+test("resolveConversationContextCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CONV_CTX_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveConversationContextCapabilities(config);
+  for (const field of CONV_CTX_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveConversationContextCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CONV_CTX_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveConversationContextCapabilities(config);
+  for (const field of CONV_CTX_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveConversationContextCapabilities returns a frozen object", () => {
+  const caps = resolveConversationContextCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "ConversationContextCapabilitySet must be frozen");
+});

package/src/capabilities.ts

@@ -1016,3 +1016,270 @@ export function resolveRecallAuxiliaryCapabilities(config: RecallAuxiliaryConfig
     cronRecallPolicy: config.cronRecallPolicyEnabled,
   });
 }
+
+// ---------------------------------------------------------------------------
+// RecallEnhancement capability set (issue #1523 batch 9).
+//
+// These 24 flags gate recall enrichment, memory reconstruction, entity
+// relationships, causal trajectory recall, CMC retrieval, and related
+// enhancement paths. Read sites span orchestrator, access-service, graph-recall,
+// and CLI research-status commands. All flags are non-optional booleans on
+// PluginConfig (defaults resolved at the parse boundary), so the projection
+// is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of recall-enhancement feature gates (issue #1523 batch 9).
+ */
+export interface RecallEnhancementCapabilitySet {
+  readonly explicitCueRecall: boolean;
+  readonly targetedFactRecall: boolean;
+  readonly focusedListRecall: boolean;
+  readonly responseGuidanceRecall: boolean;
+  readonly eventOrderRecall: boolean;
+  readonly reinforcementRecallBoost: boolean;
+  readonly recallPlannerTelemetry: boolean;
+  readonly peerProfileRecall: boolean;
+  readonly graphAssistShadowEval: boolean;
+  readonly memoryReconstruction: boolean;
+  readonly memoryLinking: boolean;
+  readonly causalTrajectoryRecall: boolean;
+  readonly causalTrajectoryMemory: boolean;
+  readonly cmcRetrieval: boolean;
+  readonly contradictionDetection: boolean;
+  readonly factArchival: boolean;
+  readonly entityRelationships: boolean;
+  readonly entityActivityLog: boolean;
+  readonly compoundingInject: boolean;
+  readonly accessTracking: boolean;
+  readonly autoPromoteToShared: boolean;
+  readonly recallGraph: boolean;
+  readonly feedback: boolean;
+  readonly identity: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveRecallEnhancementCapabilities}.
+ */
+export type RecallEnhancementConfigProjection = Pick<
+  PluginConfig,
+  | "explicitCueRecallEnabled"
+  | "targetedFactRecallEnabled"
+  | "focusedListRecallEnabled"
+  | "responseGuidanceRecallEnabled"
+  | "eventOrderRecallEnabled"
+  | "reinforcementRecallBoostEnabled"
+  | "recallPlannerTelemetryEnabled"
+  | "peerProfileRecallEnabled"
+  | "graphAssistShadowEvalEnabled"
+  | "memoryReconstructionEnabled"
+  | "memoryLinkingEnabled"
+  | "causalTrajectoryRecallEnabled"
+  | "causalTrajectoryMemoryEnabled"
+  | "cmcRetrievalEnabled"
+  | "contradictionDetectionEnabled"
+  | "factArchivalEnabled"
+  | "entityRelationshipsEnabled"
+  | "entityActivityLogEnabled"
+  | "compoundingInjectEnabled"
+  | "accessTrackingEnabled"
+  | "autoPromoteToSharedEnabled"
+  | "recallGraphEnabled"
+  | "feedbackEnabled"
+  | "identityEnabled"
+>;
+
+/**
+ * Resolve the {@link RecallEnhancementCapabilitySet} from parsed config.
+ */
+export function resolveRecallEnhancementCapabilities(config: RecallEnhancementConfigProjection): RecallEnhancementCapabilitySet {
+  return Object.freeze({
+    explicitCueRecall: config.explicitCueRecallEnabled,
+    targetedFactRecall: config.targetedFactRecallEnabled,
+    focusedListRecall: config.focusedListRecallEnabled,
+    responseGuidanceRecall: config.responseGuidanceRecallEnabled,
+    eventOrderRecall: config.eventOrderRecallEnabled,
+    reinforcementRecallBoost: config.reinforcementRecallBoostEnabled,
+    recallPlannerTelemetry: config.recallPlannerTelemetryEnabled,
+    peerProfileRecall: config.peerProfileRecallEnabled,
+    graphAssistShadowEval: config.graphAssistShadowEvalEnabled === true,
+    memoryReconstruction: config.memoryReconstructionEnabled,
+    memoryLinking: config.memoryLinkingEnabled,
+    causalTrajectoryRecall: config.causalTrajectoryRecallEnabled,
+    causalTrajectoryMemory: config.causalTrajectoryMemoryEnabled,
+    cmcRetrieval: config.cmcRetrievalEnabled,
+    contradictionDetection: config.contradictionDetectionEnabled,
+    factArchival: config.factArchivalEnabled,
+    entityRelationships: config.entityRelationshipsEnabled,
+    entityActivityLog: config.entityActivityLogEnabled,
+    compoundingInject: config.compoundingInjectEnabled,
+    accessTracking: config.accessTrackingEnabled,
+    autoPromoteToShared: config.autoPromoteToSharedEnabled,
+    recallGraph: config.recallGraphEnabled,
+    feedback: config.feedbackEnabled,
+    identity: config.identityEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// PipelineProcessing capability set (issue #1523 batch 9).
+//
+// These 22 flags gate the extraction/chunking/summarization pipeline and LLM
+// infrastructure. Read sites span orchestrator, extraction, summarizer,
+// embedding-fallback, local-llm, search, day-summary, and semantic-consolidation.
+// All flags are non-optional booleans on PluginConfig (defaults resolved at
+// the parse boundary), so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of pipeline-processing feature gates (issue #1523 batch 9).
+ */
+export interface PipelineProcessingCapabilitySet {
+  readonly chunking: boolean;
+  readonly semanticChunking: boolean;
+  readonly semanticDedup: boolean;
+  readonly summarization: boolean;
+  readonly topicExtraction: boolean;
+  readonly sessionObserver: boolean;
+  readonly profiling: boolean;
+  readonly checkpoint: boolean;
+  readonly traceWeaver: boolean;
+  readonly routingRules: boolean;
+  readonly inlineSourceAttribution: boolean;
+  readonly negativeExamples: boolean;
+  readonly hourlySummaries: boolean;
+  readonly lcm: boolean;
+  readonly localLlmFast: boolean;
+  readonly proactiveExtraction: boolean;
+  readonly delinearize: boolean;
+  readonly slowLog: boolean;
+  readonly hostEmbeddingProvider: boolean;
+  readonly memoryExtensions: boolean;
+  readonly hourlySummariesExtended: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolvePipelineProcessingCapabilities}.
+ */
+export type PipelineProcessingConfigProjection = Pick<
+  PluginConfig,
+  | "chunkingEnabled"
+  | "semanticChunkingEnabled"
+  | "semanticDedupEnabled"
+  | "summarizationEnabled"
+  | "topicExtractionEnabled"
+  | "sessionObserverEnabled"
+  | "profilingEnabled"
+  | "checkpointEnabled"
+  | "traceWeaverEnabled"
+  | "routingRulesEnabled"
+  | "inlineSourceAttributionEnabled"
+  | "negativeExamplesEnabled"
+  | "hourlySummariesEnabled"
+  | "lcmEnabled"
+  | "localLlmFastEnabled"
+  | "proactiveExtractionEnabled"
+  | "delinearizeEnabled"
+  | "slowLogEnabled"
+  | "hostEmbeddingProviderEnabled"
+  | "memoryExtensionsEnabled"
+  | "hourlySummariesExtendedEnabled"
+>;
+
+/**
+ * Resolve the {@link PipelineProcessingCapabilitySet} from parsed config.
+ */
+export function resolvePipelineProcessingCapabilities(config: PipelineProcessingConfigProjection): PipelineProcessingCapabilitySet {
+  return Object.freeze({
+    chunking: config.chunkingEnabled,
+    semanticChunking: config.semanticChunkingEnabled,
+    semanticDedup: config.semanticDedupEnabled,
+    summarization: config.summarizationEnabled,
+    topicExtraction: config.topicExtractionEnabled,
+    sessionObserver: config.sessionObserverEnabled === true,
+    profiling: config.profilingEnabled,
+    checkpoint: config.checkpointEnabled,
+    traceWeaver: config.traceWeaverEnabled,
+    routingRules: config.routingRulesEnabled,
+    inlineSourceAttribution: config.inlineSourceAttributionEnabled,
+    negativeExamples: config.negativeExamplesEnabled,
+    hourlySummaries: config.hourlySummariesEnabled,
+    lcm: config.lcmEnabled,
+    localLlmFast: config.localLlmFastEnabled,
+    proactiveExtraction: config.proactiveExtractionEnabled,
+    delinearize: config.delinearizeEnabled,
+    slowLog: config.slowLogEnabled,
+    hostEmbeddingProvider: config.hostEmbeddingProviderEnabled,
+    memoryExtensions: config.memoryExtensionsEnabled,
+    hourlySummariesExtended: config.hourlySummariesExtendedEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// ConversationContext capability set (issue #1523 batch 9).
+//
+// These 12 flags gate conversation context, shared signals, intent routing,
+// operator-aware consolidation, CMC consolidation, maintenance fanout, CLI
+// presentation, and code connectors. Read sites span orchestrator, CLI,
+// shared-context/manager, semantic-consolidation-coordinator, compounding/engine,
+// maintenance modules, procedural stats, connectors, and wearables. All flags
+// are non-optional booleans on PluginConfig (defaults resolved at the parse
+// boundary), so the projection is a pure pass-through.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of conversation/context feature gates (issue #1523 batch 9).
+ */
+export interface ConversationContextCapabilitySet {
+  readonly sharedContext: boolean;
+  readonly intentRouting: boolean;
+  readonly crossSignalsSemantic: boolean;
+  readonly sharedCrossSignalSemantic: boolean;
+  readonly operatorAwareConsolidation: boolean;
+  readonly peerProfileReasoner: boolean;
+  readonly cmcConsolidation: boolean;
+  readonly maintenanceNamespaceFanout: boolean;
+  readonly citations: boolean;
+  readonly behaviorLoopAutoTune: boolean;
+  readonly semanticRulePromotion: boolean;
+  readonly codexMarketplace: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveConversationContextCapabilities}.
+ */
+export type ConversationContextConfigProjection = Pick<
+  PluginConfig,
+  | "sharedContextEnabled"
+  | "intentRoutingEnabled"
+  | "crossSignalsSemanticEnabled"
+  | "sharedCrossSignalSemanticEnabled"
+  | "operatorAwareConsolidationEnabled"
+  | "peerProfileReasonerEnabled"
+  | "cmcConsolidationEnabled"
+  | "maintenanceNamespaceFanoutEnabled"
+  | "citationsEnabled"
+  | "behaviorLoopAutoTuneEnabled"
+  | "semanticRulePromotionEnabled"
+  | "codexMarketplaceEnabled"
+>;
+
+/**
+ * Resolve the {@link ConversationContextCapabilitySet} from parsed config.
+ */
+export function resolveConversationContextCapabilities(config: ConversationContextConfigProjection): ConversationContextCapabilitySet {
+  return Object.freeze({
+    sharedContext: config.sharedContextEnabled,
+    intentRouting: config.intentRoutingEnabled,
+    crossSignalsSemantic: config.crossSignalsSemanticEnabled,
+    sharedCrossSignalSemantic: config.sharedCrossSignalSemanticEnabled === true,
+    operatorAwareConsolidation: config.operatorAwareConsolidationEnabled,
+    peerProfileReasoner: config.peerProfileReasonerEnabled,
+    cmcConsolidation: config.cmcConsolidationEnabled,
+    maintenanceNamespaceFanout: config.maintenanceNamespaceFanoutEnabled,
+    citations: config.citationsEnabled,
+    behaviorLoopAutoTune: config.behaviorLoopAutoTuneEnabled,
+    semanticRulePromotion: config.semanticRulePromotionEnabled,
+    codexMarketplace: config.codexMarketplaceEnabled,
+  });
+}

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

@@ -21,6 +21,7 @@ import type { Orchestrator } from "../orchestrator.js";
 import { resolveCapabilities, resolveSecurityCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveConsolidationCapabilities } from "../capabilities.js";
 import type { CliCommand } from "../cli.js";
 import type { UtilityTelemetryEvent } from "../utility-telemetry.js";
+import { resolveRecallEnhancementCapabilities } from "../capabilities.js";
 import {
   runObjectiveStateStatusCliCommand,
   runCausalTrajectoryStatusCliCommand,
@@ -67,7 +68,7 @@ cmd
     const status = await runCausalTrajectoryStatusCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       causalTrajectoryStoreDir: orchestrator.config.causalTrajectoryStoreDir,
-      causalTrajectoryMemoryEnabled: orchestrator.config.causalTrajectoryMemoryEnabled,
+      causalTrajectoryMemoryEnabled: resolveRecallEnhancementCapabilities(orchestrator.config).causalTrajectoryMemory,
     });
     console.log(JSON.stringify(status, null, 2));
     console.log("OK");

package/src/cli.ts

@@ -232,6 +232,7 @@ import { getTrainingExportAdapter, listTrainingExportAdapters } from "./training
 import { renderRecallExplain, parseRecallExplainFormat } from "./recall-explain-renderer.js";
 import { renderXray } from "./recall-xray-renderer.js";
 import { parseXrayCliOptions } from "./recall-xray-cli.js";
+import { resolveConversationContextCapabilities } from "./capabilities.js";
 import {
   collectPatternMemories,
   explainPatternMemory,
@@ -6276,7 +6277,7 @@ export function registerCli(
           const options = (args[0] ?? {}) as Record<string, unknown>;
           const result = await runSemanticRulePromoteCliCommand({
             memoryDir: orchestrator.config.memoryDir,
-            semanticRulePromotionEnabled: orchestrator.config.semanticRulePromotionEnabled,
+            semanticRulePromotionEnabled: resolveConversationContextCapabilities(orchestrator.config).semanticRulePromotion,
             sourceMemoryId: String(options.memoryId ?? ""),
             dryRun: options.dryRun === true,
           });
@@ -6802,7 +6803,7 @@ export function registerCli(
             principal: resolveAccessPrincipalOverride(options.principal, orchestrator.config.agentAccessHttp.principal),
             maxBodyBytes: Number.isFinite(maxBodyBytesRaw) ? maxBodyBytesRaw : 131072,
             trustPrincipalHeader: options.trustPrincipalHeader === true,
-            citationsEnabled: orchestrator.config.citationsEnabled,
+            citationsEnabled: resolveConversationContextCapabilities(orchestrator.config).citations,
             citationsAutoDetect: orchestrator.config.citationsAutoDetect,
             emitLegacyTools: orchestrator.config.emitLegacyTools,
           });

package/src/compounding/engine.ts

@@ -8,6 +8,7 @@ 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, resolveConsolidationCapabilities } from "../capabilities.js";
+import { resolveConversationContextCapabilities } from "../capabilities.js";
 
 type MistakesFile = {
   version?: number;
@@ -496,7 +497,7 @@ export class CompoundingEngine {
     let promotionCandidates = resolveConsolidationCapabilities(this.config).compoundingSemantic
       ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics)
       : [];
-    if (this.config.cmcConsolidationEnabled) {
+    if (resolveConversationContextCapabilities(this.config).cmcConsolidation) {
       try {
         const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("../causal-consolidation.js");
         const causalCandidates = await deriveCausalPromotionCandidates({

package/src/connectors/codex-marketplace.ts

@@ -22,6 +22,7 @@ import path from "node:path";
 
 import { log } from "../logger.js";
 import type { PluginConfig } from "../types.js";
+import { resolveConversationContextCapabilities } from "../capabilities.js";
 
 // ── Types ─────────────────────────────────────────────────────────────────
 
@@ -295,7 +296,7 @@ export async function installFromMarketplace(
     debug: (msg) => log.debug(`[marketplace] ${msg}`),
   };
 
-  if (!config.codexMarketplaceEnabled) {
+  if (!resolveConversationContextCapabilities(config).codexMarketplace) {
     return {
       ok: false,
       message: "Codex marketplace is disabled in config (codexMarketplaceEnabled: false)",

package/src/day-summary.ts

@@ -3,6 +3,7 @@ import { fileURLToPath } from "node:url";
 import { log } from "./logger.js";
 import type { MemoryFile, PluginConfig } from "./types.js";
 import { discoverMemoryExtensions, renderExtensionsFooter, resolveExtensionsRoot } from "./memory-extension-host/index.js";
+import { resolvePipelineProcessingCapabilities } from "./capabilities.js";
 
 const PROMPT_RELATIVE_PATH = path.join("prompts", "day_summary.prompt.md");
 
@@ -114,7 +115,7 @@ export function formatDaySummaryMemories(memories: string | MemoryFile[]): strin
 export async function buildExtensionsFooterForSummary(
   config: PluginConfig,
 ): Promise<string> {
-  if (!config.memoryExtensionsEnabled) return "";
+  if (!resolvePipelineProcessingCapabilities(config).memoryExtensions) return "";
   const root = resolveExtensionsRoot(config);
   const extensions = await discoverMemoryExtensions(root, log);
   if (extensions.length === 0) return "";

package/src/embedding-fallback.ts

@@ -7,6 +7,7 @@ import {
 } from "./capabilities.js";
 import { readEnvVar } from "./runtime/env.js";
 import type { PluginConfig } from "./types.js";
+import { resolvePipelineProcessingCapabilities } from "./capabilities.js";
 import {
   getHostEmbeddingProvider,
   type HostEmbeddingProvider,
@@ -405,7 +406,7 @@ export class EmbeddingFallback {
 
     if (
       options.includeHost !== false &&
-      this.config.hostEmbeddingProviderEnabled !== false
+      resolvePipelineProcessingCapabilities(this.config).hostEmbeddingProvider !== false
     ) {
       const hostProvider = getHostEmbeddingProvider(this.config.memoryDir);
       if (hostProvider) {

package/src/extraction.ts

@@ -38,6 +38,7 @@ 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 { resolvePipelineProcessingCapabilities } from "./capabilities.js";
 import { resolveMemoryLifecycleCapabilities,
   resolveLocalLlmCapabilities,resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 
@@ -199,7 +200,7 @@ export class ExtractionEngine {
         }
         let content = sanitized.text;
         // De-linearize: resolve coreferences + anchor temporal expressions
-        if (this.config.delinearizeEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).delinearize) {
           content = delinearize(content, result.entities, ts);
         }
         return { ...fact, content };
@@ -578,7 +579,7 @@ export class ExtractionEngine {
     conversation: string,
     base: ExtractionResult,
   ): Promise<ExtractionResult> {
-    if (!this.config.proactiveExtractionEnabled) return base;
+    if (!resolvePipelineProcessingCapabilities(this.config).proactiveExtraction) return base;
     const maxAdditional = Math.max(0, Math.floor(this.config.maxProactiveQuestionsPerExtraction));
     if (maxAdditional === 0) return base;
     if (this.config.proactiveExtractionTimeoutMs === 0) return base;