@vellumai/assistant 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/anthropic-provider.test.ts

@@ -102,7 +102,6 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/system-prompt.js";
 import {
   AnthropicProvider,
   isPlaceholderSentinelText,
@@ -228,28 +227,8 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(assistant?.content).toEqual([{ type: "text", text: "I can help." }]);
   });
 
-  test("splits system prompt into two cache blocks on boundary marker", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const dynamicBlock = "User workspace files here.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
-
-    const system = lastStreamParams!.system as Array<{
-      type: string;
-      text: string;
-      cache_control?: { type: string; ttl?: string };
-    }>;
-    expect(system).toHaveLength(2);
-    expect(system[0].text).toBe(staticBlock);
-    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-    expect(system[1].text).toBe(dynamicBlock);
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-  });
-
-  test("omits empty dynamic system block after cache boundary", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY;
+  test("renders the system prompt as a single 1h-cached block", async () => {
+    const prompt = "You are a helpful assistant.";
 
     await provider.sendMessage([userMsg("Hi")], undefined, prompt);
 
@@ -259,16 +238,14 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       cache_control?: { type: string; ttl?: string };
     }>;
     expect(system).toHaveLength(1);
-    expect(system[0].text).toBe(staticBlock);
+    expect(system[0].text).toBe(prompt);
     expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
-  test("drops static system block cache_control when total would exceed 4", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const dynamicBlock = "User workspace files here.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    // Boundary (2 system) + tools (1) + turn-start (1) + tail (1) = 5 → must cap at 4
+  test("applies the standard 4-breakpoint cache layout in a tool-use loop", async () => {
+    // system(1) + tools(1) + turn-start(1) + tail(1) = 4, the Anthropic
+    // per-request cap.  All four breakpoints should be present.
+    const prompt = "You are a helpful assistant.";
     const messages: Message[] = [
       userMsg("Do something"),
       toolUseMsg("tu_1", "bash"),
@@ -281,13 +258,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       text: string;
       cache_control?: { type: string; ttl?: string };
     }>;
-    expect(system).toHaveLength(2);
-    // Static block's cache_control dropped (small, cheap to re-read)
-    expect(system[0].cache_control).toBeUndefined();
-    // Dynamic block keeps its cache_control
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(system).toHaveLength(1);
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
-    // Tools breakpoint still present
     const tools = lastStreamParams!.tools as Array<{
       cache_control?: { type: string; ttl?: string };
     }>;
@@ -296,7 +269,6 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       ttl: "1h",
     });
 
-    // Turn-start + tail breakpoints still present
     const sent = lastStreamParams!.messages as Array<{
       role: string;
       content: Array<{
@@ -432,6 +404,31 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("disableTurnStartCache suppresses the 1h breakpoint on the turn-starting user message", async () => {
+    // One-shot callers (e.g. the memory router) send a single user message
+    // per call with content that changes every time. Caching the turn-start
+    // block would create unused entries — `disableTurnStartCache: true`
+    // opts out.
+    await provider.sendMessage(
+      [userMsg("Pick relevant pages")],
+      undefined,
+      undefined,
+      {
+        config: { disableTurnStartCache: true },
+      },
+    );
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toBeUndefined();
+  });
+
   test("previous-turn anchor is NOT applied during a tool-use loop", async () => {
     // When the request is mid tool-use (last msg is a tool_result), the
     // turn-start anchor already covers the long prefix, so we must not

package/src/__tests__/assistant-event-hub-self-exclusion.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Tests for self-echo suppression in `AssistantEventHub`.
+ *
+ * Validates:
+ *   - hub.publish(event, { excludeClientId }) skips the matching client
+ *     subscriber and delivers to every other matching subscriber.
+ *   - Suppression is unconditional: it applies whether the broadcast is
+ *     untargeted, conversation-scoped, or capability-targeted.
+ *   - `broadcastMessage(sync_changed { originClientId })` derives the
+ *     exclusion from the message itself — no caller wiring needed.
+ *   - `broadcastMessage(sync_changed)` without an originClientId fans out
+ *     to every subscriber (the daemon-internal emit path).
+ *   - Process-type subscribers are never excluded by a clientId match.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import {
+  AssistantEventHub,
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+
+function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
+  return {
+    id: "evt_test_sync",
+    conversationId: undefined,
+    emittedAt: "2026-05-03T00:00:00.000Z",
+    message: {
+      type: "sync_changed",
+      tags: ["conversation:abc:messages"],
+      ...(originClientId ? { originClientId } : {}),
+    },
+  };
+}
+
+describe("AssistantEventHub — self-echo suppression (excludeClientId)", () => {
+  test("skips the named client and delivers to every other client", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+    const receivedC: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-c",
+      interfaceId: "macos",
+      capabilities: [],
+      callback: (e) => {
+        receivedC.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+    expect(receivedC).toHaveLength(1);
+  });
+
+  test("delivers to every subscriber when excludeClientId is omitted", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent());
+
+    expect(receivedA).toHaveLength(1);
+    expect(receivedB).toHaveLength(1);
+  });
+
+  test("excludeClientId does not match process-type subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedProcess: AssistantEvent[] = [];
+
+    // A process subscriber sits in the same hub as a client whose id
+    // matches `excludeClientId`. It must never be suppressed because
+    // `excludeClientId` only matches `type: "client"` entries — process
+    // entries have no `clientId` field at all.
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        receivedProcess.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedProcess).toHaveLength(1);
+  });
+
+  test("excludeClientId composes with conversation-scoped subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    // Scoped event for sess_x; both clients filter to sess_x; exclude A.
+    const event: AssistantEvent = {
+      id: "evt_scoped",
+      conversationId: "sess_x",
+      emittedAt: "2026-05-03T00:00:00.000Z",
+      message: {
+        type: "sync_changed",
+        tags: ["conversation:sess_x:messages"],
+        originClientId: "client-a",
+      },
+    };
+
+    await hub.publish(event, { excludeClientId: "client-a" });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+  });
+});
+
+describe("broadcastMessage — derives excludeClientId from sync_changed.originClientId", () => {
+  test("skips the originating client when originClientId is present", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        originClientId: "broadcast-a",
+      });
+      // broadcastMessage queues onto a microtask chain — yield until it
+      // drains. Two awaits cover the publish promise + its `.then` chain.
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(0);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("fans out to every client when originClientId is absent", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-c",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-d",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("ignores an empty-string originClientId (treats as absent)", async () => {
+    const receivedA: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-e",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        // Exercise the length-zero guard. `originClientId?: string` accepts
+        // empty strings at the type level, but production code path can't
+        // produce one — `buildSyncChangedMessage` trims and drops empty
+        // values before calling `broadcastMessage`.
+        originClientId: "",
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+    } finally {
+      subA.dispose();
+    }
+  });
+});

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -4,7 +4,7 @@
  * Covers:
  *   - Missing persisted value falls back to code default
  *   - Protected feature-flags.json is the sole override mechanism
- *   - Undeclared keys default to enabled
+ *   - Undeclared keys default to disabled
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -80,10 +80,10 @@ describe("isAssistantFeatureFlagEnabled", () => {
     ).toBe(true);
   });
 
-  test("unknown flag defaults to true when no persisted override", () => {
+  test("unknown flag defaults to false when no persisted override", () => {
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(false);
   });
 
   test("undeclared flag respects persisted override", () => {

package/src/__tests__/audit-log-rotation.test.ts

@@ -69,72 +69,126 @@ describe("audit log rotation", () => {
     clearTable();
   });
 
-  test("returns 0 when retentionDays is 0 (retain forever)", () => {
+  test("returns 0 when retentionDays is 0 (retain forever)", async () => {
     addInvocation(100 * ONE_DAY_MS); // 100 days old
-    const deleted = rotateToolInvocations(0);
+    const deleted = await rotateToolInvocations(0);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("returns 0 when retentionDays is negative", () => {
+  test("returns 0 when retentionDays is negative", async () => {
     addInvocation(100 * ONE_DAY_MS);
-    const deleted = rotateToolInvocations(-5);
+    const deleted = await rotateToolInvocations(-5);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("deletes records older than retentionDays", () => {
+  test("deletes records older than retentionDays", async () => {
     addInvocation(10 * ONE_DAY_MS); // 10 days old — should be deleted with 7-day retention
     addInvocation(3 * ONE_DAY_MS); // 3 days old — should be kept
     addInvocation(1 * ONE_DAY_MS); // 1 day old — should be kept
 
-    const deleted = rotateToolInvocations(7);
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(2);
   });
 
-  test("keeps all records when none exceed retention", () => {
+  test("keeps all records when none exceed retention", async () => {
     addInvocation(1 * ONE_DAY_MS);
     addInvocation(2 * ONE_DAY_MS);
     addInvocation(3 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(3);
   });
 
-  test("deletes all records when all exceed retention", () => {
+  test("deletes all records when all exceed retention", async () => {
     addInvocation(60 * ONE_DAY_MS);
     addInvocation(90 * ONE_DAY_MS);
     addInvocation(120 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(3);
     expect(getRecentInvocations(100).length).toBe(0);
   });
 
-  test("returns 0 when table is empty", () => {
-    const deleted = rotateToolInvocations(7);
+  test("returns 0 when table is empty", async () => {
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(0);
   });
 
-  test("handles 1-day retention (deletes everything older than 24h)", () => {
+  test("handles 1-day retention (deletes everything older than 24h)", async () => {
     addInvocation(2 * ONE_DAY_MS); // 2 days old — delete
     addInvocation(12 * 60 * 60 * 1000); // 12 hours old — keep
 
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("works with recordToolInvocation (via ORM)", () => {
+  test("works with recordToolInvocation (via ORM)", async () => {
     // Use raw SQL to insert (avoids db singleton issues in parallel test runs)
     // and verify the rotation/query functions work correctly with it
     addInvocation(0); // just-created record
 
     // This record was just created, so it should not be rotated
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
+
+  test(
+    "yields to the event loop while the purge is in flight (anti-block)",
+    async () => {
+      // Seed a few thousand rows so the DELETE has measurable
+      // subprocess work behind the scenes.
+      const ROW_COUNT = 2000;
+      const past = 100 * ONE_DAY_MS;
+      const sqlite = getSqlite();
+      sqlite.exec("BEGIN");
+      try {
+        for (let i = 0; i < ROW_COUNT; i++) {
+          addInvocation(past);
+        }
+        sqlite.exec("COMMIT");
+      } catch (err) {
+        sqlite.exec("ROLLBACK");
+        throw err;
+      }
+
+      // Race the purge against a `setImmediate` ping. The ping
+      // resolves on the very next event-loop iteration after it is
+      // scheduled.
+      //
+      // If the purge is async (subprocess), `rotateToolInvocations`
+      // returns a pending Promise immediately; the ping wins the race
+      // while the subprocess is still running.
+      //
+      // If the purge is ever regressed back to a synchronous DELETE,
+      // `rotateToolInvocations` blocks the main thread for the full
+      // DELETE duration. `setImmediate` cannot fire until the main
+      // thread releases, so the purge's already-resolved Promise
+      // beats the ping through the microtask queue and "purge" wins.
+      //
+      // The signal is deterministic regardless of how fast the
+      // subprocess is or how busy the event loop is.
+      const ping = new Promise<"ping">((resolve) =>
+        setImmediate(() => resolve("ping")),
+      );
+      const purgePromise = rotateToolInvocations(7);
+      const winner = await Promise.race([
+        ping,
+        purgePromise.then(() => "purge" as const),
+      ]);
+
+      expect(winner).toBe("ping");
+
+      // Drain the purge so the log + subprocess cleanup complete
+      // before the test exits.
+      const deleted = await purgePromise;
+      expect(deleted).toBe(ROW_COUNT);
+    },
+    60_000,
+  );
 });

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -108,7 +108,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
   batchSetDisplayOrders: mock(() => {}),
-  clearStrippedInjectionMetadataForConversation: mock(() => {}),
   createConversation: (opts: { conversationType: string }) => {
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };
@@ -116,7 +115,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   countConversationsByScheduleJobId: mock(() => 0),
   countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
-  clearAll: mock(() => ({ conversations: 0, messages: 0 })),
+  clearAll: mock(async () => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
@@ -156,7 +155,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: mock(() => {}),
   updateConversationUsage: mock(() => {}),
   setLastNotifiedInferenceProfile: mock(() => {}),
-  setConversationCleanedAt: mock(() => {}),
+  setConversationHistoryStrippedAt: mock(() => {}),
   wipeConversation: mock(() => ({ memoryIds: [] })),
 }));
 
@@ -182,6 +181,7 @@ mock.module("../memory/jobs-store.js", () => ({
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
   hasActiveJobOfType: mock(() => false),
+  isMemoryEnabled: () => true,
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),

package/src/__tests__/btw-routes.test.ts

@@ -317,12 +317,11 @@ describe("POST /v1/btw", () => {
 
     expect(tools).toEqual(MOCK_TOOLS);
     expect(systemPrompt).toBe(MOCK_SYSTEM_PROMPT);
+    // Persona is resolved internally now; btw-routes no longer plumbs
+    // it through to buildSystemPrompt.
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
-      channelPersona: null,
       excludeBootstrap: true,
       excludeCustomPrefix: true,
-      userPersona: null,
-      userSlug: null,
     });
     expect(options!.config!.tool_choice).toEqual({ type: "none" });
     expect(options!.config!.callSite).toBe("identityIntro");

package/src/__tests__/call-controller.test.ts

@@ -166,7 +166,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     reason: "mocked",
     deliveryResults: [],
   }),
-  registerBroadcastFn: () => {},
 }));
 
 mock.module("../calls/voice-session-bridge.js", () => {

package/src/__tests__/cancel-resolves-conversation-key.test.ts

@@ -49,7 +49,7 @@ mock.module("../daemon/handlers/conversations.js", () => ({
     return true;
   },
   switchConversation: async () => null,
-  clearAllConversations: () => 0,
+  clearAllConversations: async () => 0,
   undoLastMessage: async () => null,
   regenerateResponse: async () => null,
 }));

package/src/__tests__/channel-guardian.test.ts

@@ -2777,7 +2777,7 @@ describe("outbound voice verification", () => {
     }
   });
 
-  test("start_outbound rejects unsupported channels", async () => {
+  test("start_outbound succeeds for email channel", async () => {
     const { lastResponse } = createResponseReader();
     await handleChannelVerificationSession(
       {
@@ -2790,8 +2790,8 @@ describe("outbound voice verification", () => {
 
     const resp = lastResponse();
     expect(resp).not.toBeNull();
-    expect(resp!.success).toBe(false);
-    expect(resp!.error).toBe("unsupported_channel");
+    expect(resp!.success).toBe(true);
+    expect(resp!.channel).toBe("email");
   });
 
   test("create_session without destination falls through to inbound challenge", async () => {