@vellumai/assistant 0.8.5 → 0.8.6

package/src/memory/llm-request-log-store.ts

@@ -1,6 +1,21 @@
-import { and, asc, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNull,
+  lt,
+  lte,
+  ne,
+  or,
+  sql,
+} from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE } from "../api/constants/call-sites.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { AssistantError, ProviderError } from "../util/errors.js";
 import {
@@ -105,6 +120,80 @@ export function recordRequestLog(
   return id;
 }
 
+/**
+ * Insert a synthetic `llm_request_logs` row for an agent-loop error
+ * message that has no LLM call backing it but should appear in the
+ * inspector rail. Today the only caller is the
+ * `budget_yield_unrecovered` persistence path
+ * (`conversation-agent-loop.ts`); the helper is named generically so
+ * the next out-of-funds / provider-error / etc. path can route through
+ * the same primitive.
+ *
+ * The caller persists the user-visible assistant message separately
+ * via the `persistence` pipeline; this helper only writes the synthetic
+ * call row. `messageId` should be the id of the just-persisted notice
+ * so `getRequestLogsByMessageId` surfaces both together.
+ *
+ * Payload semantics mirror real LLM-call rows:
+ *  - `requestPayload`: the best-known LLM request body the loop was
+ *    about to send when it yielded — typically the prepared messages
+ *    snapshot and any input-token budget context. Stored as JSON so
+ *    the Raw tab renders it consistently with real calls.
+ *  - `responsePayload`: the synthetic notice text the user saw plus
+ *    the exit reason. This is the "response" from the user's point of
+ *    view — what came back from a call that never actually happened.
+ *
+ * Stamps `agent_loop_exit_reason` directly so the row already carries
+ * the reason at insert time — the post-loop
+ * `setAgentLoopExitReasonOnLatestLog` query then skips it (its IS NULL
+ * guard) and stamps the prior real LLM call instead, preserving the
+ * existing "latest LLM call carries the exit reason" invariant that
+ * other consumers depend on.
+ */
+export function recordSyntheticAgentErrorMessageLog(args: {
+  conversationId: string;
+  messageId: string;
+  exitReason: string;
+  /** User-visible notice text — goes into `response_payload`. */
+  noticeText: string;
+  /**
+   * Best-known LLM request state at the moment the loop gave up.
+   * `null` when no prepared request was available (rare — generally
+   * we know at least the conversation history we were about to send).
+   */
+  preparedRequest: unknown | null;
+  createdAt: number;
+}): string {
+  const db = getDb();
+  const id = uuid();
+  const requestPayload = JSON.stringify({
+    syntheticAgentErrorMessage: {
+      exitReason: args.exitReason,
+      preparedRequest: args.preparedRequest,
+    },
+  });
+  const responsePayload = JSON.stringify({
+    syntheticAgentErrorMessage: {
+      exitReason: args.exitReason,
+      noticeText: args.noticeText,
+    },
+  });
+  db.insert(llmRequestLogs)
+    .values({
+      id,
+      conversationId: args.conversationId,
+      messageId: args.messageId,
+      provider: null,
+      requestPayload,
+      responsePayload,
+      createdAt: args.createdAt,
+      agentLoopExitReason: args.exitReason,
+      callSite: CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE,
+    })
+    .run();
+  return id;
+}
+
 /**
  * Stamp an `agent_loop_exit_reason` onto the most-recent unstamped
  * `llm_request_logs` row for the given conversation. Called by the
@@ -208,7 +297,9 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
  * not apply turn recovery: the `conversation_id` column already includes
  * linked, unlinked, and orphaned rows for the full conversation.
  */
-export function getRequestLogsByConversationId(conversationId: string): LogRow[] {
+export function getRequestLogsByConversationId(
+  conversationId: string,
+): LogRow[] {
   const db = getDb();
   return db
     .select({
@@ -310,6 +401,100 @@ function selectUnlinkedLogsInRange(
     .all();
 }
 
+/**
+ * Fetch every `compactionAgent` log row in the conversation whose
+ * `createdAt` falls in the **open window** `(afterCreatedAt, beforeCreatedAt)`,
+ * ordered chronologically.
+ *
+ * Drives the Inspector's Compaction tab. The caller resolves both
+ * bounds:
+ *   - `beforeCreatedAt` = the selected LLM call's `createdAt` (ceiling).
+ *   - `afterCreatedAt` = the previous non-`compactionAgent` call's
+ *     `createdAt` (floor), or `null` when the selected call is the first
+ *     real call in the conversation.
+ *
+ * Both bounds are **strict**: the selected call itself never appears in
+ * its own trail (`<` ceiling), and compactions that fed an earlier real
+ * call's context don't bleed into this call's window (`>` floor). When
+ * `afterCreatedAt` is `null` the floor is dropped entirely — every
+ * preceding compaction is in scope, which is the right behavior for the
+ * very first real call in the conversation.
+ *
+ * NULL `callSite` rows (pre-migration-264) are excluded by the explicit
+ * `callSite = 'compactionAgent'` predicate without a separate IS NOT
+ * NULL clause.
+ */
+export function getCompactionLogsBetween(
+  conversationId: string,
+  afterCreatedAt: number | null,
+  beforeCreatedAt: number,
+): LogRow[] {
+  const db = getDb();
+  const predicates = [
+    eq(llmRequestLogs.conversationId, conversationId),
+    eq(llmRequestLogs.callSite, "compactionAgent"),
+    lt(llmRequestLogs.createdAt, beforeCreatedAt),
+  ];
+  if (afterCreatedAt !== null) {
+    predicates.push(gt(llmRequestLogs.createdAt, afterCreatedAt));
+  }
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
+    })
+    .from(llmRequestLogs)
+    .where(and(...predicates))
+    .orderBy(asc(llmRequestLogs.createdAt), asc(llmRequestLogs.id))
+    .all();
+}
+
+/**
+ * Find the `createdAt` of the most recent non-`compactionAgent` LLM
+ * call in the conversation strictly before `beforeCreatedAt`, or `null`
+ * when no such call exists (i.e. the cutoff is the first real call).
+ *
+ * Pairs with `getCompactionLogsBetween` to bound the compaction trail
+ * to the window between the prior real call and the selected call.
+ *
+ * "Non-compactionAgent" means `callSite IS NULL OR callSite !=
+ * 'compactionAgent'`. NULL rows are pre-migration-264 (no backfill) and
+ * are treated as real agent calls — they were `mainAgent` in practice.
+ * The OR-with-IS NULL is required because SQL's three-valued logic
+ * makes `callSite != 'compactionAgent'` return UNKNOWN (not TRUE) for
+ * NULL rows, which would otherwise filter them out.
+ */
+export function getPreviousNonCompactionCallCreatedAt(
+  conversationId: string,
+  beforeCreatedAt: number,
+): number | null {
+  const db = getDb();
+  const row = db
+    .select({ createdAt: llmRequestLogs.createdAt })
+    .from(llmRequestLogs)
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        lt(llmRequestLogs.createdAt, beforeCreatedAt),
+        or(
+          isNull(llmRequestLogs.callSite),
+          ne(llmRequestLogs.callSite, "compactionAgent"),
+        ),
+      ),
+    )
+    .orderBy(desc(llmRequestLogs.createdAt), desc(llmRequestLogs.id))
+    .limit(1)
+    .get();
+  return row?.createdAt ?? null;
+}
+
 export function getRequestLogById(logId: string): LogRow | null {
   const db = getDb();
   return (
@@ -323,7 +508,7 @@ export function getRequestLogById(logId: string): LogRow | null {
         responsePayload: llmRequestLogs.responsePayload,
         createdAt: llmRequestLogs.createdAt,
         agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
-      callSite: llmRequestLogs.callSite,
+        callSite: llmRequestLogs.callSite,
       })
       .from(llmRequestLogs)
       .where(eq(llmRequestLogs.id, logId))

package/src/memory/memory-v2-activation-log-store.ts

@@ -1,8 +1,9 @@
-import { and, desc, eq, inArray, isNull } from "drizzle-orm";
+import { and, desc, eq, gte, inArray, isNull, lte, ne } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "./db-connection.js";
 import { memoryV2ActivationLogs } from "./schema.js";
+import type { ShadowDiffLogRow } from "./v3/shadow-diff.js";
 
 export interface MemoryV2ConceptRowRecord {
   slug: string;
@@ -94,6 +95,14 @@ export interface MemoryV2ConceptRowRecord {
     | "not_injected"
     | "page_missing"
     | "corrupt";
+  /**
+   * v3 shadow only: the retrieval lane that surfaced this slug
+   * (`hot` | `sparse` | `dense` | `tree` | `edge`). Lets a shadow run be
+   * analyzed by provenance — which lane each v3 pick came from. Undefined on
+   * `router`/`per-turn`/etc. v2 rows; stored in the JSON concept blob, so older
+   * rows decode with `undefined`.
+   */
+  lane?: string;
 }
 
 export interface MemoryV2ConfigSnapshot {
@@ -157,12 +166,16 @@ export function backfillMemoryV2ActivationMessageId(
   messageId: string,
 ): void {
   const db = getDb();
+  // `v3_shadow` rows are detached telemetry written outside the live turn with
+  // a null messageId; they are not tied to any specific message. Excluding them
+  // keeps their messageId null instead of stamping them with a later turn's id.
   db.update(memoryV2ActivationLogs)
     .set({ messageId })
     .where(
       and(
         eq(memoryV2ActivationLogs.conversationId, conversationId),
         isNull(memoryV2ActivationLogs.messageId),
+        ne(memoryV2ActivationLogs.mode, "v3_shadow"),
       ),
     )
     .run();
@@ -202,3 +215,84 @@ export function getMemoryV2ActivationLogByMessageIds(
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };
 }
+
+function parseConcepts(conceptsJson: string): MemoryV2ConceptRowRecord[] {
+  try {
+    const parsed = JSON.parse(conceptsJson);
+    return Array.isArray(parsed) ? (parsed as MemoryV2ConceptRowRecord[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read the activation-log rows the v3 shadow-diff needs: every `v3_shadow` row
+ * (optionally newer than `sinceMs`), plus the `router` rows that could pair
+ * with them. The router read is bounded to the shadow rows' conversations and
+ * their time span (padded by `paddingMs`) so a shadow-diff over a few turns
+ * never scans the entire multi-GB log table. Returns `{ shadow, router }` for
+ * {@link computeShadowDiff} to pair and diff.
+ */
+export function readActivationLogsForShadowDiff(opts: {
+  sinceMs: number | null;
+  paddingMs: number;
+}): { shadow: ShadowDiffLogRow[]; router: ShadowDiffLogRow[] } {
+  const db = getDb();
+
+  const shadow = db
+    .select({
+      conversationId: memoryV2ActivationLogs.conversationId,
+      createdAt: memoryV2ActivationLogs.createdAt,
+      conceptsJson: memoryV2ActivationLogs.conceptsJson,
+    })
+    .from(memoryV2ActivationLogs)
+    .where(
+      opts.sinceMs !== null
+        ? and(
+            eq(memoryV2ActivationLogs.mode, "v3_shadow"),
+            gte(memoryV2ActivationLogs.createdAt, opts.sinceMs),
+          )
+        : eq(memoryV2ActivationLogs.mode, "v3_shadow"),
+    )
+    .orderBy(memoryV2ActivationLogs.createdAt)
+    .all()
+    .map((row) => ({
+      conversationId: row.conversationId,
+      createdAt: row.createdAt,
+      concepts: parseConcepts(row.conceptsJson),
+    }));
+
+  if (shadow.length === 0) return { shadow: [], router: [] };
+
+  const convIds = [...new Set(shadow.map((s) => s.conversationId))];
+  let tMin = Number.POSITIVE_INFINITY;
+  let tMax = Number.NEGATIVE_INFINITY;
+  for (const s of shadow) {
+    if (s.createdAt < tMin) tMin = s.createdAt;
+    if (s.createdAt > tMax) tMax = s.createdAt;
+  }
+
+  const router = db
+    .select({
+      conversationId: memoryV2ActivationLogs.conversationId,
+      createdAt: memoryV2ActivationLogs.createdAt,
+      conceptsJson: memoryV2ActivationLogs.conceptsJson,
+    })
+    .from(memoryV2ActivationLogs)
+    .where(
+      and(
+        eq(memoryV2ActivationLogs.mode, "router"),
+        inArray(memoryV2ActivationLogs.conversationId, convIds),
+        gte(memoryV2ActivationLogs.createdAt, tMin - opts.paddingMs),
+        lte(memoryV2ActivationLogs.createdAt, tMax + opts.paddingMs),
+      ),
+    )
+    .all()
+    .map((row) => ({
+      conversationId: row.conversationId,
+      createdAt: row.createdAt,
+      concepts: parseConcepts(row.conceptsJson),
+    }));
+
+  return { shadow, router };
+}

package/src/memory/migrations/265-drop-provider-connection-status.ts

@@ -0,0 +1,26 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drops the `status` column from the `provider_connections` table.
+ *
+ * Connection status ("active" | "disabled") has been removed — connections
+ * either exist or they don't. Profile status (enabled/disabled) is a separate
+ * concept and is untouched by this migration.
+ *
+ * Idempotent: checks PRAGMA table_info before issuing the DROP so re-running
+ * on a database that already lacks the column is a no-op.
+ *
+ * SQLite 3.35.0+ (Bun bundles a recent SQLite) supports ALTER TABLE DROP COLUMN.
+ */
+export function migrateDropProviderConnectionStatus(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw
+    .query(`PRAGMA table_info(provider_connections)`)
+    .all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (columnNames.has("status")) {
+    raw.exec(`ALTER TABLE provider_connections DROP COLUMN status`);
+  }
+}

package/src/memory/migrations/266-messages-client-message-id.ts

@@ -0,0 +1,43 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `client_message_id` (nullable TEXT) to the `messages` table and
+ * creates a partial unique index on `(conversation_id, client_message_id)`
+ * for rows where `client_message_id IS NOT NULL`.
+ *
+ * The client-generated correlation nonce was previously wire-protocol-only
+ * (echoed on SSE `user_message_echo` events for optimistic-row dedup) but
+ * never persisted. Storing it enables server-side idempotency: a duplicate
+ * INSERT with the same `(conversation_id, client_message_id)` pair is
+ * silently skipped via `ON CONFLICT DO NOTHING`.
+ *
+ * Idempotent — re-running is a no-op once the column and index exist.
+ */
+export function migrateMessagesClientMessageId(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(messages)`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("client_message_id")) {
+    raw.exec(`ALTER TABLE messages ADD COLUMN client_message_id TEXT`);
+  }
+
+  // Partial unique index: only enforced when client_message_id is non-NULL.
+  // Messages without a client_message_id (assistant messages, system-generated
+  // messages, legacy rows) are unconstrained.
+  const indexes = raw.query(`PRAGMA index_list(messages)`).all() as Array<{
+    name: string;
+  }>;
+  const indexNames = new Set(indexes.map((i) => i.name));
+
+  if (!indexNames.has("idx_messages_conv_client_msg_id")) {
+    raw.exec(
+      `CREATE UNIQUE INDEX idx_messages_conv_client_msg_id
+       ON messages (conversation_id, client_message_id)
+       WHERE client_message_id IS NOT NULL`,
+    );
+  }
+}

package/src/memory/migrations/index.ts

@@ -251,6 +251,8 @@ export {
   migrateMemoryV3AutoEdges,
 } from "./263-memory-v3-auto-edges.js";
 export { migrateLlmRequestLogCallSite } from "./264-llm-request-log-call-site.js";
+export { migrateDropProviderConnectionStatus } from "./265-drop-provider-connection-status.js";
+export { migrateMessagesClientMessageId } from "./266-messages-client-message-id.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/schema/conversations.ts

@@ -1,9 +1,11 @@
+import { sql } from "drizzle-orm";
 import {
   index,
   integer,
   real,
   sqliteTable,
   text,
+  uniqueIndex,
 } from "drizzle-orm/sqlite-core";
 
 export const conversations = sqliteTable(
@@ -66,8 +68,14 @@ export const messages = sqliteTable(
     content: text("content").notNull(),
     createdAt: integer("created_at").notNull(),
     metadata: text("metadata"),
+    clientMessageId: text("client_message_id"),
   },
-  (table) => [index("idx_messages_conversation_id").on(table.conversationId)],
+  (table) => [
+    index("idx_messages_conversation_id").on(table.conversationId),
+    uniqueIndex("idx_messages_conv_client_msg_id")
+      .on(table.conversationId, table.clientMessageId)
+      .where(sql`client_message_id IS NOT NULL`),
+  ],
 );
 
 export const toolInvocations = sqliteTable(

package/src/memory/schema/inference.ts

@@ -15,7 +15,6 @@ export const providerConnections = sqliteTable(
     name: text("name").primaryKey(),
     provider: text("provider").notNull(),
     auth: text("auth").notNull(),
-    status: text("status").notNull().default("active"),
     label: text("label"),
     baseUrl: text("base_url"),
     models: text("models"),

package/src/memory/v2/__tests__/backfill-jobs.test.ts

@@ -202,7 +202,10 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { getDb, resetDb } = await import("../../db-connection.js");
+const { getDb } = await import("../../db-connection.js");
+const { resetDbForTesting } = await import(
+  "../../../__tests__/db-test-helpers.js"
+);
 const { initializeDb } = await import("../../db-init.js");
 const { rawExec } = await import("../../raw-query.js");
 const { conversations, memoryJobs, messages } = await import("../../schema.js");
@@ -247,7 +250,7 @@ function makeJob(
 }
 
 beforeEach(() => {
-  resetDb();
+  resetDbForTesting();
   initializeDb();
   // The shared template-DB caching does not clear WAL state between tests,
   // so explicitly truncate every table this suite writes to. Without this,

package/src/memory/v2/__tests__/harness-metrics.test.ts

@@ -25,6 +25,15 @@ describe("harness/metrics recallAtK", () => {
   test("empty ground truth is vacuously complete (recall 1)", () => {
     expect(recallAtK([], new Set<string>(), 5)).toBe(1);
   });
+
+  test("duplicate selections cannot push recall above 1.0", () => {
+    // A retriever emitting the same slug twice must not double-count it.
+    expect(recallAtK(["a", "a"], new Set(["a"]), 10)).toBe(1);
+    // Duplicates inside the top-k window still count once.
+    const gt = new Set(["a", "b"]);
+    expect(recallAtK(["a", "a", "b"], gt, 10)).toBeCloseTo(1);
+    expect(recallAtK(["a", "a", "b"], gt, 2)).toBeCloseTo(0.5);
+  });
 });
 
 describe("harness/metrics evalTurn", () => {

package/src/memory/v2/__tests__/harness-replay-input.test.ts

@@ -195,7 +195,7 @@ describe("harness/replay-input reconstructInput", () => {
     expect(r).toBeNull();
   });
 
-  test("priorEverInjected unions injected/in_context slugs from earlier router turns", async () => {
+  test("priorEverInjected mirrors production everInjected retention from earlier router turns", async () => {
     insertMessage("u1", "c1", "user", "u1", 10);
     insertMessage("a1", "c1", "assistant", "a1", 20);
     insertMessage("u2", "c1", "user", "u2", 30);
@@ -207,7 +207,12 @@ describe("harness/replay-input reconstructInput", () => {
       [
         makeConcept("p1", "injected"),
         makeConcept("p2", "in_context"),
-        makeConcept("p3", "not_injected"),
+        // page_missing / corrupt concept pages are retained in production's
+        // everInjected (so they aren't re-attempted every turn), so the replay
+        // must include them too.
+        makeConcept("p3", "page_missing"),
+        makeConcept("p4", "corrupt"),
+        makeConcept("p5", "not_injected"),
       ],
       20,
     );
@@ -219,7 +224,7 @@ describe("harness/replay-input reconstructInput", () => {
       WORKSPACE,
     );
     const slugs = (r?.input.priorEverInjected ?? []).map((e) => e.slug).sort();
-    expect(slugs).toEqual(["p1", "p2"]);
-    expect(r?.meta.priorEverInjectedCount).toBe(2);
+    expect(slugs).toEqual(["p1", "p2", "p3", "p4"]);
+    expect(r?.meta.priorEverInjectedCount).toBe(4);
   });
 });

package/src/memory/v2/__tests__/harness-runner.test.ts

@@ -92,6 +92,32 @@ describe("harness/runner runComparison", () => {
     expect(loop?.aggregate.meanRecallAtK[5]).toBeCloseTo(0.75);
   });
 
+  test("threads the abort signal into each retriever's input", async () => {
+    const controller = new AbortController();
+    const seenSignals: (AbortSignal | undefined)[] = [];
+    const capturingRetriever: Retriever = {
+      name: "router",
+      retrieve: async (input): Promise<RetrievalOutput> => {
+        seenSignals.push(input.signal);
+        return { selectedSlugs: [], sourceBySlug: new Map() };
+      },
+    };
+
+    // Fresh reconstructed input per turn so we exercise the per-turn assignment.
+    await runComparison({
+      retrievers: [capturingRetriever],
+      oracleTurns: [oracleTurn("c1", 1, ["a"])],
+      reconstruct: async () => ({
+        ...STUB_RECONSTRUCTED,
+        input: { ...STUB_INPUT },
+      }),
+      ks: [5],
+      signal: controller.signal,
+    });
+
+    expect(seenSignals).toEqual([controller.signal]);
+  });
+
   test("skips turns whose reconstruction returns null", async () => {
     const report = await runComparison({
       retrievers: [fixedRetriever("router", ["a"])],

package/src/memory/v2/__tests__/sweep-job.test.ts

@@ -99,7 +99,10 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { resetDb, getDb } = await import("../../db-connection.js");
+const { getDb } = await import("../../db-connection.js");
+const { resetDbForTesting } = await import(
+  "../../../__tests__/db-test-helpers.js"
+);
 const { initializeDb } = await import("../../db-init.js");
 const { messages, conversations } = await import("../../schema.js");
 const { memoryV2SweepJob } = await import("../sweep-job.js");
@@ -212,7 +215,7 @@ function seedMessages(
 }
 
 beforeEach(() => {
-  resetDb();
+  resetDbForTesting();
   initializeDb();
   // Fresh memory dir per test — keeps assertions on file contents independent.
   rmSync(join(tmpWorkspace, "memory"), { recursive: true, force: true });
@@ -275,7 +278,7 @@ describe("memoryV2SweepJob — no recent messages", () => {
 });
 
 // Per-test conversation id ensures each test seeds a row that doesn't
-// collide with the previous test's row in the (shared) test DB. `resetDb`
+// collide with the previous test's row in the (shared) test DB. `resetDbForTesting`
 // is called in the outer beforeEach, but bun's mock module flow keeps the
 // DB intact long enough for the SQL inserts here to clash.
 let convCounter = 0;

package/src/memory/v2/harness/metrics.ts

@@ -36,6 +36,10 @@ export interface AggregateEval {
 /**
  * recall@k = |topK(selected) ∩ G| / |G|. An empty ground-truth set is defined
  * as recall 1 (nothing to recall — vacuously complete).
+ *
+ * The top-k window is deduped before intersecting with the ground-truth set so
+ * a retriever that emits the same slug twice (e.g. `['a','a']`) cannot count it
+ * twice and push recall above 1.0. Recall is therefore bounded in [0, 1].
  */
 export function recallAtK(
   selected: readonly string[],
@@ -44,7 +48,7 @@ export function recallAtK(
 ): number {
   if (groundTruth.size === 0) return 1;
   let hit = 0;
-  for (const slug of selected.slice(0, k)) {
+  for (const slug of new Set(selected.slice(0, k))) {
     if (groundTruth.has(slug)) hit++;
   }
   return hit / groundTruth.size;

package/src/memory/v2/harness/replay-input.ts

@@ -10,8 +10,10 @@
  *  - `nowText`: read from current workspace files (`loadNowText`). NOT stored
  *    in the log, so it may differ from what the live turn saw —
  *    always-approximate; see `ReconstructionMeta.nowReconstructedFromCurrent`.
- *  - `priorEverInjected`: the union of injected / in_context slugs from earlier
- *    `mode='router'` logs in the same conversation (turn < target).
+ *  - `priorEverInjected`: the union of retained slugs from earlier
+ *    `mode='router'` logs in the same conversation (turn < target). Retained
+ *    statuses mirror production's `everInjected` (injected / in_context, plus
+ *    page_missing / corrupt — see `PRIOR_STATUSES`).
  *
  * The anchor is the turn's assistant reply; the messages the router saw are
  * those strictly before it, so we fetch a bounded recent window up to the
@@ -172,7 +174,21 @@ export async function reconstructInput(
   };
 }
 
-const PRIOR_STATUSES = new Set<string>(["injected", "in_context"]);
+// Production's `everInjected` retains a slug once it is rendered, EXCEPT for
+// missing synthetic slugs (skills/CLI commands whose capability cache is empty
+// — see `missingSyntheticSlugs` in `injection.ts`). Concept pages that turn out
+// `page_missing` or `corrupt` at render time are still retained so they aren't
+// re-attempted every turn (see the `page_missing ... DOES land in everInjected`
+// case in `injection.test.ts`). The replay must mirror that retention or it
+// builds a narrower prior-state than live routing, skewing comparisons. Missing
+// synthetic slugs never enter the missing/corrupt buckets — they log as
+// `injected` — so widening here introduces no new synthetic-slug discrepancy.
+const PRIOR_STATUSES = new Set<string>([
+  "injected",
+  "in_context",
+  "page_missing",
+  "corrupt",
+]);
 
 /**
  * Union of slugs injected on earlier `mode='router'` turns in this conversation

package/src/memory/v2/harness/runner.ts

@@ -74,6 +74,12 @@ export async function runComparison(
     }
     turnsScored++;
 
+    // Thread the abort signal into the reconstructed input so retrievers that
+    // wrap LLM calls (e.g. the router retriever forwarding to `runRouter`) abort
+    // the in-flight per-turn call on caller disconnect — the loop gating below
+    // only stops scheduling new work, it can't cancel the current retrieval.
+    if (signal) reconstructed.input.signal = signal;
+
     const byRetriever: Record<string, TurnEval> = {};
     for (const retriever of retrievers) {
       if (signal?.aborted) break;