@remnic/core 9.3.612 → 9.3.614

package/src/access-mcp.test.ts

@@ -721,3 +721,54 @@ test("MCP profiling report rejects invalid argument types before dispatch", asyn
   assert.equal((badFormat as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, true);
   assert.equal((badLimit as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, true);
 });
+
+// ──────────────────────────────────────────────────────────────────────────
+// Issue #1427: opt-out of legacy engram.* tool aliases on tools/list
+// ──────────────────────────────────────────────────────────────────────────
+
+function listToolNames(response: unknown): string[] {
+  const tools = (response as { result?: { tools?: Array<{ name: string }> } }).result?.tools ?? [];
+  return tools.map((t) => t.name);
+}
+
+const TOOLS_LIST_REQUEST = { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} };
+
+test("tools/list advertises both remnic.* and engram.* by default (back-compat)", async () => {
+  const server = new EngramMcpServer(makeMockService());
+  const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
+  assert.ok(names.includes("remnic.recall"), "canonical name present");
+  assert.ok(names.includes("engram.recall"), "legacy alias present by default");
+  const legacyCount = names.filter((n) => n.startsWith("engram.")).length;
+  assert.ok(legacyCount > 0, "legacy aliases advertised by default");
+});
+
+test("tools/list omits engram.* aliases when emitLegacyTools is false", async () => {
+  const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
+  const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
+  assert.ok(names.includes("remnic.recall"), "canonical name still present");
+  assert.equal(
+    names.filter((n) => n.startsWith("engram.")).length,
+    0,
+    "no engram.* aliases advertised when opted out",
+  );
+  // Every advertised tool uses the canonical prefix; the surface is halved.
+  assert.ok(names.every((n) => n.startsWith("remnic.")), "all advertised tools are canonical");
+});
+
+test("emitLegacyTools=false still allows calling tools under BOTH names (advertising-only opt-out)", async () => {
+  const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
+  // Canonical call works.
+  const canonical = await server.handleRequest(makeToolRequest("remnic.recall", { query: "hello" }));
+  assert.notEqual(
+    (canonical as { result?: { isError?: boolean } }).result?.isError,
+    true,
+    "canonical remnic.recall call succeeds",
+  );
+  // Legacy call still dispatches even though it is no longer advertised.
+  const legacy = await server.handleRequest(makeToolRequest("engram.recall", { query: "hello" }));
+  assert.notEqual(
+    (legacy as { result?: { isError?: boolean } }).result?.isError,
+    true,
+    "legacy engram.recall call still works (callability preserved)",
+  );
+});

package/src/access-mcp.ts

@@ -81,11 +81,15 @@ function toLegacyToolName(name: string): string {
     : name;
 }
 
-function withToolAliases(tool: McpTool): McpTool[] {
+function withToolAliases(tool: McpTool, emitLegacyTools = true): McpTool[] {
   const canonicalName = toCanonicalToolName(tool.name);
   const canonicalTool = canonicalName === tool.name ? tool : { ...tool, name: canonicalName };
   if (canonicalName === tool.name) return [canonicalTool];
-  return [canonicalTool, tool];
+  // Issue #1427: when legacy aliases are opted out, advertise only the
+  // canonical `remnic.*` name and drop the `engram.*` duplicate. Tool *calls*
+  // still accept both names (the dispatch canonicalizes), so suppressing the
+  // alias only trims `tools/list`, not callability.
+  return emitLegacyTools ? [canonicalTool, tool] : [canonicalTool];
 }
 
 function resolveChatGptInspectorRecallSessionKey(
@@ -212,13 +216,25 @@ export class EngramMcpServer {
   private readonly citationsEnabled: boolean;
   /** Whether to auto-enable citations for Codex adapter connections. */
   private readonly citationsAutoDetect: boolean;
+  /**
+   * Whether to advertise legacy `engram.*` tool aliases alongside the canonical
+   * `remnic.*` names (issue #1427). Defaults to true for backward compatibility;
+   * set false to halve the advertised `tools/list` surface.
+   */
+  private readonly emitLegacyTools: boolean;
 
   constructor(
     private readonly service: EngramAccessService,
-    options: { principal?: string; citationsEnabled?: boolean; citationsAutoDetect?: boolean } = {},
+    options: {
+      principal?: string;
+      citationsEnabled?: boolean;
+      citationsAutoDetect?: boolean;
+      emitLegacyTools?: boolean;
+    } = {},
   ) {
     this.citationsEnabled = options.citationsEnabled === true;
     this.citationsAutoDetect = options.citationsAutoDetect !== false;
+    this.emitLegacyTools = options.emitLegacyTools !== false;
     this.authenticatedPrincipal =
       options.principal?.trim() ||
       readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() ||
@@ -1703,7 +1719,7 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-    ].flatMap((tool) => withToolAliases(tool));
+    ].flatMap((tool) => withToolAliases(tool, this.emitLegacyTools));
   }
 
   /** Get clientInfo for a specific MCP session. Returns undefined for non-MCP requests. */
@@ -1985,7 +2001,12 @@ export class EngramMcpServer {
   }
 
   private toolAcceptsArgument(name: string, key: string): boolean {
-    const tool = this.tools.find((entry) => entry.name === name);
+    // Match by canonical name so argument validation resolves whether the
+    // caller used the `engram.*` or `remnic.*` name and regardless of whether
+    // legacy aliases are advertised (issue #1427) — a tool stays callable under
+    // both names even when only the canonical alias appears in `tools/list`.
+    const target = toCanonicalToolName(name);
+    const tool = this.tools.find((entry) => toCanonicalToolName(entry.name) === target);
     const inputSchema = getObjectProperties(tool?.inputSchema);
     const properties = getObjectProperties(inputSchema?.properties);
     if (properties && Object.prototype.hasOwnProperty.call(properties, key)) {

package/src/active-recall.test.ts

@@ -198,6 +198,46 @@ test("active recall cache hits report cache-hit latency instead of reusing gener
   assert.equal(second.latencyMs, 1);
 });
 
+test("active recall cache hits append a fresh transcript entry", async () => {
+  const transcriptDir = await mkdtemp(path.join(os.tmpdir(), "active-recall-cache-transcript-"));
+  let generateCalls = 0;
+  const engine = createActiveRecallEngine(
+    {
+      async recall() {
+        return "CI worker drain after Redis reconnect storm.";
+      },
+      async generateSummary() {
+        generateCalls += 1;
+        return { text: "Redis reconnect storm caused the worker drain." };
+      },
+      now: (() => {
+        let tick = 40_000;
+        return () => tick++;
+      })(),
+    },
+    baseConfig({
+      cacheTtlMs: 5000,
+      persistTranscripts: true,
+      transcriptDir,
+    }),
+  );
+
+  const first = await engine.run(baseInput());
+  const second = await engine.run(baseInput());
+
+  assert.equal(generateCalls, 1);
+  assert.equal(first.cacheHit, false);
+  assert.equal(second.cacheHit, true);
+  assert.ok(first.transcriptPath, "expected first transcript path");
+  assert.ok(second.transcriptPath, "expected cache-hit transcript path");
+
+  const raw = await readFile(second.transcriptPath ?? "", "utf8");
+  const entries = raw.trim().split("\n").map((line) => JSON.parse(line) as { cacheHit: boolean });
+  assert.equal(entries.length, 2);
+  assert.equal(entries[0].cacheHit, false);
+  assert.equal(entries[1].cacheHit, true);
+});
+
 test("active recall cache stores an isolated snapshot instead of a mutable caller reference", async () => {
   let generateCalls = 0;
   const engine = createActiveRecallEngine(

package/src/active-recall.ts

@@ -361,11 +361,26 @@ export function createActiveRecallEngine(
       }
       const cached = cache.get(cacheKey);
       if (cacheEnabled && cached) {
-        return {
+        const result: ActiveRecallResult = {
           ...cloneRecallResult(cached.value),
           latencyMs: Math.max(0, now() - currentTime),
           cacheHit: true,
         };
+        result.transcriptPath = null;
+        if (config.persistTranscripts) {
+          try {
+            result.transcriptPath = await appendActiveRecallTranscript(
+              config.transcriptDir,
+              input,
+              config,
+              result,
+              queryBundle,
+            );
+          } catch {
+            result.transcriptPath = null;
+          }
+        }
+        return result;
       }
 
       const start = currentTime;
@@ -451,9 +466,11 @@ export function createActiveRecallEngine(
 
       if (cacheEnabled) {
         const completedAt = now();
+        const cachedValue = cloneRecallResult(result);
+        cachedValue.transcriptPath = null;
         cache.set(cacheKey, {
           expiresAt: completedAt + config.cacheTtlMs,
-          value: cloneRecallResult(result),
+          value: cachedValue,
         });
         enforceCacheLimit(cache);
       }

package/src/behavior-learner.ts

@@ -68,13 +68,15 @@ function aggregateSignalPressure(signals: BehaviorSignalEvent[]): number {
 }
 
 function selectRecentSignals(input: BehaviorLearnerInput): BehaviorSignalEvent[] {
-  if (input.learningWindowDays <= 0) return [...input.signals];
   const nowMs = (input.now ?? new Date()).getTime();
-  const minTs = nowMs - input.learningWindowDays * 86_400_000;
+  const minTs =
+    input.learningWindowDays <= 0
+      ? Number.NEGATIVE_INFINITY
+      : nowMs - input.learningWindowDays * 86_400_000;
   return input.signals.filter((signal) => {
     const ts = Date.parse(signal.timestamp);
     if (!Number.isFinite(ts)) return false;
-    return ts >= minTs;
+    return ts >= minTs && ts <= nowMs;
   });
 }
 

package/src/buffer-session.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { SmartBuffer } from "./buffer.js";
 import { parseConfig } from "./config.js";
+import type { BufferSurpriseProbe } from "./buffer.js";
 import type { BufferState, BufferTurn } from "./types.js";
 
 class FakeStorage {
@@ -111,6 +112,63 @@ test("SmartBuffer serializes concurrent addTurn mutations", async () => {
   );
 });
 
+test("SmartBuffer ignores stale surprise promotion after newer turns arrive", async () => {
+  const storage = new FakeStorage({
+    turns: [],
+    lastExtractionAt: null,
+    extractionCount: 0,
+  });
+  let resolveFirstProbe = (_score: number): void => {
+    throw new Error("first surprise probe did not start");
+  };
+  let markFirstProbeStarted = (): void => {
+    throw new Error("probe start marker was not initialized");
+  };
+  const firstProbeStarted = new Promise<void>((resolve) => {
+    markFirstProbeStarted = resolve;
+  });
+  const probe: BufferSurpriseProbe = {
+    async scoreTurn(_bufferKey, turn) {
+      if (turn.content !== "turn A") return null;
+      markFirstProbeStarted();
+      return new Promise<number>((probeResolve) => {
+        resolveFirstProbe = probeResolve;
+      });
+    },
+  };
+  const buffer = new SmartBuffer(
+    parseConfig({
+      bufferSurpriseTriggerEnabled: true,
+      bufferSurpriseThreshold: 0.35,
+      bufferSurpriseProbeTimeoutMs: 10_000,
+      triggerMode: "smart",
+    }),
+    storage as any,
+    probe,
+  );
+
+  const firstOutcomePromise = buffer.addTurnWithOutcome(
+    "thread-a",
+    makeTurn("thread-a", "turn A"),
+  );
+  await firstProbeStarted;
+
+  const secondOutcome = await buffer.addTurnWithOutcome(
+    "thread-a",
+    makeTurn("thread-a", "turn B"),
+  );
+  assert.deepEqual(secondOutcome, { decision: "keep_buffering" });
+
+  resolveFirstProbe(1);
+  const firstOutcome = await firstOutcomePromise;
+
+  assert.deepEqual(firstOutcome, { decision: "keep_buffering" });
+  assert.deepEqual(
+    buffer.getTurns("thread-a").map((turn) => turn.content),
+    ["turn A", "turn B"],
+  );
+});
+
 test("SmartBuffer clearAfterExtraction only clears the targeted logical session", async () => {
   const storage = new FakeStorage({
     turns: [],

package/src/buffer-surprise-trigger.test.ts

@@ -643,7 +643,7 @@ test("flag on: slow-probe promotion survives prefix clears before the scored tur
   );
 });
 
-test("flag on: slow-probe promotion survives later appends to same buffer", async () => {
+test("flag on: slow-probe promotion is ignored after later appends to same buffer", async () => {
   const storage = new FakeStorage(emptyBuffer());
   let releaseOldProbe: (() => void) | null = null;
   let oldProbeStarted: (() => void) | null = null;
@@ -684,8 +684,8 @@ test("flag on: slow-probe promotion survives later appends to same buffer", asyn
   (releaseOldProbe as () => void)();
   assert.equal(
     await oldDecision,
-    "extract_now",
-    "a later append must not suppress a valid surprise flush for the older turn",
+    "keep_buffering",
+    "a later append must suppress stale surprise promotion for the older turn",
   );
   const turns = buffer.getTurns("sess-1");
   assert.equal(turns.length, 2);
@@ -695,18 +695,9 @@ test("flag on: slow-probe promotion survives later appends to same buffer", asyn
 
 test("flag on: extraction clear preserves turns appended after the queued snapshot", async () => {
   const storage = new FakeStorage(emptyBuffer());
-  let releaseOldProbe: (() => void) | null = null;
-  let oldProbeStarted: (() => void) | null = null;
-  const oldProbeStartedPromise = new Promise<void>((resolve) => {
-    oldProbeStarted = resolve;
-  });
   const probe: BufferSurpriseProbe = {
     async scoreTurn(_key, turn) {
-      if (turn.content !== "old surprising turn") return null;
-      oldProbeStarted?.();
-      return new Promise<number | null>((resolve) => {
-        releaseOldProbe = () => resolve(0.99);
-      });
+      return turn.content === "old surprising turn" ? 0.99 : null;
     },
   };
   const config = parseConfig({
@@ -722,11 +713,6 @@ test("flag on: extraction clear preserves turns appended after the queued snapsh
     "sess-1",
     makeTurn("sess-1", "old surprising turn"),
   );
-  await oldProbeStartedPromise;
-
-  await buffer.addTurn("sess-1", makeTurn("sess-1", "newer ordinary turn"));
-  assert.ok(releaseOldProbe);
-  (releaseOldProbe as () => void)();
   assert.equal(await oldDecision, "extract_now");
 
   const queuedSnapshot = buffer.getTurns("sess-1");

package/src/buffer.ts

@@ -85,7 +85,8 @@ interface AddTurnMutationResult {
   decision: TriggerDecision;
   signalLevel: SignalLevel;
   priorTurns: BufferTurn[];
-  turnSnapshot: BufferTurn;
+  activeTurnsSnapshot: BufferTurn[];
+  retainedTurnsSnapshot: BufferTurn[];
   turnCountInWindow: number;
 }
 
@@ -298,9 +299,10 @@ export class SmartBuffer {
         const shouldPromote = surprise > this.config.bufferSurpriseThreshold;
         let triggered = false;
         if (shouldPromote) {
-          const currentTurns = await this.getExtractionTurnsIfTurnSnapshotStillCurrent(
+          const currentTurns = await this.getExtractionTurnsIfBufferSnapshotStillCurrent(
             bufferKey,
-            mutation.turnSnapshot,
+            mutation.activeTurnsSnapshot,
+            mutation.retainedTurnsSnapshot,
           );
           if (currentTurns) {
             log.debug(
@@ -361,7 +363,8 @@ export class SmartBuffer {
     const entry = this.entryFor(bufferKey);
     const priorTurns = entry.turns.slice();
     entry.turns.push(turn);
-    const turnSnapshot = copyBufferTurn(turn);
+    const activeTurnsSnapshot = entry.turns.map(copyBufferTurn);
+    const retainedTurnsSnapshot = (entry.retainedTurns ?? []).map(copyBufferTurn);
     if (bufferKey === "default") {
       this.state.turns = entry.turns;
     }
@@ -376,24 +379,26 @@ export class SmartBuffer {
       decision,
       signalLevel: signal.level,
       priorTurns,
-      turnSnapshot,
+      activeTurnsSnapshot,
+      retainedTurnsSnapshot,
       turnCountInWindow,
     };
   }
 
-  private async getExtractionTurnsIfTurnSnapshotStillCurrent(
+  private async getExtractionTurnsIfBufferSnapshotStillCurrent(
     bufferKey: string,
-    turnSnapshot: BufferTurn,
+    activeTurnsSnapshot: readonly BufferTurn[],
+    retainedTurnsSnapshot: readonly BufferTurn[],
   ): Promise<BufferTurn[] | null> {
     return this.enqueueMutation(async () => {
       await this.loadUnlocked();
       const entry = this.peekEntry(bufferKey);
       if (!entry) return null;
-      const stillCurrent = entry.turns.some((turn) =>
-        bufferTurnsEqual(turn, turnSnapshot),
-      );
-      if (!stillCurrent) return null;
       const retained = entry.retainedTurns ?? [];
+      const stillCurrent =
+        bufferTurnArrayIsSuffixOfSnapshot(entry.turns, activeTurnsSnapshot) &&
+        bufferTurnArraysEqual(retained, retainedTurnsSnapshot);
+      if (!stillCurrent) return null;
       return [...retained, ...entry.turns];
     });
   }
@@ -802,6 +807,29 @@ function bufferTurnsEqual(left: BufferTurn | undefined, right: BufferTurn): bool
   );
 }
 
+function bufferTurnArraysEqual(
+  left: readonly BufferTurn[],
+  right: readonly BufferTurn[],
+): boolean {
+  return (
+    left.length === right.length &&
+    left.every((turn, index) => bufferTurnsEqual(turn, right[index]))
+  );
+}
+
+function bufferTurnArrayIsSuffixOfSnapshot(
+  liveTurns: readonly BufferTurn[],
+  snapshot: readonly BufferTurn[],
+): boolean {
+  if (liveTurns.length === 0 || liveTurns.length > snapshot.length) {
+    return false;
+  }
+  const offset = snapshot.length - liveTurns.length;
+  return liveTurns.every((turn, index) =>
+    bufferTurnsEqual(turn, snapshot[offset + index]),
+  );
+}
+
 function liveTurnsFromExtractionSnapshot(
   entry: BufferEntryState,
   extractedTurns: readonly BufferTurn[],

package/src/calibration.ts

@@ -16,7 +16,7 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { FallbackLlmClient } from "./fallback-llm.js";
-import type { GatewayConfig, MemoryFile } from "./types.js";
+import type { AgentPersonaModelConfig, GatewayConfig, MemoryFile } from "./types.js";
 import { listJsonFiles, readJsonFile } from "./json-store.js";
 import { isRecord } from "./store-contract.js";
 import { log } from "./logger.js";
@@ -226,6 +226,7 @@ export async function synthesizeCalibrationRules(
   llm: FallbackLlmClient,
   existingRules: CalibrationRule[],
   agentId?: string,
+  modelChain?: AgentPersonaModelConfig,
 ): Promise<CalibrationRule[]> {
   if (corrections.length < 2) return [];
 
@@ -244,7 +245,7 @@ export async function synthesizeCalibrationRules(
       { role: "system", content: CLUSTER_PROMPT },
       { role: "user", content: `Here are ${corrections.length} corrections from this user:\n\n${correctionText}${existingRulesText}` },
     ],
-    { temperature: 0.3, maxTokens: 3000, agentId },
+    { temperature: 0.3, maxTokens: 3000, agentId, modelChain },
   );
 
   if (!response?.content) return [];
@@ -349,13 +350,14 @@ export async function runCalibrationConsolidation(options: {
   memoryDir: string;
   gatewayConfig?: GatewayConfig;
   gatewayAgentId?: string;
+  modelChain?: AgentPersonaModelConfig;
   workspaceDir?: string;
 }): Promise<CalibrationRule[]> {
   try {
     const llm = new FallbackLlmClient(options.gatewayConfig, {
       workspaceDir: options.workspaceDir,
     });
-    if (!llm.isAvailable(options.gatewayAgentId)) {
+    if (!llm.isAvailable({ agentId: options.gatewayAgentId, modelChain: options.modelChain })) {
       log.debug("[calibration] no LLM available — skipping consolidation");
       return [];
     }
@@ -368,7 +370,7 @@ export async function runCalibrationConsolidation(options: {
 
     const existingIndex = await readCalibrationIndex(options.memoryDir);
 
-    const newRules = await synthesizeCalibrationRules(corrections, llm, existingIndex.rules, options.gatewayAgentId);
+    const newRules = await synthesizeCalibrationRules(corrections, llm, existingIndex.rules, options.gatewayAgentId, options.modelChain);
     if (newRules.length === 0) {
       log.debug("[calibration] no new calibration rules synthesized");
       return existingIndex.rules;
@@ -414,6 +416,8 @@ export async function runCalibrationIfEnabled(options: {
   memoryDir: string;
   calibrationEnabled: boolean;
   gatewayConfig?: GatewayConfig;
+  gatewayAgentId?: string;
+  modelChain?: AgentPersonaModelConfig;
   workspaceDir?: string;
 }): Promise<CalibrationRule[]> {
   if (!options.calibrationEnabled) {
@@ -422,6 +426,8 @@ export async function runCalibrationIfEnabled(options: {
   return runCalibrationConsolidation({
     memoryDir: options.memoryDir,
     gatewayConfig: options.gatewayConfig,
+    gatewayAgentId: options.gatewayAgentId,
+    modelChain: options.modelChain,
     workspaceDir: options.workspaceDir,
   });
 }

package/src/causal-consolidation.test.ts

@@ -49,14 +49,24 @@ async function withTrajectoryStore<T>(
 
 function llmStub() {
   let calls = 0;
+  let availableOptions: unknown;
+  let completionOptions: unknown;
   return {
     get calls() {
       return calls;
     },
-    isAvailable() {
+    get availableOptions() {
+      return availableOptions;
+    },
+    get completionOptions() {
+      return completionOptions;
+    },
+    isAvailable(options?: unknown) {
+      availableOptions = options;
       return true;
     },
-    async chatCompletion() {
+    async chatCompletion(_messages?: unknown, options?: unknown) {
+      completionOptions = options;
       calls += 1;
       return {
         content: JSON.stringify({
@@ -154,6 +164,41 @@ test("deriveCausalPromotionCandidates calls LLM when recurrence session and succ
   );
 });
 
+test("deriveCausalPromotionCandidates forwards task model chain to availability and chat completion", async () => {
+  const llm = llmStub();
+  const modelChain = {
+    primary: "openai/task-primary",
+    fallbacks: ["openai/task-fallback"],
+  };
+  await withTrajectoryStore(
+    [
+      trajectory("t1", "a", "success"),
+      trajectory("t2", "b", "success"),
+      trajectory("t3", "c", "partial"),
+    ],
+    async ({ memoryDir, storeDir }) => {
+      const candidates = await deriveCausalPromotionCandidates({
+        memoryDir,
+        causalTrajectoryStoreDir: storeDir,
+        config: { minRecurrence: 3, minSessions: 2, successThreshold: 0.7 },
+        gatewayAgentId: "expensive-agent",
+        modelChain,
+        llmClient: llm,
+      });
+
+      assert.equal(llm.calls, 1);
+      assert.equal(candidates.length, 1);
+      assert.deepEqual(llm.availableOptions, { agentId: "expensive-agent", modelChain });
+      assert.deepEqual(llm.completionOptions, {
+        temperature: 0.2,
+        maxTokens: 2000,
+        agentId: "expensive-agent",
+        modelChain,
+      });
+    },
+  );
+});
+
 test("deriveCausalPromotionCandidates validates LLM-derived rule fields", async () => {
   const llm = llmWithContent(JSON.stringify({
     rules: [

package/src/causal-consolidation.ts

@@ -18,7 +18,7 @@ import { readChainIndex, resolveChainsDir, type CausalChainIndex, type CausalEdg
 import { listJsonFiles, readJsonFile } from "./json-store.js";
 import { isRecord } from "./store-contract.js";
 import { FallbackLlmClient, fallbackLlmRuntimeContextFromConfig } from "./fallback-llm.js";
-import type { GatewayConfig, MemoryFile, PluginConfig } from "./types.js";
+import type { AgentPersonaModelConfig, GatewayConfig, MemoryFile, PluginConfig } from "./types.js";
 import path from "node:path";
 import { log } from "./logger.js";
 import { runPostConsolidationMaterialize } from "./connectors/codex-materialize-runner.js";
@@ -64,10 +64,10 @@ export interface LlmConsolidationResult {
 const CAUSAL_RULE_CATEGORIES = new Set(["rule", "principle", "preference"]);
 
 interface ConsolidationLlmClient {
-  isAvailable(agentId?: string): boolean;
+  isAvailable(options?: { agentId?: string; modelChain?: AgentPersonaModelConfig }): boolean;
   chatCompletion(
     messages: Array<{ role: "system" | "user" | "assistant"; content: string }>,
-    options?: { temperature?: number; maxTokens?: number; agentId?: string },
+    options?: { temperature?: number; maxTokens?: number; agentId?: string; modelChain?: AgentPersonaModelConfig },
   ): Promise<{ content: string } | null>;
 }
 
@@ -188,14 +188,14 @@ If no clear patterns exist, return {"rules": [], "preferences": []}.`;
 async function consolidateWithLlm(
   context: string,
   llm: ConsolidationLlmClient,
-  agentId?: string,
+  options: { agentId?: string; modelChain?: AgentPersonaModelConfig } = {},
 ): Promise<LlmConsolidationResult> {
   const response = await llm.chatCompletion(
     [
       { role: "system", content: CONSOLIDATION_PROMPT },
       { role: "user", content: context },
     ],
-    { temperature: 0.2, maxTokens: 2000, agentId },
+    { temperature: 0.2, maxTokens: 2000, agentId: options.agentId, modelChain: options.modelChain },
   );
 
   if (!response?.content) {
@@ -369,6 +369,7 @@ export async function deriveCausalPromotionCandidates(options: {
   config: ConsolidationConfig;
   gatewayConfig?: GatewayConfig;
   gatewayAgentId?: string;
+  modelChain?: AgentPersonaModelConfig;
   workspaceDir?: string;
   pluginConfig?: PluginConfig;
   llmClient?: ConsolidationLlmClient;
@@ -400,13 +401,14 @@ export async function deriveCausalPromotionCandidates(options: {
           })
         : { workspaceDir: options.workspaceDir },
     );
-    if (!llm.isAvailable(options.gatewayAgentId)) {
+    const llmOptions = { agentId: options.gatewayAgentId, modelChain: options.modelChain };
+    if (!llm.isAvailable(llmOptions)) {
       log.debug("[cmc] no LLM available for consolidation — skipping");
       return [];
     }
 
     // Call LLM for pattern analysis
-    const result = await consolidateWithLlm(context, llm, options.gatewayAgentId);
+    const result = await consolidateWithLlm(context, llm, llmOptions);
     const candidates = llmResultToCandidates(result);
 
     log.debug(`[cmc] LLM consolidation produced ${candidates.length} rule(s) and ${result.preferences.length} preference(s)`);
@@ -426,6 +428,7 @@ export async function synthesizeCausalPreferencesViaLlm(options: {
   causalTrajectoryStoreDir?: string;
   gatewayConfig?: GatewayConfig;
   gatewayAgentId?: string;
+  modelChain?: AgentPersonaModelConfig;
   workspaceDir?: string;
   minTrajectories?: number;
 }): Promise<string | null> {
@@ -440,9 +443,10 @@ export async function synthesizeCausalPreferencesViaLlm(options: {
     const llm = new FallbackLlmClient(options.gatewayConfig, {
       workspaceDir: options.workspaceDir,
     });
-    if (!llm.isAvailable(options.gatewayAgentId)) return null;
+    const llmOptions = { agentId: options.gatewayAgentId, modelChain: options.modelChain };
+    if (!llm.isAvailable(llmOptions)) return null;
 
-    const result = await consolidateWithLlm(context, llm, options.gatewayAgentId);
+    const result = await consolidateWithLlm(context, llm, llmOptions);
     if (result.preferences.length === 0 && result.rules.length === 0) return null;
 
     const lines: string[] = ["## Behavioral Insights (from Causal Chain Analysis)", ""];