@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/recording-handler.test.ts

@@ -160,6 +160,14 @@ mock.module("node:fs", () => {
   };
 });
 
+// Capture broadcastMessage calls
+const broadcastedMessages: Array<{ type: string; [k: string]: unknown }> = [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => {
+    broadcastedMessages.push(msg as { type: string; [k: string]: unknown });
+  },
+}));
+
 // ─── Imports (after mocks) ──────────────────────────────────────────────────
 
 import {
@@ -168,38 +176,13 @@ import {
   handleRecordingStatusCore,
   handleRecordingStop,
 } from "../daemon/handlers/recording.js";
-import type { HandlerContext } from "../daemon/handlers/shared.js";
 import type { RecordingStatus } from "../daemon/message-types/computer-use.js";
-import { DebouncerMap } from "../util/debounce.js";
 
 // ─── Test helpers ───────────────────────────────────────────────────────────
 
-function createCtx(): {
-  ctx: HandlerContext;
-  sent: Array<{ type: string; [k: string]: unknown }>;
-} {
-  const sent: Array<{ type: string; [k: string]: unknown }> = [];
-
-  const ctx: HandlerContext = {
-    sharedRequestTimestamps: [],
-    debounceTimers: new DebouncerMap({ defaultDelayMs: 200 }),
-    suppressConfigReload: false,
-    setSuppressConfigReload: noop,
-    updateConfigFingerprint: noop,
-    send: (msg) => {
-      sent.push(msg as { type: string; [k: string]: unknown });
-    },
-    broadcast: (msg) => {
-      sent.push(msg as { type: string; [k: string]: unknown });
-    },
-    clearAllConversations: () => 0,
-    getOrCreateConversation: () => {
-      throw new Error("not implemented");
-    },
-    touchConversation: noop,
-  };
-
-  return { ctx, sent };
+function createSent(): Array<{ type: string; [k: string]: unknown }> {
+  broadcastedMessages.length = 0;
+  return broadcastedMessages;
 }
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
@@ -216,10 +199,10 @@ describe("handleRecordingStart", () => {
   });
 
   test("sends recording_start event and returns a UUID", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-1";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
 
     expect(recordingId).not.toBeNull();
     // UUID v4 format
@@ -234,21 +217,21 @@ describe("handleRecordingStart", () => {
   });
 
   test("passes recording options through", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const options = { captureScope: "window" as const, includeAudio: true };
 
-    handleRecordingStart("conv-2", options, ctx);
+    handleRecordingStart("conv-2", options);
 
     expect(sent[0].options).toEqual(options);
   });
 
   test("returns null when recording already active and sends no messages", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
 
-    const id1 = handleRecordingStart("conv-3", undefined, ctx);
+    const id1 = handleRecordingStart("conv-3", undefined);
     expect(id1).toBeTruthy();
 
-    const id2 = handleRecordingStart("conv-3", undefined, ctx);
+    const id2 = handleRecordingStart("conv-3", undefined);
 
     // Should return null (callers handle messaging)
     expect(id2).toBeNull();
@@ -259,13 +242,13 @@ describe("handleRecordingStart", () => {
   });
 
   test("returns null when a different conversation already has an active recording (global guard)", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
 
-    const id1 = handleRecordingStart("conv-global-a", undefined, ctx);
+    const id1 = handleRecordingStart("conv-global-a", undefined);
     expect(id1).toBeTruthy();
 
     // A second start from a different conversation should be rejected
-    const id2 = handleRecordingStart("conv-global-b", undefined, ctx);
+    const id2 = handleRecordingStart("conv-global-b", undefined);
     expect(id2).toBeNull();
 
     // Only the first call sends recording_start
@@ -287,15 +270,15 @@ describe("handleRecordingStop", () => {
   });
 
   test("sends recording_stop for an active recording", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-stop-1";
 
     // Start a recording first
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0; // Clear the start message
 
-    const result = handleRecordingStop(conversationId, ctx);
+    const result = handleRecordingStop(conversationId);
 
     expect(result).toBe(recordingId!);
     expect(sent).toHaveLength(1);
@@ -304,27 +287,27 @@ describe("handleRecordingStop", () => {
   });
 
   test("returns undefined when no active recording exists", () => {
-    const { ctx } = createCtx();
+    createSent();
 
-    const result = handleRecordingStop("conv-no-recording", ctx);
+    const result = handleRecordingStop("conv-no-recording");
 
     expect(result).toBeUndefined();
   });
 
   test("resolves to globally active recording from a different conversation", () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const convA = "conv-owner";
     const convB = "conv-stopper";
 
     // Bind socket to conv-A (the owning conversation)
 
     // Start a recording on conv-A
-    const recordingId = handleRecordingStart(convA, undefined, ctx);
+    const recordingId = handleRecordingStart(convA, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
     // Stop from conv-B — should resolve to the globally active recording on conv-A
-    const result = handleRecordingStop(convB, ctx);
+    const result = handleRecordingStop(convB);
 
     expect(result).toBe(recordingId!);
     expect(sent).toHaveLength(1);
@@ -333,13 +316,13 @@ describe("handleRecordingStop", () => {
   });
 
   test("returns recordingId when stopped via broadcast", () => {
-    const { ctx } = createCtx();
+    createSent();
     const conversationId = "conv-broadcast-stop";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
 
-    const result = handleRecordingStop(conversationId, ctx);
+    const result = handleRecordingStop(conversationId);
 
     // Broadcast-based stop always returns the recordingId
     expect(result).toBe(recordingId!);
@@ -358,10 +341,10 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles started status without errors", async () => {
-    const { ctx } = createCtx();
+    createSent();
     const conversationId = "conv-status-1";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
 
     const statusMsg: RecordingStatus = {
@@ -371,16 +354,16 @@ describe("handleRecordingStatusCore", () => {
     };
 
     // Should not throw
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
   });
 
   test("handles stopped status with file — creates attachment and notifies client", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-stopped";
 
     // Bind socket
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -399,7 +382,7 @@ describe("handleRecordingStatusCore", () => {
       durationMs: 5000,
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // Should have sent assistant_text_delta and message_complete
     const textDeltas = sent.filter((m) => m.type === "assistant_text_delta");
@@ -424,10 +407,10 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles stopped status and creates assistant message when none exists", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-no-msg";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -441,7 +424,7 @@ describe("handleRecordingStatusCore", () => {
       durationMs: 3000,
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // An assistant message should have been created via addMessage mock
     expect(mockMessages.length).toBeGreaterThanOrEqual(1);
@@ -450,12 +433,12 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles stopped status when file does not exist — notifies client", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-no-file";
 
     mockFileExists = false;
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -468,7 +451,7 @@ describe("handleRecordingStatusCore", () => {
     };
 
     // Should not throw — the handler logs the error and notifies the client
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // No attachment should have been created
     expect(mockAttachments.length).toBe(0);
@@ -484,13 +467,13 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles stopped status with zero-length file — treated as failure", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-zero-file";
 
     mockFileExists = true;
     mockFileSize = 0;
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -502,7 +485,7 @@ describe("handleRecordingStatusCore", () => {
       durationMs: 2000,
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // No attachment should have been created for a zero-length file
     expect(mockAttachments.length).toBe(0);
@@ -525,13 +508,13 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("successful finalization — attachment created and success message sent", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-success";
 
     mockFileExists = true;
     mockFileSize = 4096;
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -543,7 +526,7 @@ describe("handleRecordingStatusCore", () => {
       durationMs: 5000,
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // Attachment should have been created
     expect(mockAttachments.length).toBe(1);
@@ -562,13 +545,13 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("rejects file path outside allowed directory", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-outside-dir";
 
     mockFileExists = true;
     mockFileSize = 4096;
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -580,7 +563,7 @@ describe("handleRecordingStatusCore", () => {
       durationMs: 5000,
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // No attachment should have been created — path is outside allowlist
     expect(mockAttachments.length).toBe(0);
@@ -598,10 +581,10 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("failed finalization — failure status sent and no success message", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-fail-final";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -613,7 +596,7 @@ describe("handleRecordingStatusCore", () => {
       error: "Video writer finished with non-completed status 3",
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // No attachment should have been created
     expect(mockAttachments.length).toBe(0);
@@ -632,10 +615,10 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles failed status and notifies client", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-failed";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -646,7 +629,7 @@ describe("handleRecordingStatusCore", () => {
       error: "Permission denied",
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     // Should send error notification
     const textDeltas = sent.filter((m) => m.type === "assistant_text_delta");
@@ -659,10 +642,10 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles failed status with no error message", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-status-failed-no-err";
 
-    const recordingId = handleRecordingStart(conversationId, undefined, ctx);
+    const recordingId = handleRecordingStart(conversationId, undefined);
     expect(recordingId).not.toBeNull();
     sent.length = 0;
 
@@ -672,7 +655,7 @@ describe("handleRecordingStatusCore", () => {
       status: "failed",
     };
 
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     const textDeltas = sent.filter((m) => m.type === "assistant_text_delta");
     expect(textDeltas.length).toBeGreaterThanOrEqual(1);
@@ -680,7 +663,7 @@ describe("handleRecordingStatusCore", () => {
   });
 
   test("handles status with attachToConversationId fallback", async () => {
-    const { ctx, sent } = createCtx();
+    const sent = createSent();
     const conversationId = "conv-fallback";
 
     // Send a recording_status directly with attachToConversationId
@@ -694,7 +677,7 @@ describe("handleRecordingStatusCore", () => {
     };
 
     // Should not throw — uses attachToConversationId as fallback
-    await handleRecordingStatusCore(statusMsg, ctx);
+    await handleRecordingStatusCore(statusMsg);
 
     const textDeltas = sent.filter((m) => m.type === "assistant_text_delta");
     expect(textDeltas.length).toBeGreaterThanOrEqual(1);

package/src/__tests__/regenerate-fire-and-forget-trace.test.ts

@@ -117,6 +117,7 @@ function buildContext(
         traceEvents.push({ event, body, options });
       },
     } as unknown as HistoryConversationContext["traceEmitter"],
+    sendToClient: () => {},
     messages,
     processing: false,
     abortController: null,
@@ -139,7 +140,7 @@ describe("regenerate fire-and-forget error path", () => {
       },
     });
 
-    await regenerate(session, () => {}, "req-123");
+    await regenerate(session, "req-123");
 
     // Give the fire-and-forget .catch() a tick to run.
     await new Promise((resolve) => setImmediate(resolve));
@@ -167,7 +168,7 @@ describe("regenerate fire-and-forget error path", () => {
       },
     });
 
-    await regenerate(session, () => {});
+    await regenerate(session);
 
     await new Promise((resolve) => setImmediate(resolve));
 
@@ -185,7 +186,7 @@ describe("regenerate fire-and-forget error path", () => {
       runAgentLoop: async () => {},
     });
 
-    await regenerate(session, () => {}, "req-ok");
+    await regenerate(session, "req-ok");
 
     await new Promise((resolve) => setImmediate(resolve));
 

package/src/__tests__/relay-server.test.ts

@@ -215,10 +215,7 @@ import {
 } from "../calls/relay-server.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
 import { upsertContact } from "../contacts/contact-store.js";
-import {
-  createGuardianBinding,
-  upsertContactChannel,
-} from "../contacts/contacts-write.js";
+import { upsertContactChannel } from "../contacts/contacts-write.js";
 import {
   listCanonicalGuardianRequests,
   resolveCanonicalGuardianRequest,
@@ -238,6 +235,7 @@ import {
   getGuardianBinding,
 } from "../runtime/channel-verification-service.js";
 import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
+import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
@@ -1419,9 +1417,11 @@ describe("relay-server", () => {
     expect(relay.isVerificationSessionActive()).toBe(false);
     expect(relay.getConnectionState()).toBe("connected");
 
-    // Guardian binding should have been created
+    // Guardian binding is NOT created by the assistant — the gateway owns
+    // binding creation for inbound voice verification. The assistant only
+    // transitions to connected state and starts the normal call flow.
     const binding = getGuardianBinding("self", "phone");
-    expect(binding).not.toBeNull();
+    expect(binding).toBeNull();
 
     // Orchestrator greeting should have fired
     const textMessages = ws.sentMessages
@@ -1490,9 +1490,9 @@ describe("relay-server", () => {
     expect(relay.isVerificationSessionActive()).toBe(false);
     expect(relay.getConnectionState()).toBe("connected");
 
-    // Binding created
+    // Binding is NOT created by the assistant — gateway owns this.
     const binding = getGuardianBinding("self", "phone");
-    expect(binding).not.toBeNull();
+    expect(binding).toBeNull();
 
     // Greeting should have started
     const textMessages = ws.sentMessages
@@ -1746,18 +1746,23 @@ describe("relay-server", () => {
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
+    // The gateway creates the guardian binding before the ConversationRelay
+    // WebSocket is established, so resolveActorTrust() would find it in
+    // production. Without a gateway in this test, trust reflects the
+    // resolved state without a binding.
     const postVerify = (
       relay.getController() as unknown as {
         trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
-          guardianExternalUserId?: string;
         };
       }
     )?.trustContext;
     expect(postVerify?.sourceChannel).toBe("phone");
-    expect(postVerify?.trustClass).toBe("guardian");
-    expect(postVerify?.guardianExternalUserId).toBe(session.fromNumber);
+    // Trust class is 'unknown' because the gateway creates the binding
+    // before the relay is established. Without a gateway in this test,
+    // resolveActorTrust finds no guardian binding.
+    expect(postVerify?.trustClass).toBe("unknown");
 
     relay.destroy();
   });
@@ -4034,9 +4039,9 @@ describe("relay-server", () => {
     expect(relay.isVerificationSessionActive()).toBe(false);
     expect(relay.getConnectionState()).toBe("connected");
 
-    // Guardian binding should have been created
+    // Guardian binding is NOT created by the assistant — gateway owns this.
     const binding = getGuardianBinding("self", "phone");
-    expect(binding).not.toBeNull();
+    expect(binding).toBeNull();
 
     // Normal greeting should fire (from mockSendMessage), not the handoff copy
     const textMessages = ws.sentMessages

package/src/__tests__/require-fresh-approval.test.ts

@@ -54,8 +54,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
 };
 
@@ -136,10 +134,6 @@ mock.module("../tools/shared/filesystem/path-policy.js", () => ({
   hostPolicy: () => ({ ok: false }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: () => ({ command: "", sandboxed: false }),
-}));
-
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { ToolContext as TC } from "../tools/types.js";
@@ -231,7 +225,11 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     const result = await executor.execute(
       "bash",
       { command: "echo hello" },
-      makeContext({ isInteractive: false, trustClass: "guardian", requireFreshApproval: true }),
+      makeContext({
+        isInteractive: false,
+        trustClass: "guardian",
+        requireFreshApproval: true,
+      }),
     );
 
     expect(result.isError).toBe(true);
@@ -283,7 +281,11 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     const result = await executor.execute(
       "gmail_send_draft",
       { draft_id: "draft-123", confidence: 0.99 },
-      makeContext({ isInteractive: false, trustClass: "guardian", requireFreshApproval: true }),
+      makeContext({
+        isInteractive: false,
+        trustClass: "guardian",
+        requireFreshApproval: true,
+      }),
     );
 
     expect(result.isError).toBe(true);
@@ -318,12 +320,9 @@ describe("requireFreshApproval: persistent decisions disabled", () => {
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
     riskOverride = "high";
-
   });
 
-  afterEach(() => {
-
-  });
+  afterEach(() => {});
 
   test("manage_secure_command_tool prompt does not offer persistent decisions", async () => {
     checkResultOverride = { decision: "allow", reason: "Matched trust rule" };
@@ -372,8 +371,6 @@ describe("requireFreshApproval: persistent decisions disabled", () => {
     expect(promptEvent).toBeDefined();
     expect(promptEvent!.persistentDecisionsAllowed).toBe(false);
   });
-
-
 });
 
 // ---------------------------------------------------------------------------
@@ -386,12 +383,9 @@ describe("requireFreshApproval: grant-consumed does not skip permission check",
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
     riskOverride = "high";
-
   });
 
-  afterEach(() => {
-
-  });
+  afterEach(() => {});
 
   test("manage_secure_command_tool is prompted even when executor sets requireFreshApproval and grantConsumed would normally short-circuit", async () => {
     // This test verifies the code path in executor.ts where the
@@ -441,12 +435,9 @@ describe("requireFreshApproval: context flag propagation", () => {
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
     riskOverride = "high";
-
   });
 
-  afterEach(() => {
-
-  });
+  afterEach(() => {});
 
   test("manage_secure_command_tool sets both forcePromptSideEffects and requireFreshApproval", async () => {
     checkResultOverride = { decision: "allow", reason: "Matched trust rule" };

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -34,9 +34,9 @@ mock.module("../config/loader.js", () => ({
 mock.module("../daemon/process-message.js", () => ({
   resolveTurnChannel: () => "whatsapp",
   resolveTurnInterface: () => "whatsapp",
-  makePendingInteractionRegistrar: () => () => {},
   prepareConversationForMessage: async () => ({}),
   processMessage: async () => ({ messageId: `mock-msg-${Date.now()}` }),
+  processMessageInBackground: async () => ({ messageId: "mock-bg" }),
 }));
 
 mock.module("../daemon/approval-generators.js", () => ({

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -72,7 +72,7 @@ async function publishAndReadFrame(
     abortSignal: ac.signal,
   });
 
-  const event = buildAssistantEvent("self", message, conversationId);
+  const event = buildAssistantEvent(message, conversationId);
   await assistantEventHub.publish(event);
 
   const reader = stream.getReader();
@@ -322,7 +322,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
 
   // ── Envelope integrity ───────────────────────────────────────────────────
 
-  test("SSE envelope preserves assistantId and conversationId across all event types", async () => {
+  test("SSE envelope preserves conversationId across all event types", async () => {
     const conversationKey = "parity-envelope-check";
     const { conversationId } = getOrCreateConversation(conversationKey);
 
@@ -338,7 +338,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
       type: "assistant_text_delta" as const,
       text: "envelope test",
     };
-    const published = buildAssistantEvent("self", msg, conversationId);
+    const published = buildAssistantEvent(msg, conversationId);
     await assistantEventHub.publish(published);
 
     const reader = stream.getReader();
@@ -358,7 +358,6 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
 
     // Envelope fields
     expect(received.id).toBe(published.id);
-    expect(received.assistantId).toBe("self");
     expect(received.conversationId).toBe(conversationId);
     expect(received.emittedAt).toBe(published.emittedAt);
     // SSE frame fields