vellum 0.2.7 → 0.2.9

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -262,34 +262,51 @@ describe('ProviderCommitMessageGenerator', () => {
     expect(result.reason).toBe('invalid_output');
   });
 
-  // 11. LLM output too long (subject > 72 chars)
-  test('LLM output too long (subject > 72 chars) → returns deterministic, reason "invalid_output"', async () => {
-    const longSubject = 'a'.repeat(73);
+  // 11. LLM subject > 72 chars → truncated to 72, still source "llm"
+  test('LLM subject > 72 chars → truncated to 72, source "llm"', async () => {
+    const longSubject = 'a'.repeat(100);
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(longSubject));
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
       changedFiles: baseContext.changedFiles,
     });
-    expect(result.source).toBe('deterministic');
-    expect(result.reason).toBe('invalid_output');
+    expect(result.source).toBe('llm');
+    expect(result.reason).toBeUndefined();
+    expect(result.message.split('\n')[0].length).toBeLessThanOrEqual(72);
+    expect(result.message).toBe('a'.repeat(72));
   });
 
-  // 12. Keyless provider (Ollama) skips API key preflight
-  test('Ollama without API key → does not return missing_provider_api_key', async () => {
+  // 11b. LLM subject > 72 chars with body → subject truncated, body preserved
+  test('LLM subject > 72 chars with body → subject truncated, body preserved', async () => {
+    const longSubject = 'b'.repeat(80);
+    const body = '\n\n- bullet one\n- bullet two';
+    mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(longSubject + body));
+    const gen = getCommitMessageGenerator();
+    const result = await gen.generateCommitMessage(baseContext, {
+      changedFiles: baseContext.changedFiles,
+    });
+    expect(result.source).toBe('llm');
+    expect(result.reason).toBeUndefined();
+    expect(result.message.split('\n')[0].length).toBeLessThanOrEqual(72);
+    expect(result.message).toBe('b'.repeat(72) + body);
+  });
+
+  // 12. Keyless provider (Ollama) without fast model → missing_fast_model (skips API key check)
+  test('Ollama without API key or fast model → returns deterministic, reason "missing_fast_model"', async () => {
     (currentConfig as Record<string, unknown>).provider = 'ollama';
     currentConfig.apiKeys = {} as Record<string, string>;
-    // Ollama has no default fast model, so it will fall through to provider_error,
-    // but crucially it should NOT be blocked by missing_provider_api_key
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
       changedFiles: baseContext.changedFiles,
     });
     expect(result.source).toBe('deterministic');
+    expect(result.reason).toBe('missing_fast_model');
     expect(result.reason).not.toBe('missing_provider_api_key');
+    expect(mockSendMessage).not.toHaveBeenCalled();
   });
 
-  // 13. No default fast model for unknown provider
-  test('No default fast model for unknown provider → returns deterministic fallback', async () => {
+  // 13. Unknown provider without fast model default → missing_fast_model, no provider call
+  test('Unknown provider without fast model default → returns deterministic, reason "missing_fast_model"', async () => {
     (currentConfig as Record<string, unknown>).provider = 'exotic-provider';
     currentConfig.apiKeys = { 'exotic-provider': 'sk-exotic' } as Record<string, string>;
     const gen = getCommitMessageGenerator();
@@ -297,7 +314,29 @@ describe('ProviderCommitMessageGenerator', () => {
       changedFiles: baseContext.changedFiles,
     });
     expect(result.source).toBe('deterministic');
-    expect(result.reason).toBe('provider_error');
+    expect(result.reason).toBe('missing_fast_model');
     expect(mockSendMessage).not.toHaveBeenCalled();
   });
+
+  // 14. Fast-model override enables LLM path for provider without built-in default
+  test('fast-model override enables LLM path for provider without built-in default', async () => {
+    (currentConfig as Record<string, unknown>).provider = 'ollama';
+    currentConfig.apiKeys = {} as Record<string, string>; // Ollama is keyless
+    currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
+      ollama: 'llama3.2:3b',
+    };
+    const commitMsg = 'fix: local model commit';
+    mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
+    const gen = getCommitMessageGenerator();
+    const result = await gen.generateCommitMessage(baseContext, {
+      changedFiles: baseContext.changedFiles,
+    });
+    expect(result.source).toBe('llm');
+    expect(result.message).toBe(commitMsg);
+
+    // Verify the override model was passed
+    const callArgs = mockSendMessage.mock.calls[0];
+    const options = callArgs[3] as { config: { model: string } };
+    expect(options.config.model).toBe('llama3.2:3b');
+  });
 });

package/src/__tests__/public-ingress-urls.test.ts

@@ -0,0 +1,222 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
+
+// ---------------------------------------------------------------------------
+// Mocks — silence logger output during tests
+// ---------------------------------------------------------------------------
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of ['info', 'warn', 'error', 'debug', 'trace', 'fatal', 'silent', 'child']) {
+    stub[m] = m === 'child' ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+import {
+  getPublicBaseUrl,
+  getTwilioVoiceWebhookUrl,
+  getTwilioStatusCallbackUrl,
+  getTwilioConnectActionUrl,
+  getTwilioRelayUrl,
+  getOAuthCallbackUrl,
+  getTelegramWebhookUrl,
+} from '../inbound/public-ingress-urls.js';
+
+// ---------------------------------------------------------------------------
+// getPublicBaseUrl — fallback chain
+// ---------------------------------------------------------------------------
+
+describe('getPublicBaseUrl', () => {
+  let savedIngressEnv: string | undefined;
+
+  beforeEach(() => {
+    savedIngressEnv = process.env.INGRESS_PUBLIC_BASE_URL;
+    delete process.env.INGRESS_PUBLIC_BASE_URL;
+  });
+
+  afterEach(() => {
+    if (savedIngressEnv !== undefined) {
+      process.env.INGRESS_PUBLIC_BASE_URL = savedIngressEnv;
+    } else {
+      delete process.env.INGRESS_PUBLIC_BASE_URL;
+    }
+  });
+
+  test('returns ingress.publicBaseUrl when set', () => {
+    const result = getPublicBaseUrl({
+      ingress: { publicBaseUrl: 'https://ingress.example.com/' },
+    });
+    expect(result).toBe('https://ingress.example.com');
+  });
+
+  test('falls back to INGRESS_PUBLIC_BASE_URL env var when ingress.publicBaseUrl is empty', () => {
+    process.env.INGRESS_PUBLIC_BASE_URL = 'https://ingress-env.example.com/';
+    const result = getPublicBaseUrl({
+      ingress: { publicBaseUrl: '' },
+    });
+    expect(result).toBe('https://ingress-env.example.com');
+  });
+
+  test('falls back to INGRESS_PUBLIC_BASE_URL env var when config is empty', () => {
+    process.env.INGRESS_PUBLIC_BASE_URL = 'https://ingress-env.example.com';
+    const result = getPublicBaseUrl({});
+    expect(result).toBe('https://ingress-env.example.com');
+  });
+
+  test('throws when no source provides a value', () => {
+    expect(() => getPublicBaseUrl({
+      ingress: { publicBaseUrl: '' },
+    })).toThrow(/No public base URL configured/);
+  });
+
+  test('throws when all sources are undefined', () => {
+    expect(() => getPublicBaseUrl({})).toThrow(/No public base URL configured/);
+  });
+
+  test('normalizes trailing slashes from ingress.publicBaseUrl', () => {
+    const result = getPublicBaseUrl({
+      ingress: { publicBaseUrl: 'https://example.com///' },
+    });
+    expect(result).toBe('https://example.com');
+  });
+
+  test('trims whitespace from ingress.publicBaseUrl', () => {
+    const result = getPublicBaseUrl({
+      ingress: { publicBaseUrl: '  https://example.com  ' },
+    });
+    expect(result).toBe('https://example.com');
+  });
+
+  test('skips whitespace-only ingress.publicBaseUrl and falls through to env', () => {
+    process.env.INGRESS_PUBLIC_BASE_URL = 'https://ingress-env.example.com';
+    const result = getPublicBaseUrl({
+      ingress: { publicBaseUrl: '   ' },
+    });
+    expect(result).toBe('https://ingress-env.example.com');
+  });
+
+  test('normalizes trailing slashes from INGRESS_PUBLIC_BASE_URL', () => {
+    process.env.INGRESS_PUBLIC_BASE_URL = 'https://ingress-env.example.com///';
+    const result = getPublicBaseUrl({});
+    expect(result).toBe('https://ingress-env.example.com');
+  });
+
+  test('trims whitespace from INGRESS_PUBLIC_BASE_URL', () => {
+    process.env.INGRESS_PUBLIC_BASE_URL = '  https://ingress-env.example.com  ';
+    const result = getPublicBaseUrl({});
+    expect(result).toBe('https://ingress-env.example.com');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getTwilioVoiceWebhookUrl
+// ---------------------------------------------------------------------------
+
+describe('getTwilioVoiceWebhookUrl', () => {
+  test('builds correct URL with callSessionId', () => {
+    const url = getTwilioVoiceWebhookUrl(
+      { ingress: { publicBaseUrl: 'https://example.com' } },
+      'session-123',
+    );
+    expect(url).toBe('https://example.com/webhooks/twilio/voice?callSessionId=session-123');
+  });
+
+  test('normalizes base URL before composing', () => {
+    const url = getTwilioVoiceWebhookUrl(
+      { ingress: { publicBaseUrl: 'https://example.com/' } },
+      'abc',
+    );
+    expect(url).toBe('https://example.com/webhooks/twilio/voice?callSessionId=abc');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getTwilioStatusCallbackUrl
+// ---------------------------------------------------------------------------
+
+describe('getTwilioStatusCallbackUrl', () => {
+  test('builds correct URL', () => {
+    const url = getTwilioStatusCallbackUrl({
+      ingress: { publicBaseUrl: 'https://example.com' },
+    });
+    expect(url).toBe('https://example.com/webhooks/twilio/status');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getTwilioConnectActionUrl
+// ---------------------------------------------------------------------------
+
+describe('getTwilioConnectActionUrl', () => {
+  test('builds correct URL', () => {
+    const url = getTwilioConnectActionUrl({
+      ingress: { publicBaseUrl: 'https://example.com' },
+    });
+    expect(url).toBe('https://example.com/webhooks/twilio/connect-action');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getTwilioRelayUrl — scheme conversion
+// ---------------------------------------------------------------------------
+
+describe('getTwilioRelayUrl', () => {
+  test('converts https to wss', () => {
+    const url = getTwilioRelayUrl({
+      ingress: { publicBaseUrl: 'https://example.com' },
+    });
+    expect(url).toBe('wss://example.com/webhooks/twilio/relay');
+  });
+
+  test('converts http to ws', () => {
+    const url = getTwilioRelayUrl({
+      ingress: { publicBaseUrl: 'http://localhost:7821' },
+    });
+    expect(url).toBe('ws://localhost:7821/webhooks/twilio/relay');
+  });
+
+  test('normalizes trailing slash before conversion', () => {
+    const url = getTwilioRelayUrl({
+      ingress: { publicBaseUrl: 'https://example.com/' },
+    });
+    expect(url).toBe('wss://example.com/webhooks/twilio/relay');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getOAuthCallbackUrl
+// ---------------------------------------------------------------------------
+
+describe('getOAuthCallbackUrl', () => {
+  test('builds correct URL', () => {
+    const url = getOAuthCallbackUrl({
+      ingress: { publicBaseUrl: 'https://example.com' },
+    });
+    expect(url).toBe('https://example.com/webhooks/oauth/callback');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// getTelegramWebhookUrl
+// ---------------------------------------------------------------------------
+
+describe('getTelegramWebhookUrl', () => {
+  test('builds correct URL', () => {
+    const url = getTelegramWebhookUrl({
+      ingress: { publicBaseUrl: 'https://example.com' },
+    });
+    expect(url).toBe('https://example.com/webhooks/telegram');
+  });
+
+  test('normalizes trailing slash before composing', () => {
+    const url = getTelegramWebhookUrl({
+      ingress: { publicBaseUrl: 'https://example.com/' },
+    });
+    expect(url).toBe('https://example.com/webhooks/telegram');
+  });
+});

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

@@ -0,0 +1,343 @@
+/**
+ * IPC parity tests for the SSE assistant-events endpoint.
+ *
+ * Asserts that every streaming/delta IPC ServerMessage type is preserved
+ * exactly — field-for-field — when delivered through the SSE route.
+ *
+ * Message types covered:
+ *   - assistant_text_delta
+ *   - assistant_thinking_delta
+ *   - tool_input_delta
+ *   - tool_output_chunk
+ *   - tool_result
+ *   - message_complete   (terminal)
+ *   - generation_handoff (terminal)
+ *   - generation_cancelled (terminal)
+ */
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'runtime-events-sse-parity-')));
+
+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'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    model: 'test',
+    provider: 'test',
+    apiKeys: {},
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { assistantEventHub } from '../runtime/assistant-event-hub.js';
+import { buildAssistantEvent } from '../runtime/assistant-event.js';
+import { getOrCreateConversation } from '../memory/conversation-key-store.js';
+import type { AssistantEvent } from '../runtime/assistant-event.js';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Subscribe to the SSE endpoint for a given conversationKey, publish one
+ * event, read the first SSE frame, and return the parsed AssistantEvent.
+ *
+ * Uses handleSubscribeAssistantEvents directly (bypassing HTTP) to avoid
+ * chunked-transfer buffering in Bun's loopback implementation.
+ */
+async function publishAndReadFrame(
+  conversationKey: string,
+  message: ServerMessage,
+): Promise<AssistantEvent> {
+  const { conversationId } = getOrCreateConversation(conversationKey);
+
+  const ac = new AbortController();
+  const req = new Request(
+    `http://localhost/v1/events?conversationKey=${conversationKey}`,
+    { signal: ac.signal },
+  );
+
+  const { handleSubscribeAssistantEvents } = await import('../runtime/routes/events-routes.js');
+  const response = handleSubscribeAssistantEvents(req, new URL(req.url));
+
+  const event = buildAssistantEvent('self', message, conversationId);
+  await assistantEventHub.publish(event);
+
+  const reader = response.body!.getReader();
+  const { value } = await reader.read();
+  ac.abort();
+
+  const frame = new TextDecoder().decode(value);
+  // SSE frame: "event: assistant_event\nid: <id>\ndata: <json>\n\n"
+  const dataLine = frame.split('\n').find(l => l.startsWith('data: '));
+  if (!dataLine) throw new Error(`No data line in SSE frame:\n${frame}`);
+  return JSON.parse(dataLine.slice('data: '.length)) as AssistantEvent;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SSE IPC parity — streaming/delta message types', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM conversation_keys');
+    db.run('DELETE FROM conversations');
+  });
+
+  // ── assistant_text_delta ─────────────────────────────────────────────────
+
+  test('preserves assistant_text_delta payload', async () => {
+    const msg = {
+      type: 'assistant_text_delta' as const,
+      text: 'Hello, world!',
+      sessionId: 'conv-text-delta',
+    };
+    const event = await publishAndReadFrame('parity-text-delta', msg);
+
+    expect(event.message.type).toBe('assistant_text_delta');
+    const m = event.message as typeof msg;
+    expect(m.text).toBe('Hello, world!');
+    expect(m.sessionId).toBe('conv-text-delta');
+  });
+
+  test('preserves assistant_text_delta without optional sessionId', async () => {
+    const msg = {
+      type: 'assistant_text_delta' as const,
+      text: 'No session here',
+    };
+    const event = await publishAndReadFrame('parity-text-delta-nosession', msg);
+
+    const m = event.message as typeof msg;
+    expect(m.type).toBe('assistant_text_delta');
+    expect(m.text).toBe('No session here');
+    expect((m as Record<string, unknown>).sessionId).toBeUndefined();
+  });
+
+  // ── assistant_thinking_delta ─────────────────────────────────────────────
+
+  test('preserves assistant_thinking_delta payload', async () => {
+    const msg = {
+      type: 'assistant_thinking_delta' as const,
+      thinking: 'Let me reason through this...',
+    };
+    const event = await publishAndReadFrame('parity-thinking-delta', msg);
+
+    expect(event.message.type).toBe('assistant_thinking_delta');
+    const m = event.message as typeof msg;
+    expect(m.thinking).toBe('Let me reason through this...');
+  });
+
+  // ── tool_input_delta ─────────────────────────────────────────────────────
+
+  test('preserves tool_input_delta payload', async () => {
+    const msg = {
+      type: 'tool_input_delta' as const,
+      toolName: 'bash',
+      content: '{"command": "ls -la"}',
+      sessionId: 'conv-tool-input',
+    };
+    const event = await publishAndReadFrame('parity-tool-input-delta', msg);
+
+    expect(event.message.type).toBe('tool_input_delta');
+    const m = event.message as typeof msg;
+    expect(m.toolName).toBe('bash');
+    expect(m.content).toBe('{"command": "ls -la"}');
+    expect(m.sessionId).toBe('conv-tool-input');
+  });
+
+  // ── tool_output_chunk ────────────────────────────────────────────────────
+
+  test('preserves tool_output_chunk payload', async () => {
+    const msg = {
+      type: 'tool_output_chunk' as const,
+      chunk: 'total 42\n-rw-r--r-- 1 user group 1234 Jan 1 00:00 file.ts',
+      sessionId: 'conv-tool-output',
+      subType: 'tool_complete' as const,
+      subToolName: 'bash',
+      subToolInput: 'ls -la',
+      subToolIsError: false,
+      subToolId: 'tool-abc-123',
+    };
+    const event = await publishAndReadFrame('parity-tool-output-chunk', msg);
+
+    expect(event.message.type).toBe('tool_output_chunk');
+    const m = event.message as typeof msg;
+    expect(m.chunk).toBe(msg.chunk);
+    expect(m.sessionId).toBe('conv-tool-output');
+    expect(m.subType).toBe('tool_complete');
+    expect(m.subToolName).toBe('bash');
+    expect(m.subToolInput).toBe('ls -la');
+    expect(m.subToolIsError).toBe(false);
+    expect(m.subToolId).toBe('tool-abc-123');
+  });
+
+  test('preserves minimal tool_output_chunk (chunk only)', async () => {
+    const msg = {
+      type: 'tool_output_chunk' as const,
+      chunk: 'stdout line 1\n',
+    };
+    const event = await publishAndReadFrame('parity-tool-output-chunk-minimal', msg);
+
+    const m = event.message as typeof msg;
+    expect(m.type).toBe('tool_output_chunk');
+    expect(m.chunk).toBe('stdout line 1\n');
+  });
+
+  // ── tool_result ──────────────────────────────────────────────────────────
+
+  test('preserves tool_result payload', async () => {
+    const msg = {
+      type: 'tool_result' as const,
+      toolName: 'read_file',
+      result: 'File contents here',
+      isError: false,
+      sessionId: 'conv-tool-result',
+      status: 'success',
+    };
+    const event = await publishAndReadFrame('parity-tool-result', msg);
+
+    expect(event.message.type).toBe('tool_result');
+    const m = event.message as typeof msg;
+    expect(m.toolName).toBe('read_file');
+    expect(m.result).toBe('File contents here');
+    expect(m.isError).toBe(false);
+    expect(m.sessionId).toBe('conv-tool-result');
+    expect(m.status).toBe('success');
+  });
+
+  test('preserves tool_result with error flag', async () => {
+    const msg = {
+      type: 'tool_result' as const,
+      toolName: 'bash',
+      result: 'Command not found: foobar',
+      isError: true,
+    };
+    const event = await publishAndReadFrame('parity-tool-result-error', msg);
+
+    const m = event.message as typeof msg;
+    expect(m.type).toBe('tool_result');
+    expect(m.isError).toBe(true);
+    expect(m.result).toBe('Command not found: foobar');
+  });
+
+  // ── message_complete (terminal) ──────────────────────────────────────────
+
+  test('preserves message_complete payload', async () => {
+    const msg = {
+      type: 'message_complete' as const,
+      sessionId: 'conv-msg-complete',
+    };
+    const event = await publishAndReadFrame('parity-message-complete', msg);
+
+    expect(event.message.type).toBe('message_complete');
+    const m = event.message as typeof msg;
+    expect(m.sessionId).toBe('conv-msg-complete');
+  });
+
+  test('preserves message_complete without sessionId', async () => {
+    const msg = { type: 'message_complete' as const };
+    const event = await publishAndReadFrame('parity-message-complete-nosession', msg);
+
+    expect(event.message.type).toBe('message_complete');
+  });
+
+  // ── generation_handoff (terminal) ────────────────────────────────────────
+
+  test('preserves generation_handoff payload', async () => {
+    const msg = {
+      type: 'generation_handoff' as const,
+      sessionId: 'conv-handoff',
+      requestId: 'req-xyz-789',
+      queuedCount: 2,
+    };
+    const event = await publishAndReadFrame('parity-generation-handoff', msg);
+
+    expect(event.message.type).toBe('generation_handoff');
+    const m = event.message as typeof msg;
+    expect(m.sessionId).toBe('conv-handoff');
+    expect(m.requestId).toBe('req-xyz-789');
+    expect(m.queuedCount).toBe(2);
+  });
+
+  // ── generation_cancelled (terminal) ─────────────────────────────────────
+
+  test('preserves generation_cancelled payload', async () => {
+    const msg = {
+      type: 'generation_cancelled' as const,
+      sessionId: 'conv-cancelled',
+    };
+    const event = await publishAndReadFrame('parity-generation-cancelled', msg);
+
+    expect(event.message.type).toBe('generation_cancelled');
+    const m = event.message as typeof msg;
+    expect(m.sessionId).toBe('conv-cancelled');
+  });
+
+  // ── Envelope integrity ───────────────────────────────────────────────────
+
+  test('SSE envelope preserves assistantId and sessionId across all event types', async () => {
+    const conversationKey = 'parity-envelope-check';
+    const { conversationId } = getOrCreateConversation(conversationKey);
+
+    const ac = new AbortController();
+    const req = new Request(
+      `http://localhost/v1/events?conversationKey=${conversationKey}`,
+      { signal: ac.signal },
+    );
+    const { handleSubscribeAssistantEvents } = await import('../runtime/routes/events-routes.js');
+    const response = handleSubscribeAssistantEvents(req, new URL(req.url));
+
+    const msg: ServerMessage = { type: 'assistant_text_delta' as const, text: 'envelope test' };
+    const published = buildAssistantEvent('self', msg, conversationId);
+    await assistantEventHub.publish(published);
+
+    const reader = response.body!.getReader();
+    const { value } = await reader.read();
+    ac.abort();
+
+    const frame = new TextDecoder().decode(value);
+    const dataLine = frame.split('\n').find(l => l.startsWith('data: '))!;
+    const received = JSON.parse(dataLine.slice('data: '.length)) as AssistantEvent;
+
+    // Envelope fields
+    expect(received.id).toBe(published.id);
+    expect(received.assistantId).toBe('self');
+    expect(received.sessionId).toBe(conversationId);
+    expect(received.emittedAt).toBe(published.emittedAt);
+    // SSE frame fields
+    expect(frame).toContain('event: assistant_event');
+    expect(frame).toContain(`id: ${published.id}`);
+  });
+});