@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/calls/__tests__/relay-setup-router.test.ts

@@ -1,34 +1,33 @@
 /**
  * Tests for the inbound admission-floor enforcement in `routeSetup`.
  *
- * `routeSetup` is pure routing logic but reads several module-level singletons
- * (config, trust resolver, pending verification session, invite store). These
- * are mocked so the table below can drive trust class, member status, pending
- * challenge, and active invites independently of any DB.
+ * `routeSetup` reads several module-level singletons (config, trust resolver,
+ * pending verification session, invite store, contact store). Those I/O
+ * collaborators are mocked so the tables below can drive trust class, member
+ * status, pending challenge, active invites, and the bound invite contact
+ * directly — no database is touched.
  *
- * The floor verdict is exercised through the REAL `enforceAdmissionPolicy`
- * floor tables (`TRUST_CLASS_RANK` × `ADMISSION_FLOOR`), with the exempt-channel
- * short-circuit bypassed in the mock so the tests assert the true floor
- * semantics independent of any channel's exempt status (`phone` is now
- * enforced).
+ * The admission floor is exercised through the REAL, pure `enforceAdmissionPolicy`:
+ * `phone` is an enforced (non-exempt) channel, so the real function applies the
+ * true `rank >= floor` semantics. We deliberately do not reimplement the floor
+ * here — a test-local copy of production logic would silently drift from it.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import {
-  ADMISSION_FLOOR,
-  type AdmissionPolicy,
-} from "@vellumai/gateway-client";
+import type { AdmissionPolicy } from "@vellumai/gateway-client";
 
 import type {
   ChannelPolicy,
   ChannelStatus,
+  ContactChannel,
+  ContactRole,
+  ContactWithChannels,
 } from "../../contacts/types.js";
 import type {
   ActorTrustContext,
   TrustClass,
 } from "../../runtime/actor-trust-resolver.js";
-import { TRUST_CLASS_RANK } from "../../runtime/actor-trust-resolver.js";
 
 mock.module("../../util/logger.js", () => ({
   getLogger: () =>
@@ -43,8 +42,6 @@ mock.module("../../config/loader.js", () => ({
 let nextTrust: ActorTrustContext;
 mock.module("../../runtime/actor-trust-resolver.js", () => ({
   resolveActorTrust: () => nextTrust,
-  // Re-export the real rank table; the floor mock below consumes it.
-  TRUST_CLASS_RANK,
 }));
 
 // Controllable pending verification challenge.
@@ -55,6 +52,7 @@ mock.module("../../runtime/channel-verification-service.js", () => ({
 
 // Controllable active voice invites.
 let activeInvites: Array<{
+  contactId: string;
   friendName: string | null;
   guardianName: string | null;
   expiresAt?: number;
@@ -63,38 +61,11 @@ mock.module("../../memory/invite-store.js", () => ({
   findActiveVoiceInvites: () => activeInvites,
 }));
 
-// Real floor semantics, exemption bypassed (see file header).
-mock.module(
-  "../../runtime/routes/inbound-stages/admission-policy.js",
-  () => ({
-    enforceAdmissionPolicy: (input: {
-      trustClass: TrustClass;
-      memberStatus: ChannelStatus | undefined;
-      policy: AdmissionPolicy;
-    }) => {
-      if (input.memberStatus === "blocked" || input.memberStatus === "revoked") {
-        return {
-          admitted: false,
-          reason:
-            input.memberStatus === "blocked"
-              ? "member_blocked"
-              : "member_revoked",
-          shouldChallenge: false,
-          effectivePolicy: input.policy,
-        };
-      }
-      const rank = TRUST_CLASS_RANK[input.trustClass];
-      const floor = ADMISSION_FLOOR[input.policy];
-      if (rank >= floor) return { admitted: true };
-      return {
-        admitted: false,
-        reason: `admission_policy_${input.policy}`,
-        shouldChallenge: false,
-        effectivePolicy: input.policy,
-      };
-    },
-  }),
-);
+// Controllable bound contact for invite-redemption name resolution.
+let boundContact: { displayName?: string | null } | null = null;
+mock.module("../../contacts/contact-store.js", () => ({
+  getContact: () => boundContact,
+}));
 
 const { routeSetup } = await import("../relay-setup-router.js");
 
@@ -102,30 +73,74 @@ const { routeSetup } = await import("../relay-setup-router.js");
 // Fixtures
 // ---------------------------------------------------------------------------
 
+function makeChannel(overrides: Partial<ContactChannel> = {}): ContactChannel {
+  return {
+    id: "ch_1",
+    contactId: "ct_1",
+    type: "phone",
+    address: "+12025550142",
+    isPrimary: true,
+    externalChatId: null,
+    status: "active",
+    policy: "allow",
+    verifiedAt: null,
+    verifiedVia: null,
+    inviteId: null,
+    revokedReason: null,
+    blockedReason: null,
+    lastSeenAt: null,
+    interactionCount: 0,
+    lastInteraction: null,
+    updatedAt: null,
+    createdAt: 0,
+    ...overrides,
+  };
+}
+
+function makeContact(
+  overrides: Partial<ContactWithChannels> = {},
+): ContactWithChannels {
+  return {
+    id: "ct_1",
+    displayName: "Test Caller",
+    notes: null,
+    lastInteraction: null,
+    interactionCount: 0,
+    createdAt: 0,
+    updatedAt: 0,
+    role: "contact",
+    contactType: "human",
+    principalId: null,
+    userFile: null,
+    channels: [],
+    ...overrides,
+  };
+}
+
 function makeTrust(
   trustClass: TrustClass,
-  channel?: { status: ChannelStatus; policy?: ChannelPolicy; role?: string },
+  channel?: {
+    status: ChannelStatus;
+    policy?: ChannelPolicy;
+    role?: ContactRole;
+  },
 ): ActorTrustContext {
   const memberRecord = channel
     ? {
-        contact: {
-          displayName: "Test Caller",
-          role: channel.role ?? "trusted_contact",
-        } as never,
-        channel: {
-          id: "ch_1",
+        contact: makeContact({ role: channel.role ?? "contact" }),
+        channel: makeChannel({
           status: channel.status,
           policy: channel.policy ?? "allow",
-        } as never,
+        }),
       }
     : null;
   return {
-    canonicalSenderId: "+15551234567",
+    canonicalSenderId: "+12025550142",
     guardianBindingMatch: null,
     memberRecord,
     trustClass,
     actorMetadata: {
-      identifier: "+15551234567",
+      identifier: "+12025550142",
       displayName: undefined,
       senderDisplayName: undefined,
       memberDisplayName: undefined,
@@ -133,15 +148,15 @@ function makeTrust(
       channel: "phone",
       trustStatus: trustClass,
     },
-  } as ActorTrustContext;
+  };
 }
 
 function route(admissionPolicy?: AdmissionPolicy | null) {
   return routeSetup({
     callSessionId: "cs_1",
     session: null, // inbound
-    from: "+15551234567",
-    to: "+15559999999",
+    from: "+12025550142",
+    to: "+12025550199",
     admissionPolicy,
   });
 }
@@ -149,6 +164,7 @@ function route(admissionPolicy?: AdmissionPolicy | null) {
 beforeEach(() => {
   pendingChallenge = null;
   activeInvites = [];
+  boundContact = null;
 });
 
 // ---------------------------------------------------------------------------
@@ -334,9 +350,19 @@ describe("routeSetup — permissive floor admits to normal_call", () => {
 describe("routeSetup — floor bypasses", () => {
   test("active voice invite bypasses the floor (no_one policy)", () => {
     nextTrust = makeTrust("unknown");
-    activeInvites = [{ friendName: "Friend", guardianName: "Guardian" }];
+    activeInvites = [
+      {
+        contactId: "contact-123",
+        friendName: "Friend",
+        guardianName: "Guardian",
+      },
+    ];
+    boundContact = { displayName: "Friend Name" };
     const { outcome } = route("no_one");
     expect(outcome.action).toBe("invite_redemption");
+    if (outcome.action === "invite_redemption") {
+      expect(outcome.inviteeName).toBe("Friend Name");
+    }
   });
 
   test("pending verification challenge bypasses the floor (no_one policy)", () => {

package/src/calls/inbound-trust-reader.ts

@@ -0,0 +1,40 @@
+/**
+ * Gateway-backed per-actor inbound trust verdict reader.
+ *
+ * Resolves the inbound sender's {@link TrustVerdict} from the gateway via the
+ * `resolve_inbound_trust` IPC route. Unlike the channel-admission reader this
+ * is per-actor, NOT per-channel, so there is NO caching.
+ *
+ * Returns `null` on ANY failure (transport failure, `undefined`, malformed
+ * shape, or thrown error). The caller owns the deny policy (fail-open vs
+ * fail-closed); this reader only reports the verdict or `null`.
+ */
+
+import { type TrustVerdict, TrustVerdictSchema } from "@vellumai/gateway-client";
+
+import type { ChannelId } from "../channels/types.js";
+import { ipcCall } from "../ipc/gateway-client.js";
+
+// Short IPC timeout so the read resolves promptly rather than stalling call
+// setup on a gateway that accepts the socket but hangs.
+const TRUST_IPC_TIMEOUT_MS = 2_000;
+
+export async function getInboundTrustVerdict(input: {
+  channelType: ChannelId;
+  actorExternalId?: string;
+}): Promise<TrustVerdict | null> {
+  try {
+    const result = (await ipcCall(
+      "resolve_inbound_trust",
+      input,
+      TRUST_IPC_TIMEOUT_MS,
+    )) as { verdict?: unknown } | null | undefined;
+
+    if (!result) return null;
+
+    const parsed = TrustVerdictSchema.safeParse(result.verdict);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}

package/src/calls/relay-server.ts

@@ -71,6 +71,17 @@ const log = getLogger("relay-server");
 const UUID_SHAPED_NAME =
   /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 
+/**
+ * Return the first whitespace-delimited token of a name, or `null` when the
+ * input is null/blank. Used for greetings so "Carolina Flaherty" -> "Carolina".
+ */
+function firstToken(name: string | null | undefined): string | null {
+  if (!name) return null;
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  return trimmed.split(/\s+/)[0] ?? null;
+}
+
 // ── ConversationRelay message types ──────────────────────────────────
 
 // Messages FROM Twilio
@@ -213,11 +224,14 @@ export class RelayConnection {
 
   // Inbound voice invite redemption state
   private inviteRedemptionActive = false;
+  // In-flight guard: true while an async redemption attempt is awaiting the
+  // gateway-backed claim, so a rapidly-repeated code is deduped rather than
+  // launching a second concurrent redeemVoiceInviteCode.
+  private inviteRedemptionInFlight = false;
   private inviteRedemptionAssistantId: string | null = null;
   private inviteRedemptionFromNumber: string | null = null;
   private inviteRedemptionCodeLength = 6;
-  private inviteRedemptionFriendName: string | null = null;
-  private inviteRedemptionGuardianName: string | null = null;
+  private inviteRedemptionInviteeName: string | null = null;
 
   // In-call guardian approval wait state (friend-initiated)
   private accessRequestWaitActive = false;
@@ -646,8 +660,7 @@ export class RelayConnection {
         this.startInviteRedemption(
           outcome.assistantId,
           outcome.fromNumber,
-          outcome.friendName,
-          outcome.guardianName,
+          outcome.inviteeName,
           !resolved.isInbound,
         );
         return;
@@ -872,8 +885,14 @@ export class RelayConnection {
       | "invite_redeemed"
       | "access_approved"
       | "trusted_contact_verified";
-    friendName?: string;
-    guardianName?: string;
+    /**
+     * Display name resolved from the bound contact (or, for outbound invite
+     * calls, the session's recorded invitee name). Greeting uses only the
+     * first whitespace-delimited token; an empty/blank value triggers the
+     * neutral "Hi there" greeting rather than substituting the channel
+     * address.
+     */
+    inviteeName?: string | null;
   }): void {
     const { assistantId, fromNumber } = params;
 
@@ -898,17 +917,16 @@ export class RelayConnection {
     let handoffText: string;
 
     if (params.activationReason === "invite_redeemed") {
-      const name = params.friendName;
+      const firstName = firstToken(params.inviteeName);
       const assistantName = this.resolveAssistantLabel();
-      const gLabel = params.guardianName || guardianLabel;
-      if (name) {
+      if (firstName) {
         handoffText = assistantName
-          ? `Great, I've verified that you are ${name}. It's nice to meet you! I'm ${assistantName}, ${gLabel}'s assistant. How can I help?`
-          : `Great, I've verified that you are ${name}. It's nice to meet you! How can I help?`;
+          ? `Great, I've verified that you are ${firstName}. It's nice to meet you! I'm ${assistantName}, ${guardianLabel}'s assistant. How can I help?`
+          : `Great, I've verified that you are ${firstName}. It's nice to meet you! How can I help?`;
       } else {
         handoffText = assistantName
-          ? `Great, I've verified your identity. It's nice to meet you! I'm ${assistantName}, ${gLabel}'s assistant. How can I help?`
-          : `Great, I've verified your identity. It's nice to meet you! How can I help?`;
+          ? `Hi there! I'm ${assistantName}, ${guardianLabel}'s assistant. How can I help?`
+          : `Hi there! How can I help?`;
       }
     } else {
       handoffText = `Great! ${guardianLabel} said I can speak with you. How can I help?`;
@@ -1195,15 +1213,14 @@ export class RelayConnection {
   private startInviteRedemption(
     assistantId: string,
     fromNumber: string,
-    friendName: string | null,
-    guardianName: string | null,
+    inviteeName: string | null,
     isOutbound: boolean,
   ): void {
     this.inviteRedemptionActive = true;
+    this.inviteRedemptionInFlight = false;
     this.inviteRedemptionAssistantId = assistantId;
     this.inviteRedemptionFromNumber = fromNumber;
-    this.inviteRedemptionFriendName = friendName;
-    this.inviteRedemptionGuardianName = guardianName;
+    this.inviteRedemptionInviteeName = inviteeName;
     this.connectionState = "verification_pending";
     this.verificationAttempts = 0;
     this.verificationMaxAttempts = 1;
@@ -1216,8 +1233,8 @@ export class RelayConnection {
       maxAttempts: this.verificationMaxAttempts,
     });
 
-    const displayFriend = friendName ?? "there";
-    const displayGuardian = guardianName ?? "your contact";
+    const displayFriend = firstToken(inviteeName) ?? "there";
+    const displayGuardian = this.resolveGuardianLabel();
 
     let promptText: string;
     if (isOutbound) {
@@ -1620,11 +1637,37 @@ export class RelayConnection {
       return;
     }
 
-    const result = attemptInviteCodeRedemption({
+    // Dedup concurrent attempts: a repeated code (re-spoken / re-entered)
+    // arriving while the async gateway-backed claim is still in flight is
+    // ignored, so we never run a second redeemVoiceInviteCode that would see
+    // the invite already consumed and wrongly mark the call failed. The flag
+    // is set synchronously before awaiting and cleared in finally.
+    if (this.inviteRedemptionInFlight) {
+      log.info(
+        { callSessionId: this.callSessionId },
+        "Ignoring repeated invite code — redemption already in flight",
+      );
+      return;
+    }
+    this.inviteRedemptionInFlight = true;
+
+    try {
+      await this.runInviteCodeRedemption(enteredCode);
+    } finally {
+      this.inviteRedemptionInFlight = false;
+    }
+  }
+
+  private async runInviteCodeRedemption(enteredCode: string): Promise<void> {
+    if (!this.inviteRedemptionAssistantId || !this.inviteRedemptionFromNumber) {
+      return;
+    }
+
+    const result = await attemptInviteCodeRedemption({
       inviteRedemptionAssistantId: this.inviteRedemptionAssistantId,
       inviteRedemptionFromNumber: this.inviteRedemptionFromNumber,
       enteredCode,
-      inviteRedemptionGuardianName: this.inviteRedemptionGuardianName,
+      guardianLabel: this.resolveGuardianLabel(),
     });
 
     if (result.outcome === "success") {
@@ -1649,8 +1692,7 @@ export class RelayConnection {
         assistantId: this.inviteRedemptionAssistantId,
         fromNumber: this.inviteRedemptionFromNumber,
         activationReason: "invite_redeemed",
-        friendName: this.inviteRedemptionFriendName ?? undefined,
-        guardianName: this.inviteRedemptionGuardianName ?? undefined,
+        inviteeName: this.inviteRedemptionInviteeName,
       });
     } else {
       this.inviteRedemptionActive = false;

package/src/calls/relay-setup-router.ts

@@ -9,6 +9,7 @@
 import type { AdmissionPolicy } from "@vellumai/gateway-client";
 
 import { getConfig } from "../config/loader.js";
+import { getContact } from "../contacts/contact-store.js";
 import { findActiveVoiceInvites } from "../memory/invite-store.js";
 import {
   type ActorTrustContext,
@@ -64,8 +65,15 @@ type SetupOutcome =
       action: "invite_redemption";
       assistantId: string;
       fromNumber: string;
-      friendName: string | null;
-      guardianName: string | null;
+      /**
+       * Display name of the invitee. For inbound redemptions, resolved from the
+       * bound contact's `displayName`; falls back to the legacy `friend_name`
+       * column for pre-contact-binding invites. For outbound invite calls,
+       * carries the session-recorded `inviteFriendName`. When null/empty, the
+       * relay uses a neutral "Hi there" greeting instead of substituting the
+       * channel address.
+       */
+      inviteeName: string | null;
     }
   | { action: "name_capture"; assistantId: string; fromNumber: string }
   | {
@@ -128,8 +136,7 @@ export function routeSetup(ctx: SetupContext): {
         action: "invite_redemption" as const,
         assistantId,
         fromNumber: ctx.to,
-        friendName: ctx.session?.inviteFriendName ?? null,
-        guardianName: ctx.session?.inviteGuardianName ?? null,
+        inviteeName: ctx.session?.inviteFriendName ?? null,
       },
       resolved,
     };
@@ -289,13 +296,20 @@ export function routeSetup(ctx: SetupContext): {
         { callSessionId: ctx.callSessionId, from: ctx.from },
         "Inbound voice ACL: unknown caller has active voice invite — entering redemption flow",
       );
+      // Resolve the invitee's name from the bound contact's displayName so
+      // the post-redemption greeting matches what the guardian sees in the
+      // contact graph. `contact_id` is NOT NULL on the invite row, so every
+      // invite is bound — when the contact has no displayName the greeting
+      // falls through to the neutral "Hi there" copy in relay-server.ts
+      // rather than a stale free-text `friend_name` label.
+      const boundContact = getContact(matchedInvite.contactId);
+      const inviteeName = boundContact?.displayName?.trim() || null;
       return {
         outcome: {
           action: "invite_redemption",
           assistantId,
           fromNumber: ctx.from,
-          friendName: matchedInvite.friendName,
-          guardianName: matchedInvite.guardianName,
+          inviteeName: inviteeName ?? null,
         },
         resolved,
       };

package/src/calls/relay-verification.ts

@@ -224,7 +224,8 @@ interface InviteRedemptionParams {
   inviteRedemptionAssistantId: string;
   inviteRedemptionFromNumber: string;
   enteredCode: string;
-  inviteRedemptionGuardianName: string | null;
+  /** Resolved guardian label used in the failure TTS message. */
+  guardianLabel: string;
 }
 
 type InviteRedemptionResult =
@@ -244,17 +245,17 @@ type InviteRedemptionResult =
  * caller. Returns a structured result so the caller can handle state
  * mutations and session updates.
  */
-export function attemptInviteCodeRedemption(
+export async function attemptInviteCodeRedemption(
   params: InviteRedemptionParams,
-): InviteRedemptionResult {
+): Promise<InviteRedemptionResult> {
   const {
     inviteRedemptionAssistantId,
     inviteRedemptionFromNumber,
     enteredCode,
-    inviteRedemptionGuardianName,
+    guardianLabel,
   } = params;
 
-  const result = redeemVoiceInviteCode({
+  const result = await redeemVoiceInviteCode({
     assistantId: inviteRedemptionAssistantId,
     callerExternalUserId: inviteRedemptionFromNumber,
     sourceChannel: "phone",
@@ -270,9 +271,8 @@ export function attemptInviteCodeRedemption(
     };
   }
 
-  const displayGuardian = inviteRedemptionGuardianName ?? "your contact";
   return {
     outcome: "failure",
-    ttsMessage: `Sorry, the code you provided is incorrect or has since expired. Please ask ${displayGuardian} for a new code. Goodbye.`,
+    ttsMessage: `Sorry, the code you provided is incorrect or has since expired. Please ask ${guardianLabel} for a new code. Goodbye.`,
   };
 }

package/src/cli/commands/contacts.ts

@@ -614,22 +614,10 @@ Examples:
         .option("--note <note>", "Optional note")
         .option("--max-uses <n>", "Max redemptions")
         .option("--expires-in-ms <ms>", "Expiry duration in milliseconds")
-        .option(
-          "--contact-name <name>",
-          "Contact name for personalizing instructions",
-        )
         .option(
           "--expected-external-user-id <id>",
           "E.164 phone number (required for voice invites)",
         )
-        .option(
-          "--friend-name <name>",
-          "Friend name (required for voice invites)",
-        )
-        .option(
-          "--guardian-name <name>",
-          "Guardian name (required for voice invites)",
-        )
         .requiredOption(
           "--contact-id <id>",
           "Contact ID to bind the invite to",
@@ -640,20 +628,20 @@ Examples:
 Creates a new invite token for the specified source channel. The --source-channel
 flag is required and must be one of: telegram, phone, email, whatsapp.
 
+The invitee's display name is read from the bound contact (--contact-id);
+the guardian label is resolved at runtime. There are no free-text name flags.
+
 Optional fields:
   --note                        Free-text note attached to the invite
   --max-uses                    Maximum number of times the invite can be redeemed
   --expires-in-ms               Expiry duration in milliseconds from creation
-  --contact-name                Name used to personalize invite instructions
 
-Voice invites require three additional fields:
+Voice invites also require:
   --expected-external-user-id   E.164 phone number of the expected caller (e.g. +15551234567)
-  --friend-name                 Name the contact uses for the assistant's owner
-  --guardian-name                Name of the guardian associated with this invite
 
 Examples:
-  $ assistant contacts invites create --source-channel telegram --note "For Alice" --max-uses 1
-  $ assistant contacts invites create --source-channel phone --expected-external-user-id "+15551234567" --friend-name "Alice" --guardian-name "Bob" --contact-name "Alice Smith"`,
+  $ assistant contacts invites create --source-channel telegram --contact-id <id> --note "For Alice" --max-uses 1
+  $ assistant contacts invites create --source-channel phone --contact-id <id> --expected-external-user-id "+15551234567"`,
         )
         .action(
           async (
@@ -662,10 +650,7 @@ Examples:
               note?: string;
               maxUses?: string;
               expiresInMs?: string;
-              contactName?: string;
               expectedExternalUserId?: string;
-              friendName?: string;
-              guardianName?: string;
               contactId: string;
             },
             cmd: Command,
@@ -704,10 +689,7 @@ Examples:
                 note: opts.note,
                 maxUses,
                 expiresInMs,
-                contactName: opts.contactName,
                 expectedExternalUserId: opts.expectedExternalUserId,
-                friendName: opts.friendName,
-                guardianName: opts.guardianName,
                 contactId: opts.contactId,
               },
             });

package/src/cli/commands/db/__tests__/repair.test.ts

@@ -431,20 +431,29 @@ async function initSchema(): Promise<void> {
   // The repair step opens its own bun:sqlite handle but expects the schema
   // to already exist (production-wise, the daemon creates it). Touching the
   // global init triggers schema creation against the env-isolated path.
-  const { initializeDb } = await import("../../../../memory/db-init.js");
-  initializeDb();
-  // Close the singleton so backfill can open its own handle without
-  // collision. WAL allows concurrent handles but cleaner ownership avoids
-  // test cross-talk through the in-process cache.
   const { getDb, getSqliteFrom } =
     await import("../../../../memory/db-connection.js");
   const { clearStoredDb } = await import("../../../../memory/db-singleton.js");
+  // Drop any connections a prior test (or test file) left open against a
+  // now-deleted workspace, so init below opens fresh handles — main and the
+  // dedicated logs/memory connections — at THIS test's workspace.
+  clearStoredDb("main");
+  clearStoredDb("logs");
+  clearStoredDb("memory");
+
+  const { initializeDb } = await import("../../../../memory/db-init.js");
+  await initializeDb();
+  // Close the singletons so backfill can open its own handle without
+  // collision. WAL allows concurrent handles but cleaner ownership avoids
+  // test cross-talk through the in-process cache.
   try {
     getSqliteFrom(getDb()).close();
   } catch {
     /* already closed */
   }
-  clearStoredDb();
+  clearStoredDb("main");
+  clearStoredDb("logs");
+  clearStoredDb("memory");
 }
 
 describe("assistant db repair — conversation-backfill step", () => {