@vellumai/assistant 0.4.15 → 0.4.17

package/src/__tests__/guardian-routing-state.test.ts

@@ -1,56 +1,59 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
-import { eq } from 'drizzle-orm';
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+import { eq } from "drizzle-orm";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
 
-const testDir = mkdtempSync(join(tmpdir(), 'guardian-routing-state-test-'));
+const testDir = mkdtempSync(join(tmpdir(), "guardian-routing-state-test-"));
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 // Mock security check to always pass
-mock.module('../security/secret-ingress.js', () => ({
+mock.module("../security/secret-ingress.js", () => ({
   checkIngressForSecrets: () => ({ blocked: false }),
 }));
 
 // Mock ingress member store with a configurable member lookup.
 // By default returns an active member so ACL passes.
 let mockFindMember: (() => unknown) | null = null;
-mock.module('../memory/ingress-member-store.js', () => ({
+mock.module("../memory/ingress-member-store.js", () => ({
   findMember: (..._args: unknown[]) => {
     if (mockFindMember) return mockFindMember();
     return {
-      id: 'member-test-default',
-      assistantId: 'self',
-      sourceChannel: 'telegram',
-      externalUserId: 'telegram-user-default',
+      id: "member-test-default",
+      assistantId: "self",
+      sourceChannel: "telegram",
+      externalUserId: "telegram-user-default",
       externalChatId: null,
       displayName: null,
       username: null,
-      status: 'active',
-      policy: 'allow',
+      status: "active",
+      policy: "allow",
       inviteId: null,
       createdBySessionId: null,
       revokedReason: null,
@@ -64,49 +67,53 @@ mock.module('../memory/ingress-member-store.js', () => ({
   upsertMember: () => {},
 }));
 
-import * as channelDeliveryStore from '../memory/channel-delivery-store.js';
-import { createBinding } from '../memory/channel-guardian-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
-import { channelInboundEvents, messages } from '../memory/schema.js';
-import { sweepFailedEvents } from '../runtime/channel-retry-sweep.js';
+import * as channelDeliveryStore from "../memory/channel-delivery-store.js";
+import { createBinding } from "../memory/channel-guardian-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { channelInboundEvents, messages } from "../memory/schema.js";
+import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
 import {
   type GuardianContext,
   resolveRoutingState,
   resolveRoutingStateFromRuntime,
-} from '../runtime/guardian-context-resolver.js';
-import { handleChannelInbound } from '../runtime/routes/channel-routes.js';
+} from "../runtime/guardian-context-resolver.js";
+import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 
 initializeDb();
 
 afterAll(() => {
   resetDb();
-  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
 });
 
 function resetTables(): void {
   const db = getDb();
-  db.run('DELETE FROM channel_inbound_events');
-  db.run('DELETE FROM channel_guardian_bindings');
-  db.run('DELETE FROM channel_guardian_approval_requests');
-  db.run('DELETE FROM canonical_guardian_requests');
-  db.run('DELETE FROM conversation_keys');
-  db.run('DELETE FROM messages');
-  db.run('DELETE FROM conversations');
-  db.run('DELETE FROM assistant_ingress_members');
-  db.run('DELETE FROM external_conversation_bindings');
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM channel_guardian_bindings");
+  db.run("DELETE FROM channel_guardian_approval_requests");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM assistant_ingress_members");
+  db.run("DELETE FROM external_conversation_bindings");
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Unit tests: resolveRoutingState
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('resolveRoutingState', () => {
-  test('guardian actors are always interactive and route-resolvable', () => {
+describe("resolveRoutingState", () => {
+  test("guardian actors are always interactive and route-resolvable", () => {
     const ctx: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'guardian',
-      guardianExternalUserId: 'guardian-123',
-      guardianChatId: 'chat-123',
+      sourceChannel: "telegram",
+      trustClass: "guardian",
+      guardianExternalUserId: "guardian-123",
+      guardianChatId: "chat-123",
     };
     const state = resolveRoutingState(ctx);
     expect(state).toEqual({
@@ -116,23 +123,23 @@ describe('resolveRoutingState', () => {
     });
   });
 
-  test('guardian actors are interactive even without guardianExternalUserId', () => {
+  test("guardian actors are interactive even without guardianExternalUserId", () => {
     // Edge case: guardian is chatting in their own chat, no separate binding needed
     const ctx: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'guardian',
+      sourceChannel: "telegram",
+      trustClass: "guardian",
     };
     const state = resolveRoutingState(ctx);
     expect(state.canBeInteractive).toBe(true);
     expect(state.promptWaitingAllowed).toBe(true);
   });
 
-  test('trusted contact with resolvable guardian route is interactive', () => {
+  test("trusted contact with resolvable guardian route is interactive", () => {
     const ctx: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'trusted_contact',
-      guardianExternalUserId: 'guardian-456',
-      guardianChatId: 'guardian-chat-456',
+      sourceChannel: "telegram",
+      trustClass: "trusted_contact",
+      guardianExternalUserId: "guardian-456",
+      guardianChatId: "guardian-chat-456",
     };
     const state = resolveRoutingState(ctx);
     expect(state).toEqual({
@@ -142,10 +149,10 @@ describe('resolveRoutingState', () => {
     });
   });
 
-  test('trusted contact without guardian route is NOT interactive (fail-fast)', () => {
+  test("trusted contact without guardian route is NOT interactive (fail-fast)", () => {
     const ctx: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'trusted_contact',
+      sourceChannel: "telegram",
+      trustClass: "trusted_contact",
       // No guardianExternalUserId — no guardian binding for this channel
     };
     const state = resolveRoutingState(ctx);
@@ -156,15 +163,15 @@ describe('resolveRoutingState', () => {
     });
   });
 
-  test('unknown actors are never interactive regardless of guardian route', () => {
+  test("unknown actors are never interactive regardless of guardian route", () => {
     const withRoute: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'unknown',
-      guardianExternalUserId: 'guardian-789',
+      sourceChannel: "telegram",
+      trustClass: "unknown",
+      guardianExternalUserId: "guardian-789",
     };
     const withoutRoute: GuardianContext = {
-      sourceChannel: 'telegram',
-      trustClass: 'unknown',
+      sourceChannel: "telegram",
+      trustClass: "unknown",
     };
 
     expect(resolveRoutingState(withRoute).promptWaitingAllowed).toBe(false);
@@ -173,22 +180,22 @@ describe('resolveRoutingState', () => {
   });
 });
 
-describe('resolveRoutingStateFromRuntime', () => {
-  test('produces same result as resolveRoutingState for guardian runtime context', () => {
+describe("resolveRoutingStateFromRuntime", () => {
+  test("produces same result as resolveRoutingState for guardian runtime context", () => {
     const runtimeCtx = {
-      sourceChannel: 'telegram' as const,
-      trustClass: 'trusted_contact' as const,
-      guardianExternalUserId: 'guardian-rt-1',
+      sourceChannel: "telegram" as const,
+      trustClass: "trusted_contact" as const,
+      guardianExternalUserId: "guardian-rt-1",
     };
     const state = resolveRoutingStateFromRuntime(runtimeCtx);
     expect(state.promptWaitingAllowed).toBe(true);
     expect(state.guardianRouteResolvable).toBe(true);
   });
 
-  test('trusted contact runtime context without guardian binding is not interactive', () => {
+  test("trusted contact runtime context without guardian binding is not interactive", () => {
     const runtimeCtx = {
-      sourceChannel: 'telegram' as const,
-      trustClass: 'trusted_contact' as const,
+      sourceChannel: "telegram" as const,
+      trustClass: "trusted_contact" as const,
       // No guardianExternalUserId
     };
     const state = resolveRoutingStateFromRuntime(runtimeCtx);
@@ -201,68 +208,78 @@ describe('resolveRoutingStateFromRuntime', () => {
 // Integration tests: inbound message handler interactivity
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('inbound-message-handler trusted-contact interactivity', () => {
+describe("inbound-message-handler trusted-contact interactivity", () => {
   beforeEach(() => {
     resetTables();
     mockFindMember = null;
   });
 
-  function makeInboundRequest(overrides: Record<string, unknown> = {}): Request {
-    return new Request('http://localhost/channels/inbound', {
-      method: 'POST',
+  function makeInboundRequest(
+    overrides: Record<string, unknown> = {},
+  ): Request {
+    return new Request("http://localhost/channels/inbound", {
+      method: "POST",
       headers: {
-        'Content-Type': 'application/json',
-        'X-Gateway-Origin': 'test-token',
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": "test-token",
       },
       body: JSON.stringify({
-        sourceChannel: 'telegram',
-        interface: 'telegram',
-        conversationExternalId: 'chat-123',
+        sourceChannel: "telegram",
+        interface: "telegram",
+        conversationExternalId: "chat-123",
         externalMessageId: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-        content: 'hello',
-        actorExternalId: 'telegram-user-default',
-        replyCallbackUrl: 'https://gateway.test/deliver/telegram',
+        content: "hello",
+        actorExternalId: "telegram-user-default",
+        replyCallbackUrl: "https://gateway.test/deliver/telegram",
         ...overrides,
       }),
     });
   }
 
-  test('trusted contact with guardian binding gets interactive turn', async () => {
+  test("trusted contact with guardian binding gets interactive turn", async () => {
     // Create guardian binding so the trusted contact has a resolvable route
     createBinding({
-      assistantId: 'self',
-      channel: 'telegram',
-      guardianExternalUserId: 'guardian-user-for-tc',
-      guardianDeliveryChatId: 'guardian-chat-for-tc',
-      guardianPrincipalId: 'guardian-user-for-tc',
+      assistantId: "self",
+      channel: "telegram",
+      guardianExternalUserId: "guardian-user-for-tc",
+      guardianDeliveryChatId: "guardian-chat-for-tc",
+      guardianPrincipalId: "guardian-user-for-tc",
     });
 
     const processCalls: Array<{ options?: Record<string, unknown> }> = [];
-    const processMessage = mock(async (
-      conversationId: string,
-      _content: string,
-      _attachmentIds?: string[],
-      options?: Record<string, unknown>,
-    ) => {
-      processCalls.push({ options });
-      const messageId = `msg-tc-interactive-${Date.now()}`;
-      const db = getDb();
-      db.insert(messages).values({
-        id: messageId,
-        conversationId,
-        role: 'user',
-        content: JSON.stringify([{ type: 'text', text: 'hello' }]),
-        createdAt: Date.now(),
-      }).run();
-      return { messageId };
-    });
+    const processMessage = mock(
+      async (
+        conversationId: string,
+        _content: string,
+        _attachmentIds?: string[],
+        options?: Record<string, unknown>,
+      ) => {
+        processCalls.push({ options });
+        const messageId = `msg-tc-interactive-${Date.now()}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "hello" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      },
+    );
 
     const req = makeInboundRequest({
       externalMessageId: `msg-tc-interactive-${Date.now()}`,
     });
 
-    const res = await handleChannelInbound(req, processMessage as any, 'test-token');
-    const body = await res.json() as Record<string, unknown>;
+    const res = await handleChannelInbound(
+      req,
+      processMessage as any,
+      "test-token",
+    );
+    const body = (await res.json()) as Record<string, unknown>;
     expect(body.accepted).toBe(true);
 
     // Wait for background processing
@@ -272,36 +289,44 @@ describe('inbound-message-handler trusted-contact interactivity', () => {
     expect(processCalls[0].options?.isInteractive).toBe(true);
   });
 
-  test('trusted contact WITHOUT guardian binding gets non-interactive turn (fail-fast)', async () => {
+  test("trusted contact WITHOUT guardian binding gets non-interactive turn (fail-fast)", async () => {
     // No guardian binding created — trusted contact has no guardian route
     // but findMember still returns an active member (trusted_contact trust class)
 
     const processCalls: Array<{ options?: Record<string, unknown> }> = [];
-    const processMessage = mock(async (
-      conversationId: string,
-      _content: string,
-      _attachmentIds?: string[],
-      options?: Record<string, unknown>,
-    ) => {
-      processCalls.push({ options });
-      const messageId = `msg-tc-noroute-${Date.now()}`;
-      const db = getDb();
-      db.insert(messages).values({
-        id: messageId,
-        conversationId,
-        role: 'user',
-        content: JSON.stringify([{ type: 'text', text: 'hello' }]),
-        createdAt: Date.now(),
-      }).run();
-      return { messageId };
-    });
+    const processMessage = mock(
+      async (
+        conversationId: string,
+        _content: string,
+        _attachmentIds?: string[],
+        options?: Record<string, unknown>,
+      ) => {
+        processCalls.push({ options });
+        const messageId = `msg-tc-noroute-${Date.now()}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "hello" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      },
+    );
 
     const req = makeInboundRequest({
       externalMessageId: `msg-tc-noroute-${Date.now()}`,
     });
 
-    const res = await handleChannelInbound(req, processMessage as any, 'test-token');
-    const body = await res.json() as Record<string, unknown>;
+    const res = await handleChannelInbound(
+      req,
+      processMessage as any,
+      "test-token",
+    );
+    const body = (await res.json()) as Record<string, unknown>;
     expect(body.accepted).toBe(true);
 
     await new Promise((resolve) => setTimeout(resolve, 300));
@@ -312,42 +337,50 @@ describe('inbound-message-handler trusted-contact interactivity', () => {
     expect(processCalls[0].options?.isInteractive).toBe(false);
   });
 
-  test('guardian actors remain interactive regardless', async () => {
+  test("guardian actors remain interactive regardless", async () => {
     // Guardian binding matches the sender
     createBinding({
-      assistantId: 'self',
-      channel: 'telegram',
-      guardianExternalUserId: 'telegram-user-default',
-      guardianDeliveryChatId: 'chat-123',
-      guardianPrincipalId: 'telegram-user-default',
+      assistantId: "self",
+      channel: "telegram",
+      guardianExternalUserId: "telegram-user-default",
+      guardianDeliveryChatId: "chat-123",
+      guardianPrincipalId: "telegram-user-default",
     });
 
     const processCalls: Array<{ options?: Record<string, unknown> }> = [];
-    const processMessage = mock(async (
-      conversationId: string,
-      _content: string,
-      _attachmentIds?: string[],
-      options?: Record<string, unknown>,
-    ) => {
-      processCalls.push({ options });
-      const messageId = `msg-guardian-${Date.now()}`;
-      const db = getDb();
-      db.insert(messages).values({
-        id: messageId,
-        conversationId,
-        role: 'user',
-        content: JSON.stringify([{ type: 'text', text: 'hello' }]),
-        createdAt: Date.now(),
-      }).run();
-      return { messageId };
-    });
+    const processMessage = mock(
+      async (
+        conversationId: string,
+        _content: string,
+        _attachmentIds?: string[],
+        options?: Record<string, unknown>,
+      ) => {
+        processCalls.push({ options });
+        const messageId = `msg-guardian-${Date.now()}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "hello" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      },
+    );
 
     const req = makeInboundRequest({
       externalMessageId: `msg-guardian-${Date.now()}`,
     });
 
-    const res = await handleChannelInbound(req, processMessage as any, 'test-token');
-    const body = await res.json() as Record<string, unknown>;
+    const res = await handleChannelInbound(
+      req,
+      processMessage as any,
+      "test-token",
+    );
+    const body = (await res.json()) as Record<string, unknown>;
     expect(body.accepted).toBe(true);
 
     await new Promise((resolve) => setTimeout(resolve, 300));
@@ -356,22 +389,22 @@ describe('inbound-message-handler trusted-contact interactivity', () => {
     expect(processCalls[0].options?.isInteractive).toBe(true);
   });
 
-  test('unknown actors remain non-interactive (denied at gate)', async () => {
+  test("unknown actors remain non-interactive (denied at gate)", async () => {
     // No member record => non-member denied at the ACL gate,
     // which is the strongest form of "not interactive".
     mockFindMember = () => null;
 
     const req = makeInboundRequest({
       externalMessageId: `msg-unknown-${Date.now()}`,
-      actorExternalId: 'unknown-user-no-member',
+      actorExternalId: "unknown-user-no-member",
     });
 
-    const res = await handleChannelInbound(req, undefined, 'test-token');
-    const body = await res.json() as Record<string, unknown>;
+    const res = await handleChannelInbound(req, undefined, "test-token");
+    const body = (await res.json()) as Record<string, unknown>;
     // Unknown actors are ACL-denied: accepted but denied with reason
     expect(body.accepted).toBe(true);
     expect(body.denied).toBe(true);
-    expect(body.reason).toBe('not_a_member');
+    expect(body.reason).toBe("not_a_member");
   });
 });
 
@@ -379,22 +412,29 @@ describe('inbound-message-handler trusted-contact interactivity', () => {
 // Integration tests: channel-retry-sweep routing state
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('channel-retry-sweep routing state', () => {
+describe("channel-retry-sweep routing state", () => {
   beforeEach(() => {
     resetTables();
     mockFindMember = null;
   });
 
-  function seedFailedEvent(trustClass: 'guardian' | 'trusted_contact' | 'unknown', guardianExternalUserId?: string): string {
-    const inbound = channelDeliveryStore.recordInbound('telegram', `chat-${trustClass}`, `msg-${trustClass}-${Date.now()}`);
+  function seedFailedEvent(
+    trustClass: "guardian" | "trusted_contact" | "unknown",
+    guardianExternalUserId?: string,
+  ): string {
+    const inbound = channelDeliveryStore.recordInbound(
+      "telegram",
+      `chat-${trustClass}`,
+      `msg-${trustClass}-${Date.now()}`,
+    );
     channelDeliveryStore.storePayload(inbound.eventId, {
-      content: 'retry me',
-      sourceChannel: 'telegram',
-      interface: 'telegram',
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
       guardianCtx: {
         trustClass,
-        sourceChannel: 'telegram',
-        requesterExternalUserId: 'test-user',
+        sourceChannel: "telegram",
+        requesterExternalUserId: "test-user",
         requesterChatId: `chat-${trustClass}`,
         ...(guardianExternalUserId ? { guardianExternalUserId } : {}),
       },
@@ -403,7 +443,7 @@ describe('channel-retry-sweep routing state', () => {
     const db = getDb();
     db.update(channelInboundEvents)
       .set({
-        processingStatus: 'failed',
+        processingStatus: "failed",
         processingAttempts: 1,
         retryAfter: Date.now() - 1,
       })
@@ -413,8 +453,8 @@ describe('channel-retry-sweep routing state', () => {
     return inbound.eventId;
   }
 
-  test('trusted_contact with guardian binding replays as interactive', async () => {
-    seedFailedEvent('trusted_contact', 'guardian-for-sweep');
+  test("trusted_contact with guardian binding replays as interactive", async () => {
+    seedFailedEvent("trusted_contact", "guardian-for-sweep");
     let capturedOptions: { isInteractive?: boolean } | undefined;
 
     await sweepFailedEvents(
@@ -422,13 +462,15 @@ describe('channel-retry-sweep routing state', () => {
         capturedOptions = options as { isInteractive?: boolean };
         const messageId = `message-tc-sweep-${Date.now()}`;
         const db = getDb();
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,
@@ -437,8 +479,8 @@ describe('channel-retry-sweep routing state', () => {
     expect(capturedOptions?.isInteractive).toBe(true);
   });
 
-  test('trusted_contact without guardian binding replays as non-interactive', async () => {
-    seedFailedEvent('trusted_contact');
+  test("trusted_contact without guardian binding replays as non-interactive", async () => {
+    seedFailedEvent("trusted_contact");
     let capturedOptions: { isInteractive?: boolean } | undefined;
 
     await sweepFailedEvents(
@@ -446,13 +488,15 @@ describe('channel-retry-sweep routing state', () => {
         capturedOptions = options as { isInteractive?: boolean };
         const messageId = `message-tc-no-binding-${Date.now()}`;
         const db = getDb();
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,
@@ -461,8 +505,8 @@ describe('channel-retry-sweep routing state', () => {
     expect(capturedOptions?.isInteractive).toBe(false);
   });
 
-  test('guardian replays as interactive', async () => {
-    seedFailedEvent('guardian', 'guardian-self');
+  test("guardian replays as interactive", async () => {
+    seedFailedEvent("guardian", "guardian-self");
     let capturedOptions: { isInteractive?: boolean } | undefined;
 
     await sweepFailedEvents(
@@ -470,13 +514,15 @@ describe('channel-retry-sweep routing state', () => {
         capturedOptions = options as { isInteractive?: boolean };
         const messageId = `message-guardian-sweep-${Date.now()}`;
         const db = getDb();
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,
@@ -485,8 +531,8 @@ describe('channel-retry-sweep routing state', () => {
     expect(capturedOptions?.isInteractive).toBe(true);
   });
 
-  test('unknown replays as non-interactive', async () => {
-    seedFailedEvent('unknown');
+  test("unknown replays as non-interactive", async () => {
+    seedFailedEvent("unknown");
     let capturedOptions: { isInteractive?: boolean } | undefined;
 
     await sweepFailedEvents(
@@ -494,13 +540,15 @@ describe('channel-retry-sweep routing state', () => {
         capturedOptions = options as { isInteractive?: boolean };
         const messageId = `message-unknown-sweep-${Date.now()}`;
         const db = getDb();
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,