@remnic/core 9.3.613 → 9.3.614

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)", ""];

package/src/cli.ts

@@ -792,6 +792,7 @@ export interface AccessHttpServeCliCommandOptions {
   trustPrincipalHeader?: boolean;
   citationsEnabled?: boolean;
   citationsAutoDetect?: boolean;
+  emitLegacyTools?: boolean;
   createServer?: (options: {
     service: EngramAccessService;
     host?: string;
@@ -802,6 +803,7 @@ export interface AccessHttpServeCliCommandOptions {
     trustPrincipalHeader?: boolean;
     citationsEnabled?: boolean;
     citationsAutoDetect?: boolean;
+    emitLegacyTools?: boolean;
   }) => AccessHttpServerLike;
 }
 
@@ -2732,6 +2734,7 @@ export async function runAccessHttpServeCliCommand(
         trustPrincipalHeader: input.trustPrincipalHeader,
         citationsEnabled: input.citationsEnabled,
         citationsAutoDetect: input.citationsAutoDetect,
+        emitLegacyTools: input.emitLegacyTools,
       }));
 
     const server = createServer(options);
@@ -2772,14 +2775,24 @@ export async function runAccessMcpServeCliCommand(
   service: EngramAccessService,
   options: {
     principal?: string;
-    createServer?: (service: EngramAccessService, options: { principal?: string }) => EngramMcpServerLike;
+    emitLegacyTools?: boolean;
+    createServer?: (
+      service: EngramAccessService,
+      options: { principal?: string; emitLegacyTools?: boolean },
+    ) => EngramMcpServerLike;
     stdin?: Readable;
     stdout?: Writable;
   } = {},
 ): Promise<{ ok: true }> {
-  const server = options.createServer?.(service, { principal: options.principal }) ?? new EngramMcpServer(service, {
-    principal: options.principal,
-  });
+  const server =
+    options.createServer?.(service, {
+      principal: options.principal,
+      emitLegacyTools: options.emitLegacyTools,
+    }) ??
+    new EngramMcpServer(service, {
+      principal: options.principal,
+      emitLegacyTools: options.emitLegacyTools,
+    });
   await server.runStdio(options.stdin ?? process.stdin, options.stdout ?? process.stdout);
   return { ok: true };
 }
@@ -6939,6 +6952,7 @@ export function registerCli(
             trustPrincipalHeader: options.trustPrincipalHeader === true,
             citationsEnabled: orchestrator.config.citationsEnabled,
             citationsAutoDetect: orchestrator.config.citationsAutoDetect,
+            emitLegacyTools: orchestrator.config.emitLegacyTools,
           });
           console.log(JSON.stringify(status, null, 2));
           console.log("OK");
@@ -6977,6 +6991,7 @@ export function registerCli(
           const options = (args[0] ?? {}) as Record<string, unknown>;
           await runAccessMcpServeCliCommand(accessService, {
             principal: resolveAccessPrincipalOverride(options.principal, orchestrator.config.agentAccessHttp.principal),
+            emitLegacyTools: orchestrator.config.emitLegacyTools,
           });
         });
 

package/src/compounding/engine.ts

@@ -492,6 +492,7 @@ export class CompoundingEngine {
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
           gatewayConfig: this.config.gatewayConfig,
           gatewayAgentId: this.config.modelSource === "gateway" ? (this.config.gatewayAgentId || undefined) : undefined,
+          modelChain: this.config.modelSource === "gateway" ? this.config.taskModelChain : undefined,
           workspaceDir: this.config.workspaceDir,
           pluginConfig: this.config,
           config: {
@@ -534,6 +535,7 @@ export class CompoundingEngine {
           memoryDir: this.config.memoryDir,
           gatewayConfig: this.config.gatewayConfig,
           gatewayAgentId: this.config.modelSource === "gateway" ? (this.config.gatewayAgentId || undefined) : undefined,
+          modelChain: this.config.modelSource === "gateway" ? this.config.taskModelChain : undefined,
           workspaceDir: this.config.workspaceDir,
         });
         log.debug(`[calibration] weekly synthesis produced ${calRules.length} calibration rule(s)`);