@remnic/core 9.3.739 → 9.3.740

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;

package/src/local-llm.ts

@@ -6,6 +6,7 @@ import type { ModelRegistry } from "./model-registry.js";
 import { launchProcessSync } from "./runtime/child-process.js";
 import { mergeEnv, readEnvVar } from "./runtime/env.js";
 import { resolveLocalLlmCapabilities } from "./capabilities.js";
+import { resolvePipelineProcessingCapabilities } from "./capabilities.js";
 
 /** Trim trailing slash characters without backtracking regex. */
 function trimTrailingSlashes(s: string): string {
@@ -1186,7 +1187,7 @@ export class LocalLlmClient {
         : this.estimateTokens(messages, content);
 
       const durationMs = Date.now() - startedAtMs;
-      if (this.config.slowLogEnabled && durationMs >= this.config.slowLogThresholdMs) {
+      if (resolvePipelineProcessingCapabilities(this.config).slowLog && durationMs >= this.config.slowLogThresholdMs) {
         const promptChars = messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
         const op = options.operation ? ` op=${options.operation}` : "";
         log.warn(

package/src/maintenance/namespace-maintenance-fanout.ts

@@ -27,6 +27,7 @@
 import { resolveNamespaceCapabilities } from "../capabilities.js";
 import type { NamespaceCatalog } from "../namespaces/catalog.js";
 import type { PluginConfig } from "../types.js";
+import { resolveConversationContextCapabilities } from "../capabilities.js";
 import {
   planNamespaceMaintenance,
   readNamespaceMaintenanceLastRanStatuses,
@@ -262,7 +263,7 @@ export async function summarizeNamespaceMaintenanceHealth(
 
   return {
     generatedAt,
-    fanoutEnabled: config.maintenanceNamespaceFanoutEnabled !== false,
+    fanoutEnabled: resolveConversationContextCapabilities(config).maintenanceNamespaceFanout !== false,
     namespacesEnabled: resolveNamespaceCapabilities(config).namespaces,
     maxNamespacesPerCycle: config.maintenanceMaxNamespacesPerCycle,
     jobs,

package/src/maintenance/namespace-planner.ts

@@ -11,6 +11,7 @@ import { resolveNamespaceStorageRoot } from "../namespaces/storage.js";
 import { displayErrorDetail } from "../runtime/better-sqlite.js";
 import type { PluginConfig } from "../types.js";
 import { getConfiguredNamespaces } from "../scopes/scope-plan.js";
+import { resolveConversationContextCapabilities } from "../capabilities.js";
 
 export type NamespaceMaintenanceJobName = string;
 
@@ -227,7 +228,7 @@ export async function planNamespaceMaintenance(
     });
   }
 
-  if (resolveNamespaceCapabilities(config).namespaces && config.maintenanceNamespaceFanoutEnabled !== false) {
+  if (resolveNamespaceCapabilities(config).namespaces && resolveConversationContextCapabilities(config).maintenanceNamespaceFanout !== false) {
     const configuredSet = new Set(configured);
     try {
       const records = options.catalog?.enabled ? await options.catalog.listNamespaces() : [];

package/src/operator-toolkit.ts

@@ -56,6 +56,7 @@ import { reportBufferSurpriseDistribution } from "./buffer-surprise-report.js";
 import { readJudgeVerdictStats } from "./extraction-judge-telemetry.js";
 import { resolveIndexingCapabilities } from "./capabilities.js";
 
+
 const OPENCLAW_REMNIC_PLUGIN_IDS = ["openclaw-remnic", "openclaw-engram"] as const;
 
 function getOpenClawPluginEntries(raw: Record<string, unknown>): Record<string, unknown> | undefined {

package/src/orchestration/semantic-consolidation-coordinator.ts

@@ -49,6 +49,7 @@ import type { LocalLlmClient } from "../local-llm.js";
 import type { EmbeddingFallback } from "../embedding-fallback.js";
 import type { PluginConfig, MemoryFile, AgentPersonaModelConfig } from "../types.js";
 import { log } from "../logger.js";
+import { resolveConversationContextCapabilities } from "../capabilities.js";
 
 /** Dependencies injected by the orchestrator. All stable references or
  *  live accessors. */
@@ -193,7 +194,7 @@ export class SemanticConsolidationCoordinator {
         // `semanticConsolidationEnabled` follow the same convention,
         // while `!== false` is reserved for default-on flags.
         const operatorAwareEnabled =
-          this.config.operatorAwareConsolidationEnabled === true;
+          resolveConversationContextCapabilities(this.config).operatorAwareConsolidation === true;
         let prompt = operatorAwareEnabled
           ? buildOperatorAwareConsolidationPrompt(cluster)
           : buildConsolidationPrompt(cluster);
@@ -418,7 +419,7 @@ export class SemanticConsolidationCoordinator {
     // in a try/catch because reasoner I/O (LLM call, peer-profile
     // writes) must never abort the consolidation result. The reasoner
     // itself also defends against partial failure — see profile-reasoner.ts.
-    if (this.config.peerProfileReasonerEnabled) {
+    if (resolveConversationContextCapabilities(this.config).peerProfileReasoner) {
       try {
         const peerLlm = new FallbackLlmClient(
           this.config.gatewayConfig,