vellum 0.2.1 → 0.2.2

package/src/__tests__/session-init.benchmark.test.ts

@@ -0,0 +1,462 @@
+/**
+ * Session Initialization Benchmark
+ *
+ * Measures latency of key session startup components and end-to-end
+ * session creation timing (request to first-tool-ready state).
+ *
+ * Uses multi-sample median timing with warm-up runs to reduce sensitivity
+ * to host load and machine class. Thresholds are intentionally loose
+ * guardrails for catching regressions, not precise performance targets.
+ *
+ * Component targets (median of 5 runs):
+ * - initializeTools: < 100ms
+ * - buildSystemPrompt: < 50ms
+ * - getAllToolDefinitions: < 10ms
+ *
+ * End-to-end targets (median of 3 runs):
+ * - Session creation (no preactivated skills): < 200ms
+ * - Session creation (3 preactivated skills): < 300ms
+ * - Session constructor (sync, no loadFromDb): < 10ms
+ */
+import { afterAll, describe, expect, mock, test } from 'bun:test';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+/** Return the median of a sorted-ascending array of numbers. */
+function median(sorted: number[]): number {
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0
+    ? (sorted[mid - 1] + sorted[mid]) / 2
+    : sorted[mid];
+}
+
+const testDir = mkdtempSync(join(tmpdir(), 'session-init-bench-'));
+
+// Create subdirectories expected by platform helpers
+mkdirSync(join(testDir, 'data'), { recursive: true });
+mkdirSync(join(testDir, 'logs'), { recursive: true });
+mkdirSync(join(testDir, 'skills'), { recursive: true });
+mkdirSync(join(testDir, 'hooks'), { recursive: true });
+
+// Seed minimal prompt files so buildSystemPrompt doesn't bail on missing files
+writeFileSync(join(testDir, 'IDENTITY.md'), '# Test Identity\nYou are a test assistant.');
+writeFileSync(join(testDir, 'SOUL.md'), '# Test Soul\nBe helpful.');
+writeFileSync(join(testDir, 'USER.md'), '# Test User\nName: Benchmark Runner');
+
+// Create real skill directories so projectSkillTools can load them from the catalog
+const testSkillIds = ['bench-skill-a', 'bench-skill-b', 'bench-skill-c'];
+for (const skillId of testSkillIds) {
+  const skillDir = join(testDir, 'skills', skillId);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, 'SKILL.md'), [
+    '---',
+    `name: ${skillId}`,
+    `description: Benchmark test skill ${skillId}`,
+    '---',
+    `# ${skillId}`,
+    'A test skill for benchmarking.',
+  ].join('\n'));
+  writeFileSync(join(skillDir, 'TOOLS.json'), JSON.stringify({
+    version: 1,
+    tools: [{
+      name: `${skillId}_tool`,
+      description: `Tool for ${skillId}`,
+      category: 'benchmark',
+      risk: 'low',
+      input_schema: { type: 'object', properties: {} },
+      executor: 'run.sh',
+      execution_target: 'host',
+    }],
+  }));
+  writeFileSync(join(skillDir, 'run.sh'), '#!/bin/sh\necho ok');
+}
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  getRootDir: () => testDir,
+  getWorkspaceDir: () => testDir,
+  getWorkspaceConfigPath: () => join(testDir, 'config.json'),
+  getWorkspaceSkillsDir: () => join(testDir, 'skills'),
+  getWorkspaceHooksDir: () => join(testDir, 'hooks'),
+  getWorkspacePromptPath: (file: string) => join(testDir, file),
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getSessionTokenPath: () => join(testDir, 'session-token'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'data', 'test.db'),
+  getLogPath: () => join(testDir, 'logs', 'test.log'),
+  getHistoryPath: () => join(testDir, 'history'),
+  getHooksDir: () => join(testDir, 'hooks'),
+  getIpcBlobDir: () => join(testDir, 'ipc-blobs'),
+  getSandboxRootDir: () => join(testDir, 'sandbox'),
+  getSandboxWorkingDir: () => testDir,
+  getInterfacesDir: () => join(testDir, 'interfaces'),
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getPlatformName: () => process.platform,
+  getClipboardCommand: () => null,
+  removeSocketFile: () => {},
+  migratePath: () => {},
+  migrateToWorkspaceLayout: () => {},
+  migrateToDataLayout: () => {},
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  getCliLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  isDebug: () => false,
+  truncateForLog: (value: string, maxLen = 500) =>
+    value.length > maxLen ? value.slice(0, maxLen) + '...' : value,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockConfig = {
+  model: 'mock-model',
+  provider: 'mock',
+  sandbox: { enabled: false, backend: 'native' },
+  contextWindow: {
+    enabled: true,
+    maxInputTokens: 180000,
+    targetInputTokens: 110000,
+    compactThreshold: 0.8,
+    preserveRecentUserTurns: 8,
+    summaryMaxTokens: 1200,
+  },
+  thinking: { enabled: false, budgetTokens: 10000 },
+};
+
+mock.module('../config/loader.js', () => ({
+  API_KEY_PROVIDERS: ['anthropic', 'openai', 'gemini', 'ollama', 'fireworks', 'brave', 'perplexity'],
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+  saveConfig: () => {},
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+// Additional mocks required for Session constructor and end-to-end tests
+
+mock.module('../memory/conversation-store.js', () => ({
+  addMessage: () => ({ id: 'msg-1' }),
+  getMessages: () => [],
+  listConversations: () => [],
+  getConversation: () => null,
+  getLatestConversation: () => null,
+  createConversation: () => ({ id: 'bench-conv', title: 'Bench', threadType: 'standard' }),
+  clearAll: () => {},
+  getConversationThreadType: () => 'standard',
+  getConversationMemoryScopeId: () => 'default',
+  updateConversationTitle: () => {},
+}));
+
+mock.module('../hooks/manager.js', () => ({
+  getHookManager: () => ({
+    trigger: () => Promise.resolve(),
+    initialize: () => {},
+  }),
+}));
+
+mock.module('../tools/watch/watch-state.js', () => ({
+  watchSessions: new Map(),
+  registerWatchStartNotifier: () => {},
+  unregisterWatchStartNotifier: () => {},
+  fireWatchStartNotifier: () => {},
+  registerWatchCommentaryNotifier: () => {},
+  unregisterWatchCommentaryNotifier: () => {},
+  fireWatchCommentaryNotifier: () => {},
+  registerWatchCompletionNotifier: () => {},
+  unregisterWatchCompletionNotifier: () => {},
+  fireWatchCompletionNotifier: () => {},
+  getActiveWatchSession: () => undefined,
+  addObservation: () => {},
+  pruneWatchSessions: () => {},
+}));
+
+mock.module('../calls/call-state.js', () => ({
+  registerCallQuestionNotifier: () => {},
+  unregisterCallQuestionNotifier: () => {},
+  fireCallQuestionNotifier: () => {},
+  registerCallCompletionNotifier: () => {},
+  unregisterCallCompletionNotifier: () => {},
+  fireCallCompletionNotifier: () => {},
+  registerCallOrchestrator: () => {},
+  unregisterCallOrchestrator: () => {},
+  getCallOrchestrator: () => undefined,
+}));
+
+mock.module('../calls/call-store.js', () => ({
+  createCallSession: () => ({ id: 'mock' }),
+  getCallSession: () => null,
+  getCallSessionByCallSid: () => null,
+  getActiveCallSessionForConversation: () => null,
+  updateCallSession: () => {},
+  listRecoverableCalls: () => [],
+  recordCallEvent: () => {},
+  getCallEvents: () => [],
+  createPendingQuestion: () => ({ id: 'mock' }),
+  getPendingQuestion: () => null,
+  answerPendingQuestion: () => {},
+  expirePendingQuestions: () => {},
+  buildCallbackDedupeKey: () => '',
+  isCallbackProcessed: () => false,
+  recordProcessedCallback: () => {},
+  tryRecordProcessedCallback: () => true,
+  claimCallback: () => true,
+  releaseCallbackClaim: () => {},
+}));
+
+mock.module('../daemon/watch-handler.js', () => ({
+  lastCommentaryBySession: new Map(),
+  lastSummaryBySession: new Map(),
+}));
+
+mock.module('../tools/browser/browser-screencast.js', () => ({
+  registerSessionSender: () => {},
+  unregisterSessionSender: () => {},
+  ensureScreencast: () => Promise.resolve(),
+  updateBrowserStatus: () => {},
+  updatePagesList: () => Promise.resolve(),
+  stopBrowserScreencast: () => Promise.resolve(),
+  getElementBounds: () => Promise.resolve(null),
+  updateHighlights: () => {},
+  stopAllScreencasts: () => Promise.resolve(),
+  isScreencastActive: () => false,
+  getSender: () => undefined,
+  getScreencastSurfaceId: () => null,
+}));
+
+mock.module('../services/published-app-updater.js', () => ({
+  updatePublishedAppDeployment: () => Promise.resolve(),
+}));
+
+const { initializeTools, getAllToolDefinitions, __resetRegistryForTesting } = await import(
+  '../tools/registry.js'
+);
+const { buildSystemPrompt } = await import('../config/system-prompt.js');
+const { Session } = await import('../daemon/session.js');
+const { projectSkillTools, resetSkillToolProjection } = await import(
+  '../daemon/session-skill-tools.js'
+);
+import type { Provider } from '../providers/types.js';
+
+afterAll(() => {
+  __resetRegistryForTesting();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+describe('Session initialization benchmark', () => {
+  test('initializeTools completes under 100ms (median of 5)', async () => {
+    // Warm-up run to eliminate JIT / lazy-load overhead
+    __resetRegistryForTesting();
+    await initializeTools();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      __resetRegistryForTesting();
+      const start = performance.now();
+      await initializeTools();
+      timings.push(performance.now() - start);
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(100);
+  });
+
+  test('getAllToolDefinitions retrieves definitions under 10ms (median of 5)', async () => {
+    await initializeTools();
+
+    // Warm-up
+    getAllToolDefinitions();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      const start = performance.now();
+      const definitions = getAllToolDefinitions();
+      timings.push(performance.now() - start);
+      if (i === 0) expect(definitions.length).toBeGreaterThan(0);
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(10);
+  });
+
+  test('buildSystemPrompt assembles prompt under 50ms (median of 5)', () => {
+    // Warm-up
+    buildSystemPrompt();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      const start = performance.now();
+      const prompt = buildSystemPrompt();
+      timings.push(performance.now() - start);
+      if (i === 0) {
+        expect(prompt.length).toBeGreaterThan(0);
+        expect(prompt).toContain('Test Identity');
+      }
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(50);
+  });
+
+  test('repeated buildSystemPrompt calls are consistently fast (10 iterations)', () => {
+    const timings: number[] = [];
+    for (let i = 0; i < 10; i++) {
+      const start = performance.now();
+      buildSystemPrompt();
+      timings.push(performance.now() - start);
+    }
+
+    const maxTime = Math.max(...timings);
+    const avgTime = timings.reduce((a, b) => a + b, 0) / timings.length;
+
+    // Each call should be under 50ms, average well under 20ms
+    expect(maxTime).toBeLessThan(50);
+    expect(avgTime).toBeLessThan(20);
+  });
+
+  test('tool definitions count stays within expected range after init', async () => {
+    await initializeTools();
+    const definitions = getAllToolDefinitions();
+
+    // Sanity: we expect a meaningful number of core tools (at least 20)
+    // but not an unreasonable explosion (under 200)
+    expect(definitions.length).toBeGreaterThanOrEqual(20);
+    expect(definitions.length).toBeLessThan(200);
+  });
+});
+
+describe('End-to-end session creation benchmark', () => {
+  // Uses the real Session constructor + loadFromDb() path, which wires up
+  // the tool executor, event bus, agent loop, context window manager, and
+  // notifiers. Note: the daemon's getOrCreateSession() adds provider
+  // construction, rate limiting, concurrency guards, and evictor management
+  // on top — those are lightweight config-driven operations not benchmarked
+  // here.
+
+  const mockProvider: Provider = {
+    name: 'mock',
+    sendMessage: () =>
+      Promise.resolve({
+        content: [{ type: 'text' as const, text: 'ok' }],
+        model: 'mock-model',
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: 'end_turn',
+      }),
+  };
+  const noop = () => {};
+
+  test('session creation without preactivated skills completes under 200ms (median of 3)', async () => {
+    __resetRegistryForTesting();
+    await initializeTools();
+    const systemPrompt = buildSystemPrompt();
+
+    // Warm-up run
+    const warmup = new Session('bench-warmup-0', mockProvider, systemPrompt, 64000, noop, testDir);
+    await warmup.loadFromDb();
+    warmup.dispose();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 3; i++) {
+      const id = `bench-no-skills-${i}`;
+      const start = performance.now();
+      const session = new Session(id, mockProvider, systemPrompt, 64000, noop, testDir);
+      await session.loadFromDb();
+      timings.push(performance.now() - start);
+
+      if (i === 0) {
+        expect(session.conversationId).toBe(id);
+        expect(session.getMessages()).toHaveLength(0);
+      }
+      session.dispose();
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(200);
+  });
+
+  test('session creation with 3 preactivated skills completes under 300ms (median of 3)', async () => {
+    __resetRegistryForTesting();
+    await initializeTools();
+    const systemPrompt = buildSystemPrompt();
+
+    // Warm-up run — includes skill projection so manifest loading is JIT'd
+    const warmup = new Session('bench-warmup-s', mockProvider, systemPrompt, 64000, noop, testDir);
+    warmup.preactivatedSkillIds = testSkillIds;
+    await warmup.loadFromDb();
+    projectSkillTools([], {
+      preactivatedSkillIds: warmup.preactivatedSkillIds,
+      previouslyActiveSkillIds: warmup.skillProjectionState,
+      cache: warmup.skillProjectionCache,
+    });
+    resetSkillToolProjection(warmup.skillProjectionState);
+    warmup.dispose();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 3; i++) {
+      const id = `bench-with-skills-${i}`;
+      const start = performance.now();
+      const session = new Session(id, mockProvider, systemPrompt, 64000, noop, testDir);
+      session.preactivatedSkillIds = testSkillIds;
+      await session.loadFromDb();
+      // Skill projection runs at agent turn time, not during loadFromDb.
+      // Include it here to measure the full first-tool-ready path.
+      const projection = projectSkillTools([], {
+        preactivatedSkillIds: session.preactivatedSkillIds,
+        previouslyActiveSkillIds: session.skillProjectionState,
+        cache: session.skillProjectionCache,
+      });
+      timings.push(performance.now() - start);
+
+      if (i === 0) {
+        expect(session.conversationId).toBe(id);
+        expect(session.getMessages()).toHaveLength(0);
+        expect(projection.toolDefinitions.length).toBe(testSkillIds.length);
+      }
+      resetSkillToolProjection(session.skillProjectionState);
+      session.dispose();
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(300);
+  });
+
+  test('Session constructor (sync, no loadFromDb) completes under 10ms (median of 5)', () => {
+    const systemPrompt = buildSystemPrompt();
+
+    // Warm-up
+    const warmup = new Session('bench-events-w', mockProvider, systemPrompt, 64000, noop, testDir);
+    warmup.dispose();
+
+    const timings: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      const start = performance.now();
+      const session = new Session(`bench-events-${i}`, mockProvider, systemPrompt, 64000, noop, testDir);
+      timings.push(performance.now() - start);
+
+      if (i === 0) {
+        expect(session.eventBus.listenerCount()).toBeGreaterThan(0);
+      }
+      session.dispose();
+    }
+
+    timings.sort((a, b) => a - b);
+    expect(median(timings)).toBeLessThan(10);
+  });
+});

package/src/__tests__/session-queue.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, mock, test, beforeEach } from 'bun:test';
+import { describe, expect, mock, test, beforeEach, afterAll } from 'bun:test';
 import { rmSync, writeFileSync } from 'node:fs';
 import type { Message, ProviderResponse } from '../providers/types.js';
 import type { AgentEvent, CheckpointInfo, CheckpointDecision } from '../agent/loop.js';
@@ -8,8 +8,16 @@ import type { ServerMessage } from '../daemon/ipc-protocol.js';
 // Mocks — must precede the Session import so Bun applies them at load time.
 // ---------------------------------------------------------------------------
 
+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: () => new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getLogger: () => makeLoggerStub(),
 }));
 
 mock.module('../util/platform.js', () => ({
@@ -139,28 +147,12 @@ mock.module('../context/window-manager.js', () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Workspace/git + attachment mocks.
+// Workspace/git turn-commit test hooks.
 // ---------------------------------------------------------------------------
 
 const turnCommitCalls: Array<{ workspaceDir: string; sessionId: string; turnNumber: number }> = [];
 let turnCommitHangForever = false;
 
-mock.module('../workspace/git-service.js', () => ({
-  getWorkspaceGitService: () => ({
-    ensureInitialized: async () => {},
-  }),
-}));
-
-mock.module('../workspace/turn-commit.js', () => ({
-  commitTurnChanges: async (workspaceDir: string, sessionId: string, turnNumber: number) => {
-    turnCommitCalls.push({ workspaceDir, sessionId, turnNumber });
-    if (turnCommitHangForever) {
-      // Simulate a commit that never resolves within the timeout budget
-      await new Promise<void>(() => {});
-    }
-  },
-}));
-
 // ---------------------------------------------------------------------------
 // Usage event capture for request-ID correlation tests.
 // ---------------------------------------------------------------------------
@@ -223,6 +215,17 @@ mock.module('../agent/loop.js', () => ({
 import { Session, MAX_QUEUE_DEPTH } from '../daemon/session.js';
 import type { QueueDrainReason, QueuePolicy } from '../daemon/session.js';
 
+type SessionWithWorkspaceDeps = Session & {
+  getWorkspaceGitService?: (_workspaceDir: string) => { ensureInitialized: () => Promise<void> };
+  commitTurnChanges?: (
+    workspaceDir: string,
+    sessionId: string,
+    turnNumber: number,
+    provider?: unknown,
+    deadlineMs?: number,
+  ) => Promise<void>;
+};
+
 function makeSession(sendToClient?: (msg: ServerMessage) => void): Session {
   const provider = {
     name: 'mock',
@@ -235,7 +238,19 @@ function makeSession(sendToClient?: (msg: ServerMessage) => void): Session {
       };
     },
   };
-  return new Session('conv-1', provider, 'system prompt', 4096, sendToClient ?? (() => {}), '/tmp');
+  const session = new Session('conv-1', provider, 'system prompt', 4096, sendToClient ?? (() => {}), '/tmp');
+  const sessionWithWorkspaceDeps = session as SessionWithWorkspaceDeps;
+  sessionWithWorkspaceDeps.getWorkspaceGitService = () => ({
+    ensureInitialized: async () => {},
+  });
+  sessionWithWorkspaceDeps.commitTurnChanges = async (workspaceDir: string, sessionId: string, turnNumber: number) => {
+    turnCommitCalls.push({ workspaceDir, sessionId, turnNumber });
+    if (turnCommitHangForever) {
+      // Simulate a commit that never resolves within the timeout budget
+      await new Promise<void>(() => {});
+    }
+  };
+  return session;
 }
 
 /**
@@ -289,6 +304,10 @@ beforeEach(() => {
   linkAttachmentShouldThrow = false;
 });
 
+afterAll(() => {
+  mock.restore();
+});
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -1472,41 +1491,45 @@ describe('Regression: cancel semantics and error channel split', () => {
 
     turnCommitHangForever = true;
 
-    const events1: ServerMessage[] = [];
-    const events2: ServerMessage[] = [];
+    try {
+      const events1: ServerMessage[] = [];
+      const events2: ServerMessage[] = [];
 
-    // Start first message (promise intentionally not awaited — we test queue drain behavior)
-    const _p1 = session.processMessage('msg-1', [], (e) => events1.push(e), 'req-1');
-    await waitForPendingRun(1);
+      // Start first message (promise intentionally not awaited — we test queue drain behavior)
+      const _p1 = session.processMessage('msg-1', [], (e) => events1.push(e), 'req-1');
+      await waitForPendingRun(1);
 
-    // Enqueue a second message while the first is processing
-    session.enqueueMessage('msg-2', [], (e) => events2.push(e), 'req-2');
+      // Enqueue a second message while the first is processing
+      session.enqueueMessage('msg-2', [], (e) => events2.push(e), 'req-2');
 
-    // Complete the first agent loop run
-    resolveRun(0);
+      // Complete the first agent loop run
+      resolveRun(0);
 
-    // The turn should still complete (timeout fires) and drain the queue
-    // even though commitTurnChanges never resolves.
-    // The default turnCommitMaxWaitMs is 4000ms in the config mock,
-    // but the mock config doesn't set it, so it defaults to 4000ms.
-    // We wait for the second run to be registered, which proves the
-    // turn completed and the queue drained despite the hanging commit.
-    await waitForPendingRun(2, 10_000);
+      // The turn should still complete (timeout fires) and drain the queue
+      // even though commitTurnChanges never resolves.
+      // The default turnCommitMaxWaitMs is 4000ms in the config mock,
+      // but the mock config doesn't set it, so it defaults to 4000ms.
+      // We wait for the second run to be registered, which proves the
+      // turn completed and the queue drained despite the hanging commit.
+      await waitForPendingRun(2, 10_000);
 
-    // First message should have completed
-    const completion1 = events1.find((e) => e.type === 'message_complete');
-    expect(completion1).toBeDefined();
+      // First message should have completed
+      const completion1 = events1.find((e) => e.type === 'message_complete');
+      expect(completion1).toBeDefined();
 
-    // Second message should have been dequeued
-    const dequeued = events2.find((e) => e.type === 'message_dequeued');
-    expect(dequeued).toBeDefined();
+      // Second message should have been dequeued
+      const dequeued = events2.find((e) => e.type === 'message_dequeued');
+      expect(dequeued).toBeDefined();
 
-    // The turn commit should have been called
-    expect(turnCommitCalls).toHaveLength(1);
+      // The turn commit should have been called
+      expect(turnCommitCalls).toHaveLength(1);
 
-    // Complete the second run so the test can clean up
-    turnCommitHangForever = false;
-    resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+      // Complete the second run so the test can clean up
+      turnCommitHangForever = false;
+      resolveRun(1);
+      await new Promise((r) => setTimeout(r, 50));
+    } finally {
+      turnCommitHangForever = false;
+    }
   }, 15_000);
 });