@vellumai/assistant 0.8.4 → 0.8.5

package/src/memory/v2/router.ts

@@ -21,9 +21,11 @@
  *      since NOW.md only changes when the model rewrites it. We set the 1h
  *      TTL explicitly here to match the provider-side breakpoints; the
  *      default 5m would force unnecessary cache re-creation.
- * The Anthropic provider also auto-applies a 1h breakpoint on the last text
- * block of a turn-starting user message, so the trailing uncached block does
- * not need an explicit `cache_control`.
+ * The trailing user-message block holds `<last_turn>` content that changes
+ * every call (new user turn + new prior assistant reply), so we pass
+ * `disableTurnStartCache: true` to the provider to suppress its auto-applied
+ * 1h breakpoint there — caching it would create unused cache entries (pure
+ * cache_creation cost with no future hit).
  *
  * This module is pure orchestration — it does not mutate activation state,
  * write any files, or update the conversation. PR 10 wires it into
@@ -155,10 +157,31 @@ function emptyBatchResult(
   return { selectedSlugs: [], failureReason: reason };
 }
 
+/**
+ * One `(assistant, user)` turn pair rendered inside `<last_turn>`. The
+ * pair represents the assistant's reply followed by the user message
+ * that came after. The most recent pair's `userMessage` is the
+ * just-arrived turn that triggered the router; older pairs are walked
+ * back from conversation history. `assistantMessage` is the empty
+ * string for the oldest pair when there was no prior assistant reply
+ * (conversation start) — `runRouterBatch` skips the `[assistant]:`
+ * line entirely in that case.
+ */
+export interface RouterTurnPair {
+  assistantMessage: string;
+  userMessage: string;
+}
+
 interface RunRouterParams {
   workspaceDir: string;
-  userMessage: string;
-  assistantMessage: string;
+  /**
+   * Recent assistant/user turn pairs, oldest first. Must contain at
+   * least one entry. The last entry's `userMessage` is the just-arrived
+   * user turn the router is routing for; entries before it are walked
+   * back from conversation history. The number of pairs the production
+   * caller passes is controlled by `memory.v2.router.historical_pairs`.
+   */
+  recentTurnPairs: readonly RouterTurnPair[];
   /** Verbatim contents to inject into `<now>...</now>` on this turn. */
   nowText: string;
   /** Slugs already injected on prior turns (used to seed `<already_injected_ids>`). */
@@ -172,6 +195,28 @@ interface RunRouterParams {
    * only exercise tier 1 / tier 3 paths can omit it.
    */
   database?: DrizzleDb;
+  /**
+   * Per-call profile override forwarded to `getConfiguredProvider`. When
+   * set, the `memoryRouter` call site resolves against this profile name
+   * instead of the workspace active profile. The simulator route uses
+   * this to compare different profiles against the same query; live
+   * router callers leave it unset.
+   */
+  overrideProfile?: string;
+  /**
+   * Skip the post-union truncation to `max_page_ids`. Used by the
+   * simulator so the playground can show the full untruncated router
+   * output across all batches. Live callers (`injectViaRouter`) leave
+   * this unset so the bounded-injection contract holds.
+   */
+  disableUnionCap?: boolean;
+  /**
+   * Per-call inline router system-prompt override. Takes precedence
+   * over `memory.v2.router.router_prompt_path` and the bundled body.
+   * Used by the simulator playground for ad-hoc prompt comparisons.
+   * Live callers leave this unset.
+   */
+  routerPromptOverride?: string;
 }
 
 /**
@@ -207,7 +252,11 @@ export async function runRouter(
     return emptyResult("empty_index");
   }
 
-  const provider = await getConfiguredProvider("memoryRouter");
+  const provider = await getConfiguredProvider("memoryRouter", {
+    ...(params.overrideProfile !== undefined
+      ? { overrideProfile: params.overrideProfile }
+      : {}),
+  });
   if (!provider) {
     log.warn("memoryRouter provider unavailable; router skipped");
     return emptyResult("no_provider");
@@ -302,15 +351,18 @@ export async function runRouter(
   // exceed it (e.g. 10 batches × 10 selections each ≫ 25 cap). Apply a final
   // truncation so RouterResult honors the contract that injection.ts trusts.
   // Iteration order above is tier 1 → tier 2 → tier 3:0 → … so earlier-tier
-  // slugs win the truncation.
-  const maxPageIds = config.memory?.v2?.router?.max_page_ids ?? 25;
-  if (selectedSlugs.length > maxPageIds) {
-    log.warn(
-      { unionSize: selectedSlugs.length, max: maxPageIds },
-      "Router union across batches exceeded max_page_ids; truncating",
-    );
-    const dropped = selectedSlugs.splice(maxPageIds);
-    for (const slug of dropped) sourceBySlug.delete(slug);
+  // slugs win the truncation. The simulator passes `disableUnionCap` so the
+  // playground can show the full untruncated union for analysis.
+  if (!params.disableUnionCap) {
+    const maxPageIds = config.memory?.v2?.router?.max_page_ids ?? 25;
+    if (selectedSlugs.length > maxPageIds) {
+      log.warn(
+        { unionSize: selectedSlugs.length, max: maxPageIds },
+        "Router union across batches exceeded max_page_ids; truncating",
+      );
+      const dropped = selectedSlugs.splice(maxPageIds);
+      for (const slug of dropped) sourceBySlug.delete(slug);
+    }
   }
   return { selectedSlugs, sourceBySlug, failureReason: null };
 }
@@ -331,8 +383,7 @@ async function runRouterBatch(
 ): Promise<RouterBatchResult> {
   const {
     workspaceDir,
-    userMessage,
-    assistantMessage,
+    recentTurnPairs,
     nowText,
     priorEverInjected,
     config,
@@ -349,6 +400,7 @@ async function runRouterBatch(
       userName: resolveUserName(workspaceDir),
       pageIndexBlock: batchIndex.rendered,
     },
+    params.routerPromptOverride ?? null,
   );
 
   // Filter prior-injected to slugs present in THIS batch and map to
@@ -360,6 +412,29 @@ async function runRouterBatch(
     if (local) priorIds.push(local.id);
   }
 
+  // Trim the pairs down to the configured `<last_turn>` content budget,
+  // newest-message-first so the just-arrived user turn keeps full claim
+  // on the cap and the oldest still-includable message is front-truncated
+  // (rather than dropping the most recent message). `null` is a no-op.
+  const cappedPairs = applyHistoricalCharBudget(
+    recentTurnPairs,
+    config.memory?.v2?.router?.historical_pairs_max_chars ?? null,
+  );
+
+  // Render `<last_turn>` chronologically: each pair emits the prior
+  // assistant reply followed by the user message that came after.
+  // `assistantMessage` is the empty string on the oldest pair when there
+  // was no prior assistant reply (conversation start) — skip that line
+  // so we don't emit a dangling `[assistant]:`.
+  const lastTurnLines: string[] = [];
+  for (const pair of cappedPairs) {
+    if (pair.assistantMessage.trim().length > 0) {
+      lastTurnLines.push(`[assistant]: ${pair.assistantMessage}`);
+    }
+    lastTurnLines.push(`[user]: ${pair.userMessage}`);
+  }
+  const lastTurnBlock = `<last_turn>\n${lastTurnLines.join("\n")}\n</last_turn>`;
+
   const userMsg: Message = {
     role: "user",
     content: [
@@ -368,7 +443,7 @@ async function runRouterBatch(
         type: "text",
         text:
           `<already_injected_ids>\n${priorIds.join(", ")}\n</already_injected_ids>\n\n` +
-          `<last_turn>\n[user]: ${userMessage}\n[assistant]: ${assistantMessage}\n</last_turn>`,
+          lastTurnBlock,
       },
     ],
   };
@@ -386,6 +461,7 @@ async function runRouterBatch(
         config: {
           callSite: "memoryRouter" as const,
           tool_choice: { type: "tool" as const, name: ROUTER_TOOL_NAME },
+          disableTurnStartCache: true,
         },
         ...(signal ? { signal } : {}),
       },
@@ -453,6 +529,83 @@ async function runRouterBatch(
   return { selectedSlugs, failureReason: null };
 }
 
+/** Truncation marker prepended to a front-truncated historical message. */
+const HISTORICAL_TRUNCATION_MARKER = "…";
+
+/**
+ * Apply the `<last_turn>` content character budget to a chronological
+ * pairs array. The just-arrived user message has first claim on the
+ * budget; older messages are added newest-first until exhausted. The
+ * oldest still-includable message is front-truncated with a leading
+ * `…` so it joins coherently with the next message in time. Older pairs
+ * whose content doesn't fit are dropped entirely.
+ *
+ * Counts message content only — framing characters (`[assistant]: `,
+ * `[user]: `, newlines) are not deducted from the budget. The cap is a
+ * conservative upper bound on the dialogue content surfaced to the
+ * router, not on the exact rendered block size.
+ *
+ * Exported for tests; production calls it via `runRouterBatch`.
+ */
+export function applyHistoricalCharBudget(
+  pairs: readonly RouterTurnPair[],
+  maxChars: number | null,
+): RouterTurnPair[] {
+  if (maxChars === null || maxChars <= 0) return [...pairs];
+
+  type WalkedMsg = {
+    role: "user" | "assistant";
+    text: string;
+    pairIdx: number;
+  };
+  // Walk every message newest-first. Within a single pair the user
+  // message came AFTER the assistant message chronologically, so the
+  // user line gets first claim on the budget.
+  const walked: WalkedMsg[] = [];
+  for (let i = pairs.length - 1; i >= 0; i--) {
+    walked.push({ role: "user", text: pairs[i].userMessage, pairIdx: i });
+    walked.push({
+      role: "assistant",
+      text: pairs[i].assistantMessage,
+      pairIdx: i,
+    });
+  }
+
+  let used = 0;
+  const included = new Map<number, { assistant: string; user: string }>();
+  for (const msg of walked) {
+    const remaining = maxChars - used;
+    if (remaining <= 0) break;
+    let textToInclude: string;
+    let stop = false;
+    if (msg.text.length <= remaining) {
+      textToInclude = msg.text;
+      used += msg.text.length;
+    } else {
+      // Front-truncate so the surviving suffix of an older message
+      // connects to the next message (in chronological order) without
+      // a syntactic seam. The marker counts toward the budget so the
+      // emitted text never exceeds `maxChars` cumulatively.
+      if (remaining <= HISTORICAL_TRUNCATION_MARKER.length) break;
+      const keepChars = remaining - HISTORICAL_TRUNCATION_MARKER.length;
+      textToInclude = HISTORICAL_TRUNCATION_MARKER + msg.text.slice(-keepChars);
+      used = maxChars;
+      stop = true;
+    }
+    const slot = included.get(msg.pairIdx) ?? { assistant: "", user: "" };
+    if (msg.role === "user") slot.user = textToInclude;
+    else slot.assistant = textToInclude;
+    included.set(msg.pairIdx, slot);
+    if (stop) break;
+  }
+
+  const sortedIdxs = [...included.keys()].sort((a, b) => a - b);
+  return sortedIdxs.map((idx) => {
+    const slot = included.get(idx)!;
+    return { assistantMessage: slot.assistant, userMessage: slot.user };
+  });
+}
+
 /**
  * Build a text content block carrying an ephemeral `cache_control`
  * breakpoint with a 1h TTL. The Anthropic SDK accepts the field as an extra

package/src/memory/v3/__tests__/coactivation-store.test.ts

@@ -0,0 +1,422 @@
+/**
+ * Tests for `assistant/src/memory/v3/coactivation-store.ts`, its sibling
+ * migration `262-memory-v3-coactivation.ts`, and the loop's co-activation
+ * emission (`loop.ts`, gated by `config.memory.v3.write.coactivation`).
+ *
+ * Coverage:
+ *   - Migration creates the table + both indexes; safe to re-run.
+ *   - recordCoactivations / readCoactivations round-trip; empty list is a
+ *     no-op; `since` filters by created_at.
+ *   - A scripted 2-pass loop emits the expected pass-1 → pass-2 rows with the
+ *     correct pass_gap when the flag is on, and nothing when it is off.
+ *
+ * Uses an in-memory bun:sqlite database — no real workspace DB. The loop's
+ * lane modules are stubbed via `mock.module`, matching `loop.test.ts`.
+ */
+
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { makeMockLogger } from "../../../__tests__/helpers/mock-logger.js";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import type { DrizzleDb } from "../../db-connection.js";
+import { getSqliteFrom } from "../../db-connection.js";
+import {
+  downMemoryV3Coactivation,
+  migrateMemoryV3Coactivation,
+} from "../../migrations/262-memory-v3-coactivation.js";
+import * as schema from "../../schema.js";
+import type {
+  RetrievalInput,
+  RetrievalOutput,
+} from "../../v2/harness/retriever.js";
+import type { GateDecision, ScoutResult } from "../../v2/harness/trace.js";
+import {
+  type CoactivationRow,
+  readCoactivations,
+  recordCoactivations,
+} from "../coactivation-store.js";
+
+// memory_checkpoints is required by withCrashRecovery and is normally created
+// by an early core migration. Stand it up by hand so the v3 migration can run
+// in isolation against a fresh in-memory DB.
+const CHECKPOINTS_DDL = /*sql*/ `
+  CREATE TABLE memory_checkpoints (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  )
+`;
+
+// ---------------------------------------------------------------------------
+// Loop lane stubs — installed before importing the module under test. Mirrors
+// loop.test.ts: each test rewires the `lane` refs before calling the loop.
+// ---------------------------------------------------------------------------
+
+interface RunScoutsResult {
+  scouts: ScoutResult[];
+  sticky: Set<string>;
+  bypass: Set<string>;
+}
+interface FilterResult {
+  kept: string[];
+  trace: { judged: string[]; dropped: string[] };
+  failureReason?: string;
+}
+interface WalkResult {
+  pages: Set<string>;
+  levels: Array<{
+    node: string;
+    considered: string[];
+    descended: string[];
+    skipped: string[];
+    reasoning: string;
+  }>;
+}
+interface ExpandResult {
+  pulled: Set<string>;
+  expansions: Array<{ from: string; pulled: string[] }>;
+}
+interface GateResult {
+  decision: GateDecision;
+  selectedSlugs: string[];
+}
+
+const lane = {
+  scouts: [] as RunScoutsResult[],
+  filter: [] as FilterResult[],
+  walk: [] as WalkResult[],
+  edges: [] as ExpandResult[],
+  gate: [] as GateResult[],
+};
+
+function nextOf<T>(list: T[], index: number): T {
+  return list[Math.min(index, list.length - 1)];
+}
+
+let scoutCallCount = 0;
+let filterCallCount = 0;
+let walkCallCount = 0;
+let edgeCallCount = 0;
+let gateCallCount = 0;
+
+mock.module("../scouts.js", () => ({
+  runScouts: async (): Promise<RunScoutsResult> =>
+    nextOf(lane.scouts, scoutCallCount++),
+}));
+mock.module("../filter.js", () => ({
+  filterDenseHits: async (): Promise<FilterResult> =>
+    nextOf(lane.filter, filterCallCount++),
+}));
+mock.module("../tree-walk.js", () => ({
+  runTreeWalk: async (): Promise<WalkResult> =>
+    nextOf(lane.walk, walkCallCount++),
+}));
+mock.module("../edges.js", () => ({
+  expandEdges: async (): Promise<ExpandResult> =>
+    nextOf(lane.edges, edgeCallCount++),
+}));
+mock.module("../gate.js", () => ({
+  runGate: async (): Promise<GateResult> => nextOf(lane.gate, gateCallCount++),
+}));
+mock.module("../tree-index.js", () => ({
+  getTreeIndex: async () => ({
+    nodes: new Map(),
+    childrenByNode: new Map(),
+    parentsByNode: new Map(),
+    pageParents: new Map(),
+    root: "_root",
+  }),
+}));
+mock.module("../../v2/page-index.js", () => ({
+  getPageIndex: async () => ({
+    entries: [],
+    bySlug: new Map(),
+    byId: new Map(),
+    rendered: "",
+  }),
+}));
+
+const { runRetrievalLoop } = await import("../loop.js");
+
+let sqlite: Database;
+let database: DrizzleDb;
+
+beforeEach(() => {
+  sqlite = new Database(":memory:");
+  database = drizzle(sqlite, { schema });
+  getSqliteFrom(database).exec(CHECKPOINTS_DDL);
+  migrateMemoryV3Coactivation(database);
+
+  lane.scouts = [];
+  lane.filter = [];
+  lane.walk = [];
+  lane.edges = [];
+  lane.gate = [];
+  scoutCallCount = 0;
+  filterCallCount = 0;
+  walkCallCount = 0;
+  edgeCallCount = 0;
+  gateCallCount = 0;
+});
+
+afterEach(() => {
+  sqlite.close();
+});
+
+function scout(laneName: ScoutResult["lane"], slugs: string[]): ScoutResult {
+  return { lane: laneName, slugs };
+}
+
+function makeInput(opts?: {
+  passCap?: number;
+  coactivation?: boolean;
+}): RetrievalInput {
+  return {
+    workspaceDir: "/tmp/does-not-matter",
+    recentTurnPairs: [],
+    nowText: "NOW",
+    priorEverInjected: [],
+    config: {
+      memory: {
+        v3: {
+          passCap: opts?.passCap ?? 3,
+          lanes: {
+            hot: true,
+            sparse: true,
+            dense: true,
+            tree: true,
+            edges: true,
+          },
+          write: {
+            enabled: false,
+            consolidateIntervalMs: 3600000,
+            coactivation: opts?.coactivation ?? false,
+          },
+        },
+      },
+    } as unknown as RetrievalInput["config"],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Migration.
+// ---------------------------------------------------------------------------
+
+describe("migrateMemoryV3Coactivation", () => {
+  test("creates table and both indexes; safe to re-run", () => {
+    migrateMemoryV3Coactivation(database);
+    migrateMemoryV3Coactivation(database);
+
+    const raw = getSqliteFrom(database);
+    const table = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v3_coactivation'`,
+      )
+      .get();
+    expect(table).toBeTruthy();
+
+    const indexNames = new Set(
+      (
+        raw
+          .query(
+            `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memory_v3_coactivation'`,
+          )
+          .all() as Array<{ name: string }>
+      ).map((r) => r.name),
+    );
+    expect(indexNames.has("idx_memory_v3_coactivation_pair")).toBe(true);
+    expect(indexNames.has("idx_memory_v3_coactivation_time")).toBe(true);
+  });
+
+  test("downMemoryV3Coactivation drops the table", () => {
+    downMemoryV3Coactivation(database);
+    const table = getSqliteFrom(database)
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v3_coactivation'`,
+      )
+      .get();
+    expect(table).toBeFalsy();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Store.
+// ---------------------------------------------------------------------------
+
+describe("recordCoactivations / readCoactivations", () => {
+  test("round-trips rows oldest-first", () => {
+    const rows: CoactivationRow[] = [
+      {
+        conversationId: "conv-1",
+        turn: 3,
+        sourceSlug: "alice",
+        targetSlug: "bob",
+        passGap: 1,
+        used: 0,
+        createdAt: 1_000,
+      },
+      {
+        conversationId: "conv-1",
+        turn: 3,
+        sourceSlug: "alice",
+        targetSlug: "carol",
+        passGap: 2,
+        used: 0,
+        createdAt: 2_000,
+      },
+    ];
+    recordCoactivations(database, rows);
+
+    const read = readCoactivations(database);
+    expect(read).toHaveLength(2);
+    expect(read[0]).toMatchObject({
+      conversationId: "conv-1",
+      turn: 3,
+      sourceSlug: "alice",
+      targetSlug: "bob",
+      passGap: 1,
+      used: 0,
+      createdAt: 1_000,
+    });
+    expect(read[1].targetSlug).toBe("carol");
+    expect(read[1].passGap).toBe(2);
+  });
+
+  test("empty list is a no-op", () => {
+    recordCoactivations(database, []);
+    expect(readCoactivations(database)).toHaveLength(0);
+  });
+
+  test("since filters by created_at", () => {
+    recordCoactivations(database, [
+      {
+        conversationId: "c",
+        turn: 1,
+        sourceSlug: "a",
+        targetSlug: "b",
+        passGap: 1,
+        used: 0,
+        createdAt: 100,
+      },
+      {
+        conversationId: "c",
+        turn: 1,
+        sourceSlug: "a",
+        targetSlug: "c",
+        passGap: 1,
+        used: 0,
+        createdAt: 500,
+      },
+    ]);
+    const recent = readCoactivations(database, 300);
+    expect(recent).toHaveLength(1);
+    expect(recent[0].targetSlug).toBe("c");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Loop emission.
+// ---------------------------------------------------------------------------
+
+describe("runRetrievalLoop — co-activation emission", () => {
+  /**
+   * Script a 2-pass loop: pass 1 surfaces `a` (hot) + `b` (sparse); pass 2
+   * surfaces `c` (dense). The gate says "more" on pass 1 (selecting a, b) and
+   * "ready" on pass 2 (selecting a, b, c). So `c` is the only pass-2 target,
+   * paired with pass-1 hits a and b → two rows, both pass_gap=1.
+   */
+  function scriptTwoPass(): void {
+    lane.scouts = [
+      {
+        scouts: [scout("hot", ["a"]), scout("sparse", ["b"])],
+        sticky: new Set(),
+        bypass: new Set(),
+      },
+      {
+        scouts: [scout("dense", ["c"])],
+        sticky: new Set(),
+        bypass: new Set(),
+      },
+    ];
+    // Pass 1 has no dense scout, so the filter is only called on pass 2 (one
+    // filter call per dense pass) — its single entry keeps `c`.
+    lane.filter = [{ kept: ["c"], trace: { judged: ["c"], dropped: [] } }];
+    lane.walk = [
+      { pages: new Set(), levels: [] },
+      { pages: new Set(), levels: [] },
+    ];
+    lane.edges = [
+      { pulled: new Set(), expansions: [] },
+      { pulled: new Set(), expansions: [] },
+    ];
+    lane.gate = [
+      {
+        decision: { decision: "more", questions: ["q"] },
+        selectedSlugs: ["a", "b"],
+      },
+      { decision: { decision: "ready" }, selectedSlugs: ["a", "b", "c"] },
+    ];
+  }
+
+  test("emits pass-1 → pass-2 rows with correct pass_gap when flag is on", async () => {
+    scriptTwoPass();
+    const out: RetrievalOutput = await runRetrievalLoop(
+      makeInput({ passCap: 3, coactivation: true }),
+      { db: database, conversationId: "conv-42", turn: 7 },
+    );
+    expect(out.selectedSlugs).toEqual(["a", "b", "c"]);
+
+    const rows = readCoactivations(database);
+    // c (pass 2) paired with each pass-1 hit a and b → two rows.
+    expect(rows).toHaveLength(2);
+    const pairs = rows.map((r) => `${r.sourceSlug}->${r.targetSlug}`).sort();
+    expect(pairs).toEqual(["a->c", "b->c"]);
+    for (const r of rows) {
+      expect(r.targetSlug).toBe("c");
+      expect(r.passGap).toBe(1);
+      expect(r.used).toBe(0);
+      expect(r.conversationId).toBe("conv-42");
+      expect(r.turn).toBe(7);
+    }
+  });
+
+  test("emits nothing when the flag is off", async () => {
+    scriptTwoPass();
+    await runRetrievalLoop(makeInput({ passCap: 3, coactivation: false }), {
+      db: database,
+      conversationId: "conv-42",
+      turn: 7,
+    });
+    expect(readCoactivations(database)).toHaveLength(0);
+  });
+
+  test("single-pass selection emits nothing (no later-surfaced target)", async () => {
+    lane.scouts = [
+      {
+        scouts: [scout("hot", ["a"]), scout("sparse", ["b"])],
+        sticky: new Set(),
+        bypass: new Set(),
+      },
+    ];
+    lane.filter = [{ kept: [], trace: { judged: [], dropped: [] } }];
+    lane.walk = [{ pages: new Set(), levels: [] }];
+    lane.edges = [{ pulled: new Set(), expansions: [] }];
+    lane.gate = [
+      { decision: { decision: "ready" }, selectedSlugs: ["a", "b"] },
+    ];
+
+    await runRetrievalLoop(makeInput({ passCap: 3, coactivation: true }), {
+      db: database,
+      conversationId: "conv-1",
+      turn: 1,
+    });
+    expect(readCoactivations(database)).toHaveLength(0);
+  });
+});