@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/runtime/routes/inbound-stages/acl-enforcement.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Unit tests for `enforceIngressAcl` consuming the gateway trust verdict.
+ *
+ * Drives the stage directly with a `sourceMetadata.trustVerdict` and mocks the
+ * leaf I/O (contact store, gateway delivery, guardian notification, invite
+ * transport) so the ACL decision logic is exercised in isolation.
+ *
+ * Covers: verdict-sourced member resolution, fail-closed deny on an ABSENT
+ * verdict, hard-denies for blocked/revoked/policy, and the non-member invite
+ * intercept still firing for a present stranger verdict.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SourceMetadata, TrustVerdict } from "@vellumai/gateway-client";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// Track contact-store reads to prove findContactChannel is NOT used on the
+// verdict path. findGuardianForChannel is still called by resolveGuardianLabel.
+const findContactChannelCalls: unknown[] = [];
+mock.module("../../../contacts/contact-store.js", () => ({
+  findContactChannel: (params: unknown) => {
+    findContactChannelCalls.push(params);
+    return null;
+  },
+  findGuardianForChannel: () => null,
+}));
+
+const deliverReplyCalls: Array<{ url: string; payload: unknown }> = [];
+mock.module("../../gateway-client.js", () => ({
+  deliverChannelReply: async (url: string, payload: unknown) => {
+    deliverReplyCalls.push({ url, payload });
+  },
+}));
+
+const accessRequestCalls: unknown[] = [];
+mock.module("../../access-request-helper.js", () => ({
+  notifyGuardianOfAccessRequest: (params: unknown) => {
+    accessRequestCalls.push(params);
+    return { notified: true };
+  },
+}));
+
+// Invite transport: by default no adapter (no token). Per-test override below.
+let inviteTokenForTest: string | undefined;
+mock.module("../../channel-invite-transport.js", () => ({
+  getInviteAdapterRegistry: () => ({
+    get: () => ({
+      extractInboundToken: () => inviteTokenForTest,
+    }),
+  }),
+}));
+
+// Invite redemption: default to a successful redeem so the token intercept
+// short-circuits with an earlyResponse.
+mock.module("../../invite-redemption-service.js", () => ({
+  redeemInvite: async () => ({ ok: true, type: "redeemed", memberId: "m-1" }),
+  redeemInviteByCode: async () => ({
+    ok: true,
+    type: "redeemed",
+    memberId: "m-1",
+  }),
+}));
+
+mock.module("../../invite-redemption-templates.js", () => ({
+  getInviteRedemptionReply: () => "redeemed reply",
+}));
+
+mock.module("../../../memory/delivery-crud.js", () => ({
+  recordInbound: () => ({ duplicate: false, eventId: "evt-1" }),
+  deleteInbound: () => {},
+}));
+
+mock.module("../../../memory/delivery-status.js", () => ({
+  markProcessed: () => {},
+}));
+
+import type { AclEnforcementParams } from "./acl-enforcement.js";
+import { enforceIngressAcl } from "./acl-enforcement.js";
+
+function makeParams(
+  overrides: Partial<AclEnforcementParams> = {},
+): AclEnforcementParams {
+  return {
+    canonicalSenderId: "sender-1",
+    hasSenderIdentityClaim: true,
+    rawSenderId: "sender-1",
+    sourceChannel: "telegram",
+    conversationExternalId: "chat-1",
+    canonicalAssistantId: "assistant-1",
+    trimmedContent: "hello",
+    sourceMetadata: undefined,
+    actorDisplayName: "Sender One",
+    actorUsername: "sender_one",
+    replyCallbackUrl: "http://localhost/deliver",
+    assistantId: "assistant-1",
+    externalMessageId: "msg-1",
+    ...overrides,
+  };
+}
+
+function memberVerdict(overrides: Partial<TrustVerdict> = {}): TrustVerdict {
+  return {
+    trustClass: "trusted_contact",
+    canonicalSenderId: "sender-1",
+    contactId: "contact-1",
+    channelId: "channel-1",
+    type: "telegram",
+    address: "sender-1",
+    status: "active",
+    policy: "allow",
+    memberDisplayName: "Sender One",
+    ...overrides,
+  };
+}
+
+function withVerdict(verdict: TrustVerdict): SourceMetadata {
+  return { trustVerdict: verdict } as SourceMetadata;
+}
+
+beforeEach(() => {
+  findContactChannelCalls.length = 0;
+  deliverReplyCalls.length = 0;
+  accessRequestCalls.length = 0;
+  inviteTokenForTest = undefined;
+});
+
+afterEach(() => {
+  inviteTokenForTest = undefined;
+});
+
+describe("enforceIngressAcl — verdict-sourced member resolution", () => {
+  test("active trusted verdict is admitted (resolvedMember threaded, no deny)", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({ sourceMetadata: withVerdict(memberVerdict()) }),
+    );
+
+    expect(result.earlyResponse).toBeUndefined();
+    expect(result.resolvedMember).not.toBeNull();
+    expect(result.resolvedMember!.channel.status).toBe("active");
+    expect(result.resolvedMember!.channel.policy).toBe("allow");
+    // Member came from the verdict, never the local contact store.
+    expect(findContactChannelCalls.length).toBe(0);
+  });
+
+  test("guardian verdict is admitted purely from the verdict (empty contact store)", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(
+          memberVerdict({ trustClass: "guardian", guardianPrincipalId: "p-1" }),
+        ),
+      }),
+    );
+
+    expect(result.earlyResponse).toBeUndefined();
+    expect(result.resolvedMember!.contact.role).toBe("guardian");
+    expect(findContactChannelCalls.length).toBe(0);
+  });
+});
+
+describe("enforceIngressAcl — hard denies from the verdict status/policy", () => {
+  test("blocked verdict → member_blocked deny", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(memberVerdict({ status: "blocked" })),
+      }),
+    );
+
+    expect(result.earlyResponse).toBeDefined();
+    expect(result.earlyResponse!.reason).toBe("member_blocked");
+    // Blocked members do not trigger a guardian notification.
+    expect(accessRequestCalls.length).toBe(0);
+  });
+
+  test("revoked verdict → member_revoked deny (even under strangers)", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(memberVerdict({ status: "revoked" })),
+        effectiveAdmissionPolicy: "strangers",
+      }),
+    );
+
+    expect(result.earlyResponse!.reason).toBe("member_revoked");
+  });
+
+  test("policy deny verdict → policy_deny", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(memberVerdict({ policy: "deny" })),
+      }),
+    );
+
+    expect(result.earlyResponse!.reason).toBe("policy_deny");
+  });
+});
+
+describe("enforceIngressAcl — present stranger verdict flows through intercepts", () => {
+  test("present unknown/no-member verdict + invite token redeems via intercept", async () => {
+    inviteTokenForTest = "iv_token123";
+    const strangerVerdict: TrustVerdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "stranger-1",
+    };
+
+    const result = await enforceIngressAcl(
+      makeParams({
+        canonicalSenderId: "stranger-1",
+        rawSenderId: "stranger-1",
+        sourceMetadata: withVerdict(strangerVerdict),
+      }),
+    );
+
+    // The invite token intercept fired — NOT a fail-closed deny.
+    expect(result.earlyResponse).toBeDefined();
+    expect(result.earlyResponse!.inviteRedemption).toBe("redeemed");
+    expect(result.resolvedMember).toBeNull();
+  });
+});
+
+describe("enforceIngressAcl — fail-closed on absent verdict", () => {
+  test("absent trustVerdict → not_a_member deny even under strangers", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        // sourceMetadata present but WITHOUT trustVerdict.
+        sourceMetadata: {} as SourceMetadata,
+        effectiveAdmissionPolicy: "strangers",
+      }),
+    );
+
+    expect(result.earlyResponse).toBeDefined();
+    expect(result.earlyResponse!.reason).toBe("not_a_member");
+    expect(result.resolvedMember).toBeNull();
+    // Fail-closed deny short-circuits BEFORE any intercept or onboarding.
+    expect(deliverReplyCalls.length).toBe(0);
+    expect(accessRequestCalls.length).toBe(0);
+    expect(findContactChannelCalls.length).toBe(0);
+  });
+
+  test("no sourceMetadata at all → not_a_member deny", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({ sourceMetadata: undefined }),
+    );
+
+    expect(result.earlyResponse!.reason).toBe("not_a_member");
+    expect(result.resolvedMember).toBeNull();
+  });
+});
+
+describe("enforceIngressAcl — fail-closed on malformed member verdict", () => {
+  test("member identity + unknown policy → not_a_member deny even under strangers", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(
+          memberVerdict({ policy: "bogus" as TrustVerdict["policy"] }),
+        ),
+        effectiveAdmissionPolicy: "strangers",
+      }),
+    );
+
+    // Carries contactId/channelId but no resolvable member → fail closed,
+    // NOT admitted as a stranger by the floor.
+    expect(result.earlyResponse).toBeDefined();
+    expect(result.earlyResponse!.reason).toBe("not_a_member");
+    expect(result.resolvedMember).toBeNull();
+    expect(deliverReplyCalls.length).toBe(0);
+    expect(accessRequestCalls.length).toBe(0);
+  });
+
+  test("member identity + missing status → not_a_member deny even under strangers", async () => {
+    const result = await enforceIngressAcl(
+      makeParams({
+        sourceMetadata: withVerdict(
+          memberVerdict({ status: undefined as unknown as TrustVerdict["status"] }),
+        ),
+        effectiveAdmissionPolicy: "strangers",
+      }),
+    );
+
+    expect(result.earlyResponse!.reason).toBe("not_a_member");
+    expect(result.resolvedMember).toBeNull();
+  });
+});

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -7,12 +7,9 @@ import type { AdmissionPolicy, SourceMetadata } from "@vellumai/gateway-client";
 
 import { isInviteCodeRedemptionEnabled } from "../../../channels/config.js";
 import type { ChannelId } from "../../../channels/types.js";
-import {
-  findContactChannel,
-  findGuardianForChannel,
-} from "../../../contacts/contact-store.js";
+import { findGuardianForChannel } from "../../../contacts/contact-store.js";
+import { channelStatusToMemberStatus } from "../../../contacts/member-status.js";
 import type {
-  ChannelStatus,
   ContactChannel,
   ContactWithChannels,
 } from "../../../contacts/types.js";
@@ -41,6 +38,7 @@ import {
   redeemInviteByCode,
 } from "../../invite-redemption-service.js";
 import { getInviteRedemptionReply } from "../../invite-redemption-templates.js";
+import { resolvedMemberFromVerdict } from "../../trust-verdict-consumer.js";
 
 const log = getLogger("runtime-http");
 
@@ -122,14 +120,6 @@ export interface AclResult {
   isValidatedBootstrap?: boolean;
 }
 
-/** Map ChannelStatus to the API-facing member status (excludes "unverified"). */
-export function channelStatusToMemberStatus(
-  status: ChannelStatus,
-): Exclude<ChannelStatus, "unverified"> {
-  if (status === "unverified") return "pending";
-  return status;
-}
-
 /**
  * Enforce ingress ACL rules: member lookup, non-member/inactive denial,
  * policy enforcement (allow/deny/escalate bypass), invite token intercepts,
@@ -164,7 +154,45 @@ export async function enforceIngressAcl(
   // Slack message timestamp for permalink construction.
   const messageTs = sourceMetadata?.messageId ?? undefined;
 
-  let resolvedMember: ResolvedMember | null = null;
+  // Absent verdict = gateway could not vouch for this actor → fail-closed deny.
+  // A PRESENT verdict with no member (stranger) still flows through the
+  // intercepts below; only a missing verdict short-circuits here.
+  const verdict = sourceMetadata?.trustVerdict;
+  if (verdict == null) {
+    log.info(
+      { sourceChannel, externalUserId: canonicalSenderId },
+      "Ingress ACL: absent trust verdict, denying fail-closed",
+    );
+    return {
+      resolvedMember: null,
+      earlyResponse: {
+        accepted: true,
+        denied: true,
+        reason: "not_a_member",
+      },
+    };
+  }
+
+  // Member resolved from the gateway verdict (ACL + identity only); null for a
+  // stranger verdict, which falls through to the non-member intercepts.
+  const resolvedMember: ResolvedMember | null = resolvedMemberFromVerdict(verdict);
+
+  // A verdict carrying member identity but no resolvable member
+  // (malformed/unknown ACL) fails closed, not treated as a stranger.
+  if (!resolvedMember && (verdict.contactId || verdict.channelId)) {
+    log.info(
+      { sourceChannel, externalUserId: canonicalSenderId },
+      "Ingress ACL: member verdict with unresolvable ACL, denying fail-closed",
+    );
+    return {
+      resolvedMember: null,
+      earlyResponse: {
+        accepted: true,
+        denied: true,
+        reason: "not_a_member",
+      },
+    };
+  }
 
   // /start gv_<token> bootstrap commands must also bypass ACL — the user
   // hasn't been verified yet and needs to complete the bootstrap handshake.
@@ -181,23 +209,6 @@ export async function enforceIngressAcl(
   });
 
   if (canonicalSenderId || hasSenderIdentityClaim) {
-    // Only perform member lookup when we have a usable canonical ID.
-    // Whitespace-only senders (hasSenderIdentityClaim=true but
-    // canonicalSenderId=null) skip the lookup and fall into the deny path.
-    if (canonicalSenderId) {
-      const contactResult = findContactChannel({
-        channelType: sourceChannel,
-        address: canonicalSenderId,
-        externalChatId: conversationExternalId,
-      });
-      resolvedMember = contactResult
-        ? {
-            contact: contactResult.contact,
-            channel: contactResult.channel,
-          }
-        : null;
-    }
-
     if (!resolvedMember) {
       let denyNonMember = true;
 
@@ -875,7 +886,7 @@ async function handleInviteTokenIntercept(params: {
     };
   }
 
-  const outcome = redeemInvite({
+  const outcome = await redeemInvite({
     rawToken,
     sourceChannel,
     externalUserId: senderExternalUserId,
@@ -1077,9 +1088,9 @@ async function handleInviteCodeIntercept(params: {
     };
   }
 
-  let outcome: ReturnType<typeof redeemInviteByCode>;
+  let outcome: Awaited<ReturnType<typeof redeemInviteByCode>>;
   try {
-    outcome = redeemInviteByCode({
+    outcome = await redeemInviteByCode({
       code,
       sourceChannel,
       externalUserId: senderExternalUserId,

package/src/runtime/routes/inbound-stages/admission-policy.ts

@@ -30,10 +30,7 @@ import {
 
 import type { ChannelId } from "../../../channels/types.js";
 import type { ChannelStatus } from "../../../contacts/types.js";
-import {
-  TRUST_CLASS_RANK,
-  type TrustClass,
-} from "../../actor-trust-resolver.js";
+import type { TrustClass } from "../../actor-trust-resolver.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -75,6 +72,23 @@ export type AdmissionPolicyResult =
 // Public API
 // ---------------------------------------------------------------------------
 
+/**
+ * Trust-class ordinal compared against {@link ADMISSION_FLOOR} to make the
+ * admission decision (`rank >= floor`). Higher rank = more trusted.
+ * Blocked/revoked never reach this comparison — they short-circuit to deny on
+ * member status above — so they carry no rank here.
+ *
+ * The two halves of the floor check: this table is keyed by `TrustClass`,
+ * `ADMISSION_FLOOR` (from `@vellumai/gateway-client`) by `AdmissionPolicy`.
+ * They are only ever read together, here, so they live next to their use.
+ */
+const TRUST_CLASS_RANK: Record<TrustClass, number> = {
+  guardian: 4,
+  trusted_contact: 3,
+  unverified_contact: 2,
+  unknown: 1,
+};
+
 /**
  * Policies under which completing verification could lift the sender past
  * the floor. Used to decide whether to fire the upgrade UX on deny.
@@ -116,7 +130,8 @@ export function enforceAdmissionPolicy(
   if (input.memberStatus === "blocked" || input.memberStatus === "revoked") {
     return {
       admitted: false,
-      reason: input.memberStatus === "blocked" ? "member_blocked" : "member_revoked",
+      reason:
+        input.memberStatus === "blocked" ? "member_blocked" : "member_revoked",
       shouldChallenge: false,
       effectivePolicy: input.policy,
     };

package/src/runtime/routes/log-export-routes.ts

@@ -22,7 +22,7 @@ import { join } from "node:path";
 import { and, desc, eq, gte, lte } from "drizzle-orm";
 import { z } from "zod";
 
-import { getDb } from "../../memory/db-connection.js";
+import { getDb, getLogsDb } from "../../memory/db-connection.js";
 import {
   llmRequestLogs,
   llmUsageEvents,
@@ -168,7 +168,7 @@ async function handleExport({
         : [];
 
       const llmLogRows = capRows(
-        db
+        (getLogsDb() ?? db)
           .select()
           .from(llmRequestLogs)
           .where(

package/src/runtime/routes/memory-eval-routes.ts

@@ -16,6 +16,10 @@ import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getDb } from "../../memory/db-connection.js";
 import { runMemoryEval } from "../../memory/v3-eval/eval-packets.js";
+import {
+  type TallyResult,
+  tallyVerdicts,
+} from "../../memory/v3-eval/eval-tally.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS, type RoutePolicy } from "../auth/route-policy.js";
@@ -35,16 +39,30 @@ const MemoryEvalRunParamsSchema = z.object({
   k: z.number().int().positive().optional(),
   dense: z.boolean().optional(),
   seed: z.number().int().optional(),
+  /** Pin the exact turns to re-mine (turn ids from a prior key.json/packets.json). */
+  turnIds: z.array(z.string()).optional(),
+  /** Conversations to omit from recency mining (e.g. the migration's own chat). */
+  excludeConversationIds: z.array(z.string()).optional(),
 });
 
 const MemoryEvalRunResultSchema = z.object({
   turnsMined: z.number(),
+  turnsRequested: z.number(),
   packetsWritten: z.number(),
   packetsPath: z.string(),
   keyPath: z.string(),
+  metaPath: z.string(),
   snapshotPages: z.number(),
   stagingPages: z.number(),
   dense: z.boolean(),
+  seed: z.number(),
+  k: z.number(),
+  embedding: z.object({
+    provider: z.string(),
+    model: z.string(),
+    dims: z.number().nullable(),
+  }),
+  turnIds: z.array(z.string()),
 });
 export type MemoryEvalRunResult = z.infer<typeof MemoryEvalRunResultSchema>;
 
@@ -62,10 +80,72 @@ export async function handleMemoryEvalRun(
     workspaceDir: getWorkspaceDir(),
     db: getDb(),
   });
+  if (result.turnsMined < result.turnsRequested) {
+    log.warn(
+      { requested: result.turnsRequested, mined: result.turnsMined },
+      "Fewer eval turns mined than requested — pinned turns may have been " +
+        "deleted, or there are too few recent user turns",
+    );
+  }
   log.info(result, "memory eval packets written");
   return result;
 }
 
+const MemoryEvalTallyParamsSchema = z.object({
+  /** Judge verdicts (one or more per turn for a panel); winner derived from scores if absent. */
+  verdicts: z.array(
+    z.object({
+      turn: z.string(),
+      winner: z.string().optional(),
+      scoreA: z.number(),
+      scoreB: z.number(),
+    }),
+  ),
+  /** The per-turn A/B → snapshot/staging unblinding map from `eval` (key.json). */
+  key: z.array(
+    z.object({
+      turn: z.string(),
+      a: z.enum(["snapshot", "staging"]),
+      b: z.enum(["snapshot", "staging"]),
+    }),
+  ),
+  /** Sign-test significance threshold (default 0.05). */
+  alpha: z.number().positive().optional(),
+});
+
+const MemoryEvalTallyResultSchema = z.object({
+  turns: z.number(),
+  verdictsCounted: z.number(),
+  unmatchedVerdicts: z.number(),
+  panel: z.object({ min: z.number(), max: z.number(), mean: z.number() }),
+  snapshotWins: z.number(),
+  stagingWins: z.number(),
+  ties: z.number(),
+  decided: z.number(),
+  meanSnapshot: z.number(),
+  meanStaging: z.number(),
+  signTestP: z.number(),
+  verdict: z.enum(["wiki-wins", "tie", "wiki-loses"]),
+  gate: z.enum(["pass", "fail"]),
+  confident: z.boolean(),
+  notes: z.array(z.string()),
+});
+export type MemoryEvalTallyResult = z.infer<typeof MemoryEvalTallyResultSchema>;
+
+/**
+ * Pure: join the judge verdicts to the unblinding key and return the noise-aware
+ * gate verdict. The CLI reads the verdicts/key files and passes the arrays.
+ */
+export function handleMemoryEvalTally(body: unknown): MemoryEvalTallyResult {
+  const params = MemoryEvalTallyParamsSchema.parse(body ?? {});
+  const result: TallyResult = tallyVerdicts(
+    params.verdicts,
+    params.key,
+    params.alpha !== undefined ? { alpha: params.alpha } : {},
+  );
+  return result;
+}
+
 const WRITE_POLICY: RoutePolicy = {
   requiredScopes: ["settings.write"],
   allowedPrincipalTypes: ACTOR_PRINCIPALS,
@@ -84,4 +164,16 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: MemoryEvalRunParamsSchema,
     responseBody: MemoryEvalRunResultSchema,
   },
+  {
+    operationId: "memory_eval_tally",
+    method: "POST",
+    policy: WRITE_POLICY,
+    endpoint: "memory/eval/tally",
+    handler: ({ body }) => handleMemoryEvalTally(body),
+    summary:
+      "Unblind + tally blind-judge verdicts against the key with a noise-aware win/tie/loss verdict",
+    tags: ["memory"],
+    requestBody: MemoryEvalTallyParamsSchema,
+    responseBody: MemoryEvalTallyResultSchema,
+  },
 ];

package/src/runtime/routes/memory-item-routes.test.ts

@@ -66,7 +66,11 @@ mock.module("../../memory/qdrant-circuit-breaker.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { getDb } from "../../memory/db-connection.js";
+import {
+  getDb,
+  getMemoryDb,
+  getMemorySqlite,
+} from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
 import { memoryGraphNodes, memoryJobs } from "../../memory/schema.js";
 import { BadRequestError, ConflictError, NotFoundError } from "./errors.js";
@@ -176,8 +180,8 @@ function insertItem(opts: {
 // ---------------------------------------------------------------------------
 
 describe("Memory Item Routes", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {
@@ -186,7 +190,7 @@ describe("Memory Item Routes", () => {
     db.run("DELETE FROM memory_graph_triggers");
     db.run("DELETE FROM memory_graph_edges");
     db.run("DELETE FROM memory_graph_nodes");
-    db.run("DELETE FROM memory_jobs");
+    getMemorySqlite()!.run("DELETE FROM memory_jobs");
   });
 
   // =========================================================================
@@ -729,8 +733,7 @@ describe("Memory Item Routes", () => {
       });
 
       // Verify a memory job was enqueued
-      const db = getDb();
-      const jobs = db.select().from(memoryJobs).all();
+      const jobs = getMemoryDb()!.select().from(memoryJobs).all();
       const embedJobs = jobs.filter(
         (j) => j.type === "embed_graph_node" && j.status === "pending",
       );
@@ -835,15 +838,14 @@ describe("Memory Item Routes", () => {
       });
 
       // Clear jobs first
-      getDb().run("DELETE FROM memory_jobs");
+      getMemorySqlite()!.run("DELETE FROM memory_jobs");
 
       await callHandler(route, {
         pathParams: { id: "i1" },
         body: { statement: "new statement" },
       });
 
-      const db = getDb();
-      const jobs = db.select().from(memoryJobs).all();
+      const jobs = getMemoryDb()!.select().from(memoryJobs).all();
       const embedJobs = jobs.filter(
         (j) => j.type === "embed_graph_node" && j.status === "pending",
       );
@@ -897,8 +899,7 @@ describe("Memory Item Routes", () => {
       expect(res.status).toBe(204);
 
       // Verify a delete_qdrant_vectors job was enqueued with graph_node targetType
-      const db = getDb();
-      const jobs = db.select().from(memoryJobs).all();
+      const jobs = getMemoryDb()!.select().from(memoryJobs).all();
       const deleteJobs = jobs.filter(
         (j) => j.type === "delete_qdrant_vectors" && j.status === "pending",
       );