@vellumai/assistant 0.3.0

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

@@ -0,0 +1,465 @@
+/**
+ * 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: () => {},
+  registerCallTranscriptNotifier: () => {},
+  unregisterCallTranscriptNotifier: () => {},
+  fireCallTranscriptNotifier: () => {},
+  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-load-history-repair.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, mock, test } from 'bun:test';
+import type { Message } from '../providers/types.js';
+
+// Stub out heavy dependencies before importing Session
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getSocketPath: () => '/tmp/test.sock',
+  getDataDir: () => '/tmp',
+}));
+
+mock.module('../providers/registry.js', () => ({
+  getProvider: () => ({ name: 'mock-provider' }),
+  initializeProviders: () => {},
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    provider: 'mock-provider',
+    maxTokens: 4096,
+    thinking: false,
+    contextWindow: {
+      maxInputTokens: 100000,
+      thresholdTokens: 80000,
+      preserveRecentMessages: 6,
+      summaryModel: 'mock-model',
+      maxSummaryTokens: 512,
+    },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module('../config/system-prompt.js', () => ({
+  buildSystemPrompt: () => 'system prompt',
+}));
+
+mock.module('../permissions/trust-store.js', () => ({
+  clearCache: () => {},
+}));
+
+mock.module('../security/secret-allowlist.js', () => ({
+  resetAllowlist: () => {},
+}));
+
+// Mutable store so each test can configure its own messages
+let mockDbMessages: Array<{ id: string; role: string; content: string }> = [];
+let mockConversation: Record<string, unknown> | null = null;
+
+mock.module('../memory/conversation-store.js', () => ({
+  getMessages: () => mockDbMessages,
+  getConversation: () => mockConversation,
+  createConversation: () => ({ id: 'conv-1' }),
+  listConversations: () => [],
+}));
+
+import { Session } from '../daemon/session.js';
+
+function makeSession(): Session {
+  const provider = { name: 'mock', sendMessage: async () => ({ content: [], model: 'mock', usage: { inputTokens: 0, outputTokens: 0 }, stopReason: 'end_turn' }) };
+  return new Session('conv-1', provider, 'system prompt', 4096, () => {}, '/tmp');
+}
+
+describe('loadFromDb history repair', () => {
+  test('repairs corrupt persisted history: missing tool_result inserted', async () => {
+    mockConversation = {
+      id: 'conv-1',
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      { id: 'm1', role: 'user', content: JSON.stringify([{ type: 'text', text: 'Hello' }]) },
+      {
+        id: 'm2',
+        role: 'assistant',
+        content: JSON.stringify([
+          { type: 'tool_use', id: 'tu_1', name: 'bash', input: { cmd: 'ls' } },
+        ]),
+      },
+      // Missing user message with tool_result for tu_1
+      { id: 'm3', role: 'assistant', content: JSON.stringify([{ type: 'text', text: 'Done' }]) },
+    ];
+
+    const session = makeSession();
+    await session.loadFromDb();
+    const messages = session.getMessages();
+
+    // Repair should have inserted a synthetic user message with tool_result
+    expect(messages).toHaveLength(4);
+    expect(messages[2].role).toBe('user');
+    const trBlocks = messages[2].content.filter((b) => b.type === 'tool_result');
+    expect(trBlocks).toHaveLength(1);
+    expect(trBlocks[0].type === 'tool_result' && trBlocks[0].tool_use_id).toBe('tu_1');
+  });
+
+  test('valid history remains unchanged', async () => {
+    mockConversation = {
+      id: 'conv-1',
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    const validMessages: Message[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hi' }] },
+      {
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: 'tu_1', name: 'read', input: { path: '/a' } }],
+      },
+      {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'ok' }],
+      },
+      { role: 'assistant', content: [{ type: 'text', text: 'Got it' }] },
+    ];
+
+    mockDbMessages = validMessages.map((m, i) => ({
+      id: `m${i}`,
+      role: m.role,
+      content: JSON.stringify(m.content),
+    }));
+
+    const session = makeSession();
+    await session.loadFromDb();
+    const messages = session.getMessages();
+
+    expect(messages).toEqual(validMessages);
+  });
+
+  test('invalid JSON content does not crash load path', async () => {
+    mockConversation = {
+      id: 'conv-1',
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      { id: 'm1', role: 'user', content: 'this is not valid json {{{' },
+      { id: 'm2', role: 'assistant', content: JSON.stringify([{ type: 'text', text: 'Hi' }]) },
+    ];
+
+    const session = makeSession();
+    // Should not throw
+    await session.loadFromDb();
+    const messages = session.getMessages();
+
+    expect(messages).toHaveLength(2);
+    // The broken message should have been replaced with a text block
+    expect(messages[0].content[0].type).toBe('text');
+    expect(messages[0].content[0].type === 'text' && messages[0].content[0].text).toBe('this is not valid json {{{');
+  });
+
+  test('non-array JSON content is wrapped in a text block', async () => {
+    mockConversation = {
+      id: 'conv-1',
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      { id: 'm1', role: 'user', content: '"hello"' },
+      { id: 'm2', role: 'assistant', content: '42' },
+      { id: 'm3', role: 'user', content: '{}' },
+      { id: 'm4', role: 'assistant', content: JSON.stringify([{ type: 'text', text: 'Done' }]) },
+    ];
+
+    const session = makeSession();
+    await session.loadFromDb();
+    const messages = session.getMessages();
+
+    expect(messages).toHaveLength(4);
+    // String JSON should be wrapped
+    expect(messages[0].content).toEqual([{ type: 'text', text: '"hello"' }]);
+    // Number JSON should be wrapped
+    expect(messages[1].content).toEqual([{ type: 'text', text: '42' }]);
+    // Object JSON should be wrapped
+    expect(messages[2].content).toEqual([{ type: 'text', text: '{}' }]);
+    // Valid array content should pass through
+    expect(messages[3].content).toEqual([{ type: 'text', text: 'Done' }]);
+  });
+
+  test('assistant-role tool_result blocks are stripped during load', async () => {
+    mockConversation = {
+      id: 'conv-1',
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      { id: 'm1', role: 'user', content: JSON.stringify([{ type: 'text', text: 'Hello' }]) },
+      {
+        id: 'm2',
+        role: 'assistant',
+        content: JSON.stringify([
+          { type: 'text', text: 'Sure' },
+          { type: 'tool_result', tool_use_id: 'tu_x', content: 'stale' },
+        ]),
+      },
+    ];
+
+    const session = makeSession();
+    await session.loadFromDb();
+    const messages = session.getMessages();
+
+    expect(messages).toHaveLength(2);
+    expect(messages[1].content).toEqual([{ type: 'text', text: 'Sure' }]);
+  });
+});