@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/memory/schedule-attribution-sql.ts

@@ -0,0 +1,104 @@
+export interface ScheduleAttributionFilter {
+  scheduleId?: string;
+}
+
+export type ScheduleAttributionSqlParam = string | number;
+
+export interface ScheduleAttributionSqlFragment {
+  sql: string;
+  params: ScheduleAttributionSqlParam[];
+}
+
+export function normalizeScheduleAttributionFilter(
+  filter?: ScheduleAttributionFilter,
+): ScheduleAttributionFilter {
+  const scheduleId = filter?.scheduleId?.trim();
+  return scheduleId ? { scheduleId } : {};
+}
+
+function usageColumn(column: string, eventAlias: string): string {
+  return `${eventAlias}.${column}`;
+}
+
+function buildScheduleRunWindowPredicate({
+  eventAlias,
+  runAlias,
+  filter,
+}: {
+  eventAlias: string;
+  runAlias: string;
+  filter?: ScheduleAttributionFilter;
+}): string {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  const scheduleClause = normalized.scheduleId
+    ? `${runAlias}.job_id = ? AND `
+    : "";
+  return `${scheduleClause}${runAlias}.conversation_id = ${usageColumn(
+    "conversation_id",
+    eventAlias,
+  )}
+    AND ${usageColumn("created_at", eventAlias)} >= ${runAlias}.started_at
+    AND ${usageColumn("created_at", eventAlias)} <= COALESCE(${runAlias}.finished_at, ?)`;
+}
+
+function buildScheduleRunWindowParams(
+  filter: ScheduleAttributionFilter | undefined,
+  now: number,
+): ScheduleAttributionSqlParam[] {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  return normalized.scheduleId ? [normalized.scheduleId, now] : [now];
+}
+
+export function buildScheduleRunWindowExists({
+  eventAlias,
+  filter,
+  now,
+  runAlias = "schedule_filter_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `EXISTS (
+      SELECT 1
+      FROM cron_runs ${runAlias}
+      WHERE ${buildScheduleRunWindowPredicate({
+        eventAlias,
+        runAlias,
+        filter,
+      })}
+    )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}
+
+export function buildScheduleAttributionSubquery({
+  eventAlias,
+  filter,
+  now,
+  selectExpression,
+  runAlias = "schedule_attr_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  selectExpression: string;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `(
+    SELECT ${selectExpression}
+    FROM cron_runs ${runAlias}
+    WHERE ${buildScheduleRunWindowPredicate({
+      eventAlias,
+      runAlias,
+      filter,
+    })}
+    ORDER BY ${runAlias}.started_at DESC, ${runAlias}.id DESC
+    LIMIT 1
+  )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}

package/src/memory/schema/acp.ts

@@ -20,6 +20,10 @@ export const acpSessionHistory = sqliteTable(
     stopReason: text("stop_reason"),
     error: text("error"),
     eventLogJson: text("event_log_json").notNull().default("[]"),
+    // Working directory the agent process was spawned with. Required to
+    // resume a persisted session; null for rows written before migration
+    // 272 (those sessions are not resumable).
+    cwd: text("cwd"),
   },
   (table) => [
     index("idx_acp_session_history_started_at").on(table.startedAt),

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/schema/infrastructure.ts

@@ -21,6 +21,8 @@ export const cronJobs = sqliteTable("cron_jobs", {
   retryCount: integer("retry_count").notNull().default(0),
   maxRetries: integer("max_retries").notNull().default(3),
   retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
+  timeoutMs: integer("timeout_ms"), // script-mode execution timeout override (ms); null = use default
+  createdFromConversationId: text("created_from_conversation_id"),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
@@ -242,6 +244,16 @@ export const llmUsageEvents = sqliteTable(
     pricingStatus: text("pricing_status").notNull(),
     llmCallCount: integer("llm_call_count"),
     metadataJson: text("metadata_json"),
+    /**
+     * Version of the assistant binary at the moment THIS event was
+     * recorded (not when the batch was uploaded). Telemetry uploads
+     * batch events together and may flush days after the event fired
+     * (offline laptop, network outage, ingest clog — see May 2026
+     * incident). Stamping at record time keeps the version filter on
+     * `/admin/inference` truthful for delayed batches. Null for rows
+     * persisted before migration 267 ran.
+     */
+    assistantVersion: text("assistant_version"),
   },
   (table) => [
     index("idx_llm_usage_events_conversation_id").on(table.conversationId),
@@ -267,6 +279,21 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   abVariant: text("ab_variant"),
 });
 
+// Aggregated legacy-loopback auth-fallback counts forwarded by the gateway.
+// One row per (guard, path, failure_kind) per flush window; `count` is how many
+// requests fell back to the loopback exemption in that window. Flushed to the
+// platform telemetry endpoint by the usage telemetry reporter.
+export const authFallbackEvents = sqliteTable("auth_fallback_events", {
+  id: text("id").primaryKey(),
+  createdAt: integer("created_at").notNull(),
+  guard: text("guard").notNull(), // 'edge' | 'edge-scoped' | 'edge-guardian'
+  path: text("path").notNull(),
+  failureKind: text("failure_kind").notNull(),
+  count: integer("count").notNull(),
+  windowStart: integer("window_start").notNull(),
+  windowEnd: integer("window_end").notNull(),
+});
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

package/src/memory/usage-grouped-buckets.ts

@@ -27,6 +27,7 @@ export interface UsageGroupedSeriesBucket extends UsageDayBucket {
 
 export interface UsageGroupedBucketRow extends UsageEventBucketRow {
   group_key: string | null;
+  group_label?: string | null;
 }
 
 const VALUE_GROUP_PREFIX = "value:";
@@ -42,6 +43,9 @@ export function displayUsageGroup(
   if (groupBy === "inference_profile") {
     return groupKey === null ? "Default / Unset" : groupKey;
   }
+  if (groupBy === "schedule") {
+    return groupKey ?? "Other";
+  }
   return groupKey ?? "Other";
 }
 
@@ -102,7 +106,8 @@ export function bucketGroupedUsageEvents(
     let group = groupedBucket.groups[seriesKey];
     if (!group) {
       group = {
-        group: displayUsageGroup(options.groupBy, row.group_key),
+        group:
+          row.group_label ?? displayUsageGroup(options.groupBy, row.group_key),
         groupKey: row.group_key,
         totalInputTokens: 0,
         totalOutputTokens: 0,

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__/consolidation-job.test.ts

@@ -105,6 +105,43 @@ mock.module("../../jobs-store.js", () => ({
   isMemoryEnabled: () => true,
 }));
 
+// ── v3 health-injection mocks ───────────────────────────────────────
+//
+// The consolidation handler optionally prepends a v3 health block to the
+// prompt when a v3 flag is on AND the rendered report is non-empty. These
+// mocks let each test (a) toggle the flag, (b) decide what health block the
+// renderer produces, and (c) force the health computation to throw — without
+// materializing a real v3 data dir. The tree/core/page-index loaders are
+// stubbed to inert values; `computeV3Health` is a pass-through whose result is
+// fed to the toggleable `renderV3Health`.
+let v3FlagOn = false;
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => v3FlagOn,
+}));
+
+let renderedHealth = "";
+let computeThrows = false;
+mock.module("../../../plugins/defaults/memory-v3-shadow/health.js", () => ({
+  computeV3Health: () => {
+    if (computeThrows) throw new Error("simulated health compute failure");
+    return {};
+  },
+  renderV3Health: () => renderedHealth,
+}));
+
+mock.module("../../../plugins/defaults/memory-v3-shadow/tree.js", () => ({
+  loadLeafTree: async () => ({ leaves: new Map(), byPage: new Map() }),
+  resolveDataDir: () => "/tmp/v3-data-stub",
+}));
+
+mock.module("../../../plugins/defaults/memory-v3-shadow/core.js", () => ({
+  loadCore: async () => new Set<string>(),
+}));
+
+mock.module("../../v2/page-index.js", () => ({
+  getPageIndex: async () => ({ entries: [] }),
+}));
+
 // ── Workspace pin ───────────────────────────────────────────────────
 let tmpWorkspace: string;
 let previousWorkspaceEnv: string | undefined;
@@ -173,6 +210,11 @@ beforeEach(() => {
   emitCalls.length = 0;
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
+
+  // v3 health injection defaults: flag off, no rendered block, no throw.
+  v3FlagOn = false;
+  renderedHealth = "";
+  computeThrows = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -237,7 +279,7 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     expect(runnerLastArgs).not.toBeNull();
     expect(runnerLastArgs?.jobName).toBe("memory.consolidate");
     expect(runnerLastArgs?.source).toBe("memory_v2_consolidation");
-    expect(runnerLastArgs?.callSite).toBe("mainAgent");
+    expect(runnerLastArgs?.callSite).toBe("memoryV2Consolidation");
     expect(runnerLastArgs?.origin).toBe("memory_consolidation");
     // The whole point of this PR: opt out of activity.failed notifications
     // because consolidation runs on tight intervals and transient failures
@@ -305,6 +347,25 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     expect(existsSync(lockPath())).toBe(false);
   });
 
+  test("enqueues memory_v3_maintain as a follow-up when a v3 flag is on", async () => {
+    v3FlagOn = true;
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(enqueuedJobs.map((j) => j.type)).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+  });
+
+  test("does not enqueue memory_v3_maintain when v3 flags are off", async () => {
+    v3FlagOn = false;
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
+  });
+
   test("returns run_failed and skips follow-ups when the runner reports failure", async () => {
     runnerImpl = async () => ({
       conversationId: "conv-1",
@@ -348,6 +409,69 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   });
 });
 
+describe("memoryV2ConsolidateJob — v3 health injection", () => {
+  beforeEach(() => {
+    writeFileSync(
+      bufferPath(),
+      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n",
+    );
+  });
+
+  test("prepends the health block when a v3 flag is on and the report is actionable", async () => {
+    v3FlagOn = true;
+    renderedHealth = "memory-v3 health:\n- 2 unassigned slug(s): a, b";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    // The health block is PREPENDED, separated by a blank line, with the
+    // base consolidation prompt still present underneath it.
+    expect(prompt.startsWith(`${renderedHealth}\n\n`)).toBe(true);
+    expect(prompt).toContain("memory consolidation");
+    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
+  });
+
+  test("leaves the prompt unchanged when the report is all-green (empty render)", async () => {
+    v3FlagOn = true;
+    renderedHealth = "";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    // Prompt is exactly the resolved consolidation body.
+    expect(prompt).toContain("memory consolidation");
+  });
+
+  test("leaves the prompt unchanged when v3 flags are off even if a block would render", async () => {
+    v3FlagOn = false;
+    renderedHealth = "memory-v3 health:\n- 1 unassigned slug(s): a";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    expect(prompt).toContain("memory consolidation");
+  });
+
+  test("falls back to the base prompt when health computation throws", async () => {
+    v3FlagOn = true;
+    computeThrows = true;
+    renderedHealth = "memory-v3 health:\n- should not appear";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    // A health-compute failure must NEVER break consolidation.
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    expect(prompt).toContain("memory consolidation");
+  });
+});
+
 describe("memoryV2ConsolidateJob — concurrent invocations", () => {
   beforeEach(() => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");

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__/migration.test.ts

@@ -26,7 +26,12 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../../__tests__/helpers/mock-logger.js";
-import type { Provider, ProviderResponse } from "../../../providers/types.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../../../providers/types.js";
 
 // -- Mocks that must be installed before importing the module under test ---
 //
@@ -416,8 +421,11 @@ describe("synthesizeConceptPage", () => {
     let capturedSystem: string | undefined;
     const provider: Provider = {
       name: "stub",
-      sendMessage: async (_messages, _tools, system) => {
-        capturedSystem = system;
+      sendMessage: async (
+        _messages: Message[],
+        options?: SendMessageOptions,
+      ) => {
+        capturedSystem = options?.systemPrompt;
         return {
           content: [{ type: "text", text: "synthesized" }],
           model: "stub-model",

package/src/memory/v2/__tests__/page-index.test.ts

@@ -76,7 +76,12 @@ afterEach(() => {
 
 function makePage(
   slug: string,
-  opts: { edges?: string[]; summary?: string; body?: string } = {},
+  opts: {
+    edges?: string[];
+    summary?: string;
+    body?: string;
+    leaves?: string[];
+  } = {},
 ): ConceptPage {
   return {
     slug,
@@ -85,6 +90,7 @@ function makePage(
       ref_files: [],
       ref_urls: [],
       ...(opts.summary !== undefined ? { summary: opts.summary } : {}),
+      ...(opts.leaves !== undefined ? { leaves: opts.leaves } : {}),
     },
     body: opts.body ?? "",
   };
@@ -230,6 +236,36 @@ describe("getPageIndex", () => {
     expect(alice.edges).toEqual([bob.id]);
   });
 
+  test("exposes frontmatter leaves in the index entry", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", {
+        summary: "A",
+        leaves: ["page-a", "domain-a/topic-x"],
+      }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.leaves).toEqual([
+      "page-a",
+      "domain-a/topic-x",
+    ]);
+  });
+
+  test("defaults leaves to an empty array when the field is absent", async () => {
+    await writePage(workspaceDir, makePage("alice", { summary: "A" }));
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.leaves).toEqual([]);
+  });
+
+  test("seeded skill entries carry an empty leaves list", async () => {
+    skillState.entries = [{ id: "browser", content: "Drive a browser." }];
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("skills/browser")?.leaves).toEqual([]);
+  });
+
   test("falls back to body when frontmatter.summary is absent", async () => {
     await writePage(
       workspaceDir,

package/src/memory/v2/__tests__/router.test.ts

@@ -148,8 +148,13 @@ afterEach(() => {
 function makeProvider(response: ProviderResponse): Provider {
   return {
     name: "stub",
-    sendMessage: async (messages, tools, systemPrompt, options) => {
-      providerCalls.push({ messages, tools, systemPrompt, options });
+    sendMessage: async (messages, options) => {
+      providerCalls.push({
+        messages,
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+        options,
+      });
       // Honor abort like a real provider would — if the signal already
       // aborted, throw the canonical AbortError so callers can assert that
       // signal forwarding actually has teeth.
@@ -752,9 +757,14 @@ describe("runRouter — batched (batch_size set)", () => {
     let callCount = 0;
     providerStub = {
       name: "partial-failure",
-      sendMessage: async (messages, tools, systemPrompt, options) => {
+      sendMessage: async (messages, options) => {
         callCount += 1;
-        providerCalls.push({ messages, tools, systemPrompt, options });
+        providerCalls.push({
+          messages,
+          tools: options?.tools,
+          systemPrompt: options?.systemPrompt,
+          options,
+        });
         if (callCount === 1) throw new Error("batch 1 boom");
         return toolUseResponse([1]);
       },

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

@@ -35,8 +35,10 @@ import {
 
 import { makeMockLogger } from "../../../__tests__/helpers/mock-logger.js";
 import type {
+  Message,
   Provider,
   ProviderResponse,
+  SendMessageOptions,
   ToolUseContent,
 } from "../../../providers/types.js";
 
@@ -99,7 +101,9 @@ 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");
@@ -141,9 +145,9 @@ function makeJob(): Parameters<typeof memoryV2SweepJob>[0] {
 function makeEntriesProvider(entries: string[]): Provider {
   return {
     name: "stub",
-    sendMessage: async (msgs, _tools, systemPrompt) => {
+    sendMessage: async (msgs: Message[], options?: SendMessageOptions) => {
       providerCalls.push({
-        systemPrompt,
+        systemPrompt: options?.systemPrompt,
         userText: extractFirstUserText(msgs),
       });
       return {
@@ -212,7 +216,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 +279,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;