@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/credentials-cli.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
 
@@ -93,7 +93,6 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
       usageDescription?: string;
       expiresAt?: number | null;
       grantedScopes?: string[];
-      accountInfo?: string | null;
       alias?: string | null;
       injectionTemplates?: unknown[] | null;
     },
@@ -168,7 +167,8 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 // Import the module under test (after mocks are registered)
 // ---------------------------------------------------------------------------
 
-const { registerCredentialsCommand } = await import("../cli/credentials.js");
+const { registerCredentialsCommand } =
+  await import("../cli/commands/credentials.js");
 
 // ---------------------------------------------------------------------------
 // Test helper
@@ -317,7 +317,6 @@ describe("assistant credentials CLI", () => {
         expect(cred).toHaveProperty("usageDescription");
         expect(cred).toHaveProperty("allowedTools");
         expect(cred).toHaveProperty("allowedDomains");
-        expect(cred).toHaveProperty("accountInfo");
         expect(cred).toHaveProperty("grantedScopes");
         expect(cred).toHaveProperty("expiresAt");
         expect(cred).toHaveProperty("createdAt");
@@ -634,7 +633,6 @@ describe("assistant credentials CLI", () => {
       expect(parsed).toHaveProperty("usageDescription");
       expect(parsed).toHaveProperty("allowedTools");
       expect(parsed).toHaveProperty("allowedDomains");
-      expect(parsed).toHaveProperty("accountInfo");
       expect(parsed).toHaveProperty("grantedScopes");
       expect(parsed).toHaveProperty("expiresAt");
       expect(parsed).toHaveProperty("injectionTemplateCount");
@@ -796,6 +794,52 @@ describe("assistant credentials CLI", () => {
     });
   });
 
+  // =========================================================================
+  // instance-scoped BASE_DATA_DIR
+  // =========================================================================
+
+  describe("instance-scoped BASE_DATA_DIR", () => {
+    let savedBaseDataDir: string | undefined;
+
+    beforeEach(() => {
+      savedBaseDataDir = process.env.BASE_DATA_DIR;
+    });
+
+    afterEach(() => {
+      if (savedBaseDataDir === undefined) {
+        delete process.env.BASE_DATA_DIR;
+      } else {
+        process.env.BASE_DATA_DIR = savedBaseDataDir;
+      }
+    });
+
+    test("credential reveal reads from instance-scoped store when BASE_DATA_DIR is set", async () => {
+      // Point BASE_DATA_DIR to a temp directory (simulating instance-scoped dir)
+      const tmpDir = (await import("node:os")).tmpdir();
+      const instanceDir = (await import("node:path")).join(
+        tmpDir,
+        `vellum-test-instance-${Date.now()}`,
+      );
+      process.env.BASE_DATA_DIR = instanceDir;
+
+      // Seed a credential in the mock store
+      seedCredential("twilio", "auth_token", "instance_secret_abc123");
+
+      // Run `credentials reveal twilio:auth_token`
+      const result = await runCli(["reveal", "twilio:auth_token", "--json"]);
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.ok).toBe(true);
+      expect(parsed.value).toBe("instance_secret_abc123");
+
+      // Verify the correct key was looked up in the secure store
+      expect(secureKeyStore.has("credential:twilio:auth_token")).toBe(true);
+      expect(secureKeyStore.get("credential:twilio:auth_token")).toBe(
+        "instance_secret_abc123",
+      );
+    });
+  });
+
   // =========================================================================
   // help text quality
   // =========================================================================

package/src/__tests__/daemon-assistant-events.test.ts

@@ -6,7 +6,6 @@
  *   - send()      → one mirrored assistant event per message
  *   - broadcast() → one mirrored assistant event per message (not per socket)
  */
-import * as net from "node:net";
 import { describe, expect, mock, test } from "bun:test";
 
 // ── Platform mock (must happen before imports that read it) ─────────────────
@@ -28,7 +27,6 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => "/tmp/test.log",
   getDbPath: () => "/tmp/test.db",
   ensureDataDir: () => {},
-  removeSocketFile: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -39,23 +37,13 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // ── Imports (after mocks) ────────────────────────────────────────────────────
-import type { ServerMessage } from "../daemon/ipc-protocol.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
-function makeFakeSocket(destroyed = false): net.Socket {
-  const s = Object.create(net.Socket.prototype) as net.Socket;
-  Object.assign(s, {
-    destroyed,
-    write: () => true,
-    on: () => s,
-  });
-  return s;
-}
-
 // ── buildAssistantEvent factory ───────────────────────────────────────────────
 
 describe("buildAssistantEvent", () => {
@@ -115,7 +103,7 @@ describe("daemon send → one mirrored assistant event", () => {
     expect(received[0].message.type).toBe("assistant_text_delta");
   });
 
-  test("sessionId falls back to socket binding when message lacks it", async () => {
+  test("sessionId falls back to explicit parameter when message lacks it", async () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
@@ -123,19 +111,13 @@ describe("daemon send → one mirrored assistant event", () => {
       received.push(e);
     });
 
-    // Simulate server.ts resolving sessionId from socket→session map
-    const socketSessionMap = new Map<object, string>();
-    const fakeSocket = makeFakeSocket();
-    socketSessionMap.set(fakeSocket, "sess_from_socket");
-
     const msg: ServerMessage = { type: "pong" }; // no sessionId field
-    const sessionId = socketSessionMap.get(fakeSocket);
-    const event = buildAssistantEvent("ast_ipc", msg, sessionId);
+    const event = buildAssistantEvent("ast_ipc", msg, "sess_explicit");
 
     await hub.publish(event);
 
     expect(received).toHaveLength(1);
-    expect(received[0].sessionId).toBe("sess_from_socket");
+    expect(received[0].sessionId).toBe("sess_explicit");
   });
 });
 

package/src/__tests__/db-migration-rollback.test.ts

@@ -16,7 +16,6 @@ import { describe, expect, test } from "bun:test";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getSqliteFrom } from "../memory/db-connection.js";
-import * as schema from "../memory/schema.js";
 import {
   migrateJobDeferrals,
   migrateMemoryEntityRelationDedup,
@@ -24,7 +23,8 @@ import {
   MIGRATION_REGISTRY,
   type MigrationValidationResult,
   validateMigrationState,
-} from "../memory/schema-migration.js";
+} from "../memory/migrations/index.js";
+import * as schema from "../memory/schema.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -54,7 +54,7 @@ import { initializeDb } from "../memory/db-init.js";
 import {
   composeChannelVerifyReply,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
-} from "../runtime/guardian-verification-templates.js";
+} from "../runtime/verification-templates.js";
 
 // ---------------------------------------------------------------------------
 // DB initialization
@@ -131,16 +131,16 @@ describe("TwiML parameter propagation", () => {
     voice: "en-US-Standard-A",
   };
 
-  test("includes guardianVerificationSessionId as Parameter when provided", () => {
+  test("includes verificationSessionId as Parameter when provided", () => {
     const twiml = generateTwiML(
       "session-123",
       "wss://example.com/v1/calls/relay",
       null,
       defaultProfile,
       undefined,
-      { guardianVerificationSessionId: "gv-session-456" },
+      { verificationSessionId: "gv-session-456" },
     );
-    expect(twiml).toContain('name="guardianVerificationSessionId"');
+    expect(twiml).toContain('name="verificationSessionId"');
     expect(twiml).toContain('value="gv-session-456"');
     expect(twiml).toContain("<Parameter");
   });
@@ -173,7 +173,7 @@ describe("TwiML parameter propagation", () => {
 // ---------------------------------------------------------------------------
 
 describe("Call session mode metadata", () => {
-  test("createCallSession persists callMode and guardianVerificationSessionId", async () => {
+  test("createCallSession persists callMode and verificationSessionId", async () => {
     // Dynamic import to avoid circular dependency issues
     const { createCallSession, getCallSession } =
       await import("../calls/call-store.js");
@@ -186,18 +186,18 @@ describe("Call session mode metadata", () => {
       provider: "twilio",
       fromNumber: "+15551234567",
       toNumber: "+15559876543",
-      callMode: "guardian_verification",
-      guardianVerificationSessionId: "gv-session-test",
+      callMode: "verification",
+      verificationSessionId: "gv-session-test",
     });
 
-    expect(session.callMode).toBe("guardian_verification");
-    expect(session.guardianVerificationSessionId).toBe("gv-session-test");
+    expect(session.callMode).toBe("verification");
+    expect(session.verificationSessionId).toBe("gv-session-test");
 
     // Verify it persists to DB
     const loaded = getCallSession(session.id);
     expect(loaded).not.toBeNull();
-    expect(loaded!.callMode).toBe("guardian_verification");
-    expect(loaded!.guardianVerificationSessionId).toBe("gv-session-test");
+    expect(loaded!.callMode).toBe("verification");
+    expect(loaded!.verificationSessionId).toBe("gv-session-test");
   });
 
   test("createCallSession defaults callMode to null when not provided", async () => {
@@ -217,12 +217,12 @@ describe("Call session mode metadata", () => {
     });
 
     expect(session.callMode).toBeNull();
-    expect(session.guardianVerificationSessionId).toBeNull();
+    expect(session.verificationSessionId).toBeNull();
 
     const loaded = getCallSession(session.id);
     expect(loaded).not.toBeNull();
     expect(loaded!.callMode).toBeNull();
-    expect(loaded!.guardianVerificationSessionId).toBeNull();
+    expect(loaded!.verificationSessionId).toBeNull();
   });
 });
 
@@ -235,13 +235,13 @@ describe("Verification control messages are deterministic (guard)", () => {
     const { createHash } = await import("node:crypto");
     const { handleChannelInbound } =
       await import("../runtime/routes/inbound-message-handler.js");
-    const { createChallenge } =
-      await import("../memory/channel-guardian-store.js");
+    const { createInboundSession } =
+      await import("../memory/channel-verification-sessions.js");
 
     // Set up a pending challenge
     const secret = "123456";
     const challengeHash = createHash("sha256").update(secret).digest("hex");
-    createChallenge({
+    createInboundSession({
       id: "challenge-guard-test",
       channel: "telegram",
       challengeHash,
@@ -302,7 +302,7 @@ describe("Verification control messages are deterministic (guard)", () => {
       const body = (await response.json()) as Record<string, unknown>;
 
       // Verification should have been handled
-      expect(body.guardianVerification).toBeDefined();
+      expect(body.verificationOutcome).toBeDefined();
 
       // processMessage must NOT have been called — this is the guard
       expect(processMessageCalled).toBe(false);
@@ -319,7 +319,7 @@ describe("Verification control messages are deterministic (guard)", () => {
     const { handleChannelInbound } =
       await import("../runtime/routes/inbound-message-handler.js");
     const { createOutboundSession } =
-      await import("../runtime/channel-guardian-service.js");
+      await import("../runtime/channel-verification-service.js");
 
     // Generate a bootstrap token and create a pending_bootstrap session
     const bootstrapToken = randomBytes(16).toString("hex");
@@ -391,7 +391,7 @@ describe("Verification control messages are deterministic (guard)", () => {
       const body = (await response.json()) as Record<string, unknown>;
 
       // Bootstrap should have been handled deterministically
-      expect(body.guardianVerification).toBe("bootstrap_bound");
+      expect(body.verificationOutcome).toBe("bootstrap_bound");
       expect(body.accepted).toBe(true);
 
       // processMessage must NOT have been called — deterministic handling

package/src/__tests__/dictation-mode-detection.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { detectDictationModeHeuristic as detectDictationMode } from "../daemon/handlers/dictation.js";
-import type { DictationRequest } from "../daemon/ipc-protocol.js";
+import type { DictationRequest } from "../daemon/message-protocol.js";
 
 type DictationRequestOverrides = Omit<Partial<DictationRequest>, "context"> & {
   context?: Partial<DictationRequest["context"]>;

package/src/__tests__/dynamic-page-surface.test.ts

@@ -3,8 +3,8 @@ import { describe, expect, test } from "bun:test";
 import type {
   DynamicPageSurfaceData,
   UiSurfaceShowDynamicPage,
-} from "../daemon/ipc-protocol.js";
-import { INTERACTIVE_SURFACE_TYPES } from "../daemon/ipc-protocol.js";
+} from "../daemon/message-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "../daemon/message-protocol.js";
 import { uiShowTool } from "../tools/ui-surface/definitions.js";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -25,7 +25,7 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
   getHistoryPath: () => join(TEST_DIR, "history"),
   getHooksDir: () => join(TEST_DIR, "hooks"),
-  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+
   getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
   getInterfacesDir: () => join(TEST_DIR, "interfaces"),
@@ -35,10 +35,6 @@ mock.module("../util/platform.js", () => ({
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
   readSessionToken: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
 }));
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
@@ -74,7 +70,7 @@ mock.module("../config/loader.js", () => ({
   syncConfigToLockfile: () => {},
 }));
 
-const { buildSystemPrompt } = await import("../config/system-prompt.js");
+const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
 
 describe("Dynamic Skill Authoring Workflow prompt section", () => {
   beforeEach(() => {

package/src/__tests__/email-cli.test.ts

@@ -60,7 +60,7 @@ describe("email provider factory", () => {
 // ---------------------------------------------------------------------------
 describe("email guardrails", () => {
   test("pause blocks sends (returns outbound_paused)", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.setOutboundPaused(true);
     expect(guardrails.isOutboundPaused()).toBe(true);
@@ -71,7 +71,7 @@ describe("email guardrails", () => {
   });
 
   test("resume allows sends", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.setOutboundPaused(true);
     guardrails.setOutboundPaused(false);
@@ -81,7 +81,7 @@ describe("email guardrails", () => {
   });
 
   test("daily cap enforced", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.setDailySendCap(2);
     guardrails.incrementDailySendCount();
@@ -95,7 +95,7 @@ describe("email guardrails", () => {
   });
 
   test("blocklist checked", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.addAddressRule("block", "*@spam.com");
 
@@ -106,7 +106,7 @@ describe("email guardrails", () => {
   });
 
   test("allowlist enforcement", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.addAddressRule("allow", "*@trusted.com");
 
@@ -119,7 +119,7 @@ describe("email guardrails", () => {
   });
 
   test("rule lifecycle: add, list, remove", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     const rule = guardrails.addAddressRule("block", "*@evil.com");
     expect(rule.id).toBeTruthy();
@@ -134,17 +134,17 @@ describe("email guardrails", () => {
   });
 
   test("remove non-existent rule returns false", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
     expect(guardrails.removeAddressRule("non-existent")).toBe(false);
   });
 
   test("default cap is 25", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
     expect(guardrails.getDailySendCap()).toBe(25);
   });
 
   test("incrementDailySendCount returns new count", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     expect(guardrails.incrementDailySendCount()).toBe(1);
     expect(guardrails.incrementDailySendCount()).toBe(2);
@@ -152,7 +152,7 @@ describe("email guardrails", () => {
   });
 
   test("guardrails check priority: pause > cap > blocklist", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
 
     guardrails.setOutboundPaused(true);
     guardrails.setDailySendCap(0);
@@ -227,7 +227,7 @@ describe("email service guardrails integration", () => {
 // ---------------------------------------------------------------------------
 describe("email JSON contract", () => {
   test("guardrails status has expected shape", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
     const status = guardrails.getGuardrailsStatus();
     const json = JSON.stringify(status);
     const parsed = JSON.parse(json);
@@ -243,7 +243,7 @@ describe("email JSON contract", () => {
   });
 
   test("address rule has expected JSON fields", async () => {
-    const guardrails = await import("../cli/email-guardrails.js");
+    const guardrails = await import("../email/guardrails.js");
     const rule = guardrails.addAddressRule("block", "*@test.com");
     const parsed = JSON.parse(JSON.stringify(rule));
 

package/src/__tests__/email-service-config-fallback.test.ts

@@ -40,7 +40,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Stub guardrails (imported by service.ts but not relevant here)
-mock.module("../cli/email-guardrails.js", () => ({
+mock.module("../email/guardrails.js", () => ({
   addAddressRule: () => ({}),
   checkSendGuardrails: () => null,
   getGuardrailsStatus: () => ({}),

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -7,7 +7,6 @@ const runDeterministicChecksMock = mock();
 const createEventMock = mock();
 const updateEventDedupeKeyMock = mock();
 const dispatchDecisionMock = mock();
-const activeBindingChannels = new Set<string>(["telegram"]);
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -24,15 +23,9 @@ mock.module("../contacts/contact-store.js", () => ({
   findGuardianForChannel: (_channelType: string, _assistantId: string) => null,
 }));
 
-mock.module("../memory/channel-guardian-store.js", () => ({
-  getActiveBinding: (_assistantId: string, channel: string) =>
-    activeBindingChannels.has(channel)
-      ? {
-          guardianDeliveryChatId: "guardian-chat-123",
-          guardianExternalUserId: "guardian-user-123",
-        }
-      : null,
-}));
+// Note: stale mock for channel-guardian-store.js removed — the barrel was
+// deleted and none of the functions it mocked (getActiveBinding) existed in
+// the barrel.
 
 mock.module("../notifications/adapters/macos.js", () => ({
   VellumAdapter: class {
@@ -40,10 +33,6 @@ mock.module("../notifications/adapters/macos.js", () => ({
   },
 }));
 
-mock.module("../notifications/adapters/sms.js", () => ({
-  SmsAdapter: class {},
-}));
-
 mock.module("../notifications/adapters/telegram.js", () => ({
   TelegramAdapter: class {},
 }));
@@ -91,8 +80,6 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
     createEventMock.mockReset();
     updateEventDedupeKeyMock.mockReset();
     dispatchDecisionMock.mockReset();
-    activeBindingChannels.clear();
-    activeBindingChannels.add("telegram");
 
     createEventMock.mockReturnValue({ id: "evt-1" });
     runDeterministicChecksMock.mockResolvedValue({ passed: true });
@@ -190,8 +177,6 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
   });
 
   test("excludes unverified binding channels from connected channel candidates", async () => {
-    activeBindingChannels.clear();
-
     const decision = {
       shouldNotify: true,
       selectedChannels: ["vellum"],

package/src/__tests__/event-bus.test.ts

@@ -143,7 +143,6 @@ describe("EventBus", () => {
     await expect(
       bus.emit("daemon.lifecycle.started", {
         pid: 1,
-        socketPath: "/tmp/sock",
         startedAtMs: Date.now(),
       }),
     ).rejects.toBeInstanceOf(EventBusDisposedError);

package/src/__tests__/followup-tools.test.ts

@@ -15,8 +15,6 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/gateway-client-managed-outbound.test.ts

@@ -35,7 +35,7 @@ describe("gateway-client managed outbound lane", () => {
 
   test("translates managed callback URL into managed outbound-send request", async () => {
     await deliverChannelReply(
-      "https://platform.test/v1/internal/managed-gateway/outbound-send/?route_id=route-123&assistant_id=assistant-123&source_channel=sms&source_update_id=SM-inbound-123&callback_token=runtime-token",
+      "https://platform.test/v1/internal/managed-gateway/outbound-send/?route_id=route-123&assistant_id=assistant-123&source_channel=phone&source_update_id=CA-inbound-123&callback_token=runtime-token",
       {
         chatId: "+15550001111",
         text: "hello from runtime",
@@ -74,7 +74,7 @@ describe("gateway-client managed outbound lane", () => {
     };
     expect(body.route_id).toBe("route-123");
     expect(body.assistant_id).toBe("assistant-123");
-    expect(body.normalized_send.sourceChannel).toBe("sms");
+    expect(body.normalized_send.sourceChannel).toBe("phone");
     expect(body.normalized_send.message.to).toBe("+15550001111");
     expect(body.normalized_send.message.content).toBe("hello from runtime");
     expect(body.normalized_send.message.externalMessageId).toStartWith(
@@ -83,7 +83,7 @@ describe("gateway-client managed outbound lane", () => {
     expect(body.normalized_send.source.requestId).toBe(
       body.normalized_send.message.externalMessageId,
     );
-    expect(body.normalized_send.raw.sourceUpdateId).toBe("SM-inbound-123");
+    expect(body.normalized_send.raw.sourceUpdateId).toBe("CA-inbound-123");
   });
 
   test("retries managed outbound send on retriable upstream responses with stable idempotency key", async () => {
@@ -109,7 +109,7 @@ describe("gateway-client managed outbound lane", () => {
     ) as unknown as typeof globalThis.fetch;
 
     await deliverChannelReply(
-      "https://platform.test/v1/internal/managed-gateway/outbound-send/?route_id=route-retry&assistant_id=assistant-retry&source_channel=sms&source_update_id=SM-retry",
+      "https://platform.test/v1/internal/managed-gateway/outbound-send/?route_id=route-retry&assistant_id=assistant-retry&source_channel=phone&source_update_id=CA-retry",
       {
         chatId: "+15550002222",
         text: "retry this outbound send",
@@ -138,7 +138,7 @@ describe("gateway-client managed outbound lane", () => {
 
   test("falls back to standard callback delivery for non-managed callback URL", async () => {
     await deliverChannelReply(
-      "https://gateway.test/deliver/sms",
+      "https://gateway.test/deliver/voice",
       {
         chatId: "+15550001111",
         text: "standard gateway callback",
@@ -148,7 +148,7 @@ describe("gateway-client managed outbound lane", () => {
 
     expect(calls).toHaveLength(1);
     const call = calls[0];
-    expect(call.url).toBe("https://gateway.test/deliver/sms");
+    expect(call.url).toBe("https://gateway.test/deliver/voice");
 
     const headers = call.init.headers as Record<string, string>;
     expect(headers["Content-Type"]).toBe("application/json");