@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -30,7 +30,7 @@
  */
 
 import { createRequire } from "node:module";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   Message,
@@ -39,6 +39,10 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
+import {
+  estimatePromptTokensWithTools,
+  estimateTextTokens,
+} from "../../../../../context/token-estimator.js";
 import { OpenRouterProvider } from "../../../../../providers/openrouter/client.js";
 import { ProviderError } from "../../../../../util/errors.js";
 import { stripOrphanedSurrogates } from "../../../../../util/unicode.js";
@@ -51,6 +55,8 @@ import type { MemoryRoutingTurn, Section } from "../types.js";
 // ---------------------------------------------------------------------------
 
 let providerStub: Provider | null = null;
+let selectorContextMockActive = false;
+let selectorMaxInputTokens = 200_000;
 const registryReal = {
   ...(createRequire(import.meta.url)(
     "../../../../../providers/registry.js",
@@ -68,6 +74,16 @@ const realPluginApi = await import("@vellumai/plugin-api");
 mock.module("@vellumai/plugin-api", () => ({
   ...realPluginApi,
   getConfiguredProvider: async () => providerStub,
+  getEffectiveContextWindow: (
+    ...args: Parameters<typeof realPluginApi.getEffectiveContextWindow>
+  ) =>
+    selectorContextMockActive
+      ? {
+          provider: providerStub?.name ?? "stub",
+          model: providerStub?.defaultModel ?? "stub-model",
+          maxInputTokens: selectorMaxInputTokens,
+        }
+      : realPluginApi.getEffectiveContextWindow(...args),
 }));
 
 mock.module("../../../../../providers/registry.js", () => ({
@@ -78,15 +94,20 @@ mock.module("../../../../../providers/registry.js", () => ({
 
 mock.module("../../../../../util/logger.js", () => ({
   getLogger: () => ({
+    info: () => {},
     warn: (...args: unknown[]) => warnCalls.push({ args }),
     child: () => ({
+      info: () => {},
       warn: (...args: unknown[]) => warnCalls.push({ args }),
     }),
   }),
 }));
 
-const { selectPool, MemoryV3RetrievalUnavailableError } =
-  await import("../pool-select.js");
+const {
+  selectPool,
+  MemoryV3RetrievalUnavailableError,
+  TYPE_SAFE_POOL_KEEP_NOUL,
+} = await import("../pool-select.js");
 type SelectorPool = Parameters<typeof selectPool>[0];
 
 // ---------------------------------------------------------------------------
@@ -166,16 +187,24 @@ const CARD_A =
 const CARD_B = "# memory/concepts/page-b.md\nlead for page b";
 
 /** Two stable-prefix cards (`[1] page-a`, `[2] page-b`) and two finder lines
- * (`[3] topic-x`, `[4] page-a` — a finder hit on a stable-prefix page). */
+ * (`[3] topic-x`, `[4] page-a`, with the latter also in the prefix). */
 function makePool(): SelectorPool {
   return {
     stable: [
-      { slug: "page-a", card: CARD_A },
-      { slug: "page-b", card: CARD_B },
+      { slug: "page-a", card: CARD_A, lane: "core" },
+      { slug: "page-b", card: CARD_B, lane: "hot" },
     ],
     finder: [
-      { slug: "topic-x", descriptor: "section: about topic x" },
-      { slug: "page-a", descriptor: "section: the alpha rollout plan" },
+      {
+        slug: "topic-x",
+        descriptor: "section: about topic x",
+        lane: "needle",
+      },
+      {
+        slug: "page-a",
+        descriptor: "section: the alpha rollout plan",
+        lane: "dense",
+      },
     ],
   };
 }
@@ -222,10 +251,16 @@ function warnPayloads(): Array<Record<string, unknown>> {
 
 beforeEach(() => {
   providerStub = null;
+  selectorContextMockActive = true;
+  selectorMaxInputTokens = 200_000;
   providerCalls.length = 0;
   warnCalls.length = 0;
 });
 
+afterAll(() => {
+  selectorContextMockActive = false;
+});
+
 // ---------------------------------------------------------------------------
 // selectPool — id mapping over the concatenated numbering.
 // ---------------------------------------------------------------------------
@@ -413,6 +448,94 @@ describe("selectPool — infrastructure failures throw", () => {
     ]);
   });
 
+  test("provider failure carries the exact budgeted pool and turn", async () => {
+    selectorMaxInputTokens = 8_000;
+    const pool: SelectorPool = {
+      stable: Array.from({ length: 20 }, (_, index) => ({
+        slug: `stable-${index}`,
+        card: `stable card ${index} ${"x".repeat(4_000)}`,
+        lane: index === 0 ? ("core" as const) : ("hot" as const),
+      })),
+      finder: [
+        {
+          slug: "finder-learned",
+          descriptor: "learned association",
+          lane: "learned",
+        },
+        {
+          slug: "finder-needle",
+          descriptor: "direct lexical hit",
+          lane: "needle",
+        },
+      ],
+    };
+    const turn = {
+      ...makeTurn("preserve this current message"),
+      recentContext: `${"r".repeat(40_000)}RECENT-END`,
+      situationalContext: `old situation ${"s".repeat(20_000)}`,
+    };
+    providerStub = makeThrowingProvider();
+
+    let caught: unknown;
+    try {
+      await selectPool(pool, turn);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
+    const failure = caught as InstanceType<
+      typeof MemoryV3RetrievalUnavailableError
+    >;
+    expect(failure.pool?.stable[0]?.slug).toBe("stable-0");
+    expect(
+      (failure.pool?.stable.length ?? 0) + (failure.pool?.finder.length ?? 0),
+    ).toBeLessThan(pool.stable.length + pool.finder.length);
+    expect(
+      failure.pool?.finder.map((candidate) => candidate.slug),
+    ).not.toContain("finder-learned");
+    expect(failure.turn?.currentMessage).toBe("preserve this current message");
+    expect(failure.turn?.recentContext).toEndWith("RECENT-END");
+    expect(failure.turn?.recentContext.length).toBeLessThan(
+      turn.recentContext.length,
+    );
+    expect(failure.turn?.situationalContext).toBeUndefined();
+  });
+
+  test("throws without sending when no candidate can fit the context budget", async () => {
+    selectorMaxInputTokens = 8_000;
+    const pool: SelectorPool = {
+      stable: [
+        {
+          slug: "oversized-core",
+          card: `oversized core ${"x".repeat(40_000)}`,
+          lane: "core",
+        },
+      ],
+      finder: [],
+    };
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+
+    let caught: unknown;
+    try {
+      await selectPool(pool, makeTurn("anything"));
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
+    expect((caught as Error).message).toBe(
+      "memory-v3 pool selector has no candidate that fits the context budget",
+    );
+    expect(providerCalls).toHaveLength(0);
+    const failure = caught as InstanceType<
+      typeof MemoryV3RetrievalUnavailableError
+    >;
+    expect(failure.pool).toEqual({ stable: [], finder: [] });
+    expect(failure.turn?.currentMessage).toBe("anything");
+    expect(failure.turn?.recentContext).toBe("");
+  });
+
   test("managed provider 402 attaches a non-terminal credits notice", async () => {
     providerStub = {
       name: "managed",
@@ -497,6 +620,7 @@ describe("selectPool — request shape", () => {
     const [call] = providerCalls;
     const cfg = call.options?.config as Record<string, unknown>;
     expect(cfg?.callSite).toBe("memoryV3SelectL2");
+    expect(cfg?.selectionSeed).toBe("conv-xyz");
     expect(cfg?.tool_choice).toEqual({ type: "tool", name: "select_pages" });
     expect(cfg?.disableTurnStartCache).toBe(true);
     const tool = call.options?.tools?.[0];
@@ -507,6 +631,134 @@ describe("selectPool — request shape", () => {
     expect(Object.keys(inputSchema.properties ?? {})).toEqual(["ids"]);
   });
 
+  test("keeps forced-tool requests within 80% of the resolved context window", async () => {
+    selectorMaxInputTokens = 8_000;
+    const oversizedPool: SelectorPool = {
+      stable: Array.from({ length: 20 }, (_, index) => ({
+        slug: `stable-${index}`,
+        card: `stable card ${index} ${"x".repeat(4_000)}`,
+        lane: index === 0 ? ("core" as const) : ("hot" as const),
+      })),
+      finder: [
+        {
+          slug: "finder-learned",
+          descriptor: "learned association",
+          lane: "learned",
+        },
+        { slug: "finder-edge", descriptor: "authored link", lane: "edge" },
+        {
+          slug: "finder-needle",
+          descriptor: "direct lexical hit",
+          lane: "needle",
+        },
+      ],
+    };
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+
+    const result = await selectPool(
+      oversizedPool,
+      makeTurn("preserve this generic current message"),
+    );
+
+    expect(providerCalls).toHaveLength(1);
+    const call = providerCalls[0]!;
+    const estimatedInputTokens = estimatePromptTokensWithTools(
+      call.messages,
+      call.options?.systemPrompt,
+      call.options?.tools ?? [],
+      providerStub.name,
+    );
+    expect(estimatedInputTokens).toBeLessThanOrEqual(6_400);
+    const sent = JSON.stringify(call.messages);
+    expect(sent).toContain("preserve this generic current message");
+    expect(sent).toContain("stable card 0");
+    expect(sent).toContain("finder-needle");
+    expect(sent).not.toContain("finder-learned");
+    expect(result.pool.stable[0]?.slug).toBe("stable-0");
+    expect(result.pool.finder.map((candidate) => candidate.slug)).toContain(
+      "finder-needle",
+    );
+    expect(result.pages[0]?.slug).toBe("stable-0");
+  });
+
+  test("skips a large core card that fits only by dropping the current message", async () => {
+    selectorMaxInputTokens = 8_000;
+    const currentMessage = `CURRENT-QUERY-${"q".repeat(8_000)}`;
+    const pool: SelectorPool = {
+      stable: [
+        {
+          slug: "query-erasing-core",
+          card: `large core ${"x".repeat(20_000)}`,
+          lane: "core",
+        },
+      ],
+      finder: [
+        {
+          slug: "usable-needle",
+          descriptor: "small direct hit",
+          lane: "needle",
+        },
+      ],
+    };
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+
+    const result = await selectPool(pool, makeTurn(currentMessage));
+
+    expect(providerCalls).toHaveLength(1);
+    const sent = JSON.stringify(providerCalls[0]!.messages);
+    expect(sent).toContain(currentMessage);
+    expect(sent).not.toContain("query-erasing-core");
+    expect(sent).toContain("usable-needle");
+    expect(result.pool.stable).toEqual([]);
+    expect(result.pool.finder.map((candidate) => candidate.slug)).toEqual([
+      "usable-needle",
+    ]);
+    expect(result.turn.currentMessage).toBe(currentMessage);
+    expect(result.pages).toEqual([{ slug: "usable-needle", sections: [] }]);
+  });
+
+  test("skips an individually oversized core card and still sends a smaller direct hit", async () => {
+    selectorMaxInputTokens = 8_000;
+    const pool: SelectorPool = {
+      stable: [
+        {
+          slug: "oversized-core",
+          card: `oversized core ${"x".repeat(40_000)}`,
+          lane: "core",
+        },
+      ],
+      finder: [
+        {
+          slug: "usable-needle",
+          descriptor: "small direct hit",
+          lane: "needle",
+        },
+      ],
+    };
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+
+    const result = await selectPool(pool, makeTurn("use the direct hit"));
+
+    expect(providerCalls).toHaveLength(1);
+    expect(JSON.stringify(providerCalls[0]!.messages)).not.toContain(
+      "oversized-core",
+    );
+    expect(JSON.stringify(providerCalls[0]!.messages)).toContain(
+      "usable-needle",
+    );
+    expect(result.pool).toEqual({
+      stable: [],
+      finder: [
+        {
+          slug: "usable-needle",
+          descriptor: "small direct hit",
+          lane: "needle",
+        },
+      ],
+    });
+    expect(result.pages).toEqual([{ slug: "usable-needle", sections: [] }]);
+  });
+
   test("stable prefix renders full cards in its own block carrying cache_control", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await selectPool(makePool(), makeTurn("rollout?"));
@@ -526,8 +778,12 @@ describe("selectPool — request shape", () => {
 
     // The tail continues the numbering after the cards and is NOT cached.
     expect(tail.type).toBe("text");
-    expect(tail.text).toContain("[3] topic-x — section: about topic x");
-    expect(tail.text).toContain("[4] page-a — section: the alpha rollout plan");
+    expect(tail.text).toContain(
+      "[3] (needle) topic-x \u2014 section: about topic x",
+    );
+    expect(tail.text).toContain(
+      "[4] (dense) page-a \u2014 section: the alpha rollout plan",
+    );
     expect(tail.text).toContain("<current_message>rollout?</current_message>");
     expect(tail.text).toContain("<recent_context>");
     expect(tail.cache_control).toBeUndefined();
@@ -535,7 +791,7 @@ describe("selectPool — request shape", () => {
     expect(tail.text).not.toContain("<candidate_cards>");
   });
 
-  test("finder lines render the surfacing lane tag when one is supplied", async () => {
+  test("finder lines render the surfacing lane tag", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [] }));
     const pool = makePool();
     pool.finder = [
@@ -546,7 +802,7 @@ describe("selectPool — request shape", () => {
 
     const [, tail] = sentBlocks();
     expect(tail.text).toContain(
-      "[3] (needle) topic-x — section: about topic x",
+      "[3] (needle) topic-x \u2014 section: about topic x",
     );
     // Empty descriptor: lane tag still renders, dash omitted.
     expect(tail.text).toContain("[4] (learned) page-a");
@@ -558,7 +814,13 @@ describe("selectPool — request shape", () => {
 
     // Same stable lanes, different finder hits + message (a new turn).
     const pool2 = makePool();
-    pool2.finder = [{ slug: "page-c", descriptor: "section: something else" }];
+    pool2.finder = [
+      {
+        slug: "page-c",
+        descriptor: "section: something else",
+        lane: "needle",
+      },
+    ];
     await selectPool(pool2, makeTurn("second question"));
 
     const [prefix1, tail1] = sentBlocks(0);
@@ -571,12 +833,15 @@ describe("selectPool — request shape", () => {
   test("an empty stable prefix renders a single un-cached block", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await selectPool(
-      { stable: [], finder: [{ slug: "page-a", descriptor: "d" }] },
+      {
+        stable: [],
+        finder: [{ slug: "page-a", descriptor: "d", lane: "needle" }],
+      },
       makeTurn("x"),
     );
     const blocks = sentBlocks();
     expect(blocks).toHaveLength(1);
-    expect(blocks[0].text).toContain("[1] page-a — d");
+    expect(blocks[0].text).toContain("[1] (needle) page-a \u2014 d");
     expect(blocks[0].cache_control).toBeUndefined();
   });
 
@@ -584,28 +849,38 @@ describe("selectPool — request shape", () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     const longDescriptor = `padded   ${"z".repeat(1000)}`;
     await selectPool(
-      { stable: [], finder: [{ slug: "page-a", descriptor: longDescriptor }] },
+      {
+        stable: [],
+        finder: [
+          { slug: "page-a", descriptor: longDescriptor, lane: "needle" },
+        ],
+      },
       makeTurn("x"),
     );
     const [block] = sentBlocks();
     const line = block.text
       .split("\n")
-      .find((l) => l.startsWith("[1] page-a — "))!;
+      .find((l) => l.startsWith("[1] (needle) page-a \u2014 "))!;
     expect(line).toContain("...");
     expect(line).not.toContain("z".repeat(1000));
-    // snippet cap (300) + the `[1] page-a — ` prefix.
-    expect(line.length).toBeLessThanOrEqual(300 + "[1] page-a — ".length);
+    // snippet cap (300) plus the numbered lane/slug prefix.
+    expect(line.length).toBeLessThanOrEqual(
+      300 + "[1] (needle) page-a \u2014 ".length,
+    );
   });
 
   test("a finder candidate with an empty descriptor renders without a dangling dash", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await selectPool(
-      { stable: [], finder: [{ slug: "page-a", descriptor: "   " }] },
+      {
+        stable: [],
+        finder: [{ slug: "page-a", descriptor: "   ", lane: "needle" }],
+      },
       makeTurn("x"),
     );
     const [block] = sentBlocks();
-    expect(block.text).toContain("[1] page-a\n");
-    expect(block.text).not.toContain("[1] page-a — ");
+    expect(block.text).toContain("[1] (needle) page-a\n");
+    expect(block.text).not.toContain("[1] (needle) page-a \u2014 ");
   });
 
   test("situational context renders in the tail when present", async () => {
@@ -650,18 +925,24 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
   function sectionedPool(): SelectorPool {
     const pool = makePool();
     pool.finder = [
-      { slug: "topic-x", descriptor: "section: about topic x" },
+      {
+        slug: "topic-x",
+        descriptor: "section: about topic x",
+        lane: "needle",
+      },
       {
         slug: "page-a",
         descriptor: alpha.text,
         section: alpha,
         terms: ["rollout"],
+        lane: "needle",
       },
       {
         slug: "page-a",
         descriptor: beta.text,
         section: beta,
         terms: ["metrics"],
+        lane: "dense",
       },
     ];
     return pool;
@@ -753,13 +1034,14 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
         descriptor: alpha.text,
         section: alpha,
         terms: ["missing"],
+        lane: "needle",
       }),
       makeTurn("x"),
     );
     const [block] = sentBlocks();
     const line = block.text
       .split("\n")
-      .find((l) => l.startsWith("[1] page-a "))!;
+      .find((l) => l.startsWith("[1] (needle) page-a "))!;
     expect(
       line.endsWith("page-a - Alpha the alpha rollout plan in detail"),
     ).toBe(true);
@@ -779,13 +1061,14 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
         descriptor: lead.text,
         section: lead,
         terms: ["rollout"],
+        lane: "needle",
       }),
       makeTurn("x"),
     );
     const [block] = sentBlocks();
     const line = block.text
       .split("\n")
-      .find((l) => l.startsWith("[1] page-a "))!;
+      .find((l) => l.startsWith("[1] (needle) page-a "))!;
     expect(line.endsWith("the lead mentions the rollout early on")).toBe(true);
     expect(line).not.toContain("§");
     expect(line).not.toContain("…");
@@ -833,13 +1116,14 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
         descriptor: notes.text,
         section: notes,
         terms: ["weekly_turnip"],
+        lane: "needle",
       }),
       makeTurn("x"),
     );
     const [block] = sentBlocks();
     const line = block.text
       .split("\n")
-      .find((l) => l.startsWith("[1] page-a "))!;
+      .find((l) => l.startsWith("[1] (needle) page-a "))!;
     expect(line.endsWith("§Notes: we said: weekly, turnip is the label")).toBe(
       true,
     );
@@ -863,6 +1147,7 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
         descriptor: section.text,
         section,
         terms: ["turnip"],
+        lane: "needle",
       }),
       makeTurn("turnip?"),
     );
@@ -870,7 +1155,7 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
     expect(stripOrphanedSurrogates(block.text)).toBe(block.text);
     const line = block.text
       .split("\n")
-      .find((l) => l.startsWith("[1] page-a "))!;
+      .find((l) => l.startsWith("[1] (needle) page-a "))!;
     expect(line).toContain("§Rollout: … ");
     expect(line).toContain("turnip");
     expect(line.endsWith(" …")).toBe(true);
@@ -968,3 +1253,317 @@ describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
     expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// selectPool: TypeSafe System One noul-per-candidate path.
+// ---------------------------------------------------------------------------
+
+function typesafeResponse(answers: Record<string, unknown>): ProviderResponse {
+  return {
+    model: "jev-latest",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: JSON.stringify(answers, null, 2) }],
+    rawResponse: { answers },
+  };
+}
+
+function makeTypesafeProvider(response: ProviderResponse): Provider {
+  return {
+    name: "typesafe",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      return response;
+    },
+  };
+}
+
+function noulAnswer(noul: number): { type: "noul"; noul: number } {
+  return { type: "noul", noul };
+}
+
+describe("selectPool: TypeSafe System One", () => {
+  test("keeps selector requests within 80% of the resolved context window while preserving the newest candidates", async () => {
+    selectorMaxInputTokens = 32_000;
+    const oversizedPool: SelectorPool = {
+      stable: Array.from({ length: 40 }, (_, index) => ({
+        slug: `stable-${index}`,
+        card: `stable card ${index} ${"x".repeat(5_000)}`,
+        lane: index === 0 ? ("core" as const) : ("hot" as const),
+      })),
+      finder: [
+        { slug: "finder-needle", descriptor: "needle", lane: "needle" },
+        { slug: "finder-dense", descriptor: "dense", lane: "dense" },
+        { slug: "finder-edge", descriptor: "edge", lane: "edge" },
+        { slug: "finder-learned", descriptor: "learned", lane: "learned" },
+      ],
+    };
+    let retainedSlugs: string[] = [];
+    providerStub = {
+      name: "typesafe",
+      defaultModel: "jev-latest",
+      sendMessage: async (messages, options) => {
+        providerCalls.push({ messages, options });
+        const payload = JSON.parse(
+          (messages[0]!.content[0] as { text: string }).text,
+        ) as {
+          state: {
+            candidates: Record<string, { slug: string; text: string }>;
+            current_message: string;
+          };
+          questions: Record<string, unknown>;
+        };
+        retainedSlugs = Object.values(payload.state.candidates).map(
+          (candidate) => candidate.slug,
+        );
+        const answers = Object.fromEntries(
+          retainedSlugs.map((_, index) => [
+            String(index + 1),
+            noulAnswer(
+              index === 0 || index === retainedSlugs.length - 1 ? 1 : 0,
+            ),
+          ]),
+        );
+        return typesafeResponse(answers);
+      },
+    };
+
+    const currentMessage = "preserve this current message";
+    const result = await selectPool(oversizedPool, makeTurn(currentMessage));
+
+    expect(providerCalls).toHaveLength(1);
+    const payloadText = (
+      providerCalls[0]!.messages[0]!.content[0] as { text: string }
+    ).text;
+    const payload = JSON.parse(payloadText) as {
+      state: {
+        candidates: Record<string, { slug: string; text: string }>;
+        current_message: string;
+      };
+      questions: Record<string, unknown>;
+    };
+    const estimatedWireTokens = estimateTextTokens(
+      JSON.stringify({
+        state: payload.state,
+        model: "jev-latest",
+        questions: payload.questions,
+      }),
+    );
+    expect(estimatedWireTokens).toBeLessThanOrEqual(25_600);
+    expect(payload.state.current_message).toBe(currentMessage);
+    expect(retainedSlugs.length).toBeLessThan(44);
+    expect(retainedSlugs).toContain("stable-0");
+    expect(retainedSlugs).toContain("finder-needle");
+    expect(retainedSlugs).toContain("finder-dense");
+    expect(retainedSlugs).not.toContain("finder-learned");
+    expect(Object.keys(payload.questions)).toHaveLength(retainedSlugs.length);
+    expect(result.pool.stable[0]?.slug).toBe("stable-0");
+    expect(result.pool.finder.map((candidate) => candidate.slug)).toEqual([
+      "finder-needle",
+      "finder-dense",
+    ]);
+    expect(result.pages).toEqual([
+      { slug: retainedSlugs[0], sections: [] },
+      { slug: retainedSlugs[retainedSlugs.length - 1], sections: [] },
+    ]);
+    expect(result.keptAll).toBe(false);
+  });
+
+  test("drops the trailing current-message duplicate before trimming recent context", async () => {
+    selectorMaxInputTokens = 8_000;
+    let payload: {
+      state: {
+        current_message: string;
+        recent_context: string;
+        situation?: string;
+      };
+    } | null = null;
+    providerStub = {
+      name: "typesafe",
+      defaultModel: "jev-latest",
+      sendMessage: async (messages, options) => {
+        providerCalls.push({ messages, options });
+        payload = JSON.parse(
+          (messages[0]!.content[0] as { text: string }).text,
+        ) as typeof payload;
+        return typesafeResponse({
+          "1": noulAnswer(1),
+          "2": noulAnswer(0),
+          "3": noulAnswer(0),
+          "4": noulAnswer(0),
+        });
+      },
+    };
+    const currentMessage = `current query ${"q".repeat(2_000)}`;
+    const previousAssistant = `preceding assistant reply ${"a".repeat(2_000)}`;
+    const turn = {
+      ...makeTurn(currentMessage),
+      recentContext: `${previousAssistant}\n${currentMessage}`,
+      situationalContext: `old situation ${"s".repeat(30_000)}`,
+    };
+
+    const result = await selectPool(makePool(), turn);
+
+    expect(payload).not.toBeNull();
+    expect(payload!.state.current_message).toBe(currentMessage);
+    expect(payload!.state.recent_context).toBe(previousAssistant);
+    expect(payload!.state.recent_context).not.toContain(currentMessage);
+    expect(payload!.state.situation?.length ?? 0).toBeLessThan(
+      turn.situationalContext.length,
+    );
+    expect(result.turn.currentMessage).toBe(currentMessage);
+    expect(result.turn.recentContext).toBe(previousAssistant);
+  });
+
+  test("preserves the current message and newest recent-context suffix when turn context is oversized", async () => {
+    selectorMaxInputTokens = 8_000;
+    let payload: {
+      state: {
+        candidates: Record<string, { slug: string; text: string }>;
+        current_message: string;
+        recent_context: string;
+        situation?: string;
+      };
+      questions: Record<string, unknown>;
+    } | null = null;
+    providerStub = {
+      name: "typesafe",
+      defaultModel: "jev-latest",
+      sendMessage: async (messages, options) => {
+        providerCalls.push({ messages, options });
+        payload = JSON.parse(
+          (messages[0]!.content[0] as { text: string }).text,
+        ) as typeof payload;
+        const ids = Object.keys(payload!.state.candidates);
+        return typesafeResponse(
+          Object.fromEntries(ids.map((id) => [id, noulAnswer(1)])),
+        );
+      },
+    };
+    const currentMessage = "keep the complete current message";
+    const recentSuffix = "RECENT-CONTEXT-END";
+    const turn = {
+      ...makeTurn(currentMessage),
+      recentContext: `${"r".repeat(40_000)}${recentSuffix}`,
+      situationalContext: `old situation ${"s".repeat(20_000)}`,
+    };
+
+    await selectPool(makePool(), turn);
+
+    expect(payload).not.toBeNull();
+    expect(payload!.state.current_message).toBe(currentMessage);
+    expect(payload!.state.recent_context).toEndWith(recentSuffix);
+    expect(payload!.state.recent_context.length).toBeLessThan(
+      turn.recentContext.length,
+    );
+    expect(payload!.state.situation).toBeUndefined();
+    const estimatedWireTokens = estimateTextTokens(
+      JSON.stringify({
+        state: payload!.state,
+        model: "jev-latest",
+        questions: payload!.questions,
+      }),
+    );
+    expect(estimatedWireTokens).toBeLessThanOrEqual(6_400);
+  });
+
+  test("sends one noul per candidate and no select_pages tool", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.9),
+        "2": noulAnswer(0.1),
+        "3": noulAnswer(0.8),
+        "4": noulAnswer(0.2),
+      }),
+    );
+
+    await selectPool(makePool(), makeTurn("rollout?"));
+
+    expect(providerCalls).toHaveLength(1);
+    const [call] = providerCalls;
+    expect(call.options?.tools).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)
+        ?.tool_choice,
+    ).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)?.callSite,
+    ).toBe("memoryV3SelectL2");
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)
+        ?.selectionSeed,
+    ).toBe("conv-xyz");
+
+    const payload = JSON.parse(
+      (call.messages[0]!.content[0] as { text: string }).text,
+    ) as {
+      state: {
+        candidates: Record<string, { slug: string; text: string }>;
+        current_message: string;
+        selector_instructions: string;
+      };
+      questions: Record<string, { type: string; instructions: string }>;
+    };
+    expect(Object.keys(payload.questions)).toEqual(["1", "2", "3", "4"]);
+    expect(payload.questions["1"]?.type).toBe("noul");
+    expect(payload.questions["1"]?.instructions).toContain("`candidates.1`");
+    expect(payload.state.candidates["1"]?.slug).toBe("page-a");
+    expect(payload.state.candidates["1"]?.text).toBe(CARD_A);
+    expect(payload.state.candidates["3"]?.slug).toBe("topic-x");
+    expect(payload.state.current_message).toBe("rollout?");
+    expect(payload.state.selector_instructions.length).toBeGreaterThan(0);
+  });
+
+  test("keeps candidates at or above the inclusive noul threshold", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL),
+        "2": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL - 0.01),
+        "3": noulAnswer(0.91),
+        "4": noulAnswer(0.12),
+      }),
+    );
+
+    const result = await selectPool(makePool(), makeTurn("rollout?"));
+    expect(result.keptAll).toBe(false);
+    expect(result.pages).toEqual([
+      { slug: "page-a", sections: [] },
+      { slug: "topic-x", sections: [] },
+    ]);
+  });
+
+  test("an all-below-threshold pool is a deliberate empty selection", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.1),
+        "2": noulAnswer(0.2),
+        "3": noulAnswer(0.05),
+        "4": noulAnswer(0.3),
+      }),
+    );
+
+    const pool = makePool();
+    const turn = makeTurn("nothing relevant");
+    const result = await selectPool(pool, turn);
+    expect(result).toEqual({
+      pages: [],
+      keptAll: false,
+      pool,
+      turn,
+    });
+  });
+
+  test("unusable answers throw after the re-prompt retry", async () => {
+    providerStub = makeTypesafeProvider({
+      model: "jev-latest",
+      stopReason: "end_turn",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      content: [{ type: "text", text: "not-json" }],
+    });
+
+    await expect(selectPool(makePool(), makeTurn("x"))).rejects.toThrow(
+      MemoryV3RetrievalUnavailableError,
+    );
+    expect(providerCalls).toHaveLength(3);
+  });
+});