@remnic/core 9.3.613 → 9.3.614

package/dist/transfer/types.d.ts

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

package/dist/types.d.ts

@@ -564,6 +564,9 @@ interface PluginConfig {
     qmdChunkStrategy: "auto" | "regex";
     qmdCandidateLimit?: number;
     qmdQueryRerankEnabled: boolean;
+    qmdSearchStrategy: "hybrid" | "lex-vec" | "lex";
+    qmdSubprocessStrategy: "query" | "search";
+    qmdDaemonTimeoutMs: number;
     qmdIndexName?: string;
     qmdForceCpu: boolean;
     qmdGpuBackend?: "auto" | "metal" | "cuda" | "vulkan" | "false";
@@ -1217,6 +1220,18 @@ interface PluginConfig {
     modelSource: "plugin" | "gateway";
     gatewayAgentId: string;
     fastGatewayAgentId: string;
+    /**
+     * Optional task-specific model chain for Remnic's background LLM work —
+     * extraction, the extraction judge, fact/profile/identity consolidation,
+     * summarization, semantic consolidation, calibration, and causal
+     * consolidation. When set, this chain is resolved through gateway providers
+     * instead of using gatewayAgentId or agents.defaults.model. All task paths
+     * route through the shared `gatewayTaskChainOptions` helper.
+     *
+     * Only takes effect when `modelSource: "gateway"`; ignored (with a startup
+     * warning) under `modelSource: "plugin"`. See issue #1365 / PR #1370.
+     */
+    taskModelChain?: AgentPersonaModelConfig;
     namespacesEnabled: boolean;
     defaultNamespace: string;
     sharedNamespace: string;
@@ -1378,6 +1393,15 @@ interface PluginConfig {
     behaviorLoopMaxDeltaPerCycle: number;
     behaviorLoopProtectedParams: string[];
     recallPlannerEnabled: boolean;
+    /**
+     * Opt-in gate for LLM-based recall planning (issue #1367 / Option C). When
+     * false (the default) recall mode is decided by the regex heuristic
+     * `planRecallMode()`. When true, the planner consults an LLM (routed through
+     * the gateway/fallback chain — provider-agnostic) and falls back to the
+     * heuristic on timeout/error/unavailable. `recallPlannerShadowMode` runs the
+     * LLM for telemetry only without changing the effective mode.
+     */
+    recallPlannerLlmEnabled: boolean;
     recallPlannerModel: string;
     recallPlannerTimeoutMs: number;
     recallPlannerUseResponsesApi: boolean;
@@ -1631,6 +1655,14 @@ interface PluginConfig {
     binaryLifecycleBackendType: "filesystem" | "s3" | "none";
     /** Base path for the filesystem backend. Required when backendType is "filesystem". */
     binaryLifecycleBackendPath: string;
+    /**
+     * Advertise legacy `engram_*` / `engram.*` MCP tool aliases alongside the
+     * canonical `remnic_*` names (issue #1427). Default true for backward
+     * compatibility. Set false to halve the advertised MCP `tools/list` surface;
+     * tools stay callable under both names regardless. Also settable via
+     * `REMNIC_EMIT_LEGACY_TOOLS` (falls back to `ENGRAM_EMIT_LEGACY_TOOLS`).
+     */
+    emitLegacyTools: boolean;
     /** Enable oai-mem-citation blocks in recall responses. Default false. */
     citationsEnabled: boolean;
     /** Auto-enable citations when the Codex adapter is detected. Default true. */

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-KGK2QKWL.js";
+} from "./chunk-4R4KTDIE.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-learner.js

@@ -3,7 +3,7 @@ import {
   learnUtilityPromotionWeights,
   readUtilityLearningSnapshot,
   resolveUtilityLearningStatePath
-} from "./chunk-3BP57I6J.js";
+} from "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
 import "./chunk-TBBDFYXW.js";
 import "./chunk-A2IYSXDQ.js";

package/dist/utility-runtime.js

@@ -2,8 +2,8 @@ import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
-} from "./chunk-W7L6HXUC.js";
-import "./chunk-3BP57I6J.js";
+} from "./chunk-LXOM6IQU.js";
+import "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
 import "./chunk-TBBDFYXW.js";
 import "./chunk-A2IYSXDQ.js";

package/dist/verified-recall.js

@@ -1,11 +1,11 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-ZT3EGNLR.js";
+} from "./chunk-QPD426WT.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-YFS5OEKO.js";
+import "./chunk-7MLB4NCL.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-4H5ZJHEN.js";
-import "./chunk-KGK2QKWL.js";
+import "./chunk-4R4KTDIE.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-KILOTVIF.js";

package/dist/work/board.js

@@ -2,8 +2,8 @@ import {
   exportWorkBoardMarkdown,
   exportWorkBoardSnapshot,
   importWorkBoardSnapshot
-} from "../chunk-ETUPBUHB.js";
-import "../chunk-L227SKTB.js";
+} from "../chunk-GDASG7NC.js";
+import "../chunk-GDB4J2H3.js";
 import "../chunk-5UZXUTVO.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/work/storage.d.ts

@@ -16,6 +16,7 @@ declare class WorkStorage {
     private writeNewProject;
     private writeProjectRecord;
     private enqueueProjectMutation;
+    private enqueueTaskMutation;
     private parseTask;
     private parseProject;
     createTask(input: CreateWorkTaskInput, now?: Date): Promise<WorkTask>;
@@ -24,6 +25,7 @@ declare class WorkStorage {
     updateTask(id: string, patch: UpdateWorkTaskInput, now?: Date, options?: {
         skipStatusTransitionValidation?: boolean;
     }): Promise<WorkTask | null>;
+    private updateTaskUnlocked;
     transitionTask(id: string, nextStatus: WorkTaskStatus, now?: Date): Promise<WorkTask>;
     deleteTask(id: string): Promise<boolean>;
     createProject(input: CreateWorkProjectInput, now?: Date): Promise<WorkProject>;

package/dist/work/storage.js

@@ -1,7 +1,7 @@
 import {
   WORK_ID_PATTERN,
   WorkStorage
-} from "../chunk-L227SKTB.js";
+} from "../chunk-GDB4J2H3.js";
 import "../chunk-5UZXUTVO.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.613",
+  "version": "9.3.614",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-http.ts

@@ -49,6 +49,8 @@ export interface EngramAccessHttpServerOptions {
   citationsEnabled?: boolean;
   /** Auto-enable citations for Codex adapter connections (issue #379). */
   citationsAutoDetect?: boolean;
+  /** Advertise legacy engram.* tool aliases on tools/list (issue #1427). Default true. */
+  emitLegacyTools?: boolean;
 }
 
 export interface EngramAccessHttpServerStatus {
@@ -247,6 +249,7 @@ export class EngramAccessHttpServer {
       principal: options.principal,
       citationsEnabled: options.citationsEnabled,
       citationsAutoDetect: options.citationsAutoDetect,
+      emitLegacyTools: options.emitLegacyTools,
     });
   }
 

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: [],