@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/orchestrate.test.ts

@@ -17,7 +17,7 @@ import type {
   Message,
   Provider,
   ProviderResponse,
-} from "../../../providers/types.js";
+} from "../../../../providers/types.js";
 import type { NeedleIndex } from "../needle.js";
 import type {
   LeafNode,
@@ -35,13 +35,13 @@ import evalTurns from "./fixtures/eval-turns.json" with { type: "json" };
 
 let providerStub: Provider | null = null;
 
-mock.module("../../../providers/provider-send-message.js", () => ({
+mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => providerStub,
   extractToolUse: (response: ProviderResponse) =>
     response.content.find((b) => b.type === "tool_use"),
 }));
 
-mock.module("../../../util/logger.js", () => ({
+mock.module("../../../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: (_t, prop) => (prop === "child" ? () => ({}) : () => {}),
@@ -217,6 +217,43 @@ describe("orchestrate — fixture sequence (carry-forward)", () => {
     expect(t2.currentSelections.map((s) => s.slug)).not.toContain("page-a");
     expect(t2.finalInjection).toContain("page-a");
   });
+
+  test("carry-forward survives a turn whose selections fill the cap", async () => {
+    const tree = makeTree();
+    // Cap of 1: under a naive record-then-cap order this turn's own selection
+    // would evict the carried page before injection. Snapshotting the carry
+    // BEFORE recording this turn keeps the earlier page in the injection.
+    const workingSet = new WorkingSet(1);
+    const needle = fakeNeedle([]);
+    const stub = (selectIds: number[]): Provider => ({
+      name: "stub",
+      sendMessage: async (_messages, options) =>
+        options?.tools?.[0]?.name === "open_leaves"
+          ? toolUseResponse("open_leaves", { ids: [1] })
+          : toolUseResponse("select_pages", { ids: selectIds, pinned_ids: [] }),
+    });
+
+    providerStub = stub([1]); // turn 1 → page-a
+    await orchestrate(makeTurn(1, "page a"), {
+      tree,
+      core: new Set(),
+      needle,
+      workingSet,
+      pageSummary: summaryOf,
+    });
+
+    providerStub = stub([2]); // turn 2 → page-b, never re-selects page-a
+    const t2 = await orchestrate(makeTurn(2, "page b"), {
+      tree,
+      core: new Set(),
+      needle,
+      workingSet,
+      pageSummary: summaryOf,
+    });
+
+    expect(t2.currentSelections.map((s) => s.slug)).toEqual(["page-b"]);
+    expect(t2.finalInjection).toContain("page-a"); // carried despite the cap
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -298,14 +335,16 @@ describe("orchestrate — edge cases", () => {
     expect(result.finalInjection).toEqual(["page-a", "page-b"]);
   });
 
-  test("L1 routing fallback (omitted ids → all leaves) still works", async () => {
+  test("omitted L1 ids opens only the deterministic lanes, not the whole tree", async () => {
     const tree = makeTree();
-    // Omitted ids → routeL1 opens ALL leaves; select everything per leaf.
+    // L1 omits ids → routeL1 opens NO routed leaves; only the needle/core lanes
+    // drive the open set, so the whole tree is never fanned out (topic-y, which
+    // nothing routes or needles to, stays closed).
     providerStub = {
       name: "stub",
       sendMessage: async (_messages, options) => {
         if (options?.tools?.[0]?.name === "open_leaves") {
-          return toolUseResponse("open_leaves", {}); // omitted ids
+          return toolUseResponse("open_leaves", {}); // omitted ids → []
         }
         return toolUseResponse("select_pages", {}); // omitted → all members
       },
@@ -313,15 +352,12 @@ describe("orchestrate — edge cases", () => {
     const result = await orchestrate(makeTurn(1, "x"), {
       tree,
       core: new Set(),
-      needle: fakeNeedle([]),
+      needle: fakeNeedle(["page-a"]), // needle opens domain-a/topic-x only
       workingSet: new WorkingSet(),
       pageSummary: summaryOf,
     });
-    expect(result.openedLeaves).toEqual([
-      "domain-a/topic-x",
-      "domain-a/topic-y",
-    ]);
-    expect(result.finalInjection).toEqual(["page-a", "page-b", "page-c"]);
+    expect(result.openedLeaves).toEqual(["domain-a/topic-x"]);
+    expect(result.finalInjection).toEqual(["page-a", "page-b"]);
   });
 
   test("pinned current-turn selections land in the working set", async () => {

package/src/plugins/defaults/memory-v3-shadow/__tests__/provider-blocks.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from "bun:test";
+
+import { cachedTextBlock } from "../provider-blocks.js";
+
+describe("cachedTextBlock", () => {
+  test("stamps an ephemeral cache_control with a 1h TTL", () => {
+    const block = cachedTextBlock("stable leaf block");
+    expect(block).toMatchObject({ type: "text", text: "stable leaf block" });
+    expect(
+      (block as unknown as { cache_control?: unknown }).cache_control,
+    ).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+});

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/reconcile.test.ts

@@ -3,8 +3,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import type { Provider } from "../../../providers/types.js";
-import { readPage, writePage } from "../../v2/page-store.js";
+import { readPage, writePage } from "../../../../memory/v2/page-store.js";
+import type { Provider } from "../../../../providers/types.js";
 import { type LeafRef, reconcileTree } from "../reconcile.js";
 
 /**

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/render-injection.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { wrapMemoryBlock } from "../../memory-marker.js";
+import { wrapMemoryBlock } from "../../../../memory/memory-marker.js";
 import { renderMemoryBlock } from "../render-injection.js";
 import { Slug } from "../types.js";
 

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/router.test.ts

@@ -3,10 +3,13 @@
  *
  * Coverage matrix:
  *   - Returned IDs map to the right leaves by 1-based index, in model order.
- *   - Omitted `ids` → ALL leaves (recall-safe).
+ *   - Omitted `ids` → no leaves (the router must name leaves explicitly,
+ *     never open the whole tree).
  *   - Explicit `ids: []` → no leaves (deliberate abstention).
  *   - Out-of-range / duplicate IDs ignored, no throw.
- *   - No provider / missing tool_use / schema mismatch / throw → ALL leaves.
+ *   - No provider / missing tool_use / schema mismatch / throw → no leaves
+ *     (degrade to the deterministic lanes), the last three after a re-prompt
+ *     retry; a malformed response that recovers on retry returns its IDs.
  *   - The rendered leaf block is byte-identical across two calls with
  *     different queries (the cache invariant).
  *   - The system prompt mentions "register" (locks the routing commitment).
@@ -22,7 +25,7 @@ import type {
   ProviderResponse,
   SendMessageOptions,
   ToolUseContent,
-} from "../../../providers/types.js";
+} from "../../../../providers/types.js";
 import type { LeafNode, LeafPath, LeafTree, TurnContext } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -38,13 +41,13 @@ interface ProviderCall {
 }
 const providerCalls: ProviderCall[] = [];
 
-mock.module("../../../providers/provider-send-message.js", () => ({
+mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => providerStub,
   extractToolUse: (response: ProviderResponse) =>
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
-mock.module("../../../util/logger.js", () => ({
+mock.module("../../../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: (_t, prop) => (prop === "child" ? () => ({}) : () => {}),
@@ -76,6 +79,45 @@ function toolUseResponse(input: Record<string, unknown>): ProviderResponse {
   };
 }
 
+/** A 200 response that carries no tool_use — the malformed-but-successful case
+ * the re-prompt retry exists to recover from. */
+function noToolResponse(): ProviderResponse {
+  return {
+    model: "stub-model",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: "no tool call" }],
+  };
+}
+
+/** Provider returning a different response per call (the i-th call returns
+ * responses[i], or the last entry once exhausted), recording each call so a
+ * test can assert how many attempts were made. */
+function makeSequenceProvider(responses: ProviderResponse[]): Provider {
+  let i = 0;
+  return {
+    name: "sequence",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      const response = responses[Math.min(i, responses.length - 1)];
+      i += 1;
+      return response;
+    },
+  };
+}
+
+/** Provider that records each call and then throws — for the throw-after-retries
+ * path (the provider's own RetryProvider has already exhausted its backoff). */
+function makeThrowingProvider(): Provider {
+  return {
+    name: "throwing",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      throw new Error("boom");
+    },
+  };
+}
+
 function makeLeaf(path: LeafPath, description: string): LeafNode {
   return {
     path,
@@ -101,8 +143,6 @@ function makeTree(): LeafTree {
   };
 }
 
-const SORTED_PATHS = ["people/alice", "people/bob", "projects/atlas"];
-
 function makeTurn(currentMessage: string): TurnContext {
   return {
     conversationId: "conv-xyz",
@@ -128,10 +168,10 @@ describe("routeL1 — id mapping", () => {
     expect(result).toEqual(["projects/atlas", "people/alice"]);
   });
 
-  test("omitted ids opens ALL leaves (recall-safe)", async () => {
+  test("omitted ids opens no leaves (must name leaves explicitly)", async () => {
     providerStub = makeProvider(toolUseResponse({}));
     const result = await routeL1(makeTurn("anything"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
   });
 
   test("explicit empty ids opens no leaves (abstention)", async () => {
@@ -157,39 +197,43 @@ describe("routeL1 — id mapping", () => {
   });
 });
 
-describe("routeL1 — recall-safe fallbacks", () => {
-  test("no provider → ALL leaves", async () => {
+describe("routeL1 — degradation on failure", () => {
+  test("no provider → no leaves, without calling the provider", async () => {
     providerStub = null;
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(0);
   });
 
-  test("missing tool_use → ALL leaves", async () => {
-    providerStub = makeProvider({
-      model: "stub-model",
-      stopReason: "end_turn",
-      usage: { inputTokens: 0, outputTokens: 0 },
-      content: [{ type: "text", text: "no tool call" }],
-    });
+  test("missing tool_use → no leaves after retrying", async () => {
+    providerStub = makeProvider(noToolResponse());
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("schema mismatch → ALL leaves", async () => {
+  test("schema mismatch → no leaves after retrying", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: "not-an-array" }));
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("provider throw → ALL leaves", async () => {
-    providerStub = {
-      name: "throwing",
-      sendMessage: async () => {
-        throw new Error("boom");
-      },
-    };
+  test("provider throw → no leaves after retrying", async () => {
+    providerStub = makeThrowingProvider();
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
+  });
+
+  test("a malformed response that recovers on retry returns its IDs", async () => {
+    providerStub = makeSequenceProvider([
+      noToolResponse(),
+      toolUseResponse({ ids: [2] }),
+    ]);
+    const result = await routeL1(makeTurn("bob?"), makeTree());
+    expect(result).toEqual(["people/bob"]);
+    expect(providerCalls).toHaveLength(2);
   });
 });
 
@@ -213,11 +257,11 @@ describe("routeL1 — request shape", () => {
     const [blockA, blockB] = providerCalls[0].messages[0].content as Array<{
       type: string;
       text: string;
-      cache_control?: { type: string };
+      cache_control?: { type: string; ttl?: string };
     }>;
     expect(blockA.type).toBe("text");
     expect(blockA.text).toContain("<leaves>");
-    expect(blockA.cache_control).toEqual({ type: "ephemeral" });
+    expect(blockA.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
     expect(blockB.type).toBe("text");
     expect(blockB.text).toContain("<current_message>alice?</current_message>");
@@ -225,6 +269,34 @@ describe("routeL1 — request shape", () => {
     expect(blockB.cache_control).toBeUndefined();
   });
 
+  test("situational context renders in the per-turn block when present", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(
+      {
+        ...makeTurn("x"),
+        situationalContext: "Today is Saturday. Alice's anniversary is today.",
+      },
+      makeTree(),
+    );
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).toContain(
+      "<situation>Today is Saturday. Alice's anniversary is today.</situation>",
+    );
+  });
+
+  test("situational context is omitted when the turn has none", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(makeTurn("x"), makeTree());
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).not.toContain("<situation>");
+  });
+
+  test("system prompt mentions situation (locks the routing commitment)", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(makeTurn("x"), makeTree());
+    expect(providerCalls[0].options?.systemPrompt).toMatch(/[Ss]ituation/);
+  });
+
   test("system prompt mentions register (locks the routing commitment)", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await routeL1(makeTurn("x"), makeTree());

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/selection-log-store.test.ts

@@ -20,14 +20,14 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { migrateAddMemoryV3Selections } from "../../migrations/268-add-memory-v3-selections.js";
-import * as schema from "../../schema.js";
+import { migrateAddMemoryV3Selections } from "../../../../memory/migrations/268-add-memory-v3-selections.js";
+import * as schema from "../../../../memory/schema.js";
 
 const realFlags = {
-  ...(await import("../../../config/assistant-feature-flags.js")),
+  ...(await import("../../../../config/assistant-feature-flags.js")),
 };
-const realLoader = { ...(await import("../../../config/loader.js")) };
-const realDb = { ...(await import("../../db-connection.js")) };
+const realLoader = { ...(await import("../../../../config/loader.js")) };
+const realDb = { ...(await import("../../../../memory/db-connection.js")) };
 const realPageContent = { ...(await import("../page-content.js")) };
 
 let storeMockActive = false;
@@ -64,7 +64,7 @@ function seed(
   }
 }
 
-mock.module("../../../config/assistant-feature-flags.js", () => ({
+mock.module("../../../../config/assistant-feature-flags.js", () => ({
   ...realFlags,
   isAssistantFeatureFlagEnabled: (key: string, config: unknown) =>
     storeMockActive
@@ -81,12 +81,12 @@ mock.module("../../../config/assistant-feature-flags.js", () => ({
         ),
 }));
 
-mock.module("../../../config/loader.js", () => ({
+mock.module("../../../../config/loader.js", () => ({
   ...realLoader,
   getConfig: () => (storeMockActive ? {} : realLoader.getConfig()),
 }));
 
-mock.module("../../db-connection.js", () => ({
+mock.module("../../../../memory/db-connection.js", () => ({
   ...realDb,
   getDb: () => (storeMockActive ? testDb : realDb.getDb()),
   getSqliteFrom: (db: unknown) =>

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/selector.test.ts

@@ -4,9 +4,12 @@
  * Coverage matrix:
  *   - Returned IDs map to the right member slugs by 1-based index, with
  *     `pinned` driven by `pinned_ids`.
- *   - Omitted `ids` → ALL members of the leaf (recall-safe).
+ *   - Omitted `ids` → ALL members of the leaf (recall-safe; bounded to one
+ *     leaf, so this stays a select-all unlike the L1 router).
  *   - Explicit `ids: []` → no pages (deliberate abstention).
- *   - No provider / missing tool_use / schema mismatch / throw → ALL members.
+ *   - No provider / missing tool_use / schema mismatch / throw → no pages
+ *     (degrade to the deterministic lanes), the last three after a re-prompt
+ *     retry; a malformed response that recovers on retry returns its pages.
  *   - The per-leaf `<pages>` prefix is byte-identical across two calls with
  *     different turns (the cache invariant).
  *   - `selectAcrossLeaves` flattens per-leaf results and never exceeds the
@@ -23,7 +26,7 @@ import type {
   ProviderResponse,
   SendMessageOptions,
   ToolUseContent,
-} from "../../../providers/types.js";
+} from "../../../../providers/types.js";
 import type {
   LeafNode,
   LeafPath,
@@ -45,13 +48,13 @@ interface ProviderCall {
 }
 const providerCalls: ProviderCall[] = [];
 
-mock.module("../../../providers/provider-send-message.js", () => ({
+mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => providerStub,
   extractToolUse: (response: ProviderResponse) =>
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
-mock.module("../../../util/logger.js", () => ({
+mock.module("../../../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: (_t, prop) => (prop === "child" ? () => ({}) : () => {}),
@@ -83,6 +86,45 @@ function toolUseResponse(input: Record<string, unknown>): ProviderResponse {
   };
 }
 
+/** A 200 response that carries no tool_use — the malformed-but-successful case
+ * the re-prompt retry exists to recover from. */
+function noToolResponse(): ProviderResponse {
+  return {
+    model: "stub-model",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: "no tool call" }],
+  };
+}
+
+/** Provider returning a different response per call (the i-th call returns
+ * responses[i], or the last entry once exhausted), recording each call so a
+ * test can assert how many attempts were made. */
+function makeSequenceProvider(responses: ProviderResponse[]): Provider {
+  let i = 0;
+  return {
+    name: "sequence",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      const response = responses[Math.min(i, responses.length - 1)];
+      i += 1;
+      return response;
+    },
+  };
+}
+
+/** Provider that records each call and then throws — for the throw-after-retries
+ * path (the provider's own RetryProvider has already exhausted its backoff). */
+function makeThrowingProvider(): Provider {
+  return {
+    name: "throwing",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      throw new Error("boom");
+    },
+  };
+}
+
 function makeLeaf(path: LeafPath, members: Slug[]): LeafNode {
   return {
     path,
@@ -206,10 +248,8 @@ describe("selectFromLeaf — id mapping", () => {
 // selectFromLeaf — recall-safe fallbacks.
 // ---------------------------------------------------------------------------
 
-describe("selectFromLeaf — recall-safe fallbacks", () => {
-  const allAlice = ALICE_MEMBERS.map((slug) => ({ slug, pinned: false }));
-
-  test("no provider → ALL members", async () => {
+describe("selectFromLeaf — degradation on failure", () => {
+  test("no provider → no pages, without calling the provider", async () => {
     providerStub = null;
     const result = await selectFromLeaf(
       "people/alice",
@@ -217,26 +257,23 @@ describe("selectFromLeaf — recall-safe fallbacks", () => {
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(0);
   });
 
-  test("missing tool_use → ALL members", async () => {
-    providerStub = makeProvider({
-      model: "stub-model",
-      stopReason: "end_turn",
-      usage: { inputTokens: 0, outputTokens: 0 },
-      content: [{ type: "text", text: "no tool call" }],
-    });
+  test("missing tool_use → no pages after retrying", async () => {
+    providerStub = makeProvider(noToolResponse());
     const result = await selectFromLeaf(
       "people/alice",
       makeTurn("x"),
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("schema mismatch → ALL members", async () => {
+  test("schema mismatch → no pages after retrying", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: "not-an-array" }));
     const result = await selectFromLeaf(
       "people/alice",
@@ -244,23 +281,35 @@ describe("selectFromLeaf — recall-safe fallbacks", () => {
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("provider throw → ALL members", async () => {
-    providerStub = {
-      name: "throwing",
-      sendMessage: async () => {
-        throw new Error("boom");
-      },
-    };
+  test("provider throw → no pages after retrying", async () => {
+    providerStub = makeThrowingProvider();
     const result = await selectFromLeaf(
       "people/alice",
       makeTurn("x"),
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
+  });
+
+  test("a malformed response that recovers on retry returns its pages", async () => {
+    providerStub = makeSequenceProvider([
+      noToolResponse(),
+      toolUseResponse({ ids: [2] }),
+    ]);
+    const result = await selectFromLeaf(
+      "people/alice",
+      makeTurn("the 1:1"),
+      makeTree(),
+      summaryOf,
+    );
+    expect(result).toEqual([{ slug: "alice-1on1", pinned: false }]);
+    expect(providerCalls).toHaveLength(2);
   });
 });
 
@@ -298,13 +347,13 @@ describe("selectFromLeaf — request shape", () => {
     const [blockA, blockB] = providerCalls[0].messages[0].content as Array<{
       type: string;
       text: string;
-      cache_control?: { type: string };
+      cache_control?: { type: string; ttl?: string };
     }>;
     expect(blockA.type).toBe("text");
     expect(blockA.text).toContain("<leaf>people/alice</leaf>");
     expect(blockA.text).toContain("<pages>");
     expect(blockA.text).toContain("[1] alice-bio — summary of alice-bio");
-    expect(blockA.cache_control).toEqual({ type: "ephemeral" });
+    expect(blockA.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
     expect(blockB.type).toBe("text");
     expect(blockB.text).toContain("<current_message>alice?</current_message>");
@@ -312,6 +361,23 @@ describe("selectFromLeaf — request shape", () => {
     expect(blockB.cache_control).toBeUndefined();
   });
 
+  test("situational context renders in the per-turn block when present", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await selectFromLeaf(
+      "people/alice",
+      {
+        ...makeTurn("alice?"),
+        situationalContext: "Today is Saturday. Alice's anniversary is today.",
+      },
+      makeTree(),
+      summaryOf,
+    );
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).toContain(
+      "<situation>Today is Saturday. Alice's anniversary is today.</situation>",
+    );
+  });
+
   test("system prompt mentions pinned (locks the pinning commitment)", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await selectFromLeaf("people/alice", makeTurn("x"), makeTree(), summaryOf);