feat: use real moav2 source as RL task suite — symlinked sandbox, 3 real service tasks

Dockerfile

@@ -1,8 +1,17 @@
 FROM ghcr.io/meta-pytorch/openenv-base:latest
 
-# Install node for running vitest
-RUN apt-get update && apt-get install -y nodejs npm && rm -rf /var/lib/apt/lists/*
+# Install node 20 + npm
+RUN apt-get update && apt-get install -y curl && \
+    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/*
 
+# Copy moav2 source and pre-install all dependencies once
+# (node_modules will be symlinked into per-request sandboxes — no 700MB copy per reset)
+COPY moav2/ /app/moav2/
+RUN cd /app/moav2 && npm install --no-audit --no-fund
+
+# Copy env server
 COPY src/core/ /app/src/core/
 COPY src/envs/moa_env/ /app/src/envs/moa_env/
 

moav2/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "moav2",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "dev:web": "vite",
+    "dev:ios": "npx cap run ios",
+    "dev:android": "npx cap run android",
+    "build:ios": "npm run build:web && npx cap sync ios",
+    "build:android": "npm run build:web && npx cap sync android",
+    "mobile:android": "./scripts/android-build-install.sh",
+    "dev:electron": "npm run build:main && concurrently --kill-others-on-fail -n compile,renderer,electron \"npm run dev:compile\" \"npm run dev:renderer\" \"npm run dev:electron:run\"",
+    "dev:compile": "tsc -p tsconfig.main.json --watch --preserveWatchOutput",
+    "dev:renderer": "ELECTRON_RENDERER=1 vite",
+    "dev:electron:run": "sleep 3 && unset ELECTRON_RUN_AS_NODE && CLOUDSDK_ACTIVE_CONFIG_NAME=moa-os VITE_DEV_SERVER_URL=http://localhost:14000 electron .",
+    "build": "npm run build:main && npm run build:web",
+    "build:main": "tsc -p tsconfig.main.json && cp src/electron/preload.cjs dist/electron/",
+    "build:web": "vite build",
+    "test": "vitest run",
+    "test:e2e": "playwright test",
+    "test:e2e:headed": "playwright test --headed",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "history": "npx tsx src/cli/index.ts",
+    "postinstall": "electron-rebuild --only node-pty",
+    "rebuild:electron": "electron-rebuild --only node-pty"
+  },
+  "main": "dist/electron/main.js",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.29.0",
+    "@capacitor/android": "^8.1.0",
+    "@capacitor/browser": "^8.0.1",
+    "@capacitor/core": "^8.1.0",
+    "@capacitor/ios": "^8.1.0",
+    "@capgo/inappbrowser": "^8.1.24",
+    "@mariozechner/pi-agent-core": "latest",
+    "@mariozechner/pi-ai": "latest",
+    "@zenfs/core": "^2.5.0",
+    "@zenfs/dom": "^1.2.7",
+    "path-browserify": "^1.0.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-markdown": "^9.0.0",
+    "wa-sqlite": "^1.0.0",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0",
+    "xterm-addon-search": "^0.13.0",
+    "xterm-addon-unicode11": "^0.6.0",
+    "xterm-addon-web-links": "^0.9.0",
+    "xterm-addon-webgl": "^0.16.0"
+  },
+  "devDependencies": {
+    "@capacitor/cli": "^8.1.0",
+    "@electron/rebuild": "^4.0.0",
+    "@playwright/test": "^1.54.2",
+    "@sinclair/typebox": "^0.34.48",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "concurrently": "^8.2.0",
+    "electron": "^40.6.0",
+    "fake-indexeddb": "^6.2.5",
+    "jsdom": "^28.0.0",
+    "node-pty": "^1.1.0",
+    "tailwindcss": "^3.3.0",
+    "typescript": "^5.3.0",
+    "vite": "^5.0.0",
+    "vite-plugin-electron-renderer": "^0.14.6",
+    "vitest": "^4.0.18"
+  }
+}

moav2/src/__tests__/agent-buffer-no-model.test.tsx

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen } from '@testing-library/react'
+
+const mockState = {
+  messages: [],
+  streamingBlocks: [],
+  input: '',
+  isStreaming: false,
+  expandedTools: new Set<string>(),
+  agentReady: false,
+  isLoading: false,
+  model: '',
+  sendError: null,
+}
+
+vi.mock('../core/services/session-store', () => ({
+  sessionStore: {
+    subscribe: () => () => {},
+    getSession: () => mockState,
+    initSession: vi.fn(),
+    sendMessage: vi.fn(),
+    setInput: vi.fn(),
+    toggleTool: vi.fn(),
+    clearSendError: vi.fn(),
+  },
+}))
+
+import AgentBuffer from '../ui/components/AgentBuffer'
+
+describe('AgentBuffer model-less session UX', () => {
+  it('shows configure provider prompt when model is empty', () => {
+    const onModelClick = vi.fn()
+    render(<AgentBuffer sessionId="s1" model="" onModelClick={onModelClick} />)
+
+    expect(screen.getByText(/configure a provider/i)).toBeTruthy()
+    const button = screen.getByRole('button', { name: /open settings/i })
+    fireEvent.click(button)
+    expect(onModelClick).toHaveBeenCalled()
+  })
+})

moav2/src/__tests__/agent-buffer-ui.test.tsx

@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render, screen } from '@testing-library/react'
+import AgentBuffer from '../ui/components/AgentBuffer'
+
+let mockState: any
+const listeners = new Set<() => void>()
+
+vi.mock('../core/services/session-store', () => ({
+  sessionStore: {
+    subscribe: (listener: () => void) => {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    getSession: () => mockState,
+    initSession: vi.fn(),
+    toggleTool: vi.fn(),
+    setInput: vi.fn(),
+    sendMessage: vi.fn(),
+    clearSendError: vi.fn(),
+  },
+}))
+
+describe('AgentBuffer UI states', () => {
+  afterEach(() => {
+    cleanup()
+  })
+
+  beforeEach(() => {
+    ;(Element.prototype as any).scrollIntoView = vi.fn()
+    listeners.clear()
+    mockState = {
+      messages: [],
+      streamingBlocks: [],
+      expandedTools: new Set<string>(),
+      input: '',
+      isLoading: false,
+      isStreaming: false,
+      isWaitingForResponse: false,
+      agentReady: true,
+      sendError: '',
+    }
+  })
+
+  it('shows only the dot indicator while waiting for response', () => {
+    mockState.isWaitingForResponse = true
+    mockState.messages = [
+      {
+        id: 'u1',
+        role: 'user',
+        blocks: [{ id: 'ub1', type: 'text', content: 'hello' }],
+        createdAt: Date.now(),
+      },
+    ]
+
+    render(<AgentBuffer sessionId="s1" model="anthropic-oauth:claude-3-7-sonnet" />)
+
+    expect(screen.getByLabelText('Assistant is thinking')).toBeTruthy()
+    expect(screen.queryByText('Waiting for response')).toBeNull()
+  })
+
+  it('shows streaming thinking block instead of waiting indicator once assistant starts', () => {
+    mockState.isWaitingForResponse = true
+    mockState.isStreaming = true
+    mockState.streamingBlocks = [
+      { id: 't1', type: 'thinking', content: 'Analyzing request...' },
+    ]
+
+    render(<AgentBuffer sessionId="s1" model="anthropic-oauth:claude-3-7-sonnet" />)
+
+    expect(screen.queryByLabelText('Assistant is thinking')).toBeNull()
+    expect(screen.getByText('Thinking...')).toBeTruthy()
+  })
+})

moav2/src/__tests__/browser-buffer-capacitor.test.tsx

@@ -0,0 +1,90 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { act, render } from '@testing-library/react'
+
+const openExternal = vi.fn()
+
+const controllerMock = {
+  open: vi.fn(async () => undefined),
+  setUrl: vi.fn(async () => undefined),
+  goBack: vi.fn(async () => undefined),
+  reload: vi.fn(async () => undefined),
+  show: vi.fn(async () => undefined),
+  hide: vi.fn(async () => undefined),
+  close: vi.fn(async () => undefined),
+  updateBounds: vi.fn(async () => undefined),
+  addEventListener: vi.fn(() => () => undefined),
+}
+
+const createController = vi.fn(() => controllerMock)
+
+vi.mock('../core/platform', () => ({
+  getPlatform: () => ({
+    type: 'capacitor',
+    shell: { openExternal },
+  }),
+}))
+
+vi.mock('../platform/capacitor/capacitor-browser', () => ({
+  createCapacitorBrowserController: () => createController(),
+}))
+
+import BrowserBuffer from '../ui/components/BrowserBuffer'
+
+describe('BrowserBuffer capacitor mode', () => {
+  beforeAll(() => {
+    ;(globalThis as any).ResizeObserver = class {
+      observe() {}
+      disconnect() {}
+    }
+  })
+
+  beforeEach(() => {
+    createController.mockClear()
+    openExternal.mockClear()
+    for (const key of Object.keys(controllerMock) as Array<keyof typeof controllerMock>) {
+      controllerMock[key].mockClear()
+    }
+  })
+
+  it('creates controller lazily and opens when active', async () => {
+    render(<BrowserBuffer id="b1" isActive />)
+    await act(async () => {})
+
+    expect(createController).toHaveBeenCalledTimes(1)
+    expect(controllerMock.open).toHaveBeenCalledTimes(1)
+    expect(controllerMock.open).toHaveBeenCalledWith('https://www.google.com', expect.objectContaining({ width: 1, height: 1 }))
+  })
+
+  it('hides and shows webview for tab switch and palette events', async () => {
+    const { rerender } = render(<BrowserBuffer id="b1" isActive />)
+    await act(async () => {})
+
+    rerender(<BrowserBuffer id="b1" isActive={false} />)
+    await act(async () => {})
+    expect(controllerMock.hide).toHaveBeenCalled()
+
+    rerender(<BrowserBuffer id="b1" isActive />)
+    await act(async () => {})
+    expect(controllerMock.show).toHaveBeenCalled()
+    expect(controllerMock.updateBounds).toHaveBeenCalled()
+
+    act(() => {
+      window.dispatchEvent(new CustomEvent('moa:command-palette-open'))
+    })
+    expect(controllerMock.hide).toHaveBeenCalled()
+
+    act(() => {
+      window.dispatchEvent(new CustomEvent('moa:command-palette-close'))
+    })
+    expect(controllerMock.show).toHaveBeenCalled()
+  })
+
+  it('closes controller on unmount', async () => {
+    const { unmount } = render(<BrowserBuffer id="b1" isActive />)
+    await act(async () => {})
+
+    unmount()
+    await act(async () => {})
+    expect(controllerMock.close).toHaveBeenCalledTimes(1)
+  })
+})

moav2/src/__tests__/browser-history.test.ts

@@ -0,0 +1,596 @@
+/**
+ * Browser History Persistence tests.
+ *
+ * Verifies that the DatabaseManager (IndexedDB-based) correctly persists
+ * sessions and messages across re-initialization, which simulates a browser
+ * page reload. Uses fake-indexeddb to provide IndexedDB in the jsdom test env.
+ *
+ * Tests cover:
+ * - Database initialization
+ * - Session CRUD (create, read, list, update, delete)
+ * - Message persistence (add, retrieve by session, update, delete)
+ * - Session list ordering (most recently updated first)
+ * - Message ordering (chronological)
+ * - Session deletion cascading to messages
+ * - Empty database handling
+ * - Data survives re-initialization (simulated page reload)
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import 'fake-indexeddb/auto'
+import { IDBFactory } from 'fake-indexeddb'
+import { DatabaseManager } from '../core/services/db'
+
+// ---------------------------------------------------------------------------
+// Helper: small delay to ensure distinct timestamps
+// ---------------------------------------------------------------------------
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+// ---------------------------------------------------------------------------
+// Helper: create a fresh DatabaseManager instance (simulates page reload)
+// ---------------------------------------------------------------------------
+async function createFreshDb(): Promise<DatabaseManager> {
+  const mgr = new DatabaseManager()
+  await mgr.init()
+  return mgr
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('Browser History Persistence (DatabaseManager)', () => {
+  let db: DatabaseManager
+
+  beforeEach(async () => {
+    // Reset IndexedDB completely for test isolation
+    globalThis.indexedDB = new IDBFactory()
+    db = await createFreshDb()
+  })
+
+  // =========================================================================
+  // Database Initialization
+  // =========================================================================
+
+  describe('Database Initialization', () => {
+    it('initializes without errors', async () => {
+      const mgr = new DatabaseManager()
+      await expect(mgr.init()).resolves.not.toThrow()
+    })
+
+    it('can be initialized multiple times on the same database (idempotent)', async () => {
+      const mgr1 = await createFreshDb()
+      const mgr2 = await createFreshDb()
+      // Both should work independently on the same underlying DB
+      const s1 = await mgr1.createSession('model-a')
+      const s2 = await mgr2.createSession('model-b')
+      expect(s1.id).toBeTruthy()
+      expect(s2.id).toBeTruthy()
+    })
+  })
+
+  // =========================================================================
+  // Session CRUD
+  // =========================================================================
+
+  describe('Session CRUD', () => {
+    it('creates a session with correct fields', async () => {
+      const session = await db.createSession('claude-3.5-sonnet')
+      expect(session.id).toBeTruthy()
+      expect(session.title).toBe('New Chat')
+      expect(session.model).toBe('claude-3.5-sonnet')
+      expect(session.createdAt).toBeGreaterThan(0)
+      expect(session.updatedAt).toBeGreaterThan(0)
+      expect(session.createdAt).toBe(session.updatedAt)
+    })
+
+    it('retrieves a session by ID', async () => {
+      const created = await db.createSession('model-a')
+      const retrieved = await db.getSession(created.id)
+      expect(retrieved).not.toBeNull()
+      expect(retrieved!.id).toBe(created.id)
+      expect(retrieved!.title).toBe('New Chat')
+      expect(retrieved!.model).toBe('model-a')
+    })
+
+    it('returns null for non-existent session', async () => {
+      const result = await db.getSession('non-existent-id')
+      expect(result).toBeNull()
+    })
+
+    it('lists all sessions', async () => {
+      await db.createSession('model-a')
+      await delay(10)
+      await db.createSession('model-b')
+      await delay(10)
+      await db.createSession('model-c')
+
+      const sessions = await db.listSessions()
+      expect(sessions.length).toBe(3)
+    })
+
+    it('lists sessions sorted by sortOrder ascending (creation date)', async () => {
+      const s1 = await db.createSession('model-a')
+      await delay(15)
+      const s2 = await db.createSession('model-b')
+      await delay(15)
+      const s3 = await db.createSession('model-c')
+
+      const sessions = await db.listSessions()
+      expect(sessions.length).toBe(3)
+      // Sorted by sortOrder ascending (oldest first by default)
+      expect(sessions[0].id).toBe(s1.id)
+      expect(sessions[1].id).toBe(s2.id)
+      expect(sessions[2].id).toBe(s3.id)
+    })
+
+    it('updates session title', async () => {
+      const session = await db.createSession('model-a')
+      await delay(10)
+      const updated = await db.updateSession(session.id, { title: 'My Conversation' })
+      expect(updated).not.toBeNull()
+      expect(updated!.title).toBe('My Conversation')
+      expect(updated!.updatedAt).toBeGreaterThan(session.updatedAt)
+    })
+
+    it('updates session model', async () => {
+      const session = await db.createSession('model-a')
+      await delay(10)
+      const updated = await db.updateSession(session.id, { model: 'model-b' })
+      expect(updated).not.toBeNull()
+      expect(updated!.model).toBe('model-b')
+    })
+
+    it('updateSession returns null for non-existent session', async () => {
+      const result = await db.updateSession('non-existent', { title: 'Nope' })
+      expect(result).toBeNull()
+    })
+
+    it('removes a session', async () => {
+      const session = await db.createSession('model-a')
+      await db.removeSession(session.id)
+      const result = await db.getSession(session.id)
+      expect(result).toBeNull()
+    })
+
+    it('session ordering is stable after update (sortOrder-based)', async () => {
+      const s1 = await db.createSession('model-a')
+      await delay(15)
+      const s2 = await db.createSession('model-b')
+      await delay(15)
+
+      // s1 created first, so it should be first (sortOrder ascending)
+      let sessions = await db.listSessions()
+      expect(sessions[0].id).toBe(s1.id)
+
+      // Updating s1 title does NOT change sortOrder — order remains stable
+      await delay(15)
+      await db.updateSession(s1.id, { title: 'Updated' })
+
+      sessions = await db.listSessions()
+      expect(sessions[0].id).toBe(s1.id)
+      expect(sessions[1].id).toBe(s2.id)
+    })
+  })
+
+  // =========================================================================
+  // Message Persistence
+  // =========================================================================
+
+  describe('Message Persistence', () => {
+    let sessionId: string
+
+    beforeEach(async () => {
+      const session = await db.createSession('test-model')
+      sessionId = session.id
+    })
+
+    it('adds a message with correct fields', async () => {
+      const msg = await db.addMessage(sessionId, 'user', 'Hello world')
+      expect(msg.id).toBeTruthy()
+      expect(msg.sessionId).toBe(sessionId)
+      expect(msg.role).toBe('user')
+      expect(msg.content).toBe('Hello world')
+      expect(msg.createdAt).toBeGreaterThan(0)
+    })
+
+    it('retrieves messages by session ID', async () => {
+      await db.addMessage(sessionId, 'user', 'First message')
+      await delay(5)
+      await db.addMessage(sessionId, 'assistant', 'Second message')
+
+      const messages = await db.getMessages(sessionId)
+      expect(messages.length).toBe(2)
+      expect(messages[0].content).toBe('First message')
+      expect(messages[1].content).toBe('Second message')
+    })
+
+    it('messages are ordered chronologically (createdAt ascending)', async () => {
+      await db.addMessage(sessionId, 'user', 'First')
+      await delay(10)
+      await db.addMessage(sessionId, 'assistant', 'Second')
+      await delay(10)
+      await db.addMessage(sessionId, 'user', 'Third')
+
+      const messages = await db.getMessages(sessionId)
+      expect(messages.length).toBe(3)
+      expect(messages[0].content).toBe('First')
+      expect(messages[1].content).toBe('Second')
+      expect(messages[2].content).toBe('Third')
+      // Verify ordering
+      expect(messages[0].createdAt).toBeLessThanOrEqual(messages[1].createdAt)
+      expect(messages[1].createdAt).toBeLessThanOrEqual(messages[2].createdAt)
+    })
+
+    it('messages are scoped to their session', async () => {
+      const session2 = await db.createSession('model-b')
+      await db.addMessage(sessionId, 'user', 'Session 1 message')
+      await db.addMessage(session2.id, 'user', 'Session 2 message')
+
+      const msgs1 = await db.getMessages(sessionId)
+      const msgs2 = await db.getMessages(session2.id)
+
+      expect(msgs1.length).toBe(1)
+      expect(msgs1[0].content).toBe('Session 1 message')
+      expect(msgs2.length).toBe(1)
+      expect(msgs2[0].content).toBe('Session 2 message')
+    })
+
+    it('addMessage updates session updatedAt', async () => {
+      const sessionBefore = await db.getSession(sessionId)
+      await delay(15)
+      await db.addMessage(sessionId, 'user', 'New message')
+      const sessionAfter = await db.getSession(sessionId)
+
+      expect(sessionAfter).not.toBeNull()
+      expect(sessionAfter!.updatedAt).toBeGreaterThan(sessionBefore!.updatedAt)
+    })
+
+    it('adds message with blocks', async () => {
+      const blocks = [
+        { id: 'b1', type: 'text' as const, content: 'Hello' },
+        { id: 'b2', type: 'tool' as const, toolName: 'bash', status: 'completed' as const },
+      ]
+      const msg = await db.addMessage(sessionId, 'assistant', 'text', { blocks })
+      expect(msg.blocks).toBeDefined()
+      expect(msg.blocks!.length).toBe(2)
+      expect(msg.blocks![0].content).toBe('Hello')
+      expect(msg.blocks![1].toolName).toBe('bash')
+    })
+
+    it('adds message with partial flag', async () => {
+      const msg = await db.addMessage(sessionId, 'assistant', '', { partial: true })
+      expect(msg.partial).toBe(true)
+    })
+
+    it('adds message with custom ID', async () => {
+      const customId = 'custom-msg-id-123'
+      const msg = await db.addMessage(sessionId, 'user', 'With custom ID', { id: customId })
+      expect(msg.id).toBe(customId)
+    })
+
+    it('updates message content', async () => {
+      const msg = await db.addMessage(sessionId, 'assistant', 'Initial')
+      await db.updateMessage(msg.id, { content: 'Updated content' })
+
+      const messages = await db.getMessages(sessionId)
+      expect(messages[0].content).toBe('Updated content')
+    })
+
+    it('updates message partial flag', async () => {
+      const msg = await db.addMessage(sessionId, 'assistant', '', { partial: true })
+      await db.updateMessage(msg.id, { partial: false })
+
+      const messages = await db.getMessages(sessionId)
+      // partial should be explicitly false
+      expect(messages[0].partial).toBe(false)
+    })
+
+    it('removes a message', async () => {
+      const msg = await db.addMessage(sessionId, 'user', 'To be deleted')
+      expect((await db.getMessages(sessionId)).length).toBe(1)
+
+      await db.removeMessage(msg.id)
+      expect((await db.getMessages(sessionId)).length).toBe(0)
+    })
+  })
+
+  // =========================================================================
+  // Session Deletion Cascade
+  // =========================================================================
+
+  describe('Session Deletion Cascade', () => {
+    it('deleting a session also deletes its messages', async () => {
+      const session = await db.createSession('model-a')
+      await db.addMessage(session.id, 'user', 'Message 1')
+      await db.addMessage(session.id, 'assistant', 'Message 2')
+      await db.addMessage(session.id, 'user', 'Message 3')
+
+      // Verify messages exist
+      expect((await db.getMessages(session.id)).length).toBe(3)
+
+      // Delete session
+      await db.removeSession(session.id)
+
+      // Session should be gone
+      expect(await db.getSession(session.id)).toBeNull()
+
+      // Messages should also be gone
+      expect((await db.getMessages(session.id)).length).toBe(0)
+    })
+
+    it('deleting a session does not affect other sessions messages', async () => {
+      const s1 = await db.createSession('model-a')
+      const s2 = await db.createSession('model-b')
+      await db.addMessage(s1.id, 'user', 'S1 message')
+      await db.addMessage(s2.id, 'user', 'S2 message')
+
+      // Delete s1
+      await db.removeSession(s1.id)
+
+      // s2 messages should be intact
+      const s2Messages = await db.getMessages(s2.id)
+      expect(s2Messages.length).toBe(1)
+      expect(s2Messages[0].content).toBe('S2 message')
+    })
+  })
+
+  // =========================================================================
+  // Empty Database Handling
+  // =========================================================================
+
+  describe('Empty Database Handling', () => {
+    it('listSessions returns empty array when no sessions exist', async () => {
+      const sessions = await db.listSessions()
+      expect(sessions).toEqual([])
+    })
+
+    it('getMessages returns empty array for non-existent session', async () => {
+      const messages = await db.getMessages('non-existent-session-id')
+      expect(messages).toEqual([])
+    })
+
+    it('getMessages returns empty array for session with no messages', async () => {
+      const session = await db.createSession('model-a')
+      const messages = await db.getMessages(session.id)
+      expect(messages).toEqual([])
+    })
+  })
+
+  // =========================================================================
+  // Data Survives Re-initialization (Simulated Page Reload)
+  // =========================================================================
+
+  describe('Persistence Across Re-initialization', () => {
+    it('sessions survive re-initialization', async () => {
+      const session = await db.createSession('model-a')
+      await db.updateSession(session.id, { title: 'Persistent Chat' })
+
+      // Simulate page reload: create a new DatabaseManager on the same IndexedDB
+      const db2 = await createFreshDb()
+
+      const sessions = await db2.listSessions()
+      expect(sessions.length).toBe(1)
+      expect(sessions[0].id).toBe(session.id)
+      expect(sessions[0].title).toBe('Persistent Chat')
+      expect(sessions[0].model).toBe('model-a')
+    })
+
+    it('messages survive re-initialization', async () => {
+      const session = await db.createSession('model-a')
+      await db.addMessage(session.id, 'user', 'Hello!')
+      await delay(5)
+      await db.addMessage(session.id, 'assistant', 'Hi there!')
+
+      // Simulate page reload
+      const db2 = await createFreshDb()
+
+      const messages = await db2.getMessages(session.id)
+      expect(messages.length).toBe(2)
+      expect(messages[0].role).toBe('user')
+      expect(messages[0].content).toBe('Hello!')
+      expect(messages[1].role).toBe('assistant')
+      expect(messages[1].content).toBe('Hi there!')
+    })
+
+    it('multiple sessions and messages survive re-initialization', async () => {
+      const s1 = await db.createSession('model-a')
+      const s2 = await db.createSession('model-b')
+      await db.addMessage(s1.id, 'user', 'S1 msg 1')
+      await db.addMessage(s1.id, 'assistant', 'S1 msg 2')
+      await db.addMessage(s2.id, 'user', 'S2 msg 1')
+
+      // Simulate page reload
+      const db2 = await createFreshDb()
+
+      const sessions = await db2.listSessions()
+      expect(sessions.length).toBe(2)
+
+      const s1msgs = await db2.getMessages(s1.id)
+      const s2msgs = await db2.getMessages(s2.id)
+      expect(s1msgs.length).toBe(2)
+      expect(s2msgs.length).toBe(1)
+    })
+
+    it('message blocks survive re-initialization', async () => {
+      const session = await db.createSession('model-a')
+      const blocks = [
+        { id: 'blk-1', type: 'text' as const, content: 'Markdown content here' },
+        { id: 'blk-2', type: 'tool' as const, toolName: 'read', args: { path: '/a.txt' }, status: 'completed' as const, result: 'file contents' },
+      ]
+      await db.addMessage(session.id, 'assistant', 'text', { blocks })
+
+      // Simulate page reload
+      const db2 = await createFreshDb()
+
+      const messages = await db2.getMessages(session.id)
+      expect(messages.length).toBe(1)
+      expect(messages[0].blocks).toBeDefined()
+      expect(messages[0].blocks!.length).toBe(2)
+      expect(messages[0].blocks![0].content).toBe('Markdown content here')
+      expect(messages[0].blocks![1].toolName).toBe('read')
+      expect(messages[0].blocks![1].result).toBe('file contents')
+    })
+
+    it('session ordering is preserved after re-initialization', async () => {
+      const s1 = await db.createSession('model-a')
+      await delay(15)
+      const s2 = await db.createSession('model-b')
+      await delay(15)
+      const s3 = await db.createSession('model-c')
+
+      // Simulate page reload
+      const db2 = await createFreshDb()
+
+      const sessions = await db2.listSessions()
+      // Sorted by sortOrder ascending (oldest first)
+      expect(sessions[0].id).toBe(s1.id)
+      expect(sessions[1].id).toBe(s2.id)
+      expect(sessions[2].id).toBe(s3.id)
+    })
+
+    it('deleted sessions stay deleted after re-initialization', async () => {
+      const s1 = await db.createSession('model-a')
+      const s2 = await db.createSession('model-b')
+      await db.addMessage(s1.id, 'user', 'msg')
+      await db.removeSession(s1.id)
+
+      // Simulate page reload
+      const db2 = await createFreshDb()
+
+      const sessions = await db2.listSessions()
+      expect(sessions.length).toBe(1)
+      expect(sessions[0].id).toBe(s2.id)
+
+      // s1 messages should also be gone
+      const s1msgs = await db2.getMessages(s1.id)
+      expect(s1msgs.length).toBe(0)
+    })
+  })
+
+  // =========================================================================
+  // Provider Operations (Basic Verification)
+  // =========================================================================
+
+  describe('Provider Operations', () => {
+    it('adds and lists providers', async () => {
+      const provider = await db.addProvider('TestProvider', 'https://api.test.com', 'test-key-123')
+      expect(provider.id).toBeTruthy()
+      expect(provider.name).toBe('TestProvider')
+      expect(provider.baseUrl).toBe('https://api.test.com')
+
+      const providers = await db.listProviders()
+      expect(providers.length).toBe(1)
+      expect(providers[0].name).toBe('TestProvider')
+    })
+
+    it('removes trailing slash from baseUrl', async () => {
+      const provider = await db.addProvider('Test', 'https://api.test.com///', 'key')
+      expect(provider.baseUrl).toBe('https://api.test.com')
+    })
+
+    it('providers survive re-initialization', async () => {
+      await db.addProvider('Persistent', 'https://api.persist.com', 'key')
+
+      const db2 = await createFreshDb()
+      const providers = await db2.listProviders()
+      expect(providers.length).toBe(1)
+      expect(providers[0].name).toBe('Persistent')
+    })
+  })
+
+  // =========================================================================
+  // OAuth Credentials (Basic Verification)
+  // =========================================================================
+
+  describe('OAuth Credentials', () => {
+    it('stores and retrieves OAuth credentials', async () => {
+      await db.setOAuthCredentials('anthropic', {
+        refresh: 'refresh-token',
+        access: 'access-token',
+        expires: Date.now() + 3600000,
+      })
+
+      const creds = await db.getOAuthCredentials('anthropic')
+      expect(creds).not.toBeNull()
+      expect(creds!.refresh).toBe('refresh-token')
+      expect(creds!.access).toBe('access-token')
+    })
+
+    it('removes OAuth credentials', async () => {
+      await db.setOAuthCredentials('anthropic', {
+        refresh: 'r', access: 'a', expires: 0,
+      })
+      await db.removeOAuthCredentials('anthropic')
+      const creds = await db.getOAuthCredentials('anthropic')
+      expect(creds).toBeNull()
+    })
+
+    it('OAuth credentials survive re-initialization', async () => {
+      await db.setOAuthCredentials('google', {
+        refresh: 'g-refresh', access: 'g-access', expires: 9999999,
+      })
+
+      const db2 = await createFreshDb()
+      const creds = await db2.getOAuthCredentials('google')
+      expect(creds).not.toBeNull()
+      expect(creds!.refresh).toBe('g-refresh')
+    })
+  })
+
+  // =========================================================================
+  // Edge Cases
+  // =========================================================================
+
+  describe('Edge Cases', () => {
+    it('handles many sessions', async () => {
+      const count = 20
+      for (let i = 0; i < count; i++) {
+        await db.createSession(`model-${i}`)
+      }
+      const sessions = await db.listSessions()
+      expect(sessions.length).toBe(count)
+    })
+
+    it('handles many messages in one session', async () => {
+      const session = await db.createSession('model-a')
+      const count = 50
+      for (let i = 0; i < count; i++) {
+        await db.addMessage(session.id, i % 2 === 0 ? 'user' : 'assistant', `Message ${i}`)
+      }
+      const messages = await db.getMessages(session.id)
+      expect(messages.length).toBe(count)
+      // Verify chronological ordering
+      for (let i = 1; i < messages.length; i++) {
+        expect(messages[i].createdAt).toBeGreaterThanOrEqual(messages[i - 1].createdAt)
+      }
+    })
+
+    it('handles empty string content in messages', async () => {
+      const session = await db.createSession('model-a')
+      const msg = await db.addMessage(session.id, 'assistant', '')
+      expect(msg.content).toBe('')
+
+      const messages = await db.getMessages(session.id)
+      expect(messages[0].content).toBe('')
+    })
+
+    it('handles special characters in session title', async () => {
+      const session = await db.createSession('model-a')
+      await db.updateSession(session.id, { title: 'Session with "quotes" & <tags> and unicode: \u{1F680}' })
+
+      const retrieved = await db.getSession(session.id)
+      expect(retrieved!.title).toBe('Session with "quotes" & <tags> and unicode: \u{1F680}')
+    })
+
+    it('handles special characters in message content', async () => {
+      const session = await db.createSession('model-a')
+      const content = '```javascript\nconsole.log("hello")\n```\n\nUnicode: \u{1F600} \nHTML: <div class="test">&amp;</div>'
+      await db.addMessage(session.id, 'user', content)
+
+      const messages = await db.getMessages(session.id)
+      expect(messages[0].content).toBe(content)
+    })
+  })
+})

moav2/src/__tests__/capacitor-boot.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest'
+import 'fake-indexeddb/auto'
+import { setPlatform, getPlatform } from '../core/platform'
+import { createCapacitorPlatform } from '../platform/capacitor'
+
+// Mock capacitor environment globals if necessary
+vi.mock('@capacitor/browser', () => ({
+  Browser: {
+    open: vi.fn().mockResolvedValue(undefined)
+  }
+}))
+
+describe('Platform Boot (Capacitor)', () => {
+  beforeAll(async () => {
+    // We assume createCapacitorPlatform handles its own setup.
+    // For now, it might reuse some browser components (like ZenFS) 
+    // or provide its own capacitor-specific implementations.
+    const platform = await createCapacitorPlatform()
+    setPlatform(platform)
+  })
+
+  it('initializes capacitor platform', () => {
+    expect(getPlatform().type).toBe('capacitor')
+  })
+
+  it('has filesystem with read/write', async () => {
+    const { fs } = getPlatform()
+    fs.mkdirSync('/test-cap', { recursive: true })
+    fs.writeFileSync('/test-cap/hello.txt', 'world')
+    expect(fs.readFileSync('/test-cap/hello.txt', 'utf-8')).toBe('world')
+  })
+
+  it('has filesystem async read/write', async () => {
+    const { fs } = getPlatform()
+    fs.mkdirSync('/test-cap', { recursive: true })
+    await fs.writeFile('/test-cap/hello-async.txt', 'world-async')
+    const content = await fs.readFile('/test-cap/hello-async.txt', 'utf-8')
+    expect(content).toBe('world-async')
+  })
+  
+  it('has process stub', () => {
+    const { process } = getPlatform()
+    expect(process.cwd()).toBe('/')
+    expect(typeof process.env).toBe('object')
+  })
+
+  it('has shell with openExternal', () => {
+    expect(getPlatform().shell.openExternal).toBeDefined()
+    expect(typeof getPlatform().shell.openExternal).toBe('function')
+  })
+
+  it('has sqlite interface', () => {
+    expect(getPlatform().sqlite).toBeDefined()
+    expect(typeof getPlatform().sqlite.open).toBe('function')
+  })
+})

moav2/src/__tests__/capacitor-browser.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCapacitorBrowserController } from '../platform/capacitor/capacitor-browser'
+
+describe('capacitor browser controller', () => {
+  const listeners = new Map<string, (event: any) => void>()
+
+  const plugin = {
+    openWebView: vi.fn(async () => ({ id: 'wv-1' })),
+    setUrl: vi.fn(async () => ({})),
+    goBack: vi.fn(async () => ({})),
+    reload: vi.fn(async () => ({})),
+    show: vi.fn(async () => undefined),
+    hide: vi.fn(async () => undefined),
+    close: vi.fn(async () => ({})),
+    updateDimensions: vi.fn(async () => undefined),
+    addListener: vi.fn(async (eventName: string, listener: (event: any) => void) => {
+      listeners.set(eventName, listener)
+      return { remove: vi.fn(async () => undefined) }
+    }),
+  }
+
+  beforeEach(() => {
+    listeners.clear()
+    for (const value of Object.values(plugin)) {
+      value.mockClear()
+    }
+    ;(window as any).__moaCapgoInAppBrowser = { InAppBrowser: plugin }
+  })
+
+  it('opens webview and proxies controller methods', async () => {
+    const controller = createCapacitorBrowserController()
+    await controller.open('https://example.com', { x: 10, y: 20, width: 200, height: 300 })
+
+    expect(plugin.openWebView).toHaveBeenCalledWith(expect.objectContaining({
+      url: 'https://example.com',
+      x: 10,
+      y: 20,
+      width: 200,
+      height: 300,
+      toolbarType: 'navigation',
+    }))
+
+    await controller.setUrl('https://next.example.com')
+    await controller.goBack()
+    await controller.reload()
+    await controller.hide()
+    await controller.show()
+    await controller.updateBounds({ x: 1, y: 2, width: 3, height: 4 })
+    await controller.close()
+
+    expect(plugin.setUrl).toHaveBeenCalledWith({ id: 'wv-1', url: 'https://next.example.com' })
+    expect(plugin.goBack).toHaveBeenCalledWith({ id: 'wv-1' })
+    expect(plugin.reload).toHaveBeenCalledWith({ id: 'wv-1' })
+    expect(plugin.hide).toHaveBeenCalled()
+    expect(plugin.show).toHaveBeenCalled()
+    expect(plugin.updateDimensions).toHaveBeenCalledWith({ id: 'wv-1', x: 1, y: 2, width: 3, height: 4 })
+    expect(plugin.close).toHaveBeenCalledWith({ id: 'wv-1' })
+  })
+
+  it('emits url, loaded, error, and close events', async () => {
+    const controller = createCapacitorBrowserController()
+    const onUrl = vi.fn()
+    const onLoaded = vi.fn()
+    const onError = vi.fn()
+    const onClose = vi.fn()
+
+    controller.addEventListener('url', onUrl)
+    controller.addEventListener('loaded', onLoaded)
+    controller.addEventListener('error', onError)
+    controller.addEventListener('close', onClose)
+
+    await controller.open('https://example.com')
+
+    listeners.get('urlChangeEvent')?.({ id: 'wv-1', url: 'https://changed.example.com' })
+    listeners.get('browserPageLoaded')?.({ id: 'wv-1' })
+    listeners.get('pageLoadError')?.({ id: 'wv-1', message: 'bad gateway' })
+    listeners.get('closeEvent')?.({ id: 'wv-1' })
+
+    expect(onUrl).toHaveBeenCalledWith({ url: 'https://changed.example.com' })
+    expect(onLoaded).toHaveBeenCalledWith({})
+    expect(onError).toHaveBeenCalledWith({ message: 'bad gateway' })
+    expect(onClose).toHaveBeenCalledWith({})
+  })
+})

moav2/src/__tests__/capacitor-mini-shell.test.ts

@@ -0,0 +1,157 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCapacitorMiniShell } from '../platform/capacitor/capacitor-mini-shell'
+import { setPlatform } from '../core/platform'
+import path from 'path'
+
+function createMemoryFs() {
+  const files = new Map<string, string>()
+  const dirs = new Set<string>(['/'])
+
+  const normalize = (p: string) => path.posix.resolve('/', p)
+
+  const ensureDir = (p: string) => {
+    const target = normalize(p)
+    const stack: string[] = []
+    let cursor = target
+    while (!dirs.has(cursor) && cursor !== '/') {
+      stack.push(cursor)
+      cursor = path.posix.dirname(cursor)
+    }
+    dirs.add('/')
+    while (stack.length > 0) {
+      dirs.add(stack.pop() as string)
+    }
+  }
+
+  return {
+    readFile: async (p: string) => files.get(normalize(p)) || '',
+    readFileSync: (p: string) => files.get(normalize(p)) || '',
+    writeFile: async (p: string, content: string) => {
+      const n = normalize(p)
+      ensureDir(path.posix.dirname(n))
+      files.set(n, content)
+    },
+    writeFileSync: (p: string, content: string) => {
+      const n = normalize(p)
+      ensureDir(path.posix.dirname(n))
+      files.set(n, content)
+    },
+    existsSync: (p: string) => {
+      const n = normalize(p)
+      return files.has(n) || dirs.has(n)
+    },
+    mkdirSync: (p: string) => {
+      ensureDir(p)
+    },
+    readdirSync: (p: string) => {
+      const n = normalize(p)
+      const out: string[] = []
+      for (const dir of dirs) {
+        if (dir !== n && path.posix.dirname(dir) === n) out.push(path.posix.basename(dir))
+      }
+      for (const file of files.keys()) {
+        if (path.posix.dirname(file) === n) out.push(path.posix.basename(file))
+      }
+      return out.sort()
+    },
+    statSync: (p: string) => {
+      const n = normalize(p)
+      return {
+        isFile: () => files.has(n),
+        isDirectory: () => dirs.has(n),
+        size: files.get(n)?.length || 0,
+      }
+    },
+    unlinkSync: (p: string) => {
+      files.delete(normalize(p))
+    },
+  }
+}
+
+describe('capacitor mini shell', () => {
+  let shell: ReturnType<typeof createCapacitorMiniShell>
+  const execSpy = vi.fn(async () => ({ stdout: '', stderr: '', exitCode: 0 }))
+  const execSyncSpy = vi.fn(() => '')
+
+  beforeAll(async () => {
+    const fs = createMemoryFs()
+    setPlatform({
+      type: 'capacitor',
+      fs: fs as any,
+      path: path.posix as any,
+      process: {
+        exec: execSpy,
+        execSync: execSyncSpy,
+        cwd: () => '/',
+        env: {},
+        homedir: () => '/',
+      },
+      sqlite: { open: async () => ({ exec: async () => {}, prepare: () => ({ run: async () => {}, get: async () => ({}), all: async () => [] }), close: async () => {} }) },
+      shell: { openExternal: () => {} },
+    } as any)
+  })
+
+  beforeEach(() => {
+    shell = createCapacitorMiniShell()
+  })
+
+  it('supports pwd and cd', async () => {
+    const pwd = await shell.execute('pwd')
+    expect(pwd.output).toBe('/')
+
+    await shell.execute('mkdir docs')
+    const cd = await shell.execute('cd docs')
+    expect(cd.output).toBe('')
+
+    const pwd2 = await shell.execute('pwd')
+    expect(pwd2.output).toBe('/docs')
+
+    const badCd = await shell.execute('cd missing')
+    expect(badCd.output).toContain('no such file or directory')
+    expect(shell.getCwd()).toBe('/docs')
+  })
+
+  it('supports touch, ls, cat, echo, rm', async () => {
+    await shell.execute('mkdir notes')
+    await shell.execute('cd notes')
+    await shell.execute('touch todo.txt')
+    await shell.execute('mkdir dir-a')
+
+    const ls = await shell.execute('ls')
+    expect(ls.output).toContain('todo.txt')
+    expect(ls.output).toContain('dir-a/')
+
+    const echo = await shell.execute('echo hello')
+    expect(echo.output).toBe('hello')
+
+    const echoQuoted = await shell.execute('echo "hello world"')
+    expect(echoQuoted.output).toBe('hello world')
+
+    const cat = await shell.execute('cat todo.txt')
+    expect(cat.output).toBe('')
+
+    await shell.execute('touch nested/a/b.txt')
+    const nested = await shell.execute('ls nested')
+    expect(nested.output).toContain('a/')
+
+    const rm = await shell.execute('rm todo.txt')
+    expect(rm.output).toBe('')
+
+    const rmDir = await shell.execute('rm dir-a')
+    expect(rmDir.output).toContain('Is a directory')
+  })
+
+  it('supports help, clear and unknown commands', async () => {
+    const help = await shell.execute('help')
+    expect(help.output).toContain('print current directory')
+
+    const clear = await shell.execute('clear')
+    expect(clear.clear).toBe(true)
+
+    const unknown = await shell.execute('nope')
+    expect(unknown.output).toContain('command not found: nope')
+
+    expect(execSpy).not.toHaveBeenCalled()
+    expect(execSyncSpy).not.toHaveBeenCalled()
+  })
+})

moav2/src/__tests__/cli-history.test.ts

@@ -0,0 +1,505 @@
+/**
+ * CLI History tests — TDD tests for the terminal chat history CLI tool.
+ *
+ * Tests the database reader, command formatting (list, view, search),
+ * and edge cases (empty DB, missing sessions, partial messages, JSON output).
+ *
+ * Uses the configured SQLite adapter in in-memory mode for fast, real-fidelity testing.
+ */
+
+// @vitest-environment node
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import {
+  HistoryDbReader,
+  type CliSession,
+  type CliMessage,
+} from '../cli/db-reader'
+import {
+  formatSessionList,
+  formatSessionView,
+  formatSearchResults,
+} from '../cli/history'
+
+// ---------------------------------------------------------------------------
+// Helper: seed test data into a HistoryDbReader's underlying database
+// ---------------------------------------------------------------------------
+
+async function createTestReader(): Promise<HistoryDbReader> {
+  return await HistoryDbReader.create(':memory:')
+}
+
+async function seedSessions(reader: HistoryDbReader, count: number): Promise<CliSession[]> {
+  const sessions: CliSession[] = []
+  for (let i = 0; i < count; i++) {
+    const session: CliSession = {
+      id: `session-${i + 1}`,
+      title: `Chat ${i + 1}`,
+      model: `claude-3-${i % 2 === 0 ? 'opus' : 'sonnet'}`,
+      createdAt: 1700000000000 + i * 3600000,
+      updatedAt: 1700000000000 + i * 3600000 + 1800000,
+    }
+    await reader.insertSession(session)
+    sessions.push(session)
+  }
+  return sessions
+}
+
+async function seedMessages(
+  reader: HistoryDbReader,
+  sessionId: string,
+  messages: Array<{ role: string; content: string; partial?: boolean }>
+): Promise<CliMessage[]> {
+  const result: CliMessage[] = []
+  for (let i = 0; i < messages.length; i++) {
+    const msg: CliMessage = {
+      id: `msg-${sessionId}-${i + 1}`,
+      sessionId,
+      role: messages[i].role as 'user' | 'assistant' | 'system',
+      content: messages[i].content,
+      partial: messages[i].partial ? 1 : 0,
+      createdAt: 1700000000000 + i * 60000,
+    }
+    await reader.insertMessage(msg)
+    result.push(msg)
+  }
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Database Reader Tests
+// ---------------------------------------------------------------------------
+
+describe('HistoryDbReader', () => {
+  let reader: HistoryDbReader
+
+  beforeEach(async () => {
+    reader = await createTestReader()
+  })
+
+  afterEach(async () => {
+    await reader.close()
+  })
+
+  it('creates tables on initialization', async () => {
+    // If we can list sessions without error, tables exist
+    const sessions = await reader.listSessions()
+    expect(sessions).toEqual([])
+  })
+
+  it('lists sessions sorted by updatedAt descending', async () => {
+    await seedSessions(reader, 3)
+    const sessions = await reader.listSessions()
+    expect(sessions).toHaveLength(3)
+    // Most recently updated first
+    expect(sessions[0].id).toBe('session-3')
+    expect(sessions[1].id).toBe('session-2')
+    expect(sessions[2].id).toBe('session-1')
+  })
+
+  it('lists sessions with limit', async () => {
+    await seedSessions(reader, 5)
+    const sessions = await reader.listSessions(2)
+    expect(sessions).toHaveLength(2)
+    expect(sessions[0].id).toBe('session-5')
+    expect(sessions[1].id).toBe('session-4')
+  })
+
+  it('gets a session by ID', async () => {
+    await seedSessions(reader, 2)
+    const session = await reader.getSession('session-1')
+    expect(session).toBeDefined()
+    expect(session!.title).toBe('Chat 1')
+    expect(session!.model).toBe('claude-3-opus')
+  })
+
+  it('returns null for non-existent session', async () => {
+    const session = await reader.getSession('nonexistent')
+    expect(session).toBeNull()
+  })
+
+  it('gets messages for a session sorted by createdAt ascending', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there!' },
+      { role: 'user', content: 'How are you?' },
+    ])
+
+    const messages = await reader.getMessages('session-1')
+    expect(messages).toHaveLength(3)
+    expect(messages[0].content).toBe('Hello')
+    expect(messages[1].content).toBe('Hi there!')
+    expect(messages[2].content).toBe('How are you?')
+  })
+
+  it('filters out partial messages', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Partial response...', partial: true },
+      { role: 'assistant', content: 'Complete response' },
+    ])
+
+    const messages = await reader.getMessages('session-1')
+    expect(messages).toHaveLength(2)
+    expect(messages[0].content).toBe('Hello')
+    expect(messages[1].content).toBe('Complete response')
+  })
+
+  it('filters messages by role', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Q1' },
+      { role: 'assistant', content: 'A1' },
+      { role: 'user', content: 'Q2' },
+      { role: 'assistant', content: 'A2' },
+    ])
+
+    const userMsgs = await reader.getMessages('session-1', { role: 'user' })
+    expect(userMsgs).toHaveLength(2)
+    expect(userMsgs.every(m => m.role === 'user')).toBe(true)
+  })
+
+  it('limits messages', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Msg 1' },
+      { role: 'assistant', content: 'Msg 2' },
+      { role: 'user', content: 'Msg 3' },
+      { role: 'assistant', content: 'Msg 4' },
+      { role: 'user', content: 'Msg 5' },
+    ])
+
+    const messages = await reader.getMessages('session-1', { limit: 2 })
+    // Limit takes the last N messages
+    expect(messages).toHaveLength(2)
+    expect(messages[0].content).toBe('Msg 4')
+    expect(messages[1].content).toBe('Msg 5')
+  })
+
+  it('returns empty array for messages of non-existent session', async () => {
+    const messages = await reader.getMessages('nonexistent')
+    expect(messages).toEqual([])
+  })
+
+  it('searches messages case-insensitively', async () => {
+    await seedSessions(reader, 2)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Fix the LOGIN bug' },
+      { role: 'assistant', content: 'I will check the login handler' },
+    ])
+    await seedMessages(reader, 'session-2', [
+      { role: 'user', content: 'Refactor the auth module' },
+    ])
+
+    const results = await reader.searchMessages('login')
+    expect(results).toHaveLength(2)
+    // Results are ordered by createdAt DESC, so the assistant message (later timestamp) comes first
+    const contents = results.map(r => r.content)
+    expect(contents.some(c => c.includes('LOGIN'))).toBe(true)
+    expect(contents.some(c => c.includes('login handler'))).toBe(true)
+  })
+
+  it('searches messages with session filter', async () => {
+    await seedSessions(reader, 2)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Fix the login bug' },
+    ])
+    await seedMessages(reader, 'session-2', [
+      { role: 'user', content: 'The login page is broken' },
+    ])
+
+    const results = await reader.searchMessages('login', { sessionId: 'session-1' })
+    expect(results).toHaveLength(1)
+    expect(results[0].sessionId).toBe('session-1')
+  })
+
+  it('searches messages with limit', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'the first message' },
+      { role: 'assistant', content: 'the second message' },
+      { role: 'user', content: 'the third message' },
+    ])
+
+    const results = await reader.searchMessages('the', { limit: 2 })
+    expect(results).toHaveLength(2)
+  })
+
+  it('returns empty for search with no matches', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello world' },
+    ])
+
+    const results = await reader.searchMessages('xyznonexistent')
+    expect(results).toEqual([])
+  })
+
+  it('excludes partial messages from search results', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'assistant', content: 'partial match here', partial: true },
+      { role: 'assistant', content: 'complete match here' },
+    ])
+
+    const results = await reader.searchMessages('match')
+    expect(results).toHaveLength(1)
+    expect(results[0].content).toBe('complete match here')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// History Formatting Tests
+// ---------------------------------------------------------------------------
+
+describe('formatSessionList', () => {
+  let reader: HistoryDbReader
+
+  beforeEach(async () => {
+    reader = await createTestReader()
+  })
+
+  afterEach(async () => {
+    await reader.close()
+  })
+
+  it('returns formatted list of sessions', async () => {
+    await seedSessions(reader, 3)
+    const output = await formatSessionList(reader, {})
+    expect(output).toContain('3 session(s)')
+    expect(output).toContain('session-1')
+    expect(output).toContain('session-2')
+    expect(output).toContain('session-3')
+    expect(output).toContain('Chat 1')
+    expect(output).toContain('Chat 2')
+    expect(output).toContain('Chat 3')
+    expect(output).toContain('claude-3-opus')
+  })
+
+  it('returns "No sessions found." for empty database', async () => {
+    const output = await formatSessionList(reader, {})
+    expect(output).toBe('No sessions found.')
+  })
+
+  it('respects limit option', async () => {
+    await seedSessions(reader, 5)
+    const output = await formatSessionList(reader, { limit: 2 })
+    expect(output).toContain('2 session(s)')
+    // Should contain the 2 most recent, not the oldest
+    expect(output).toContain('session-5')
+    expect(output).toContain('session-4')
+    expect(output).not.toContain('session-1')
+  })
+
+  it('outputs JSON when json flag is set', async () => {
+    await seedSessions(reader, 2)
+    const output = await formatSessionList(reader, { json: true })
+    const parsed = JSON.parse(output)
+    expect(Array.isArray(parsed)).toBe(true)
+    expect(parsed).toHaveLength(2)
+    expect(parsed[0]).toHaveProperty('id')
+    expect(parsed[0]).toHaveProperty('title')
+    expect(parsed[0]).toHaveProperty('model')
+  })
+
+  it('outputs empty JSON array for empty database with json flag', async () => {
+    const output = await formatSessionList(reader, { json: true })
+    const parsed = JSON.parse(output)
+    expect(parsed).toEqual([])
+  })
+})
+
+describe('formatSessionView', () => {
+  let reader: HistoryDbReader
+
+  beforeEach(async () => {
+    reader = await createTestReader()
+  })
+
+  afterEach(async () => {
+    await reader.close()
+  })
+
+  it('returns formatted messages for a session', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello there' },
+      { role: 'assistant', content: 'Hi! How can I help?' },
+    ])
+
+    const output = await formatSessionView(reader, 'session-1', {})
+    expect(output).toContain('Chat 1')
+    expect(output).toContain('session-1')
+    expect(output).toContain('user')
+    expect(output).toContain('Hello there')
+    expect(output).toContain('assistant')
+    expect(output).toContain('Hi! How can I help?')
+  })
+
+  it('returns error for non-existent session', async () => {
+    const output = await formatSessionView(reader, 'nonexistent', {})
+    expect(output).toContain('Session not found: nonexistent')
+  })
+
+  it('filters messages by role', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Question 1' },
+      { role: 'assistant', content: 'Answer 1' },
+      { role: 'user', content: 'Question 2' },
+    ])
+
+    const output = await formatSessionView(reader, 'session-1', { role: 'user' })
+    expect(output).toContain('Question 1')
+    expect(output).toContain('Question 2')
+    expect(output).not.toContain('Answer 1')
+  })
+
+  it('excludes partial messages', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Partial...', partial: true },
+      { role: 'assistant', content: 'Complete response' },
+    ])
+
+    const output = await formatSessionView(reader, 'session-1', {})
+    expect(output).toContain('Hello')
+    expect(output).toContain('Complete response')
+    expect(output).not.toContain('Partial...')
+  })
+
+  it('handles session with no messages', async () => {
+    await seedSessions(reader, 1)
+    const output = await formatSessionView(reader, 'session-1', {})
+    expect(output).toContain('No messages')
+  })
+
+  it('outputs JSON when json flag is set', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi' },
+    ])
+
+    const output = await formatSessionView(reader, 'session-1', { json: true })
+    const parsed = JSON.parse(output)
+    expect(parsed).toHaveProperty('session')
+    expect(parsed).toHaveProperty('messages')
+    expect(parsed.messages).toHaveLength(2)
+  })
+
+  it('respects limit option', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Msg 1' },
+      { role: 'assistant', content: 'Msg 2' },
+      { role: 'user', content: 'Msg 3' },
+      { role: 'assistant', content: 'Msg 4' },
+    ])
+
+    const output = await formatSessionView(reader, 'session-1', { limit: 2 })
+    // Should show last 2 messages
+    expect(output).toContain('Msg 3')
+    expect(output).toContain('Msg 4')
+    expect(output).not.toContain('Msg 1')
+  })
+})
+
+describe('formatSearchResults', () => {
+  let reader: HistoryDbReader
+
+  beforeEach(async () => {
+    reader = await createTestReader()
+  })
+
+  afterEach(async () => {
+    await reader.close()
+  })
+
+  it('returns formatted search results', async () => {
+    await seedSessions(reader, 2)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Fix the login bug' },
+    ])
+    await seedMessages(reader, 'session-2', [
+      { role: 'user', content: 'The login page needs work' },
+    ])
+
+    const output = await formatSearchResults(reader, 'login', {})
+    expect(output).toContain('login')
+    expect(output).toContain('2 match')
+    expect(output).toContain('Chat 1')
+    expect(output).toContain('Chat 2')
+  })
+
+  it('returns no matches message for empty results', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'Hello' },
+    ])
+
+    const output = await formatSearchResults(reader, 'xyznonexistent', {})
+    expect(output).toContain('No matches found for "xyznonexistent"')
+  })
+
+  it('filters by session', async () => {
+    await seedSessions(reader, 2)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'login issue' },
+    ])
+    await seedMessages(reader, 'session-2', [
+      { role: 'user', content: 'login page' },
+    ])
+
+    const output = await formatSearchResults(reader, 'login', { sessionId: 'session-1' })
+    expect(output).toContain('1 match')
+    expect(output).toContain('Chat 1')
+    expect(output).not.toContain('Chat 2')
+  })
+
+  it('respects limit option', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'the first' },
+      { role: 'assistant', content: 'the second' },
+      { role: 'user', content: 'the third' },
+    ])
+
+    const output = await formatSearchResults(reader, 'the', { limit: 2 })
+    expect(output).toContain('2 match')
+  })
+
+  it('outputs JSON when json flag is set', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'fix the bug' },
+    ])
+
+    const output = await formatSearchResults(reader, 'bug', { json: true })
+    const parsed = JSON.parse(output)
+    expect(Array.isArray(parsed)).toBe(true)
+    expect(parsed).toHaveLength(1)
+    expect(parsed[0]).toHaveProperty('sessionId')
+    expect(parsed[0]).toHaveProperty('sessionTitle')
+    expect(parsed[0]).toHaveProperty('content')
+  })
+
+  it('returns empty JSON array for no matches with json flag', async () => {
+    const output = await formatSearchResults(reader, 'nothing', { json: true })
+    const parsed = JSON.parse(output)
+    expect(parsed).toEqual([])
+  })
+
+  it('handles special characters in search query', async () => {
+    await seedSessions(reader, 1)
+    await seedMessages(reader, 'session-1', [
+      { role: 'user', content: 'What about O\'Brien?' },
+    ])
+
+    // Should not throw an error
+    const output = await formatSearchResults(reader, "O'Brien", {})
+    expect(output).toContain('1 match')
+  })
+})

moav2/src/__tests__/command-palette-utils.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  fuzzyMatch,
+  fuzzyScore,
+  tokenFuzzyMatch,
+  tokenFuzzyScore,
+  sortByRecency,
+  sortFiltered,
+  recordUsage,
+  getRecencyMap,
+  pruneRecencyMap,
+  type RecencyMap,
+} from '../ui/components/commandPaletteUtils'
+
+// --- fuzzyMatch ---
+
+describe('fuzzyMatch', () => {
+  it('matches non-contiguous characters in order', () => {
+    expect(fuzzyMatch('nse', 'New Session')).toBe(true)
+  })
+
+  it('rejects characters out of order', () => {
+    // "sna" — s(Session) n(sessioN) a(?) — no 'a' after 'n', so no match
+    expect(fuzzyMatch('sna', 'New Session')).toBe(false)
+    // "zz" — no 'z' in text at all
+    expect(fuzzyMatch('zz', 'New Session')).toBe(false)
+  })
+
+  it('is case-insensitive', () => {
+    expect(fuzzyMatch('AG', 'Agent')).toBe(true)
+    expect(fuzzyMatch('ag', 'AGENT')).toBe(true)
+  })
+
+  it('matches single character', () => {
+    expect(fuzzyMatch('s', 'Settings')).toBe(true)
+    expect(fuzzyMatch('z', 'Settings')).toBe(false)
+  })
+
+  it('empty query matches everything', () => {
+    expect(fuzzyMatch('', 'anything')).toBe(true)
+    expect(fuzzyMatch('', '')).toBe(true)
+  })
+
+  it('query longer than text never matches', () => {
+    expect(fuzzyMatch('longquery', 'ab')).toBe(false)
+  })
+
+  it('exact match works', () => {
+    expect(fuzzyMatch('Agent', 'Agent')).toBe(true)
+  })
+
+  it('matches with spaces in text', () => {
+    expect(fuzzyMatch('bk', 'Browser: Back')).toBe(true)
+  })
+})
+
+// --- fuzzyScore ---
+
+describe('fuzzyScore', () => {
+  it('returns 0 for consecutive match', () => {
+    expect(fuzzyScore('set', 'Settings')).toBe(0)
+  })
+
+  it('returns -1 for no match', () => {
+    expect(fuzzyScore('xyz', 'Settings')).toBe(-1)
+  })
+
+  it('tighter match scores lower (better)', () => {
+    const settingsScore = fuzzyScore('set', 'Settings')
+    const selectScore = fuzzyScore('set', 'Select Model')
+    // "set" in "Settings" is consecutive (gap=0)
+    // "set" in "Select Model" has s-e gap
+    expect(settingsScore).toBeLessThan(selectScore)
+  })
+
+  it('empty query returns 0', () => {
+    expect(fuzzyScore('', 'anything')).toBe(0)
+  })
+
+  it('scores prefix match as 0', () => {
+    expect(fuzzyScore('bro', 'Browser: Back')).toBe(0)
+  })
+
+  it('scores spread-out match higher (worse) than tight match', () => {
+    // "ag" in "Agent" = consecutive = 0
+    // "ag" in "Agent: Clear Input" also consecutive = 0 (same start)
+    const score1 = fuzzyScore('ai', 'Agent: Clear Input')
+    const score2 = fuzzyScore('ai', 'AI')
+    expect(score2).toBeLessThanOrEqual(score1)
+  })
+})
+
+// --- sortByRecency ---
+
+describe('sortByRecency', () => {
+  const items = [
+    { id: 'a', label: 'Alpha', category: 'Test' },
+    { id: 'b', label: 'Beta', category: 'Test' },
+    { id: 'c', label: 'Charlie', category: 'Test' },
+    { id: 'd', label: 'Delta', category: 'Test' },
+  ]
+
+  it('sorts recently used items first', () => {
+    const recency: RecencyMap = {
+      c: 1000,
+      a: 500,
+    }
+    const sorted = sortByRecency(items, recency)
+    expect(sorted.map(i => i.id)).toEqual(['c', 'a', 'b', 'd'])
+  })
+
+  it('unused items sort alphabetically after used ones', () => {
+    const recency: RecencyMap = { b: 100 }
+    const sorted = sortByRecency(items, recency)
+    expect(sorted[0].id).toBe('b')
+    // remaining: Alpha, Charlie, Delta — alphabetical
+    expect(sorted.slice(1).map(i => i.id)).toEqual(['a', 'c', 'd'])
+  })
+
+  it('all unused — pure alphabetical', () => {
+    const sorted = sortByRecency(items, {})
+    expect(sorted.map(i => i.id)).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  it('does not mutate the original array', () => {
+    const original = [...items]
+    sortByRecency(items, { c: 1000 })
+    expect(items).toEqual(original)
+  })
+})
+
+// --- sortFiltered ---
+
+describe('sortFiltered', () => {
+  const items = [
+    { id: 'settings', label: 'Settings', category: 'Settings' },
+    { id: 'select-model', label: 'Select Model', category: 'Model' },
+    { id: 'session-new', label: 'New Session', category: 'Session' },
+  ]
+
+  it('with query, sorts by fuzzy score first', () => {
+    const sorted = sortFiltered(items, 'set', {})
+    // "Settings" has score 0 (consecutive), "Select Model" has score > 0
+    expect(sorted[0].id).toBe('settings')
+  })
+
+  it('with no query, sorts by recency', () => {
+    const recency: RecencyMap = { 'session-new': 2000, 'settings': 1000 }
+    const sorted = sortFiltered(items, '', recency)
+    expect(sorted[0].id).toBe('session-new')
+    expect(sorted[1].id).toBe('settings')
+  })
+
+  it('same score falls through to recency', () => {
+    const recency: RecencyMap = { 'select-model': 5000 }
+    // Both "Settings" and "Select Model" start with 's'
+    const sorted = sortFiltered(items, 's', recency)
+    // scores may differ, but if tied, recency breaks it
+    const selectIdx = sorted.findIndex(i => i.id === 'select-model')
+    const sessionIdx = sorted.findIndex(i => i.id === 'session-new')
+    // select-model has recency, session-new doesn't — select-model should be before session-new
+    // (unless score difference overrides)
+    expect(selectIdx).toBeLessThan(sessionIdx)
+  })
+
+  it('matches across category + label combined', () => {
+    const cmds = [
+      { id: 'session-delete', label: 'Delete Session', category: 'Session' },
+      { id: 'settings', label: 'Settings', category: 'Settings' },
+    ]
+    const matched = cmds.filter(
+      item => tokenFuzzyMatch('sd', item.category + ' ' + item.label)
+    )
+    expect(matched.length).toBe(1)
+    expect(matched[0].id).toBe('session-delete')
+  })
+})
+
+// --- tokenFuzzyMatch ---
+
+describe('tokenFuzzyMatch', () => {
+  it('matches tokens in any order', () => {
+    // "se d" — "se" matches Session, "d" matches Delete — order reversed in text, still matches
+    expect(tokenFuzzyMatch('se d', 'Session Delete Session')).toBe(true)
+  })
+
+  it('matches single token same as fuzzyMatch', () => {
+    expect(tokenFuzzyMatch('nse', 'New Session')).toBe(true)
+    expect(tokenFuzzyMatch('zzz', 'New Session')).toBe(false)
+  })
+
+  it('requires ALL tokens to match', () => {
+    // "se z" — "se" matches but "z" doesn't
+    expect(tokenFuzzyMatch('se z', 'Session Delete')).toBe(false)
+  })
+
+  it('empty query matches everything', () => {
+    expect(tokenFuzzyMatch('', 'anything')).toBe(true)
+    expect(tokenFuzzyMatch('   ', 'anything')).toBe(true)
+  })
+
+  it('each token matches independently against full text', () => {
+    // "d se" — both "d" and "se" match in "Delete Session"
+    expect(tokenFuzzyMatch('d se', 'Delete Session')).toBe(true)
+  })
+
+  it('matches category prefix + label query', () => {
+    // "buf ag" — "buf" matches "Buffer", "ag" matches "Agent"
+    expect(tokenFuzzyMatch('buf ag', 'Buffer Agent')).toBe(true)
+    // Reversed order still works
+    expect(tokenFuzzyMatch('ag buf', 'Buffer Agent')).toBe(true)
+  })
+})
+
+// --- tokenFuzzyScore ---
+
+describe('tokenFuzzyScore', () => {
+  it('returns -1 if any token fails', () => {
+    expect(tokenFuzzyScore('se z', 'Session Delete')).toBe(-1)
+  })
+
+  it('in-order tokens score better than out-of-order', () => {
+    // "buf ag" on "Buffer Agent" — in order
+    const inOrder = tokenFuzzyScore('buf ag', 'Buffer Agent')
+    // "ag buf" on "Buffer Agent" — out of order
+    const outOfOrder = tokenFuzzyScore('ag buf', 'Buffer Agent')
+    expect(inOrder).toBeLessThan(outOfOrder)
+  })
+
+  it('tighter matches score better', () => {
+    // "set" on "Settings foo" — consecutive, score 0
+    const tight = tokenFuzzyScore('set', 'Settings foo')
+    // "s t" on "Settings foo" — two tokens, each matches but spread out
+    const loose = tokenFuzzyScore('s t', 'Settings foo')
+    expect(tight).toBeLessThanOrEqual(loose)
+  })
+
+  it('empty query returns 0', () => {
+    expect(tokenFuzzyScore('', 'anything')).toBe(0)
+  })
+})
+
+// --- recordUsage + getRecencyMap (localStorage) ---
+
+describe('recordUsage / getRecencyMap', () => {
+  beforeEach(() => {
+    localStorage.clear()
+  })
+
+  it('records and retrieves usage', () => {
+    recordUsage('test-cmd')
+    const map = getRecencyMap()
+    expect(map['test-cmd']).toBeGreaterThan(0)
+  })
+
+  it('overwrites previous timestamp on re-use', () => {
+    recordUsage('cmd-a')
+    const first = getRecencyMap()['cmd-a']
+    // Small delay to get different timestamp
+    recordUsage('cmd-a')
+    const second = getRecencyMap()['cmd-a']
+    expect(second).toBeGreaterThanOrEqual(first)
+  })
+
+  it('returns empty map when localStorage is empty', () => {
+    expect(getRecencyMap()).toEqual({})
+  })
+
+  it('handles corrupted localStorage gracefully', () => {
+    localStorage.setItem('moa:command-recency', 'not-json!!!')
+    expect(getRecencyMap()).toEqual({})
+  })
+})
+
+// --- pruneRecencyMap ---
+
+describe('pruneRecencyMap', () => {
+  it('keeps map as-is when under limit', () => {
+    const map: RecencyMap = { a: 100, b: 200 }
+    expect(pruneRecencyMap(map, 200)).toEqual(map)
+  })
+
+  it('prunes oldest entries when over limit', () => {
+    const map: RecencyMap = {}
+    for (let i = 0; i < 210; i++) {
+      map[`cmd-${i}`] = i // timestamps 0-209
+    }
+    const pruned = pruneRecencyMap(map, 200)
+    const ids = Object.keys(pruned)
+    expect(ids.length).toBe(200)
+    // Oldest (cmd-0 through cmd-9) should be gone
+    expect(pruned['cmd-0']).toBeUndefined()
+    expect(pruned['cmd-9']).toBeUndefined()
+    // Most recent should remain
+    expect(pruned['cmd-209']).toBe(209)
+    expect(pruned['cmd-10']).toBe(10)
+  })
+
+  it('keeps exactly maxSize entries', () => {
+    const map: RecencyMap = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+    const pruned = pruneRecencyMap(map, 3)
+    expect(Object.keys(pruned).length).toBe(3)
+    // Should keep c, d, e (most recent)
+    expect(pruned['e']).toBe(5)
+    expect(pruned['d']).toBe(4)
+    expect(pruned['c']).toBe(3)
+  })
+})

moav2/src/__tests__/command-palette.test.tsx

@@ -0,0 +1,463 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { render, screen, fireEvent, cleanup } from '@testing-library/react'
+import CommandPalette from '../ui/components/CommandPalette'
+
+// jsdom doesn't implement scrollIntoView
+Element.prototype.scrollIntoView = vi.fn()
+
+const noop = () => {}
+
+function defaultProps(overrides: Record<string, unknown> = {}) {
+  return {
+    isOpen: true,
+    onClose: noop,
+    activeBuffer: 'agent' as const,
+    onSwitchBuffer: noop,
+    sessions: [
+      { id: 's1', title: 'Chat One', model: 'claude', createdAt: 1, updatedAt: 1 },
+      { id: 's2', title: 'Chat Two', model: 'claude', createdAt: 2, updatedAt: 2 },
+    ],
+    activeSessionId: 's1',
+    onSwitchSession: noop,
+    onCreateSession: noop,
+    onOpenSettings: noop,
+    onOpenSettingsTab: noop,
+    canCreateSession: true,
+    onDeleteSession: noop,
+    onRenameSession: noop,
+    currentModel: 'claude-sonnet',
+    availableModels: [
+      { value: 'claude-sonnet', label: 'Claude Sonnet', group: 'Anthropic' },
+    ],
+    onSelectModel: noop,
+    onBrowserBack: noop,
+    onBrowserForward: noop,
+    onBrowserReload: noop,
+    onBrowserFocusUrl: noop,
+    onAgentClearInput: noop,
+    onAgentStopGeneration: noop,
+    isStreaming: false,
+    ...overrides,
+  }
+}
+
+afterEach(() => {
+  cleanup()
+})
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('CommandPalette keyboard navigation', () => {
+  it('Ctrl+N moves selection down', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // First item should be selected initially
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    expect(items[0].classList.contains('selected')).toBe(true)
+
+    // Press Ctrl+N to move down
+    fireEvent.keyDown(input, { key: 'n', ctrlKey: true })
+    expect(items[1].classList.contains('selected')).toBe(true)
+  })
+
+  it('Ctrl+P moves selection up', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Move down first, then up
+    fireEvent.keyDown(input, { key: 'n', ctrlKey: true })
+    expect(items[1].classList.contains('selected')).toBe(true)
+
+    fireEvent.keyDown(input, { key: 'p', ctrlKey: true })
+    expect(items[0].classList.contains('selected')).toBe(true)
+  })
+
+  it('Ctrl+P wraps from top to bottom', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // At index 0, Ctrl+P should wrap to last item
+    fireEvent.keyDown(input, { key: 'p', ctrlKey: true })
+    expect(items[items.length - 1].classList.contains('selected')).toBe(true)
+  })
+
+  it('Ctrl+N wraps from bottom to top', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Navigate to last item first
+    fireEvent.keyDown(input, { key: 'p', ctrlKey: true })
+    expect(items[items.length - 1].classList.contains('selected')).toBe(true)
+
+    // Ctrl+N should wrap to first
+    fireEvent.keyDown(input, { key: 'n', ctrlKey: true })
+    expect(items[0].classList.contains('selected')).toBe(true)
+  })
+})
+
+describe('CommandPalette checkmark rendering', () => {
+  it('shows checkmark for active selectable items', () => {
+    // activeBuffer is 'agent', so the Agent buffer item should have a checkmark
+    render(<CommandPalette {...defaultProps()} />)
+    const checkmarks = document.querySelectorAll('.command-palette-check')
+    expect(checkmarks.length).toBeGreaterThan(0)
+    // The checkmark character
+    expect(checkmarks[0].textContent).toBe('\u2713')
+  })
+
+  it('does not show old "current" badge', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const activeBadges = document.querySelectorAll('.command-palette-active')
+    expect(activeBadges.length).toBe(0)
+  })
+
+  it('executable items never show checkmark', () => {
+    // "New Session" is executable — should have no checkmark even though other items do
+    render(<CommandPalette {...defaultProps()} />)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const newSessionItem = items.find(b => b.textContent?.includes('New Session'))
+    expect(newSessionItem).toBeDefined()
+    const check = newSessionItem!.querySelector('.command-palette-check')
+    expect(check).toBeNull()
+  })
+})
+
+describe('CommandPalette fuzzy search', () => {
+  it('filters by fuzzy match', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // Type fuzzy query "nse" — should match "New Session"
+    fireEvent.change(input, { target: { value: 'nse' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const labels = items.map(b => b.querySelector('.command-palette-label')?.textContent)
+    expect(labels.some(l => l === 'New Session')).toBe(true)
+  })
+
+  it('matches tokens in any order across category + label', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // "se d" — "se" matches Session category, "d" matches Delete
+    fireEvent.change(input, { target: { value: 'se d' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const labels = items.map(b => b.querySelector('.command-palette-label')?.textContent)
+    expect(labels.some(l => l === 'Delete Session')).toBe(true)
+  })
+
+  it('shows empty state for unmatched query', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: 'zzzzz' } })
+
+    expect(screen.getByText('No matching commands')).toBeDefined()
+  })
+})
+
+describe('CommandPalette ArrowDown/ArrowUp navigation', () => {
+  it('ArrowDown increments selectedIndex', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    expect(items[0].classList.contains('selected')).toBe(true)
+
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    expect(items[1].classList.contains('selected')).toBe(true)
+  })
+
+  it('ArrowUp decrements selectedIndex', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Move down first
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    expect(items[1].classList.contains('selected')).toBe(true)
+
+    // Move back up
+    fireEvent.keyDown(input, { key: 'ArrowUp' })
+    expect(items[0].classList.contains('selected')).toBe(true)
+  })
+
+  it('ArrowUp wraps from top to bottom', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // At index 0, ArrowUp should wrap to last item
+    fireEvent.keyDown(input, { key: 'ArrowUp' })
+    expect(items[items.length - 1].classList.contains('selected')).toBe(true)
+  })
+
+  it('ArrowDown wraps from bottom to top', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Navigate to last item first
+    fireEvent.keyDown(input, { key: 'ArrowUp' })
+    expect(items[items.length - 1].classList.contains('selected')).toBe(true)
+
+    // ArrowDown should wrap to first
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    expect(items[0].classList.contains('selected')).toBe(true)
+  })
+
+  it('multiple ArrowDown presses advance sequentially', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+
+    // Should be at index 3
+    expect(items[3].classList.contains('selected')).toBe(true)
+  })
+})
+
+describe('CommandPalette bang prefix filtering', () => {
+  it('!a filters to agent/session commands only', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: '!a' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const categories = items.map(b => b.querySelector('.command-palette-category')?.textContent?.toLowerCase())
+
+    // All visible items should be agent or session
+    for (const cat of categories) {
+      expect(cat === 'session' || cat === 'agent').toBe(true)
+    }
+    // Should have at least some items
+    expect(items.length).toBeGreaterThan(0)
+  })
+
+  it('!t filters to terminal commands only', () => {
+    render(<CommandPalette {...defaultProps({
+      terminalTabs: [{ id: 't1', title: 'Thread 1' }],
+      activeTerminalTabId: 't1',
+      onSwitchTerminalTab: noop,
+      onCreateTerminalTab: noop,
+    })} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: '!t' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const categories = items.map(b => b.querySelector('.command-palette-category')?.textContent?.toLowerCase())
+
+    for (const cat of categories) {
+      expect(cat).toBe('terminal')
+    }
+    expect(items.length).toBeGreaterThan(0)
+  })
+
+  it('!b filters to browser commands only', () => {
+    render(<CommandPalette {...defaultProps({
+      browserTabs: [{ id: 'b1', title: 'Browser Tab 1' }],
+      activeBrowserTabId: 'b1',
+      onSwitchBrowserTab: noop,
+      onCreateBrowserTab: noop,
+    })} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: '!b' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const categories = items.map(b => b.querySelector('.command-palette-category')?.textContent?.toLowerCase())
+
+    for (const cat of categories) {
+      expect(cat === 'browser' || cat === 'browser tab').toBe(true)
+    }
+    expect(items.length).toBeGreaterThan(0)
+  })
+
+  it('!a with search further filters within agent commands', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // "!a new" — agent filter + fuzzy "new"
+    fireEvent.change(input, { target: { value: '!a new' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const labels = items.map(b => b.querySelector('.command-palette-label')?.textContent)
+
+    // Should match "New Session" within agent/session category
+    expect(labels.some(l => l === 'New Session')).toBe(true)
+
+    // Should NOT show browser/terminal/settings commands
+    const categories = items.map(b => b.querySelector('.command-palette-category')?.textContent?.toLowerCase())
+    for (const cat of categories) {
+      expect(cat === 'session' || cat === 'agent').toBe(true)
+    }
+  })
+
+  it('shows correct placeholder for bang prefix', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: '!b' } })
+
+    // After re-render, the placeholder should update to "Search browser tabs..."
+    // We verify by checking the input still has the bang value
+    expect((input as HTMLInputElement).value).toBe('!b')
+  })
+
+  it('bang prefix with no matching items shows empty state', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.change(input, { target: { value: '!t zzzzz' } })
+
+    expect(screen.getByText('No matching commands')).toBeDefined()
+  })
+})
+
+describe('CommandPalette recency tracking', () => {
+  it('records usage when a command is executed via Enter', () => {
+    // Use a spy for onClose so the palette doesn't unmount
+    const onClose = vi.fn()
+    render(<CommandPalette {...defaultProps({ onClose })} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // Press Enter on the first item
+    fireEvent.keyDown(input, { key: 'Enter' })
+
+    // Check localStorage was updated
+    const raw = localStorage.getItem('moa:command-recency')
+    expect(raw).not.toBeNull()
+    const map = JSON.parse(raw!)
+    expect(Object.keys(map).length).toBeGreaterThan(0)
+  })
+
+  it('records usage when a command is clicked', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Click the second item
+    fireEvent.click(items[1])
+
+    const raw = localStorage.getItem('moa:command-recency')
+    expect(raw).not.toBeNull()
+    const map = JSON.parse(raw!)
+    expect(Object.keys(map).length).toBeGreaterThan(0)
+  })
+})
+
+describe('CommandPalette Escape behavior', () => {
+  it('Escape closes the palette in command mode', () => {
+    const onClose = vi.fn()
+    render(<CommandPalette {...defaultProps({ onClose })} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    fireEvent.keyDown(input, { key: 'Escape' })
+    expect(onClose).toHaveBeenCalledOnce()
+  })
+
+  it('mouseEnter updates selected index', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+
+    // Hover over 3rd item
+    fireEvent.mouseEnter(items[2])
+    expect(items[2].classList.contains('selected')).toBe(true)
+    // Previous should no longer be selected
+    expect(items[0].classList.contains('selected')).toBe(false)
+  })
+})
+
+describe('CommandPalette initial mode behavior', () => {
+  it('opens directly in model list when initialMode is models', () => {
+    render(<CommandPalette {...defaultProps({ initialMode: 'models' })} />)
+    expect(screen.getByPlaceholderText(/Select a model/)).toBeDefined()
+  })
+
+  it('Escape closes when opened directly in model mode', () => {
+    const onClose = vi.fn()
+    render(<CommandPalette {...defaultProps({ initialMode: 'models', onClose })} />)
+    const input = screen.getByPlaceholderText(/Select a model/)
+
+    fireEvent.keyDown(input, { key: 'Escape' })
+    expect(onClose).toHaveBeenCalledOnce()
+  })
+
+  it('Backspace closes when opened directly in model mode', () => {
+    const onClose = vi.fn()
+    render(<CommandPalette {...defaultProps({ initialMode: 'models', onClose })} />)
+    const input = screen.getByPlaceholderText(/Select a model/)
+
+    fireEvent.keyDown(input, { key: 'Backspace' })
+    expect(onClose).toHaveBeenCalledOnce()
+  })
+})
+
+describe('CommandPalette open/close events', () => {
+  it('dispatches open and close lifecycle events', () => {
+    const onOpen = vi.fn()
+    const onClose = vi.fn()
+    window.addEventListener('moa:command-palette-open', onOpen)
+    window.addEventListener('moa:command-palette-close', onClose)
+
+    const { rerender, unmount } = render(<CommandPalette {...defaultProps({ isOpen: true })} />)
+    expect(onOpen).toHaveBeenCalledOnce()
+
+    rerender(<CommandPalette {...defaultProps({ isOpen: false })} />)
+    expect(onClose).toHaveBeenCalledOnce()
+
+    window.removeEventListener('moa:command-palette-open', onOpen)
+    window.removeEventListener('moa:command-palette-close', onClose)
+    unmount()
+  })
+})
+
+describe('CommandPalette session switching', () => {
+  it('shows all sessions as selectable items', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const labels = items.map(b => b.querySelector('.command-palette-label')?.textContent)
+
+    expect(labels).toContain('Chat One')
+    expect(labels).toContain('Chat Two')
+  })
+
+  it('marks active session with checkmark', () => {
+    render(<CommandPalette {...defaultProps()} />)
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const chatOneItem = items.find(b => b.querySelector('.command-palette-label')?.textContent === 'Chat One')
+    expect(chatOneItem).toBeDefined()
+    // Chat One is activeSessionId='s1', so it should have a checkmark
+    const check = chatOneItem!.querySelector('.command-palette-check')
+    expect(check).not.toBeNull()
+  })
+
+  it('calls onSwitchSession when a session is selected via Enter', () => {
+    const onSwitchSession = vi.fn()
+    const onClose = vi.fn()
+    render(<CommandPalette {...defaultProps({ onSwitchSession, onClose })} />)
+    const input = screen.getByPlaceholderText(/Type a command/)
+
+    // Search for "Chat Two" to filter to that session
+    fireEvent.change(input, { target: { value: 'Chat Two' } })
+
+    const items = screen.getAllByRole('button').filter(b => b.classList.contains('command-palette-item'))
+    const chatTwoItem = items.find(b => b.querySelector('.command-palette-label')?.textContent === 'Chat Two')
+    expect(chatTwoItem).toBeDefined()
+
+    // Click it
+    fireEvent.click(chatTwoItem!)
+    expect(onSwitchSession).toHaveBeenCalledWith('s2')
+  })
+})

moav2/src/__tests__/dropdown.test.tsx

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { render, screen, fireEvent, cleanup } from '@testing-library/react'
+import Dropdown from '../ui/components/Dropdown'
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('Dropdown', () => {
+  it('opens and selects with Enter', () => {
+    const onChange = vi.fn()
+    render(
+      <Dropdown
+        options={[
+          { value: 'a', label: 'Alpha' },
+          { value: 'b', label: 'Beta' },
+        ]}
+        value="a"
+        onChange={onChange}
+      />
+    )
+
+    const trigger = screen.getByRole('combobox')
+    fireEvent.click(trigger)
+    expect(screen.getByRole('listbox')).toBeTruthy()
+
+    fireEvent.keyDown(trigger, { key: 'ArrowDown' })
+    fireEvent.keyDown(trigger, { key: 'Enter' })
+    expect(onChange).toHaveBeenCalledWith('b')
+  })
+
+  it('supports Ctrl+N and Ctrl+P navigation', () => {
+    render(
+      <Dropdown
+        options={[
+          { value: 'a', label: 'Alpha' },
+          { value: 'b', label: 'Beta' },
+          { value: 'c', label: 'Gamma' },
+        ]}
+        value="a"
+        onChange={() => {}}
+      />
+    )
+
+    const trigger = screen.getByRole('combobox')
+    fireEvent.click(trigger)
+
+    fireEvent.keyDown(trigger, { key: 'n', ctrlKey: true })
+    expect(screen.getByRole('option', { name: 'Beta' }).className).toContain('highlighted')
+
+    fireEvent.keyDown(trigger, { key: 'p', ctrlKey: true })
+    expect(screen.getByRole('option', { name: /Alpha/ }).className).toContain('highlighted')
+  })
+
+  it('closes on Escape', () => {
+    render(
+      <Dropdown
+        options={[{ value: 'a', label: 'Alpha' }]}
+        value="a"
+        onChange={() => {}}
+      />
+    )
+
+    const trigger = screen.getByRole('combobox')
+    fireEvent.click(trigger)
+    expect(screen.getByRole('listbox')).toBeTruthy()
+    fireEvent.keyDown(trigger, { key: 'Escape' })
+    expect(screen.queryByRole('listbox')).toBeNull()
+  })
+
+  it('applies aria-selected to the selected value', () => {
+    render(
+      <Dropdown
+        options={[
+          { value: 'a', label: 'Alpha' },
+          { value: 'b', label: 'Beta' },
+        ]}
+        value="b"
+        onChange={() => {}}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('combobox'))
+    expect(screen.getByRole('option', { name: 'Alpha' }).getAttribute('aria-selected')).toBe('false')
+    expect(screen.getByRole('option', { name: /Beta/ }).getAttribute('aria-selected')).toBe('true')
+  })
+
+  it('closes on outside click and returns focus to trigger', () => {
+    render(
+      <>
+        <button type="button">Outside</button>
+        <Dropdown
+          options={[{ value: 'a', label: 'Alpha' }]}
+          value="a"
+          onChange={() => {}}
+        />
+      </>
+    )
+
+    const trigger = screen.getByRole('combobox')
+    fireEvent.click(trigger)
+    expect(screen.getByRole('listbox')).toBeTruthy()
+
+    fireEvent.mouseDown(screen.getByRole('button', { name: 'Outside' }))
+    expect(screen.queryByRole('listbox')).toBeNull()
+    expect(document.activeElement).toBe(trigger)
+  })
+})

moav2/src/__tests__/event-store.test.ts

@@ -0,0 +1,483 @@
+/**
+ * EventStore tests.
+ *
+ * wa-sqlite uses WASM which does not load in jsdom/vitest, so we test EventStore
+ * by providing a mock PlatformDatabase that implements the same async interface.
+ * This verifies EventStore's logic (append, query, search, materialize, count,
+ * replay) without requiring an actual WASM SQLite binary.
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import 'fake-indexeddb/auto'
+import { setPlatform } from '../core/platform'
+import type { Platform, PlatformDatabase, PlatformStatement, PlatformSqlite } from '../core/platform/types'
+import { EventStore } from '../core/services/event-store'
+
+// ---------------------------------------------------------------------------
+// In-memory SQL-ish database mock that mimics PlatformDatabase
+// ---------------------------------------------------------------------------
+
+interface Row {
+  rowid: number
+  id: string
+  type: string
+  payload: string
+  actor: string
+  session_id: string | null
+  causation_id: string | null
+  correlation_id: string | null
+  timestamp: number
+}
+
+class InMemoryDB implements PlatformDatabase {
+  private rows: Row[] = []
+  private nextRowId = 1
+
+  async exec(_sql: string): Promise<void> {
+    // Schema creation — no-op for in-memory store
+  }
+
+  prepare(sql: string): PlatformStatement {
+    const self = this
+    const trimmed = sql.trim()
+
+    return {
+      async run(...params: any[]): Promise<any> {
+        if (trimmed.toUpperCase().startsWith('INSERT')) {
+          const row: Row = {
+            rowid: self.nextRowId++,
+            id: params[0],
+            type: params[1],
+            payload: params[2],
+            actor: params[3],
+            session_id: params[4],
+            causation_id: params[5],
+            correlation_id: params[6],
+            timestamp: params[7],
+          }
+          self.rows.push(row)
+          return { changes: 1 }
+        }
+        return { changes: 0 }
+      },
+
+      async get(...params: any[]): Promise<any> {
+        const rows = await this.all(...params)
+        return rows.length > 0 ? rows[0] : undefined
+      },
+
+      async all(...params: any[]): Promise<any[]> {
+        return self.executeQuery(trimmed, params)
+      },
+    }
+  }
+
+  async close(): Promise<void> {}
+
+  /**
+   * Simple query engine supporting the SQL patterns EventStore generates.
+   */
+  private executeQuery(sql: string, params: any[]): any[] {
+    const upper = sql.toUpperCase()
+
+    // SELECT COUNT(*) as cnt FROM events ...
+    if (upper.includes('SELECT COUNT(*)')) {
+      const filtered = this.applyFilters(upper, params)
+      return [{ cnt: filtered.length }]
+    }
+
+    // SELECT DISTINCT type FROM events ORDER BY type
+    if (upper.includes('SELECT DISTINCT TYPE FROM')) {
+      const types = [...new Set(this.rows.map(r => r.type))].sort()
+      return types.map(t => ({ type: t }))
+    }
+
+    // SELECT DISTINCT session_id FROM events WHERE session_id IS NOT NULL
+    if (upper.includes('SELECT DISTINCT SESSION_ID FROM')) {
+      const sessions = [...new Set(
+        this.rows.filter(r => r.session_id != null).map(r => r.session_id)
+      )].sort()
+      return sessions.map(s => ({ session_id: s }))
+    }
+
+    // SELECT * FROM events WHERE id = ?
+    if (upper.includes('WHERE ID = ?')) {
+      const row = this.rows.find(r => r.id === params[0])
+      return row ? [row] : []
+    }
+
+    // FTS search: SELECT e.* FROM events e INNER JOIN events_fts ...
+    if (upper.includes('EVENTS_FTS MATCH')) {
+      return this.executeFtsSearch(upper, params)
+    }
+
+    // Generic SELECT with WHERE / ORDER BY / LIMIT / OFFSET
+    return this.executeGenericSelect(upper, params)
+  }
+
+  private executeFtsSearch(upper: string, params: any[]): any[] {
+    const query = (params[0] as string).toLowerCase()
+    let filtered = this.rows.filter(r =>
+      r.type.toLowerCase().includes(query) ||
+      r.payload.toLowerCase().includes(query)
+    )
+
+    if (upper.includes('E.SESSION_ID = ?')) {
+      filtered = filtered.filter(r => r.session_id === params[1])
+      const limit = params[2] ?? 50
+      return filtered.slice(0, limit)
+    }
+
+    const limit = params[1] ?? 50
+    return filtered.slice(0, limit)
+  }
+
+  private executeGenericSelect(upper: string, params: any[]): any[] {
+    let filtered = this.applyFilters(upper, params)
+    let paramIdx = this.countWhereParams(upper)
+
+    // ORDER BY
+    if (upper.includes('ORDER BY TIMESTAMP ASC')) {
+      filtered.sort((a, b) => a.timestamp - b.timestamp || a.id.localeCompare(b.id))
+    } else if (upper.includes('ORDER BY TIMESTAMP DESC')) {
+      filtered.sort((a, b) => b.timestamp - a.timestamp || b.id.localeCompare(a.id))
+    }
+
+    // LIMIT ? OFFSET ?
+    if (upper.includes('LIMIT ?')) {
+      const limit = params[paramIdx++]
+      const offset = upper.includes('OFFSET ?') ? params[paramIdx++] : 0
+      filtered = filtered.slice(offset, offset + limit)
+    } else {
+      // LIMIT with literal number (e.g., LIMIT 1 in getLatest)
+      const limitMatch = upper.match(/LIMIT\s+(\d+)/)
+      if (limitMatch) {
+        filtered = filtered.slice(0, parseInt(limitMatch[1]))
+      }
+    }
+
+    return filtered
+  }
+
+  /**
+   * Apply WHERE clause filters. Returns filtered rows.
+   * Params are consumed in the order EventStore generates them:
+   * type, session_id, actor, timestamp>=, timestamp<=
+   */
+  private applyFilters(upper: string, params: any[]): Row[] {
+    let filtered = [...this.rows]
+    if (!upper.includes('WHERE')) return filtered
+
+    let paramIdx = 0
+
+    // type LIKE ? or type = ?
+    if (upper.includes('TYPE LIKE ?')) {
+      const pattern = params[paramIdx++] as string
+      const regex = new RegExp('^' + pattern.replace(/%/g, '.*') + '$')
+      filtered = filtered.filter(r => regex.test(r.type))
+    } else if (upper.includes('TYPE = ?')) {
+      const typeVal = params[paramIdx++]
+      filtered = filtered.filter(r => r.type === typeVal)
+    }
+
+    // session_id = ?
+    if (upper.includes('SESSION_ID = ?')) {
+      const sidVal = params[paramIdx++]
+      filtered = filtered.filter(r => r.session_id === sidVal)
+    }
+
+    // actor = ?
+    if (upper.includes('ACTOR = ?')) {
+      const actorVal = params[paramIdx++]
+      filtered = filtered.filter(r => r.actor === actorVal)
+    }
+
+    // timestamp >= ?
+    if (upper.includes('TIMESTAMP >= ?')) {
+      const since = params[paramIdx++]
+      filtered = filtered.filter(r => r.timestamp >= since)
+    }
+
+    // timestamp <= ?
+    if (upper.includes('TIMESTAMP <= ?')) {
+      const until = params[paramIdx++]
+      filtered = filtered.filter(r => r.timestamp <= until)
+    }
+
+    return filtered
+  }
+
+  private countWhereParams(upper: string): number {
+    if (!upper.includes('WHERE')) return 0
+    let count = 0
+    if (upper.includes('TYPE LIKE ?') || upper.includes('TYPE = ?')) count++
+    if (upper.includes('SESSION_ID = ?')) count++
+    if (upper.includes('ACTOR = ?')) count++
+    if (upper.includes('TIMESTAMP >= ?')) count++
+    if (upper.includes('TIMESTAMP <= ?')) count++
+    return count
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Mock platform with in-memory SQLite replacement
+// ---------------------------------------------------------------------------
+
+function createMockPlatform(): Platform {
+  const dbInstances = new Map<string, InMemoryDB>()
+
+  const mockSqlite: PlatformSqlite = {
+    async open(name: string): Promise<PlatformDatabase> {
+      if (!dbInstances.has(name)) {
+        dbInstances.set(name, new InMemoryDB())
+      }
+      return dbInstances.get(name)!
+    }
+  }
+
+  return {
+    fs: {
+      readFile: async () => '',
+      readFileSync: () => '',
+      writeFile: async () => {},
+      writeFileSync: () => {},
+      existsSync: () => false,
+      mkdirSync: () => {},
+      readdirSync: () => [],
+      statSync: () => ({ isFile: () => false, isDirectory: () => false, size: 0 }),
+      unlinkSync: () => {},
+    },
+    path: {
+      join: (...parts: string[]) => parts.join('/').replace(/\/+/g, '/'),
+      dirname: (p: string) => p.split('/').slice(0, -1).join('/') || '/',
+      resolve: (...parts: string[]) => parts.join('/'),
+      basename: (p: string) => p.split('/').pop() || '',
+      extname: (p: string) => { const m = p.match(/\.[^.]+$/); return m ? m[0] : '' },
+      sep: '/',
+    },
+    process: {
+      exec: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
+      execSync: () => '',
+      cwd: () => '/',
+      env: {},
+      homedir: () => '/',
+    },
+    sqlite: mockSqlite,
+    shell: { openExternal: () => {} },
+    type: 'browser',
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('EventStore (with in-memory mock DB)', () => {
+  let store: EventStore
+
+  beforeEach(async () => {
+    const platform = createMockPlatform()
+    setPlatform(platform)
+    store = await EventStore.create()
+  })
+
+  it('appends and retrieves an event', async () => {
+    const evt = await store.append({
+      type: 'message.sent',
+      payload: { text: 'hello world' },
+      actor: 'user',
+      sessionId: 'test-session',
+    })
+
+    expect(evt.id).toBeTruthy()
+    expect(evt.timestamp).toBeGreaterThan(0)
+    expect(evt.type).toBe('message.sent')
+    expect(evt.payload.text).toBe('hello world')
+
+    const retrieved = await store.getById(evt.id)
+    expect(retrieved).toBeDefined()
+    expect(retrieved!.payload.text).toBe('hello world')
+    expect(retrieved!.actor).toBe('user')
+    expect(retrieved!.sessionId).toBe('test-session')
+  })
+
+  it('queries by type with glob pattern', async () => {
+    await store.append({ type: 'message.sent', payload: { text: 'a' }, actor: 'user' })
+    await store.append({ type: 'file.read', payload: { path: '/x' }, actor: 'agent' })
+    await store.append({ type: 'message.received', payload: { text: 'b' }, actor: 'agent' })
+
+    const messages = await store.query({ type: 'message.*' })
+    expect(messages.length).toBeGreaterThanOrEqual(2)
+    expect(messages.every(m => m.type.startsWith('message.'))).toBe(true)
+  })
+
+  it('queries by exact type', async () => {
+    await store.append({ type: 'message.sent', payload: { text: 'a' }, actor: 'user' })
+    await store.append({ type: 'file.read', payload: { path: '/x' }, actor: 'agent' })
+
+    const fileEvents = await store.query({ type: 'file.read' })
+    expect(fileEvents.length).toBe(1)
+    expect(fileEvents[0].type).toBe('file.read')
+  })
+
+  it('queries by session', async () => {
+    await store.append({ type: 'test.event', payload: {}, actor: 'user', sessionId: 'session-a' })
+    await store.append({ type: 'test.event', payload: {}, actor: 'user', sessionId: 'session-b' })
+    await store.append({ type: 'test.event', payload: {}, actor: 'user', sessionId: 'session-a' })
+
+    const result = await store.query({ sessionId: 'session-a' })
+    expect(result.length).toBe(2)
+    expect(result.every(e => e.sessionId === 'session-a')).toBe(true)
+  })
+
+  it('queries by actor', async () => {
+    await store.append({ type: 'x', payload: {}, actor: 'user' })
+    await store.append({ type: 'x', payload: {}, actor: 'agent' })
+    await store.append({ type: 'x', payload: {}, actor: 'user' })
+
+    const result = await store.query({ actor: 'user' })
+    expect(result.length).toBe(2)
+    expect(result.every(e => e.actor === 'user')).toBe(true)
+  })
+
+  it('full-text search works', async () => {
+    await store.append({ type: 'note', payload: { text: 'quantum computing is fascinating' }, actor: 'user' })
+    await store.append({ type: 'note', payload: { text: 'classical computing' }, actor: 'user' })
+
+    const results = await store.search('quantum')
+    expect(results.length).toBeGreaterThanOrEqual(1)
+    expect(results.some(r => r.payload.text.includes('quantum'))).toBe(true)
+  })
+
+  it('search returns empty for empty query', async () => {
+    await store.append({ type: 'note', payload: { text: 'something' }, actor: 'user' })
+    const results = await store.search('  ')
+    expect(results.length).toBe(0)
+  })
+
+  it('materializes a session', async () => {
+    const sid = 'mat-session'
+    await store.append({ type: 'message.sent', payload: { text: 'hi' }, actor: 'user', sessionId: sid })
+    await store.append({ type: 'file.read', payload: { path: '/x' }, actor: 'agent', sessionId: sid })
+    await store.append({ type: 'intent.created', payload: { goal: 'test' }, actor: 'user', sessionId: sid })
+    await store.append({ type: 'command.executed', payload: { cmd: 'ls' }, actor: 'agent', sessionId: sid })
+    await store.append({ type: 'session.created', payload: {}, actor: 'system', sessionId: sid })
+    await store.append({ type: 'unknown.event', payload: {}, actor: 'system', sessionId: sid })
+
+    const mat = await store.materialize(sid)
+    expect(mat.messages.length).toBeGreaterThanOrEqual(1)
+    expect(mat.fileOps.length).toBeGreaterThanOrEqual(1)
+    expect(mat.intents.length).toBeGreaterThanOrEqual(1)
+    expect(mat.commands.length).toBeGreaterThanOrEqual(1)
+    expect(mat.sessions.length).toBeGreaterThanOrEqual(1)
+    expect(mat.other.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('materialize returns empty categories for non-existent session', async () => {
+    const mat = await store.materialize('nonexistent')
+    expect(mat.messages.length).toBe(0)
+    expect(mat.fileOps.length).toBe(0)
+    expect(mat.intents.length).toBe(0)
+  })
+
+  it('counts events (no filter)', async () => {
+    const initial = await store.count()
+    await store.append({ type: 'count.test', payload: {}, actor: 'system' })
+    expect(await store.count()).toBe(initial + 1)
+  })
+
+  it('counts events with type filter', async () => {
+    await store.append({ type: 'alpha', payload: {}, actor: 'user' })
+    await store.append({ type: 'beta', payload: {}, actor: 'user' })
+    await store.append({ type: 'alpha', payload: {}, actor: 'user' })
+
+    expect(await store.count('alpha')).toBe(2)
+    expect(await store.count('beta')).toBe(1)
+  })
+
+  it('counts events with session filter', async () => {
+    await store.append({ type: 'x', payload: {}, actor: 'user', sessionId: 'count-s1' })
+    await store.append({ type: 'x', payload: {}, actor: 'user', sessionId: 'count-s2' })
+    await store.append({ type: 'x', payload: {}, actor: 'user', sessionId: 'count-s1' })
+
+    expect(await store.count(undefined, 'count-s1')).toBe(2)
+    expect(await store.count(undefined, 'count-s2')).toBe(1)
+  })
+
+  it('replays with a reducer', async () => {
+    const sid = 'replay-session'
+    await store.append({ type: 'counter.inc', payload: { n: 1 }, actor: 'user', sessionId: sid })
+    await store.append({ type: 'counter.inc', payload: { n: 2 }, actor: 'user', sessionId: sid })
+    await store.append({ type: 'counter.inc', payload: { n: 3 }, actor: 'user', sessionId: sid })
+
+    const total = await store.replay(
+      (sum, evt) => sum + (evt.payload.n || 0),
+      0,
+      { sessionId: sid, type: 'counter.inc' }
+    )
+    expect(total).toBe(6)
+  })
+
+  it('replay with no matching events returns initial state', async () => {
+    const result = await store.replay(
+      (sum, _evt) => sum + 1,
+      42,
+      { sessionId: 'nonexistent', type: 'nope' }
+    )
+    expect(result).toBe(42)
+  })
+
+  it('appendBatch inserts multiple events', async () => {
+    const events = await store.appendBatch([
+      { type: 'batch.a', payload: { i: 1 }, actor: 'user' },
+      { type: 'batch.b', payload: { i: 2 }, actor: 'user' },
+      { type: 'batch.c', payload: { i: 3 }, actor: 'user' },
+    ])
+    expect(events.length).toBe(3)
+    expect(events[0].type).toBe('batch.a')
+    expect(events[2].type).toBe('batch.c')
+
+    expect(await store.count('batch.*')).toBe(3)
+  })
+
+  it('getLatest returns the most recent event of a type', async () => {
+    await store.append({ type: 'latest.test', payload: { v: 1 }, actor: 'user' })
+    // Small delay to ensure distinct timestamps
+    await new Promise(r => setTimeout(r, 5))
+    await store.append({ type: 'latest.test', payload: { v: 2 }, actor: 'user' })
+
+    const latest = await store.getLatest('latest.test')
+    expect(latest).toBeDefined()
+    expect(latest!.payload.v).toBe(2)
+  })
+
+  it('getLatest returns null when no events match', async () => {
+    const latest = await store.getLatest('nonexistent.type')
+    expect(latest).toBeNull()
+  })
+
+  it('types() returns all distinct event types', async () => {
+    await store.append({ type: 'alpha', payload: {}, actor: 'user' })
+    await store.append({ type: 'beta', payload: {}, actor: 'user' })
+    await store.append({ type: 'alpha', payload: {}, actor: 'user' })
+
+    const types = await store.types()
+    expect(types).toContain('alpha')
+    expect(types).toContain('beta')
+    expect(types.length).toBe(2)
+  })
+
+  it('sessions() returns all distinct session IDs', async () => {
+    await store.append({ type: 'x', payload: {}, actor: 'user', sessionId: 'sess-1' })
+    await store.append({ type: 'x', payload: {}, actor: 'user', sessionId: 'sess-2' })
+    await store.append({ type: 'x', payload: {}, actor: 'user' }) // no session
+
+    const sessions = await store.sessions()
+    expect(sessions).toContain('sess-1')
+    expect(sessions).toContain('sess-2')
+    expect(sessions.length).toBe(2)
+  })
+
+  it('close() does not throw', async () => {
+    await expect(store.close()).resolves.not.toThrow()
+  })
+})

moav2/src/__tests__/model-resolver-openai-oauth.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@mariozechner/pi-ai', () => ({
+  getModel: vi.fn((provider: string, id: string) => {
+    if (provider === 'google-vertex') return { id, provider, api: 'google-vertex' }
+    return { id, provider, api: 'openai-responses' }
+  }),
+  getProviders: vi.fn(() => ['openai-codex']),
+  getModels: vi.fn(() => [{ id: 'gpt-5', provider: 'openai-codex', api: 'openai-responses' }]),
+}))
+
+import { resolveModel } from '../core/services/model-resolver'
+
+describe('model resolver openai oauth', () => {
+  it('resolves openai-oauth via openai-codex provider registry', async () => {
+    const model = await resolveModel({ modelId: 'gpt-5', authMethod: 'openai-oauth' })
+    expect(model.provider).toBe('openai-codex')
+  })
+
+  it('resolves anthropic-oauth via anthropic provider registry', async () => {
+    const model = await resolveModel({ modelId: 'claude-3-7-sonnet', authMethod: 'anthropic-oauth' })
+    expect(model.provider).toBe('anthropic')
+  })
+
+  it('resolves vertex via google-vertex provider registry', async () => {
+    const model = await resolveModel({ modelId: 'gemini-2.5-pro', authMethod: 'vertex' })
+    expect(model.provider).toBe('google-vertex')
+  })
+
+  it('resolves vertex-express using google-vertex registry model', async () => {
+    const model = await resolveModel({ modelId: 'gemini-2.5-pro', authMethod: 'vertex-express' })
+    expect(model.api).toBe('google-vertex')
+    expect(model.provider).toBe('google-vertex')
+  })
+})

moav2/src/__tests__/oauth-code-bridge.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from 'vitest'
+import { OAuthCodeBridge } from '../core/services/oauth-code-bridge'
+
+describe('OAuthCodeBridge', () => {
+  it('submits immediately when resolver is attached', () => {
+    const bridge = new OAuthCodeBridge()
+    const resolve = vi.fn()
+    const reject = vi.fn()
+
+    bridge.attachResolver({ resolve, reject })
+    const result = bridge.submitCode('abc123')
+
+    expect(result).toEqual({ accepted: true, queued: false })
+    expect(resolve).toHaveBeenCalledWith('abc123')
+    expect(reject).not.toHaveBeenCalled()
+  })
+
+  it('queues code when submitted before resolver and auto-submits when resolver appears', () => {
+    const bridge = new OAuthCodeBridge()
+    const resolve = vi.fn()
+    const reject = vi.fn()
+
+    const early = bridge.submitCode('late-resolver-code')
+    const flushed = bridge.attachResolver({ resolve, reject })
+
+    expect(early).toEqual({ accepted: false, queued: true })
+    expect(flushed).toBe(true)
+    expect(resolve).toHaveBeenCalledWith('late-resolver-code')
+    expect(reject).not.toHaveBeenCalled()
+  })
+
+  it('cancels pending work and rejects active resolver', () => {
+    const bridge = new OAuthCodeBridge()
+    const resolve = vi.fn()
+    const reject = vi.fn()
+
+    bridge.attachResolver({ resolve, reject })
+    bridge.cancel('flow reset')
+
+    expect(reject).toHaveBeenCalledOnce()
+    expect(resolve).not.toHaveBeenCalled()
+  })
+})

moav2/src/__tests__/pin-system.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Pin system tests.
+ *
+ * Tests the tab sorting logic used across sessions, terminal tabs, and
+ * browser tabs.  The core `sortTabs` function lives in db.ts but is not
+ * exported, so we replicate it here for direct unit testing.
+ *
+ * We also test the pin/unpin sort-order assignment logic that lives in
+ * App.tsx (pinSession, pinTerminalTab, pinBrowserTab).
+ */
+import { describe, it, expect } from 'vitest'
+
+// ---------------------------------------------------------------------------
+// Replicated sortTabs from db.ts (not exported)
+// ---------------------------------------------------------------------------
+
+interface TabLike {
+  id: string
+  pinned: boolean
+  sortOrder: number
+}
+
+/** Sort tabs: pinned first (by sortOrder), then unpinned (by sortOrder) */
+function sortTabs<T extends TabLike>(tabs: T[]): T[] {
+  return [...tabs].sort((a, b) => {
+    if (a.pinned && !b.pinned) return -1
+    if (!a.pinned && b.pinned) return 1
+    return a.sortOrder - b.sortOrder
+  })
+}
+
+// ---------------------------------------------------------------------------
+// sortTabs tests
+// ---------------------------------------------------------------------------
+
+describe('sortTabs', () => {
+  it('places pinned tabs before unpinned tabs', () => {
+    const tabs: TabLike[] = [
+      { id: 'u1', pinned: false, sortOrder: 0 },
+      { id: 'p1', pinned: true, sortOrder: 0 },
+      { id: 'u2', pinned: false, sortOrder: 1 },
+    ]
+    const sorted = sortTabs(tabs)
+    expect(sorted[0].id).toBe('p1')
+    expect(sorted[1].id).toBe('u1')
+    expect(sorted[2].id).toBe('u2')
+  })
+
+  it('sorts pinned tabs by sortOrder among themselves', () => {
+    const tabs: TabLike[] = [
+      { id: 'p2', pinned: true, sortOrder: 2 },
+      { id: 'p1', pinned: true, sortOrder: 1 },
+      { id: 'p3', pinned: true, sortOrder: 3 },
+    ]
+    const sorted = sortTabs(tabs)
+    expect(sorted.map(t => t.id)).toEqual(['p1', 'p2', 'p3'])
+  })
+
+  it('sorts unpinned tabs by sortOrder among themselves', () => {
+    const tabs: TabLike[] = [
+      { id: 'u3', pinned: false, sortOrder: 3 },
+      { id: 'u1', pinned: false, sortOrder: 1 },
+      { id: 'u2', pinned: false, sortOrder: 2 },
+    ]
+    const sorted = sortTabs(tabs)
+    expect(sorted.map(t => t.id)).toEqual(['u1', 'u2', 'u3'])
+  })
+
+  it('handles empty array', () => {
+    expect(sortTabs([])).toEqual([])
+  })
+
+  it('handles single pinned tab', () => {
+    const tabs: TabLike[] = [{ id: 'p1', pinned: true, sortOrder: 0 }]
+    expect(sortTabs(tabs)).toEqual(tabs)
+  })
+
+  it('handles single unpinned tab', () => {
+    const tabs: TabLike[] = [{ id: 'u1', pinned: false, sortOrder: 0 }]
+    expect(sortTabs(tabs)).toEqual(tabs)
+  })
+
+  it('does not mutate the input array', () => {
+    const tabs: TabLike[] = [
+      { id: 'u1', pinned: false, sortOrder: 0 },
+      { id: 'p1', pinned: true, sortOrder: 0 },
+    ]
+    const original = [...tabs]
+    sortTabs(tabs)
+    expect(tabs).toEqual(original)
+  })
+
+  it('correctly interleaves when pinned sortOrders are higher than unpinned', () => {
+    // Pinned tabs should still come first regardless of absolute sortOrder value
+    const tabs: TabLike[] = [
+      { id: 'u1', pinned: false, sortOrder: 0 },
+      { id: 'p1', pinned: true, sortOrder: 100 },
+      { id: 'u2', pinned: false, sortOrder: 1 },
+      { id: 'p2', pinned: true, sortOrder: 50 },
+    ]
+    const sorted = sortTabs(tabs)
+    // Pinned first (sorted by sortOrder: 50, 100), then unpinned (0, 1)
+    expect(sorted.map(t => t.id)).toEqual(['p2', 'p1', 'u1', 'u2'])
+  })
+
+  it('preserves stable order for tabs with equal sortOrder and pin state', () => {
+    // JavaScript sort is not guaranteed to be stable in all engines,
+    // but modern V8 (used by Node/Vitest) is stable. We test the
+    // expected behavior.
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: false, sortOrder: 0 },
+      { id: 'b', pinned: false, sortOrder: 0 },
+    ]
+    const sorted = sortTabs(tabs)
+    // With equal sortOrder, order should be stable (a before b)
+    expect(sorted[0].id).toBe('a')
+    expect(sorted[1].id).toBe('b')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Pin assignment logic (from App.tsx pinSession/pinTerminalTab/pinBrowserTab)
+// ---------------------------------------------------------------------------
+
+describe('pin sortOrder assignment', () => {
+  // When pinning a tab, the app sets:
+  //   sortOrder = max(pinned sortOrders) + 1
+  // This places the newly pinned tab at the bottom of the pinned section.
+
+  function computePinSortOrder(tabs: TabLike[]): number {
+    const pinnedTabs = tabs.filter(t => t.pinned)
+    const maxPinnedOrder = pinnedTabs.length > 0
+      ? Math.max(...pinnedTabs.map(t => t.sortOrder))
+      : -1
+    return maxPinnedOrder + 1
+  }
+
+  it('assigns sortOrder 0 when no tabs are pinned', () => {
+    const tabs: TabLike[] = [
+      { id: 'u1', pinned: false, sortOrder: 0 },
+      { id: 'u2', pinned: false, sortOrder: 1 },
+    ]
+    expect(computePinSortOrder(tabs)).toBe(0)
+  })
+
+  it('assigns sortOrder = max + 1 when tabs are already pinned', () => {
+    const tabs: TabLike[] = [
+      { id: 'p1', pinned: true, sortOrder: 0 },
+      { id: 'p2', pinned: true, sortOrder: 3 },
+      { id: 'u1', pinned: false, sortOrder: 5 },
+    ]
+    // max pinned sortOrder is 3, so new pin gets 4
+    expect(computePinSortOrder(tabs)).toBe(4)
+  })
+
+  it('assigns correct sortOrder with single pinned tab', () => {
+    const tabs: TabLike[] = [
+      { id: 'p1', pinned: true, sortOrder: 7 },
+    ]
+    expect(computePinSortOrder(tabs)).toBe(8)
+  })
+
+  it('ignores unpinned sortOrders when computing pin position', () => {
+    const tabs: TabLike[] = [
+      { id: 'u1', pinned: false, sortOrder: 100 },
+      { id: 'p1', pinned: true, sortOrder: 2 },
+    ]
+    // Only pinned sortOrders matter; max is 2
+    expect(computePinSortOrder(tabs)).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Reorder logic (from App.tsx reorderSessions/reorderTerminalTabs etc.)
+// ---------------------------------------------------------------------------
+
+describe('reorder tabs', () => {
+  // After drag-and-drop, the app:
+  // 1. Splices the item from fromIndex, inserts at toIndex
+  // 2. Recalculates sortOrder = index for all items
+
+  function reorderTabs(tabs: TabLike[], fromIndex: number, toIndex: number): TabLike[] {
+    const reordered = [...tabs]
+    const [moved] = reordered.splice(fromIndex, 1)
+    reordered.splice(toIndex, 0, moved)
+    return reordered.map((t, i) => ({ ...t, sortOrder: i }))
+  }
+
+  it('moves tab forward (lower to higher index)', () => {
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: false, sortOrder: 0 },
+      { id: 'b', pinned: false, sortOrder: 1 },
+      { id: 'c', pinned: false, sortOrder: 2 },
+    ]
+    const result = reorderTabs(tabs, 0, 2)
+    expect(result.map(t => t.id)).toEqual(['b', 'c', 'a'])
+    expect(result.map(t => t.sortOrder)).toEqual([0, 1, 2])
+  })
+
+  it('moves tab backward (higher to lower index)', () => {
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: false, sortOrder: 0 },
+      { id: 'b', pinned: false, sortOrder: 1 },
+      { id: 'c', pinned: false, sortOrder: 2 },
+    ]
+    const result = reorderTabs(tabs, 2, 0)
+    expect(result.map(t => t.id)).toEqual(['c', 'a', 'b'])
+    expect(result.map(t => t.sortOrder)).toEqual([0, 1, 2])
+  })
+
+  it('no-op when from and to are the same', () => {
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: false, sortOrder: 0 },
+      { id: 'b', pinned: false, sortOrder: 1 },
+    ]
+    const result = reorderTabs(tabs, 1, 1)
+    expect(result.map(t => t.id)).toEqual(['a', 'b'])
+    expect(result.map(t => t.sortOrder)).toEqual([0, 1])
+  })
+
+  it('recalculates all sortOrders sequentially', () => {
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: true, sortOrder: 10 },
+      { id: 'b', pinned: true, sortOrder: 20 },
+      { id: 'c', pinned: false, sortOrder: 30 },
+    ]
+    const result = reorderTabs(tabs, 1, 0)
+    // After reorder: [b, a, c], all sortOrders become 0, 1, 2
+    expect(result.map(t => t.sortOrder)).toEqual([0, 1, 2])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Combined pin + sort scenario tests
+// ---------------------------------------------------------------------------
+
+describe('pin + sort integration', () => {
+  it('newly pinned tab appears at bottom of pinned section after re-sort', () => {
+    // Scenario: 2 pinned (sortOrder 0, 1), 2 unpinned (sortOrder 0, 1)
+    // Pin the first unpinned tab -> it gets sortOrder = max(1) + 1 = 2
+    const tabs: TabLike[] = [
+      { id: 'p1', pinned: true, sortOrder: 0 },
+      { id: 'p2', pinned: true, sortOrder: 1 },
+      { id: 'u1', pinned: false, sortOrder: 0 },
+      { id: 'u2', pinned: false, sortOrder: 1 },
+    ]
+
+    // Simulate pinning u1
+    const pinnedSortOrder = Math.max(...tabs.filter(t => t.pinned).map(t => t.sortOrder)) + 1
+    const updated = tabs.map(t =>
+      t.id === 'u1' ? { ...t, pinned: true, sortOrder: pinnedSortOrder } : t
+    )
+
+    const sorted = sortTabs(updated)
+    // Expected order: p1(pin,0), p2(pin,1), u1(pin,2), u2(unpin,1)
+    expect(sorted.map(t => t.id)).toEqual(['p1', 'p2', 'u1', 'u2'])
+    // u1 is now the last pinned item
+    const pinnedIds = sorted.filter(t => t.pinned).map(t => t.id)
+    expect(pinnedIds).toEqual(['p1', 'p2', 'u1'])
+  })
+
+  it('unpinned tab falls to the unpinned section after re-sort', () => {
+    const tabs: TabLike[] = [
+      { id: 'p1', pinned: true, sortOrder: 0 },
+      { id: 'p2', pinned: true, sortOrder: 1 },
+      { id: 'u1', pinned: false, sortOrder: 0 },
+    ]
+
+    // Unpin p2 (just set pinned: false, keep sortOrder)
+    const updated = tabs.map(t =>
+      t.id === 'p2' ? { ...t, pinned: false } : t
+    )
+
+    const sorted = sortTabs(updated)
+    // p1 stays pinned first, then unpinned sorted by sortOrder: u1(0), p2(1)
+    expect(sorted[0].id).toBe('p1')
+    expect(sorted[0].pinned).toBe(true)
+    // Unpinned section: u1 has sortOrder 0, p2 has sortOrder 1
+    expect(sorted[1].id).toBe('u1')
+    expect(sorted[2].id).toBe('p2')
+  })
+
+  it('handles all tabs pinned', () => {
+    const tabs: TabLike[] = [
+      { id: 'a', pinned: true, sortOrder: 2 },
+      { id: 'b', pinned: true, sortOrder: 0 },
+      { id: 'c', pinned: true, sortOrder: 1 },
+    ]
+    const sorted = sortTabs(tabs)
+    expect(sorted.map(t => t.id)).toEqual(['b', 'c', 'a'])
+  })
+
+  it('handles all tabs unpinned', () => {
+    const tabs: TabLike[] = [
+      { id: 'c', pinned: false, sortOrder: 2 },
+      { id: 'a', pinned: false, sortOrder: 0 },
+      { id: 'b', pinned: false, sortOrder: 1 },
+    ]
+    const sorted = sortTabs(tabs)
+    expect(sorted.map(t => t.id)).toEqual(['a', 'b', 'c'])
+  })
+})

moav2/src/__tests__/platform-boot.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Platform Boot tests — verifies browser platform init, fs, path, process, shell.
+ * Tests the browser platform backed by @zenfs/core (IndexedDB via fake-indexeddb in jsdom).
+ */
+import { describe, it, expect, beforeAll } from 'vitest'
+import 'fake-indexeddb/auto'
+import { setPlatform, getPlatform } from '../core/platform'
+import { createBrowserPlatform } from '../platform/browser'
+
+describe('Platform Boot', () => {
+  beforeAll(async () => {
+    const platform = await createBrowserPlatform()
+    setPlatform(platform)
+  })
+
+  it('initializes browser platform', () => {
+    expect(getPlatform().type).toBe('browser')
+  })
+
+  it('has filesystem with read/write', () => {
+    const { fs } = getPlatform()
+    fs.mkdirSync('/test-boot', { recursive: true })
+    fs.writeFileSync('/test-boot/hello.txt', 'world')
+    expect(fs.readFileSync('/test-boot/hello.txt', 'utf-8')).toBe('world')
+  })
+
+  it('has filesystem existsSync', () => {
+    const { fs } = getPlatform()
+    expect(fs.existsSync('/test-boot/hello.txt')).toBe(true)
+    expect(fs.existsSync('/test-boot/nope.txt')).toBe(false)
+  })
+
+  it('has filesystem readdirSync', () => {
+    const { fs } = getPlatform()
+    const entries = fs.readdirSync('/test-boot')
+    expect(entries).toContain('hello.txt')
+  })
+
+  it('has filesystem statSync', () => {
+    const { fs } = getPlatform()
+    const stat = fs.statSync('/test-boot/hello.txt')
+    expect(stat.isFile()).toBe(true)
+    expect(stat.isDirectory()).toBe(false)
+    expect(stat.size).toBeGreaterThan(0)
+  })
+
+  it('has filesystem unlinkSync', () => {
+    const { fs } = getPlatform()
+    fs.writeFileSync('/test-boot/to-delete.txt', 'bye')
+    expect(fs.existsSync('/test-boot/to-delete.txt')).toBe(true)
+    fs.unlinkSync('/test-boot/to-delete.txt')
+    expect(fs.existsSync('/test-boot/to-delete.txt')).toBe(false)
+  })
+
+  it('has async readFile/writeFile', async () => {
+    const { fs } = getPlatform()
+    fs.mkdirSync('/test-async', { recursive: true })
+    await fs.writeFile('/test-async/data.txt', 'async-content')
+    const content = await fs.readFile('/test-async/data.txt', 'utf-8')
+    expect(content).toBe('async-content')
+  })
+
+  it('has path utilities', () => {
+    const { path } = getPlatform()
+    expect(path.join('/a', 'b', 'c')).toBe('/a/b/c')
+    expect(path.dirname('/a/b/c.txt')).toBe('/a/b')
+    expect(path.basename('/a/b/c.txt')).toBe('c.txt')
+    expect(path.basename('/a/b/c.txt', '.txt')).toBe('c')
+    expect(path.extname('/a/b/c.txt')).toBe('.txt')
+    expect(path.sep).toBe('/')
+  })
+
+  it('has path.resolve', () => {
+    const { path } = getPlatform()
+    // resolve should produce an absolute path
+    const resolved = path.resolve('/a', 'b', 'c')
+    expect(resolved).toBe('/a/b/c')
+  })
+
+  it('has process stub', () => {
+    const { process } = getPlatform()
+    expect(process.cwd()).toBe('/')
+    expect(process.homedir()).toBe('/')
+    expect(typeof process.env).toBe('object')
+  })
+
+  it('has process.exec that returns browser mode message', async () => {
+    const { process } = getPlatform()
+    const result = await process.exec('ls -la')
+    expect(result.stdout).toContain('Browser mode')
+    expect(result.exitCode).toBe(1)
+  })
+
+  it('has process.execSync that returns browser mode message', () => {
+    const { process } = getPlatform()
+    const result = process.execSync('ls -la')
+    expect(result).toContain('Browser mode')
+  })
+
+  it('has shell with openExternal', () => {
+    expect(getPlatform().shell.openExternal).toBeDefined()
+    expect(typeof getPlatform().shell.openExternal).toBe('function')
+  })
+
+  it('has sqlite interface', () => {
+    expect(getPlatform().sqlite).toBeDefined()
+    expect(typeof getPlatform().sqlite.open).toBe('function')
+  })
+})

moav2/src/__tests__/provider-smoke.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@mariozechner/pi-ai', () => ({
+  getModel: vi.fn((provider: string, id: string) => ({ id, provider, api: provider === 'google-vertex' ? 'google-vertex' : 'openai-responses' })),
+  getProviders: vi.fn(() => ['anthropic', 'openai-codex', 'google-vertex', 'custom-provider']),
+  getModels: vi.fn((provider: string) => [{ id: 'provider-model', provider, api: 'openai-responses' }]),
+}))
+
+import { resolveModel } from '../core/services/model-resolver'
+import { getAnthropicBrowserAuthError, resolveVertexFallback } from '../core/services/provider-guards'
+
+describe('provider smoke tests', () => {
+  it('falls back vertex to vertex-express when express key exists', () => {
+    const resolved = resolveVertexFallback('vertex:gemini-2.5-pro', null, null, 'vx-123')
+    expect(resolved.authMethod).toBe('vertex-express')
+    expect(resolved.modelId).toBe('gemini-2.5-pro')
+  })
+
+  it('shows a friendly error when vertex has no credentials', () => {
+    expect(() => resolveVertexFallback('vertex:gemini-2.5-pro', null, null, null)).toThrow(
+      'Vertex AI is not configured. Add Vertex project/location or set a Vertex Express API key in Settings > Vertex AI.',
+    )
+  })
+
+  it('blocks anthropic api key usage in browser mode', () => {
+    expect(getAnthropicBrowserAuthError('anthropic-key', 'browser')).toContain('switch to OAuth')
+    expect(getAnthropicBrowserAuthError('anthropic-oauth', 'browser')).toBeNull()
+  })
+
+  it('resolves anthropic oauth model', async () => {
+    const model = await resolveModel({ modelId: 'claude-3-7-sonnet', authMethod: 'anthropic-oauth' })
+    expect(model.provider).toBe('anthropic')
+  })
+
+  it('resolves openai oauth model', async () => {
+    const model = await resolveModel({ modelId: 'gpt-5', authMethod: 'openai-oauth' })
+    expect(model.provider).toBe('openai-codex')
+  })
+
+  it('resolves vertex express model', async () => {
+    const model = await resolveModel({ modelId: 'gemini-2.5-pro', authMethod: 'vertex-express' })
+    expect(model.provider).toBe('google-vertex')
+  })
+
+  it('resolves custom provider model', async () => {
+    const model = await resolveModel({ modelId: 'unregistered-model', authMethod: 'custom-provider', providerBaseUrl: 'https://example.com' })
+    expect(model.provider).toBe('custom-provider')
+  })
+})

moav2/src/__tests__/retry.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { isRetryableError, sleep, withRetry } from '../core/services/retry'
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('isRetryableError', () => {
+  it('retries for status 429 and 5xx', () => {
+    expect(isRetryableError({ status: 429 })).toBe(true)
+    expect(isRetryableError({ statusCode: 503 })).toBe(true)
+    expect(isRetryableError({ response: { status: 500 } })).toBe(true)
+  })
+
+  it('retries for common retryable keywords', () => {
+    expect(isRetryableError({ message: 'RESOURCE_EXHAUSTED' })).toBe(true)
+    expect(isRetryableError({ message: 'DEADLINE_EXCEEDED' })).toBe(true)
+    expect(isRetryableError({ message: 'fetch failed' })).toBe(true)
+    expect(isRetryableError({ message: 'rate limit exceeded' })).toBe(true)
+    expect(isRetryableError({ message: 'At capacity right now' })).toBe(true)
+    expect(isRetryableError({ code: 'ECONNREFUSED' })).toBe(true)
+  })
+
+  it('does not retry for non-retryable errors', () => {
+    expect(isRetryableError({ status: 401, message: 'Invalid API key' })).toBe(false)
+    expect(isRetryableError({ message: 'Model not found' })).toBe(false)
+  })
+})
+
+describe('sleep', () => {
+  it('resolves after delay', async () => {
+    const start = Date.now()
+    await sleep(5)
+    expect(Date.now() - start).toBeGreaterThanOrEqual(1)
+  })
+
+  it('rejects when aborted', async () => {
+    const controller = new AbortController()
+    const pending = sleep(50, controller.signal)
+    controller.abort()
+    await expect(pending).rejects.toThrow('Request was aborted')
+  })
+})
+
+describe('withRetry', () => {
+  it('retries retryable failures and eventually succeeds', async () => {
+    const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0)
+    const fn = vi
+      .fn<() => Promise<string>>()
+      .mockRejectedValueOnce(new Error('rate limit exceeded'))
+      .mockRejectedValueOnce(new Error('Server overloaded'))
+      .mockResolvedValue('ok')
+
+    const onRetry = vi.fn()
+    const result = await withRetry(fn, {
+      maxRetries: 4,
+      initialDelayMs: 1,
+      maxDelayMs: 10,
+      jitterRatio: 0,
+      onRetry,
+    })
+
+    expect(result).toBe('ok')
+    expect(fn).toHaveBeenCalledTimes(3)
+    expect(onRetry).toHaveBeenCalledTimes(2)
+    expect(onRetry).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ attempt: 1, maxRetries: 4, delayMs: 1 })
+    )
+    expect(onRetry).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ attempt: 2, maxRetries: 4, delayMs: 2 })
+    )
+    randomSpy.mockRestore()
+  })
+
+  it('does not retry non-retryable failures', async () => {
+    const error = new Error('Invalid API key (401)')
+    const fn = vi.fn<() => Promise<string>>().mockRejectedValue(error)
+
+    await expect(
+      withRetry(fn, {
+        initialDelayMs: 1,
+        jitterRatio: 0,
+      })
+    ).rejects.toThrow('Invalid API key')
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('respects max retries', async () => {
+    const fn = vi.fn<() => Promise<string>>().mockRejectedValue(new Error('fetch failed'))
+
+    await expect(
+      withRetry(fn, {
+        maxRetries: 2,
+        initialDelayMs: 1,
+        maxDelayMs: 5,
+        jitterRatio: 0,
+      })
+    ).rejects.toThrow('fetch failed')
+
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  it('stops retries when aborted', async () => {
+    const controller = new AbortController()
+    const fn = vi.fn<() => Promise<string>>().mockRejectedValue(new Error('fetch failed'))
+
+    await expect(
+      withRetry(fn, {
+        maxRetries: 4,
+        initialDelayMs: 50,
+        jitterRatio: 0,
+        signal: controller.signal,
+        onRetry: () => controller.abort(),
+      })
+    ).rejects.toThrow('Request was aborted')
+
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+})

moav2/src/__tests__/scroll-behavior.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Scroll behavior tests for AgentBuffer.
+ *
+ * The AgentBuffer component uses a useEffect that calls
+ * messagesEndRef.current?.scrollIntoView({ behavior }) where behavior
+ * is 'instant' during streaming and 'smooth' otherwise.
+ *
+ * We also test the pure helper `systemMessageClass` which classifies
+ * system message content for CSS styling.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { isRetryableError } from '../core/services/retry'
+
+// ---------------------------------------------------------------------------
+// 1. systemMessageClass — pure function extracted from AgentBuffer.tsx
+// ---------------------------------------------------------------------------
+
+// The function is defined inline in AgentBuffer.tsx (not exported), so we
+// replicate it here for direct unit testing.  If it ever gets extracted and
+// exported, swap this for a direct import.
+function systemMessageClass(content: string): string {
+  const lower = content.toLowerCase()
+  if (
+    lower.includes('error') ||
+    lower.includes('failed') ||
+    lower.includes('not ready') ||
+    lower.includes('not found') ||
+    lower.includes('denied') ||
+    lower.includes('authentication') ||
+    lower.includes('not configured') ||
+    lower.includes('no api key')
+  ) {
+    return 'system-error'
+  }
+  if (lower.includes('retrying')) {
+    return 'system-retry'
+  }
+  return ''
+}
+
+describe('systemMessageClass', () => {
+  it('returns "system-error" for messages containing "error"', () => {
+    expect(systemMessageClass('Something went wrong: error')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "failed"', () => {
+    expect(systemMessageClass('Request failed with status 500')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "not ready"', () => {
+    expect(systemMessageClass('Agent is not ready')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "not found"', () => {
+    expect(systemMessageClass('Model not found')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "denied"', () => {
+    expect(systemMessageClass('Permission denied')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "authentication"', () => {
+    expect(systemMessageClass('Authentication failed')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "not configured"', () => {
+    expect(systemMessageClass('Provider not configured')).toBe('system-error')
+  })
+
+  it('returns "system-error" for "no api key"', () => {
+    expect(systemMessageClass('No API key set')).toBe('system-error')
+  })
+
+  it('returns "system-retry" for "retrying"', () => {
+    expect(systemMessageClass('Retrying... (attempt 2/3)')).toBe('system-retry')
+  })
+
+  it('returns empty string for neutral system messages', () => {
+    expect(systemMessageClass('Session started')).toBe('')
+  })
+
+  it('is case-insensitive', () => {
+    expect(systemMessageClass('ERROR: something broke')).toBe('system-error')
+    expect(systemMessageClass('RETRYING connection')).toBe('system-retry')
+  })
+
+  it('prioritizes error over retry when both present', () => {
+    // "error" check comes first in the if-chain
+    expect(systemMessageClass('Error: retrying...')).toBe('system-error')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. Scroll behavior logic — unit test of the scroll decision
+// ---------------------------------------------------------------------------
+
+// The actual useEffect in AgentBuffer does:
+//   messagesEndRef.current?.scrollIntoView({
+//     behavior: state.isStreaming ? 'instant' : 'smooth'
+//   })
+//
+// We test the logic that determines scroll behavior separately from the
+// React component to keep these tests fast and deterministic.
+
+describe('scroll behavior decision', () => {
+  function resolveScrollBehavior(isStreaming: boolean): ScrollBehavior {
+    return isStreaming ? 'instant' : 'smooth'
+  }
+
+  it('uses instant scroll during streaming', () => {
+    expect(resolveScrollBehavior(true)).toBe('instant')
+  })
+
+  it('uses smooth scroll after streaming ends', () => {
+    expect(resolveScrollBehavior(false)).toBe('smooth')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. Scroll trigger conditions — the effect depends on specific state
+// ---------------------------------------------------------------------------
+
+describe('scroll trigger conditions', () => {
+  // The useEffect dependency array is:
+  //   [state.messages.length, state.streamingBlocks.length, state.isStreaming]
+  // We simulate state transitions and verify the effect would fire.
+
+  interface ScrollState {
+    messagesLength: number
+    streamingBlocksLength: number
+    isStreaming: boolean
+  }
+
+  function shouldScroll(prev: ScrollState, next: ScrollState): boolean {
+    // The effect fires when any dep changes
+    return (
+      prev.messagesLength !== next.messagesLength ||
+      prev.streamingBlocksLength !== next.streamingBlocksLength ||
+      prev.isStreaming !== next.isStreaming
+    )
+  }
+
+  it('triggers scroll when a new message is added', () => {
+    const prev: ScrollState = { messagesLength: 2, streamingBlocksLength: 0, isStreaming: false }
+    const next: ScrollState = { messagesLength: 3, streamingBlocksLength: 0, isStreaming: false }
+    expect(shouldScroll(prev, next)).toBe(true)
+  })
+
+  it('triggers scroll when streaming blocks update', () => {
+    const prev: ScrollState = { messagesLength: 2, streamingBlocksLength: 1, isStreaming: true }
+    const next: ScrollState = { messagesLength: 2, streamingBlocksLength: 2, isStreaming: true }
+    expect(shouldScroll(prev, next)).toBe(true)
+  })
+
+  it('triggers scroll when streaming state changes', () => {
+    const prev: ScrollState = { messagesLength: 2, streamingBlocksLength: 3, isStreaming: true }
+    const next: ScrollState = { messagesLength: 2, streamingBlocksLength: 3, isStreaming: false }
+    expect(shouldScroll(prev, next)).toBe(true)
+  })
+
+  it('does not trigger scroll when nothing changes', () => {
+    const prev: ScrollState = { messagesLength: 2, streamingBlocksLength: 0, isStreaming: false }
+    const next: ScrollState = { messagesLength: 2, streamingBlocksLength: 0, isStreaming: false }
+    expect(shouldScroll(prev, next)).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. Session switch — empty session hero text
+// ---------------------------------------------------------------------------
+
+describe('empty session detection', () => {
+  // In AgentBuffer, the hero text is shown when:
+  //   const hasContent = state.messages.length > 0 || state.streamingBlocks.length > 0
+  //   {!hasContent ? <div className="empty-chat"> ... }
+
+  function hasContent(messagesLength: number, streamingBlocksLength: number): boolean {
+    return messagesLength > 0 || streamingBlocksLength > 0
+  }
+
+  it('shows hero text when no messages and no streaming blocks', () => {
+    expect(hasContent(0, 0)).toBe(false)
+  })
+
+  it('hides hero text when messages exist', () => {
+    expect(hasContent(1, 0)).toBe(true)
+  })
+
+  it('hides hero text when streaming blocks exist', () => {
+    expect(hasContent(0, 1)).toBe(true)
+  })
+
+  it('hides hero text when both exist', () => {
+    expect(hasContent(3, 2)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. SessionStore (unit tests of subscribe/notify)
+// ---------------------------------------------------------------------------
+
+describe('SessionStore subscribe/notify', () => {
+  // We test the core subscribe/notify contract without importing the real
+  // SessionStore (which has heavy dependencies on agent-service, db, etc.)
+
+  class MinimalStore {
+    private listeners = new Set<() => void>()
+    subscribe(listener: () => void): () => void {
+      this.listeners.add(listener)
+      return () => this.listeners.delete(listener)
+    }
+    notify() {
+      for (const listener of this.listeners) listener()
+    }
+  }
+
+  it('notifies all subscribers', () => {
+    const store = new MinimalStore()
+    const fn1 = vi.fn()
+    const fn2 = vi.fn()
+    store.subscribe(fn1)
+    store.subscribe(fn2)
+    store.notify()
+    expect(fn1).toHaveBeenCalledOnce()
+    expect(fn2).toHaveBeenCalledOnce()
+  })
+
+  it('unsubscribe removes the listener', () => {
+    const store = new MinimalStore()
+    const fn = vi.fn()
+    const unsub = store.subscribe(fn)
+    unsub()
+    store.notify()
+    expect(fn).not.toHaveBeenCalled()
+  })
+
+  it('multiple unsubscribes are idempotent', () => {
+    const store = new MinimalStore()
+    const fn = vi.fn()
+    const unsub = store.subscribe(fn)
+    unsub()
+    unsub() // second call should be harmless
+    store.notify()
+    expect(fn).not.toHaveBeenCalled()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 6. isRetryableError shared helper
+// ---------------------------------------------------------------------------
+
+describe('isRetryableError', () => {
+
+  it('identifies rate limit errors as transient', () => {
+    expect(isRetryableError({ message: 'Error 429: rate limit exceeded' })).toBe(true)
+    expect(isRetryableError({ message: 'rate limit exceeded' })).toBe(true)
+  })
+
+  it('identifies server errors as transient', () => {
+    expect(isRetryableError({ message: 'Internal server error 500' })).toBe(true)
+    expect(isRetryableError({ message: 'Bad gateway 502' })).toBe(true)
+    expect(isRetryableError({ message: 'Service unavailable 503' })).toBe(true)
+  })
+
+  it('identifies network errors as transient', () => {
+    expect(isRetryableError({ message: 'fetch failed' })).toBe(true)
+    expect(isRetryableError({ message: 'ECONNREFUSED' })).toBe(true)
+    expect(isRetryableError({ message: 'ECONNRESET' })).toBe(true)
+  })
+
+  it('identifies timeout errors as transient', () => {
+    expect(isRetryableError({ message: 'Request timed out' })).toBe(true)
+  })
+
+  it('identifies overloaded errors as transient', () => {
+    expect(isRetryableError({ message: 'Server overloaded' })).toBe(true)
+    expect(isRetryableError({ message: 'At capacity' })).toBe(true)
+  })
+
+  it('does NOT treat auth errors as transient', () => {
+    expect(isRetryableError({ message: 'Invalid API key (401)' })).toBe(false)
+    expect(isRetryableError({ message: 'Forbidden (403)' })).toBe(false)
+  })
+
+  it('does NOT treat model-not-found as transient', () => {
+    expect(isRetryableError({ message: 'Model does not exist' })).toBe(false)
+  })
+
+  it('handles non-Error objects gracefully', () => {
+    expect(isRetryableError('timeout')).toBe(true)
+    expect(isRetryableError('something unknown')).toBe(false)
+  })
+})

moav2/src/__tests__/session-store-waiting.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentEvent } from '@mariozechner/pi-agent-core'
+import { hasAssistantResponseStarted } from '../core/services/session-waiting'
+
+describe('session store waiting state', () => {
+  it('clears waiting as soon as assistant emits message_update', () => {
+    const event = {
+      type: 'message_update',
+      assistantMessageEvent: { type: 'thinking_start' },
+    } as unknown as AgentEvent
+
+    expect(hasAssistantResponseStarted(event)).toBe(true)
+  })
+
+  it('clears waiting when tool execution starts before text', () => {
+    const event = { type: 'tool_execution_start' } as unknown as AgentEvent
+    expect(hasAssistantResponseStarted(event)).toBe(true)
+  })
+
+  it('does not clear waiting for unrelated events', () => {
+    const event = { type: 'message_start' } as unknown as AgentEvent
+    expect(hasAssistantResponseStarted(event)).toBe(false)
+  })
+})

moav2/src/__tests__/set-system-prompt-tool.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createSetSystemPromptTool } from '../core/tools/set-system-prompt-tool'
+
+describe('set_system_prompt tool', () => {
+  it('applies prompt and returns success', async () => {
+    const applySystemPrompt = vi.fn(async () => {})
+    const tool = createSetSystemPromptTool({ applySystemPrompt })
+
+    const result = await tool.execute('t1', { prompt: '  new prompt  ' })
+
+    expect(applySystemPrompt).toHaveBeenCalledWith('new prompt')
+    expect((result.content[0] as any).text).toContain('updated')
+    expect((result.details as any).ok).toBe(true)
+  })
+
+  it('returns validation error for empty prompt', async () => {
+    const applySystemPrompt = vi.fn(async () => {})
+    const tool = createSetSystemPromptTool({ applySystemPrompt })
+
+    const result = await tool.execute('t1', { prompt: '   ' })
+
+    expect(applySystemPrompt).not.toHaveBeenCalled()
+    expect((result.content[0] as any).text).toContain('Error')
+    expect((result.details as any).ok).toBe(false)
+  })
+})

moav2/src/__tests__/terminal-buffer-capacitor.test.tsx

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+
+let platformType: 'browser' | 'capacitor' | 'electron' = 'capacitor'
+
+vi.mock('../core/platform', () => ({
+  getPlatform: () => ({
+    type: platformType,
+  }),
+}))
+
+import TerminalBuffer from '../ui/components/TerminalBuffer'
+
+describe('TerminalBuffer capacitor mode', () => {
+  it('renders capacitor terminal instead of unavailable state', () => {
+    platformType = 'capacitor'
+    render(<TerminalBuffer id="t1" />)
+    expect(screen.queryByText(/Terminal requires desktop mode/)).toBeNull()
+    expect(screen.getByText(/Mini shell/)).toBeTruthy()
+  })
+
+  it('keeps browser fallback message in plain browser mode', () => {
+    platformType = 'browser'
+    render(<TerminalBuffer id="t2" />)
+    expect(screen.getByText(/Terminal requires desktop mode/)).toBeTruthy()
+  })
+})

moav2/src/__tests__/tools.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Agent Tools tests — verifies write, read, edit, bash, and search tools
+ * in browser mode backed by @zenfs/core (IndexedDB via fake-indexeddb).
+ */
+import { describe, it, expect, beforeAll } from 'vitest'
+import 'fake-indexeddb/auto'
+import { setPlatform, getPlatform } from '../core/platform'
+import { createBrowserPlatform } from '../platform/browser'
+import { createReadTool } from '../core/tools/read-tool'
+import { createWriteTool } from '../core/tools/write-tool'
+import { createEditTool } from '../core/tools/edit-tool'
+import { createBashTool } from '../core/tools/bash-tool'
+import { createSearchTool } from '../core/tools/search-tool'
+import { createAllTools } from '../core/tools'
+
+/** Helper to extract text from tool result content block */
+function text(result: any, idx = 0): string {
+  return (result.content[idx] as any).text
+}
+
+describe('Agent Tools (browser mode)', () => {
+  beforeAll(async () => {
+    const platform = await createBrowserPlatform()
+    setPlatform(platform)
+  })
+
+  describe('write + read', () => {
+    it('writes and reads a file', async () => {
+      const write = createWriteTool()
+      const read = createReadTool()
+
+      const writeResult = await write.execute('t1', { path: '/project/test.txt', content: 'Hello from MOA' })
+      expect(text(writeResult)).toContain('Wrote')
+      expect(text(writeResult)).toContain('/project/test.txt')
+
+      const readResult = await read.execute('t2', { path: '/project/test.txt' })
+      expect(text(readResult)).toBe('Hello from MOA')
+    })
+
+    it('creates parent directories automatically', async () => {
+      const write = createWriteTool()
+      const read = createReadTool()
+
+      await write.execute('t1', { path: '/deep/nested/dir/file.txt', content: 'deep content' })
+      const result = await read.execute('t2', { path: '/deep/nested/dir/file.txt' })
+      expect(text(result)).toBe('deep content')
+    })
+
+    it('read returns error for non-existent file', async () => {
+      const read = createReadTool()
+      const result = await read.execute('t1', { path: '/nonexistent/file.txt' })
+      expect(text(result)).toContain('Error')
+    })
+
+    it('write overwrites existing file', async () => {
+      const write = createWriteTool()
+      const read = createReadTool()
+
+      await write.execute('t1', { path: '/project/overwrite.txt', content: 'first' })
+      await write.execute('t2', { path: '/project/overwrite.txt', content: 'second' })
+      const result = await read.execute('t3', { path: '/project/overwrite.txt' })
+      expect(text(result)).toBe('second')
+    })
+  })
+
+  describe('edit', () => {
+    it('replaces text in a file', async () => {
+      const write = createWriteTool()
+      const edit = createEditTool()
+      const read = createReadTool()
+
+      await write.execute('t1', { path: '/project/edit.txt', content: 'foo bar baz' })
+      await edit.execute('t2', { path: '/project/edit.txt', old_string: 'bar', new_string: 'QUX' })
+      const result = await read.execute('t3', { path: '/project/edit.txt' })
+      expect(text(result)).toBe('foo QUX baz')
+    })
+
+    it('returns error when old_string not found', async () => {
+      const write = createWriteTool()
+      const edit = createEditTool()
+
+      await write.execute('t1', { path: '/project/edit2.txt', content: 'hello' })
+      const result = await edit.execute('t2', { path: '/project/edit2.txt', old_string: 'MISSING', new_string: 'x' })
+      expect(text(result)).toContain('not found')
+    })
+
+    it('replaces only first occurrence', async () => {
+      const write = createWriteTool()
+      const edit = createEditTool()
+      const read = createReadTool()
+
+      await write.execute('t1', { path: '/project/edit3.txt', content: 'aaa bbb aaa' })
+      await edit.execute('t2', { path: '/project/edit3.txt', old_string: 'aaa', new_string: 'ZZZ' })
+      const result = await read.execute('t3', { path: '/project/edit3.txt' })
+      expect(text(result)).toBe('ZZZ bbb aaa')
+    })
+
+    it('returns error for non-existent file', async () => {
+      const edit = createEditTool()
+      const result = await edit.execute('t1', { path: '/nonexistent/edit.txt', old_string: 'a', new_string: 'b' })
+      expect(text(result)).toContain('Error')
+    })
+  })
+
+  describe('bash', () => {
+    it('returns browser mode message', async () => {
+      const bash = createBashTool()
+      const result = await bash.execute('t1', { command: 'ls -la' })
+      // In browser mode, process.exec returns exitCode=1 and stdout contains "Browser mode"
+      // The bash tool formats exitCode!=0 as "stdout:\n...\nstderr:\n..."
+      expect(text(result)).toContain('Browser mode')
+    })
+
+    it('includes the attempted command in output', async () => {
+      const bash = createBashTool()
+      const result = await bash.execute('t1', { command: 'echo hello' })
+      expect(text(result)).toContain('echo hello')
+    })
+  })
+
+  describe('search', () => {
+    it('searches file content in browser mode', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      // Create a file with searchable content
+      await write.execute('t1', { path: '/searchtest/file.ts', content: 'const hello = "world"' })
+      const result = await search.execute('t2', { query: 'hello', path: '/searchtest', type: 'content' })
+      expect(text(result)).toContain('hello')
+    })
+
+    it('searches filenames in browser mode', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      await write.execute('t1', { path: '/searchtest2/app.tsx', content: 'export default function App() {}' })
+      const result = await search.execute('t2', { query: '*.tsx', path: '/searchtest2', type: 'files' })
+      expect(text(result)).toContain('app.tsx')
+    })
+
+    it('returns no matches for content not present', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      await write.execute('t1', { path: '/searchtest3/data.txt', content: 'alpha beta gamma' })
+      const result = await search.execute('t2', { query: 'zzzzz', path: '/searchtest3', type: 'content' })
+      expect(text(result)).toContain('No matches')
+    })
+
+    it('returns no matches for filenames not present', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      await write.execute('t1', { path: '/searchtest4/index.js', content: 'x' })
+      const result = await search.execute('t2', { query: '*.py', path: '/searchtest4', type: 'files' })
+      expect(text(result)).toContain('No matches')
+    })
+
+    it('content search includes line numbers', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      await write.execute('t1', {
+        path: '/searchtest5/multi.txt',
+        content: 'line one\nline two target\nline three',
+      })
+      const result = await search.execute('t2', { query: 'target', path: '/searchtest5', type: 'content' })
+      // Browser file search returns "path:linenum: content"
+      expect(text(result)).toContain(':2:')
+      expect(text(result)).toContain('target')
+    })
+
+    it('searches with default path when path not specified', async () => {
+      const write = createWriteTool()
+      const search = createSearchTool()
+
+      // Write to root (browser cwd is /)
+      await write.execute('t1', { path: '/rootsearch.txt', content: 'findme' })
+      const result = await search.execute('t2', { query: 'findme' })
+      expect(text(result)).toContain('findme')
+    })
+  })
+
+  describe('tool metadata', () => {
+    it('tools have name, label, description, parameters', () => {
+      const tools = [
+        createReadTool(),
+        createWriteTool(),
+        createEditTool(),
+        createBashTool(),
+        createSearchTool(),
+      ]
+
+      for (const tool of tools) {
+        expect(tool.name).toBeTruthy()
+        expect(tool.label).toBeTruthy()
+        expect(tool.description).toBeTruthy()
+        expect(tool.parameters).toBeDefined()
+        expect(typeof tool.execute).toBe('function')
+      }
+    })
+
+    it('tools have distinct names', () => {
+      const tools = [
+        createReadTool(),
+        createWriteTool(),
+        createEditTool(),
+        createBashTool(),
+        createSearchTool(),
+      ]
+      const names = tools.map(t => t.name)
+      expect(new Set(names).size).toBe(names.length)
+    })
+
+    it('registers web_fetch in default tool set', () => {
+      const tools = createAllTools()
+      expect(tools.some(t => t.name === 'web_fetch')).toBe(true)
+    })
+  })
+})

moav2/src/__tests__/window-constraints.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest'
+import { WINDOW_CONSTRAINTS } from '../electron/window-constraints'
+
+describe('WINDOW_CONSTRAINTS', () => {
+  it('enforces a minimum width to prevent resize thrashing', () => {
+    expect(WINDOW_CONSTRAINTS.minWidth).toBeGreaterThanOrEqual(480)
+  })
+
+  it('enforces a minimum height to prevent resize thrashing', () => {
+    expect(WINDOW_CONSTRAINTS.minHeight).toBeGreaterThanOrEqual(360)
+  })
+
+  it('default size is larger than minimum', () => {
+    expect(WINDOW_CONSTRAINTS.width).toBeGreaterThan(WINDOW_CONSTRAINTS.minWidth)
+    expect(WINDOW_CONSTRAINTS.height).toBeGreaterThan(WINDOW_CONSTRAINTS.minHeight)
+  })
+})

moav2/src/cli/db-reader.ts

@@ -0,0 +1,236 @@
+/**
+ * HistoryDbReader — SQLite-backed reader for MOA chat history.
+ *
+ * Uses Node's built-in SQLite (`node:sqlite`) through an async API.
+ * This is a read-only tool for CLI access; the Electron app writes to this database.
+ *
+ * The reader also provides insert methods for testing purposes.
+ */
+
+type StatementLike = {
+  all(...params: any[]): any[]
+  get(...params: any[]): any
+  run(...params: any[]): any
+}
+
+type DbLike = {
+  exec(sql: string): void
+  pragma?(sql: string): void
+  prepare(sql: string): StatementLike
+  close(): void
+}
+
+async function openDatabase(dbPath: string): Promise<DbLike> {
+  try {
+    const nodeSqlite = await import('node:sqlite')
+    const db = new nodeSqlite.DatabaseSync(dbPath)
+    return {
+      exec(sql: string) {
+        db.exec(sql)
+      },
+      pragma(sql: string) {
+        db.exec(`PRAGMA ${sql}`)
+      },
+      prepare(sql: string) {
+        return db.prepare(sql)
+      },
+      close() {
+        db.close()
+      },
+    }
+  } catch (err: any) {
+    throw new Error(`Could not initialize SQLite for ${dbPath}: ${err?.message ?? String(err)}`)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface CliSession {
+  id: string
+  title: string
+  model: string
+  createdAt: number
+  updatedAt: number
+}
+
+export interface CliMessage {
+  id: string
+  sessionId: string
+  role: 'user' | 'assistant' | 'system'
+  content: string
+  blocks?: string      // JSON-serialized MessageBlock[]
+  partial: number      // 0 or 1
+  createdAt: number
+}
+
+export interface SearchResult extends CliMessage {
+  sessionTitle: string
+}
+
+export interface GetMessagesOptions {
+  role?: string
+  limit?: number
+}
+
+export interface SearchOptions {
+  sessionId?: string
+  limit?: number
+}
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  model TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  updatedAt INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  sessionId TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL DEFAULT '',
+  blocks TEXT,
+  partial INTEGER DEFAULT 0,
+  createdAt INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_sessionId ON messages(sessionId);
+CREATE INDEX IF NOT EXISTS idx_messages_createdAt ON messages(createdAt);
+CREATE INDEX IF NOT EXISTS idx_sessions_updatedAt ON sessions(updatedAt);
+`
+
+// ---------------------------------------------------------------------------
+// Reader
+// ---------------------------------------------------------------------------
+
+export class HistoryDbReader {
+  private db: DbLike
+
+  private constructor(db: DbLike) {
+    this.db = db
+  }
+
+  static async create(dbPath: string): Promise<HistoryDbReader> {
+    const db = await openDatabase(dbPath)
+    const reader = new HistoryDbReader(db)
+    reader.init()
+    return reader
+  }
+
+  private init(): void {
+    this.db.pragma('journal_mode = WAL')
+    this.db.pragma('foreign_keys = OFF')
+    this.db.exec(SCHEMA_SQL)
+  }
+
+  async close(): Promise<void> {
+    this.db.close()
+  }
+
+  // --- Query methods ---
+
+  async listSessions(limit?: number): Promise<CliSession[]> {
+    let sql = 'SELECT * FROM sessions ORDER BY updatedAt DESC'
+    if (limit !== undefined && limit > 0) {
+      sql += ` LIMIT ${limit}`
+    }
+    return this.db.prepare(sql).all() as CliSession[]
+  }
+
+  async getSession(id: string): Promise<CliSession | null> {
+    const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as CliSession | undefined
+    return row ?? null
+  }
+
+  async getMessages(sessionId: string, opts?: GetMessagesOptions): Promise<CliMessage[]> {
+    const conditions = ['sessionId = ?', 'partial = 0']
+    const params: any[] = [sessionId]
+
+    if (opts?.role) {
+      conditions.push('role = ?')
+      params.push(opts.role)
+    }
+
+    let sql = `SELECT * FROM messages WHERE ${conditions.join(' AND ')} ORDER BY createdAt ASC`
+
+    if (opts?.limit !== undefined && opts.limit > 0) {
+      // To get the LAST N messages, we use a subquery
+      sql = `SELECT * FROM (
+        SELECT * FROM messages WHERE ${conditions.join(' AND ')} ORDER BY createdAt DESC LIMIT ${opts.limit}
+      ) sub ORDER BY createdAt ASC`
+    }
+
+    return this.db.prepare(sql).all(...params) as CliMessage[]
+  }
+
+  async searchMessages(query: string, opts?: SearchOptions): Promise<SearchResult[]> {
+    if (!query.trim()) return []
+
+    const conditions = ['m.partial = 0', 'm.content LIKE ?']
+    const params: any[] = [`%${query}%`]
+
+    if (opts?.sessionId) {
+      conditions.push('m.sessionId = ?')
+      params.push(opts.sessionId)
+    }
+
+    const limit = opts?.limit ?? 20
+
+    const sql = `
+      SELECT m.*, s.title as sessionTitle
+      FROM messages m
+      JOIN sessions s ON s.id = m.sessionId
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY m.createdAt DESC
+      LIMIT ${limit}
+    `
+
+    return this.db.prepare(sql).all(...params) as SearchResult[]
+  }
+
+  // --- Insert methods (for testing) ---
+
+  async insertSession(session: CliSession): Promise<void> {
+    this.db.prepare(
+      'INSERT OR REPLACE INTO sessions (id, title, model, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?)'
+    ).run(session.id, session.title, session.model, session.createdAt, session.updatedAt)
+  }
+
+  async insertMessage(message: CliMessage): Promise<void> {
+    this.db.prepare(
+      'INSERT OR REPLACE INTO messages (id, sessionId, role, content, blocks, partial, createdAt) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    ).run(
+      message.id,
+      message.sessionId,
+      message.role,
+      message.content,
+      message.blocks ?? null,
+      message.partial,
+      message.createdAt
+    )
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Default database path resolution
+// ---------------------------------------------------------------------------
+
+export function getDefaultDbPath(): string {
+  const os = require('os')
+  const path = require('path')
+
+  // Check environment variable override
+  if (process.env.MOA_DB_PATH) {
+    return process.env.MOA_DB_PATH
+  }
+
+  return path.join(os.homedir(), '.moa', 'chat-history.db')
+}

moav2/src/cli/history.ts

@@ -0,0 +1,127 @@
+/**
+ * History command implementations.
+ *
+ * Pure functions that take a HistoryDbReader and options, returning formatted strings.
+ * No direct stdout writes — the CLI entry point handles I/O.
+ */
+
+import { HistoryDbReader, type CliSession, type CliMessage, type SearchResult } from './db-reader'
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+function formatTimestamp(ms: number): string {
+  const d = new Date(ms)
+  return d.toISOString().slice(0, 16).replace('T', ' ')
+}
+
+function formatTime(ms: number): string {
+  const d = new Date(ms)
+  return d.toISOString().slice(11, 16)
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text
+  return text.substring(0, maxLen) + '...'
+}
+
+// ---------------------------------------------------------------------------
+// List Sessions
+// ---------------------------------------------------------------------------
+
+export interface ListOptions {
+  limit?: number
+  json?: boolean
+}
+
+export async function formatSessionList(reader: HistoryDbReader, opts: ListOptions): Promise<string> {
+  const sessions = await reader.listSessions(opts.limit)
+
+  if (opts.json) {
+    return JSON.stringify(sessions, null, 2)
+  }
+
+  if (sessions.length === 0) {
+    return 'No sessions found.'
+  }
+
+  const lines = sessions.map((s: CliSession) => {
+    const created = formatTimestamp(s.createdAt)
+    const updated = formatTimestamp(s.updatedAt)
+    return `  [${s.id}] "${s.title}"\n  Model: ${s.model}    Created: ${created}    Updated: ${updated}`
+  })
+
+  return `${sessions.length} session(s):\n\n${lines.join('\n\n')}`
+}
+
+// ---------------------------------------------------------------------------
+// View Session
+// ---------------------------------------------------------------------------
+
+export interface ViewOptions {
+  limit?: number
+  role?: string
+  json?: boolean
+}
+
+export async function formatSessionView(reader: HistoryDbReader, sessionId: string, opts: ViewOptions): Promise<string> {
+  const session = await reader.getSession(sessionId)
+  if (!session) {
+    return `Session not found: ${sessionId}`
+  }
+
+  const messages = await reader.getMessages(sessionId, {
+    role: opts.role,
+    limit: opts.limit,
+  })
+
+  if (opts.json) {
+    return JSON.stringify({ session, messages }, null, 2)
+  }
+
+  if (messages.length === 0) {
+    return `Session: "${session.title}" (${session.id})\nModel: ${session.model}\nCreated: ${formatTimestamp(session.createdAt)}\n\nNo messages in this session.`
+  }
+
+  const header = `Session: "${session.title}" (${session.id})\nModel: ${session.model}\nCreated: ${formatTimestamp(session.createdAt)}\n\n--- Messages (${messages.length}) ---`
+
+  const msgLines = messages.map((m: CliMessage) => {
+    const time = formatTime(m.createdAt)
+    return `\n[${time}] ${m.role}:\n  ${truncate(m.content, 500)}`
+  })
+
+  return header + msgLines.join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// Search
+// ---------------------------------------------------------------------------
+
+export interface SearchCommandOptions {
+  limit?: number
+  sessionId?: string
+  json?: boolean
+}
+
+export async function formatSearchResults(reader: HistoryDbReader, query: string, opts: SearchCommandOptions): Promise<string> {
+  const results = await reader.searchMessages(query, {
+    sessionId: opts.sessionId,
+    limit: opts.limit,
+  })
+
+  if (opts.json) {
+    return JSON.stringify(results, null, 2)
+  }
+
+  if (results.length === 0) {
+    return `No matches found for "${query}".`
+  }
+
+  const lines = results.map((r: SearchResult) => {
+    const time = formatTime(r.createdAt)
+    return `  [${r.sessionId}] "${r.sessionTitle}" | [${time}] ${r.role}:\n    ${truncate(r.content, 300)}`
+  })
+
+  return `Search results for "${query}" (${results.length} match${results.length === 1 ? '' : 'es'}):\n\n${lines.join('\n\n')}`
+}

moav2/src/cli/index.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * MOA History CLI — Access chat history from the terminal.
+ *
+ * Usage:
+ *   moa history list [--limit N] [--json]
+ *   moa history view <session-id> [--limit N] [--role <role>] [--json]
+ *   moa history search <query> [--limit N] [--session <id>] [--json]
+ *
+ * Options:
+ *   --db <path>    Override database path (default: ~/.moa/chat-history.db)
+ *   --help         Show help
+ */
+
+import { HistoryDbReader, getDefaultDbPath } from './db-reader'
+import { formatSessionList, formatSessionView, formatSearchResults } from './history'
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+interface ParsedArgs {
+  command: string
+  positional: string[]
+  flags: Record<string, string | boolean>
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  // Skip node and script path
+  const args = argv.slice(2)
+  const command = args[0] || ''
+  const positional: string[] = []
+  const flags: Record<string, string | boolean> = {}
+
+  let i = 1
+  while (i < args.length) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      // Check if next arg is a value (not a flag)
+      if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        flags[key] = args[i + 1]
+        i += 2
+      } else {
+        flags[key] = true
+        i++
+      }
+    } else {
+      positional.push(arg)
+      i++
+    }
+  }
+
+  return { command, positional, flags }
+}
+
+// ---------------------------------------------------------------------------
+// Help text
+// ---------------------------------------------------------------------------
+
+const HELP_TEXT = `
+MOA History CLI — Access chat history from the terminal.
+
+Usage:
+  npx tsx src/cli/index.ts list [--limit N] [--json]
+  npx tsx src/cli/index.ts view <session-id> [--limit N] [--role <role>] [--json]
+  npx tsx src/cli/index.ts search <query> [--limit N] [--session <id>] [--json]
+
+Commands:
+  list                    List all chat sessions
+  view <session-id>       View messages in a session
+  search <query>          Search across all messages
+
+Options:
+  --limit N               Limit number of results
+  --role <role>           Filter messages by role (user, assistant, system)
+  --session <id>          Restrict search to a specific session
+  --json                  Output as JSON
+  --db <path>             Override database path (default: ~/.moa/chat-history.db)
+  --help                  Show this help
+
+Environment:
+  MOA_DB_PATH             Override database path
+`.trim()
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const parsed = parseArgs(process.argv)
+
+  if (parsed.flags.help || parsed.command === 'help' || !parsed.command) {
+    console.log(HELP_TEXT)
+    process.exit(parsed.command ? 0 : 2)
+  }
+
+  // Resolve database path
+  const dbPath = typeof parsed.flags.db === 'string' ? parsed.flags.db : getDefaultDbPath()
+
+  let reader: HistoryDbReader
+  try {
+    reader = await HistoryDbReader.create(dbPath)
+  } catch (err: any) {
+    console.error(`Error: Could not open database at ${dbPath}`)
+    console.error(err.message)
+    console.error('\nMake sure the MOA database exists. Run the Electron app first to create it,')
+    console.error('or specify a different path with --db <path> or MOA_DB_PATH env variable.')
+    process.exit(1)
+  }
+
+  try {
+    const json = !!parsed.flags.json
+    const limit = typeof parsed.flags.limit === 'string' ? parseInt(parsed.flags.limit, 10) : undefined
+
+    switch (parsed.command) {
+      case 'list': {
+        const output = await formatSessionList(reader, { limit, json })
+        console.log(output)
+        break
+      }
+
+      case 'view': {
+        const sessionId = parsed.positional[0]
+        if (!sessionId) {
+          console.error('Error: session ID is required for the view command.')
+          console.error('Usage: moa history view <session-id>')
+          process.exit(2)
+        }
+        const role = typeof parsed.flags.role === 'string' ? parsed.flags.role : undefined
+        const output = await formatSessionView(reader, sessionId, { limit, role, json })
+
+        if (output.startsWith('Session not found:')) {
+          console.error(output)
+          process.exit(3)
+        }
+
+        console.log(output)
+        break
+      }
+
+      case 'search': {
+        const query = parsed.positional[0]
+        if (!query) {
+          console.error('Error: search query is required.')
+          console.error('Usage: moa history search <query>')
+          process.exit(2)
+        }
+        const sessionId = typeof parsed.flags.session === 'string' ? parsed.flags.session : undefined
+        const output = await formatSearchResults(reader, query, { limit, sessionId, json })
+        console.log(output)
+        break
+      }
+
+      default:
+        console.error(`Unknown command: ${parsed.command}`)
+        console.error('Valid commands: list, view, search')
+        console.error('Run with --help for usage information.')
+        process.exit(2)
+    }
+  } finally {
+    await reader.close()
+  }
+}
+
+main().catch((err: any) => {
+  console.error(err?.message ?? String(err))
+  process.exit(1)
+})

moav2/src/core/platform/index.ts

@@ -0,0 +1,16 @@
+import type { Platform } from './types'
+
+let _platform: Platform | null = null
+
+export function setPlatform(p: Platform): void {
+  _platform = p
+}
+
+export function getPlatform(): Platform {
+  if (!_platform) {
+    throw new Error('Platform not initialized. Call setPlatform() before using any platform APIs.')
+  }
+  return _platform
+}
+
+export type { Platform, PlatformFs, PlatformPath, PlatformProcess, PlatformDatabase, PlatformStatement, PlatformSqlite, PlatformShell } from './types'

moav2/src/core/platform/types.ts

@@ -0,0 +1,61 @@
+// Platform abstraction — every Node.js dependency goes through this interface.
+// Browser, Electron, and Capacitor each provide their own implementation.
+
+export interface PlatformFs {
+  readFile(path: string, encoding: 'utf-8'): Promise<string>
+  readFileSync(path: string, encoding: 'utf-8'): string
+  writeFile(path: string, content: string): Promise<void>
+  writeFileSync(path: string, content: string): void
+  existsSync(path: string): boolean
+  mkdirSync(path: string, opts?: { recursive: boolean }): void
+  readdirSync(path: string): string[]
+  statSync(path: string): { isFile(): boolean; isDirectory(): boolean; size: number }
+  unlinkSync(path: string): void
+}
+
+export interface PlatformPath {
+  join(...parts: string[]): string
+  dirname(p: string): string
+  resolve(...parts: string[]): string
+  basename(p: string, ext?: string): string
+  extname(p: string): string
+  sep: string
+}
+
+export interface PlatformProcess {
+  exec(command: string, opts?: { timeout?: number; maxBuffer?: number; cwd?: string }):
+    Promise<{ stdout: string; stderr: string; exitCode: number }>
+  execSync(command: string, opts?: { encoding?: string; timeout?: number; maxBuffer?: number; cwd?: string }): string
+  cwd(): string
+  env: Record<string, string | undefined>
+  homedir(): string
+}
+
+export interface PlatformDatabase {
+  exec(sql: string): Promise<void>
+  prepare(sql: string): PlatformStatement
+  close(): Promise<void>
+}
+
+export interface PlatformStatement {
+  run(...params: any[]): Promise<any>
+  get(...params: any[]): Promise<any>
+  all(...params: any[]): Promise<any[]>
+}
+
+export interface PlatformSqlite {
+  open(name: string): Promise<PlatformDatabase>
+}
+
+export interface PlatformShell {
+  openExternal(url: string): void
+}
+
+export interface Platform {
+  fs: PlatformFs
+  path: PlatformPath
+  process: PlatformProcess
+  sqlite: PlatformSqlite
+  shell: PlatformShell
+  type: 'browser' | 'electron' | 'capacitor'
+}

moav2/src/core/services/action-logger.ts

@@ -0,0 +1,45 @@
+// Action Logger — singleton wrapper around EventStore for convenient action logging
+// Initialize with the platform's EventStore instance at boot.
+// Provides typed convenience methods for logging different action categories.
+// All logging is fire-and-forget: failures are silently caught so they never
+// break the calling code.
+
+import { EventStore } from './event-store'
+
+let store: EventStore | null = null
+
+/** Wire up the action logger with an initialised EventStore. Call once at boot. */
+export function initActionLogger(eventStore: EventStore): void {
+  store = eventStore
+}
+
+/** Get the underlying EventStore (or null if not yet initialised). */
+export function getActionLogger(): EventStore | null {
+  return store
+}
+
+/** Fire-and-forget: append an action event. Never throws. */
+export function logAction(
+  type: string,
+  payload: Record<string, any>,
+  opts?: {
+    actor?: string
+    sessionId?: string
+    causationId?: string
+    correlationId?: string
+  },
+): void {
+  if (!store) return
+  store
+    .append({
+      type,
+      payload,
+      actor: opts?.actor ?? 'system',
+      sessionId: opts?.sessionId,
+      causationId: opts?.causationId,
+      correlationId: opts?.correlationId,
+    })
+    .catch(() => {
+      // Logging must never break the caller — swallow errors silently.
+    })
+}

moav2/src/core/services/agent-service.ts

@@ -0,0 +1,312 @@
+import { Agent } from '@mariozechner/pi-agent-core'
+import type { AgentEvent, AgentTool, AgentMessage } from '@mariozechner/pi-agent-core'
+import type { Model } from '@mariozechner/pi-ai'
+import { createAllTools } from './tools/index'
+
+export interface AgentConfig {
+  model: Model<any>
+  tools?: AgentTool<any, any>[]
+  systemPrompt?: string
+  getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined
+}
+
+export interface StreamingBlock {
+  id: string
+  type: 'text' | 'tool' | 'thinking'
+  content?: string
+  toolCallId?: string
+  toolName?: string
+  args?: Record<string, any>
+  status?: 'running' | 'completed' | 'error'
+  result?: string
+}
+
+let _blockCounter = 0
+function nextBlockId() {
+  return `blk-${++_blockCounter}-${Date.now()}`
+}
+
+export class AgentService {
+  private agents: Map<string, Agent> = new Map()
+  private subscribers: Map<string, Set<(event: AgentEvent) => void>> = new Map()
+  private streamingBuffers: Set<string> = new Set()
+  // Accumulates streaming blocks so UI can recover on remount
+  private streamingBlocks: Map<string, StreamingBlock[]> = new Map()
+  // Tracks partial DB message IDs — survives component remounts
+  private partialMsgIds: Map<string, string> = new Map()
+
+  createAgent(bufferId: string, config: AgentConfig): Agent {
+    if (this.agents.has(bufferId)) {
+      return this.agents.get(bufferId)!
+    }
+
+    const agent = new Agent({
+      getApiKey: config.getApiKey,
+    })
+
+    agent.setModel(config.model)
+    // Web fetch support matrix:
+    // - Anthropic (API key/OAuth): supported via tool use.
+    // - OpenAI (API key/OAuth): supported via function/tool calling.
+    // - Vertex AI / Vertex Express: supported via function/tool calling.
+    // - Custom OpenAI-compatible providers: supported when they implement tool calling.
+    agent.setTools(config.tools ?? createAllTools())
+
+    if (config.systemPrompt) {
+      agent.setSystemPrompt(config.systemPrompt)
+    }
+
+    agent.subscribe((event: AgentEvent) => {
+      if (event.type === 'agent_start') {
+        this.streamingBuffers.add(bufferId)
+        this.streamingBlocks.set(bufferId, [])
+      }
+
+      // Accumulate blocks in the service so UI can recover on remount
+      this.accumulateBlock(bufferId, event)
+
+      // Notify subscribers BEFORE clearing state on agent_end
+      // so they can read the final blocks
+      const subs = this.subscribers.get(bufferId)
+      if (subs) {
+        for (const fn of subs) {
+          fn(event)
+        }
+      }
+
+      // Clean up streaming state AFTER notifying subscribers
+      if (event.type === 'agent_end') {
+        this.streamingBuffers.delete(bufferId)
+        this.streamingBlocks.delete(bufferId)
+      }
+    })
+
+    this.agents.set(bufferId, agent)
+    return agent
+  }
+
+  getAgent(bufferId: string): Agent | undefined {
+    return this.agents.get(bufferId)
+  }
+
+  /**
+   * Hot-swap the model on an existing agent without destroying it.
+   * Preserves conversation history, tools, subscriptions, and streaming state.
+   * Also updates the getApiKey callback if the auth method changed.
+   */
+  updateModel(bufferId: string, model: Model<any>, getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined): void {
+    const agent = this.agents.get(bufferId)
+    if (!agent) {
+      throw new Error(`No agent for buffer ${bufferId} — cannot update model`)
+    }
+    agent.setModel(model)
+    if (getApiKey) {
+      agent.getApiKey = getApiKey
+    }
+  }
+
+  destroyAgent(bufferId: string): void {
+    const agent = this.agents.get(bufferId)
+    if (agent) {
+      agent.abort()
+      this.agents.delete(bufferId)
+      this.subscribers.delete(bufferId)
+      this.streamingBlocks.delete(bufferId)
+      this.streamingBuffers.delete(bufferId)
+      this.partialMsgIds.delete(bufferId)
+    }
+  }
+
+  /** Clean up agents for sessions that no longer exist */
+  pruneAgents(activeSessionIds: Set<string>): void {
+    for (const bufferId of this.agents.keys()) {
+      if (!activeSessionIds.has(bufferId) && !this.streamingBuffers.has(bufferId)) {
+        this.destroyAgent(bufferId)
+      }
+    }
+  }
+
+  async prompt(bufferId: string, message: string, images?: { type: 'image'; data: string; mimeType: string }[]): Promise<void> {
+    const agent = this.agents.get(bufferId)
+    if (!agent) {
+      throw new Error(`No agent for buffer ${bufferId}`)
+    }
+    await agent.prompt(message, images)
+  }
+
+  steer(bufferId: string, message: string): void {
+    const agent = this.agents.get(bufferId)
+    if (!agent) {
+      throw new Error(`No agent for buffer ${bufferId}`)
+    }
+
+    // Snapshot current streaming blocks before steering
+    // This allows UI to split the output at the interruption point
+    const currentBlocks = this.streamingBlocks.get(bufferId)
+    if (currentBlocks && currentBlocks.length > 0) {
+      // Emit a custom event so UI can capture the "before" blocks
+      const subs = this.subscribers.get(bufferId)
+      if (subs) {
+        for (const fn of subs) {
+          fn({ type: 'steer_interrupt', blocks: [...currentBlocks] } as any)
+        }
+      }
+      // Clear streaming blocks - new content after steer will be fresh
+      this.streamingBlocks.set(bufferId, [])
+    }
+
+    agent.steer({
+      role: 'user',
+      content: [{ type: 'text', text: message }],
+      timestamp: Date.now(),
+    })
+  }
+
+  isStreaming(bufferId: string): boolean {
+    return this.streamingBuffers.has(bufferId)
+  }
+
+  // Returns a snapshot of in-progress streaming blocks for a buffer.
+  // Used by UI to recover state after remount.
+  getStreamingBlocks(bufferId: string): StreamingBlock[] {
+    return this.streamingBlocks.get(bufferId) || []
+  }
+
+  // Partial message ID tracking — stored here so it survives component remounts
+  setPartialMsgId(bufferId: string, id: string): void {
+    this.partialMsgIds.set(bufferId, id)
+  }
+  getPartialMsgId(bufferId: string): string | null {
+    return this.partialMsgIds.get(bufferId) || null
+  }
+  clearPartialMsgId(bufferId: string): void {
+    this.partialMsgIds.delete(bufferId)
+  }
+
+  // Hydrate agent with prior conversation from DB messages.
+  // Only injects if agent has empty history (fresh creation, not HMR).
+  hydrateFromMessages(bufferId: string, dbMessages: { role: string; content: string }[]): void {
+    const agent = this.agents.get(bufferId)
+    if (!agent) return
+    // Don't overwrite existing history (agent survived HMR and already has context)
+    // Only return if we have actual user/assistant messages.
+    // If we only have a system message (from initialization), we should still hydrate.
+    const hasConversationHistory = agent.state.messages.some(m => (m.role as string) !== 'system')
+    if (hasConversationHistory) return
+
+    const agentMessages: AgentMessage[] = []
+    for (const m of dbMessages) {
+      if (m.role === 'user') {
+        agentMessages.push({
+          role: 'user',
+          content: m.content,
+          timestamp: Date.now(),
+        } as AgentMessage)
+      } else if (m.role === 'assistant' && m.content) {
+        // Inject assistant messages as simplified text so the agent knows its own prior responses.
+        // Cast via unknown because we're constructing a minimal AssistantMessage shape.
+        agentMessages.push({
+          role: 'assistant',
+          content: [{ type: 'text', text: m.content }],
+          api: 'anthropic',
+          provider: 'anthropic',
+          model: 'unknown',
+          usage: { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+          stopReason: 'stop',
+          timestamp: Date.now(),
+        } as unknown as AgentMessage)
+      }
+    }
+    if (agentMessages.length > 0) {
+      agent.replaceMessages(agentMessages)
+    }
+  }
+
+  private accumulateBlock(bufferId: string, event: AgentEvent): void {
+    const blocks = this.streamingBlocks.get(bufferId)
+    if (!blocks) return
+
+    const ae = event as any
+    switch (event.type) {
+      case 'message_update': {
+        const assistantEvent = ae.assistantMessageEvent
+        if (!assistantEvent) break
+
+        if (assistantEvent.type === 'thinking_start') {
+          blocks.push({ id: nextBlockId(), type: 'thinking', content: '' })
+          break
+        }
+
+        if (assistantEvent.type === 'thinking_delta') {
+          const last = blocks[blocks.length - 1]
+          if (last && last.type === 'thinking') {
+            last.content = (last.content || '') + assistantEvent.delta
+          } else {
+            blocks.push({ id: nextBlockId(), type: 'thinking', content: assistantEvent.delta })
+          }
+          break
+        }
+
+        if (assistantEvent.type === 'thinking_end') {
+          break
+        }
+
+        if (assistantEvent.type === 'text_delta') {
+          const last = blocks[blocks.length - 1]
+          if (last && last.type === 'text') {
+            last.content = (last.content || '') + assistantEvent.delta
+          } else {
+            blocks.push({ id: nextBlockId(), type: 'text', content: assistantEvent.delta })
+          }
+        }
+        break
+      }
+      case 'tool_execution_start':
+        blocks.push({
+          id: nextBlockId(),
+          type: 'tool',
+          toolCallId: ae.toolCallId,
+          toolName: ae.toolName,
+          args: ae.args,
+          status: 'running',
+        })
+        break
+      case 'tool_execution_end': {
+        const block = blocks.find(b => b.type === 'tool' && b.toolCallId === ae.toolCallId)
+        if (block) {
+          block.status = ae.isError ? 'error' : 'completed'
+          block.result = ae.result?.content?.map((c: any) => c.text || '').join('') || JSON.stringify(ae.result)
+        }
+        break
+      }
+      case 'message_end': {
+        if (ae.message?.errorMessage || ae.message?.stopReason === 'error') {
+          blocks.push({ id: nextBlockId(), type: 'text', content: `\n\n**Error:** ${ae.message.errorMessage || 'Unknown API error'}` })
+        }
+        break
+      }
+    }
+  }
+
+  abort(bufferId: string): void {
+    const agent = this.agents.get(bufferId)
+    if (agent) {
+      agent.abort()
+    }
+  }
+
+  subscribe(bufferId: string, listener: (event: AgentEvent) => void): () => void {
+    if (!this.subscribers.has(bufferId)) {
+      this.subscribers.set(bufferId, new Set())
+    }
+    const subs = this.subscribers.get(bufferId)!
+    subs.add(listener)
+    return () => {
+      subs.delete(listener)
+    }
+  }
+}
+
+// Singleton instance — in moav2 we don't rely on window.__agentService for HMR survival.
+// The entry point manages lifecycle.
+export const agentService = new AgentService()

moav2/src/core/services/db.ts

@@ -0,0 +1,377 @@
+export interface Provider {
+  id: string
+  name: string
+  baseUrl: string
+  apiKey: string
+  createdAt: number
+}
+
+export interface StoredOAuthCredentials {
+  provider: string   // keyPath — e.g. 'anthropic'
+  refresh: string
+  access: string
+  expires: number
+  accountId?: string
+}
+
+export interface Session {
+  id: string
+  title: string
+  model: string
+  systemPrompt?: string
+  createdAt: number
+  updatedAt: number
+  pinned: boolean
+  sortOrder: number
+}
+
+export interface TerminalTab {
+  id: string
+  title: string
+  createdAt: number
+  pinned: boolean
+  sortOrder: number
+}
+
+export interface BrowserTab {
+  id: string
+  title: string
+  url: string
+  createdAt: number
+  pinned: boolean
+  sortOrder: number
+}
+
+export interface MessageBlock {
+  id: string
+  type: 'text' | 'tool'
+  content?: string
+  toolCallId?: string
+  toolName?: string
+  args?: Record<string, any>
+  status?: 'running' | 'completed' | 'error'
+  result?: string
+}
+
+export interface Message {
+  id: string
+  sessionId: string
+  role: 'user' | 'assistant' | 'system'
+  content: string
+  blocks?: MessageBlock[]
+  partial?: boolean
+  createdAt: number
+}
+
+/** Sort tabs: pinned first (by sortOrder), then unpinned (by sortOrder) */
+function sortTabs<T extends { pinned: boolean; sortOrder: number }>(tabs: T[]): T[] {
+  return tabs.sort((a, b) => {
+    if (a.pinned && !b.pinned) return -1
+    if (!a.pinned && b.pinned) return 1
+    return a.sortOrder - b.sortOrder
+  })
+}
+
+function openDatabase(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open('moa', 3)
+    request.onupgradeneeded = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result
+      const oldVersion = event.oldVersion
+
+      if (oldVersion < 1) {
+        const providers = db.createObjectStore('providers', { keyPath: 'id' })
+        providers.createIndex('name', 'name', { unique: false })
+
+        const sessions = db.createObjectStore('sessions', { keyPath: 'id' })
+        sessions.createIndex('updatedAt', 'updatedAt', { unique: false })
+
+        const messages = db.createObjectStore('messages', { keyPath: 'id' })
+        messages.createIndex('sessionId', 'sessionId', { unique: false })
+        messages.createIndex('createdAt', 'createdAt', { unique: false })
+
+        const events = db.createObjectStore('events', { keyPath: 'id' })
+        events.createIndex('type', 'type', { unique: false })
+      }
+
+      if (oldVersion < 2) {
+        db.createObjectStore('oauth-credentials', { keyPath: 'provider' })
+      }
+
+      if (oldVersion < 3) {
+        // Add terminal-tabs and browser-tabs stores
+        db.createObjectStore('terminal-tabs', { keyPath: 'id' })
+        db.createObjectStore('browser-tabs', { keyPath: 'id' })
+        // Existing sessions will get pinned/sortOrder defaults on read
+      }
+    }
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error)
+  })
+}
+
+function req<T>(request: IDBRequest<T>): Promise<T> {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error)
+  })
+}
+
+/** Backfill pinned/sortOrder for sessions migrated from v2 */
+function backfillSession(s: Session): Session {
+  if (s.pinned === undefined) s.pinned = false
+  if (s.sortOrder === undefined) s.sortOrder = s.createdAt
+  return s
+}
+
+export class DatabaseManager {
+  private db: IDBDatabase | null = null
+
+  async init(): Promise<void> {
+    this.db = await openDatabase()
+  }
+
+  private getStore(name: string, mode: IDBTransactionMode = 'readonly'): IDBObjectStore {
+    if (!this.db) throw new Error('Database not initialized')
+    return this.db.transaction(name, mode).objectStore(name)
+  }
+
+  // === Provider operations ===
+
+  async addProvider(name: string, baseUrl: string, apiKey: string): Promise<Provider> {
+    const provider: Provider = {
+      id: crypto.randomUUID(),
+      name,
+      baseUrl: baseUrl.replace(/\/+$/, ''),
+      apiKey,
+      createdAt: Date.now(),
+    }
+    await req(this.getStore('providers', 'readwrite').put(provider))
+    return provider
+  }
+
+  async getProvider(id: string): Promise<Provider | null> {
+    const result = await req(this.getStore('providers').get(id))
+    return result || null
+  }
+
+  async listProviders(): Promise<Provider[]> {
+    const all = await req(this.getStore('providers').getAll())
+    return all.sort((a: Provider, b: Provider) => a.createdAt - b.createdAt)
+  }
+
+  async updateProvider(id: string, updates: Partial<Pick<Provider, 'name' | 'baseUrl' | 'apiKey'>>): Promise<Provider | null> {
+    const store = this.getStore('providers', 'readwrite')
+    const provider = await req(store.get(id)) as Provider | undefined
+    if (!provider) return null
+    if (updates.name !== undefined) provider.name = updates.name
+    if (updates.baseUrl !== undefined) provider.baseUrl = updates.baseUrl.replace(/\/+$/, '')
+    if (updates.apiKey !== undefined) provider.apiKey = updates.apiKey
+    await req(store.put(provider))
+    return provider
+  }
+
+  async removeProvider(id: string): Promise<boolean> {
+    try {
+      await req(this.getStore('providers', 'readwrite').delete(id))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  // === OAuth credential operations ===
+
+  async getOAuthCredentials(provider: string): Promise<StoredOAuthCredentials | null> {
+    const result = await req(this.getStore('oauth-credentials').get(provider))
+    return result || null
+  }
+
+  async setOAuthCredentials(provider: string, creds: { refresh: string; access: string; expires: number; accountId?: string }): Promise<void> {
+    const record: StoredOAuthCredentials = { provider, ...creds }
+    await req(this.getStore('oauth-credentials', 'readwrite').put(record))
+  }
+
+  async removeOAuthCredentials(provider: string): Promise<void> {
+    await req(this.getStore('oauth-credentials', 'readwrite').delete(provider))
+  }
+
+  // === Session operations ===
+
+  async createSession(model: string): Promise<Session> {
+    const now = Date.now()
+    const session: Session = {
+      id: crypto.randomUUID(),
+      title: 'New Chat',
+      model,
+      createdAt: now,
+      updatedAt: now,
+      pinned: false,
+      sortOrder: now,
+    }
+    await req(this.getStore('sessions', 'readwrite').put(session))
+    return session
+  }
+
+  async getSession(id: string): Promise<Session | null> {
+    const result = await req(this.getStore('sessions').get(id))
+    return result ? backfillSession(result) : null
+  }
+
+  async listSessions(): Promise<Session[]> {
+    const all = await req(this.getStore('sessions').getAll())
+    return sortTabs(all.map(backfillSession))
+  }
+
+  async updateSession(id: string, updates: Partial<Pick<Session, 'title' | 'model' | 'systemPrompt' | 'pinned' | 'sortOrder'>>): Promise<Session | null> {
+    const store = this.getStore('sessions', 'readwrite')
+    const session = await req(store.get(id)) as Session | undefined
+    if (!session) return null
+    backfillSession(session)
+    if (updates.title !== undefined) session.title = updates.title
+    if (updates.model !== undefined) session.model = updates.model
+    if (updates.systemPrompt !== undefined) session.systemPrompt = updates.systemPrompt
+    if (updates.pinned !== undefined) session.pinned = updates.pinned
+    if (updates.sortOrder !== undefined) session.sortOrder = updates.sortOrder
+    session.updatedAt = Date.now()
+    await req(store.put(session))
+    return session
+  }
+
+  async removeSession(id: string): Promise<void> {
+    const messages = await this.getMessages(id)
+    const msgStore = this.getStore('messages', 'readwrite')
+    for (const m of messages) {
+      await req(msgStore.delete(m.id))
+    }
+    await req(this.getStore('sessions', 'readwrite').delete(id))
+  }
+
+  // === Terminal Tab operations ===
+
+  async createTerminalTab(title?: string): Promise<TerminalTab> {
+    const now = Date.now()
+    const tab: TerminalTab = {
+      id: crypto.randomUUID(),
+      title: title || 'New Thread',
+      createdAt: now,
+      pinned: false,
+      sortOrder: now,
+    }
+    await req(this.getStore('terminal-tabs', 'readwrite').put(tab))
+    return tab
+  }
+
+  async listTerminalTabs(): Promise<TerminalTab[]> {
+    const all = await req(this.getStore('terminal-tabs').getAll())
+    return sortTabs(all)
+  }
+
+  async updateTerminalTab(id: string, updates: Partial<Pick<TerminalTab, 'title' | 'pinned' | 'sortOrder'>>): Promise<TerminalTab | null> {
+    const store = this.getStore('terminal-tabs', 'readwrite')
+    const tab = await req(store.get(id)) as TerminalTab | undefined
+    if (!tab) return null
+    if (updates.title !== undefined) tab.title = updates.title
+    if (updates.pinned !== undefined) tab.pinned = updates.pinned
+    if (updates.sortOrder !== undefined) tab.sortOrder = updates.sortOrder
+    await req(store.put(tab))
+    return tab
+  }
+
+  async removeTerminalTab(id: string): Promise<void> {
+    await req(this.getStore('terminal-tabs', 'readwrite').delete(id))
+  }
+
+  // === Browser Tab operations ===
+
+  async createBrowserTab(title?: string, url?: string): Promise<BrowserTab> {
+    const now = Date.now()
+    const tab: BrowserTab = {
+      id: crypto.randomUUID(),
+      title: title || 'Browser',
+      url: url || '',
+      createdAt: now,
+      pinned: false,
+      sortOrder: now,
+    }
+    await req(this.getStore('browser-tabs', 'readwrite').put(tab))
+    return tab
+  }
+
+  async listBrowserTabs(): Promise<BrowserTab[]> {
+    const all = await req(this.getStore('browser-tabs').getAll())
+    return sortTabs(all)
+  }
+
+  async updateBrowserTab(id: string, updates: Partial<Pick<BrowserTab, 'title' | 'url' | 'pinned' | 'sortOrder'>>): Promise<BrowserTab | null> {
+    const store = this.getStore('browser-tabs', 'readwrite')
+    const tab = await req(store.get(id)) as BrowserTab | undefined
+    if (!tab) return null
+    if (updates.title !== undefined) tab.title = updates.title
+    if (updates.url !== undefined) tab.url = updates.url
+    if (updates.pinned !== undefined) tab.pinned = updates.pinned
+    if (updates.sortOrder !== undefined) tab.sortOrder = updates.sortOrder
+    await req(store.put(tab))
+    return tab
+  }
+
+  async removeBrowserTab(id: string): Promise<void> {
+    await req(this.getStore('browser-tabs', 'readwrite').delete(id))
+  }
+
+  // === Message operations ===
+
+  async addMessage(
+    sessionId: string,
+    role: 'user' | 'assistant' | 'system',
+    content: string,
+    opts?: { blocks?: MessageBlock[]; partial?: boolean; id?: string }
+  ): Promise<Message> {
+    const message: Message = {
+      id: opts?.id || crypto.randomUUID(),
+      sessionId,
+      role,
+      content,
+      createdAt: Date.now(),
+    }
+    if (opts?.blocks) message.blocks = opts.blocks
+    if (opts?.partial) message.partial = true
+    await req(this.getStore('messages', 'readwrite').put(message))
+
+    const sessionStore = this.getStore('sessions', 'readwrite')
+    const session = await req(sessionStore.get(sessionId)) as Session | undefined
+    if (session) {
+      session.updatedAt = Date.now()
+      await req(sessionStore.put(session))
+    }
+
+    return message
+  }
+
+  async updateMessage(id: string, updates: Partial<Pick<Message, 'content' | 'blocks' | 'partial'>>): Promise<void> {
+    const store = this.getStore('messages', 'readwrite')
+    const msg = await req(store.get(id)) as Message | undefined
+    if (!msg) return
+    if (updates.content !== undefined) msg.content = updates.content
+    if (updates.blocks !== undefined) msg.blocks = updates.blocks
+    if (updates.partial !== undefined) msg.partial = updates.partial
+    else if (updates.partial === undefined && 'partial' in updates) delete msg.partial
+    await req(store.put(msg))
+  }
+
+  async removeMessage(id: string): Promise<void> {
+    await req(this.getStore('messages', 'readwrite').delete(id))
+  }
+
+  async getMessages(sessionId: string): Promise<Message[]> {
+    const index = this.getStore('messages').index('sessionId')
+    const all = await req(index.getAll(sessionId))
+    return all.sort((a: Message, b: Message) => a.createdAt - b.createdAt)
+  }
+}
+
+// Shared singleton instance
+export const db = new DatabaseManager()
+
+// Ready promise — consumers can await this before using db
+export const dbReady: Promise<void> = db.init()

moav2/src/core/services/event-store.ts

@@ -0,0 +1,449 @@
+// Event Store — foundational history primitive for MOA v2
+// Uses PlatformDatabase (async) accessed via getPlatform().sqlite
+// Architecture: append-only event log with FTS5 search and left-fold projections
+
+import { getPlatform } from '../platform'
+import type { PlatformDatabase } from '../platform/types'
+
+// ---------------------------------------------------------------------------
+// Types (unchanged from moa v1)
+// ---------------------------------------------------------------------------
+
+export interface MoaEvent {
+  id: string                     // Sortable timestamp-based ID (base36 ts + random)
+  type: string                   // e.g. 'message.sent', 'file.read', 'session.created'
+  payload: Record<string, any>   // Event-specific data (stored as JSON)
+  actor: string                  // 'user' | 'agent' | 'system'
+  sessionId?: string             // Optional session context
+  causationId?: string           // What event/command caused this
+  correlationId?: string         // Root transaction/session ID
+  timestamp: number              // Date.now() at append time
+}
+
+export type NewEvent = Omit<MoaEvent, 'id' | 'timestamp'>
+
+export interface QueryOpts {
+  type?: string        // Filter by event type. Supports glob: 'message.*'
+  sessionId?: string   // Filter by session
+  actor?: string       // Filter by actor
+  since?: number       // Timestamp lower bound (inclusive)
+  until?: number       // Timestamp upper bound (inclusive)
+  limit?: number       // Max results, default 100
+  offset?: number      // Pagination offset, default 0
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Deserialize a row from the events table into a MoaEvent */
+function rowToEvent(row: any): MoaEvent {
+  return {
+    id: row.id,
+    type: row.type,
+    payload: JSON.parse(row.payload),
+    actor: row.actor,
+    sessionId: row.session_id ?? undefined,
+    causationId: row.causation_id ?? undefined,
+    correlationId: row.correlation_id ?? undefined,
+    timestamp: row.timestamp,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// EventStore
+// ---------------------------------------------------------------------------
+
+export class EventStore {
+  private db: PlatformDatabase
+
+  private constructor(db: PlatformDatabase) {
+    this.db = db
+  }
+
+  /** Async factory — creates and initializes the event store */
+  static async create(): Promise<EventStore> {
+    const { sqlite } = getPlatform()
+    const db = await sqlite.open('moa-events.db')
+    const store = new EventStore(db)
+    await store.init()
+    return store
+  }
+
+  // -------------------------------------------------------------------------
+  // Schema initialisation (async — all db ops return Promises)
+  // -------------------------------------------------------------------------
+
+  private async init(): Promise<void> {
+    // Core events table — append-only, no UPDATE / DELETE in normal operation
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id               TEXT PRIMARY KEY,
+        type             TEXT NOT NULL,
+        payload          TEXT NOT NULL,
+        actor            TEXT NOT NULL,
+        session_id       TEXT,
+        causation_id     TEXT,
+        correlation_id   TEXT,
+        timestamp        INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_type      ON events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_session    ON events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp  ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_actor      ON events(actor);
+      CREATE INDEX IF NOT EXISTS idx_events_corr       ON events(correlation_id);
+    `)
+
+    // FTS5 virtual table for full-text search over type + payload text
+    // content= keeps FTS in sync via triggers (external content table pattern)
+    await this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        type,
+        payload,
+        content=events,
+        content_rowid=rowid
+      );
+    `)
+
+    // Triggers to keep the FTS index in sync with the events table.
+    // We wrap each in a try because CREATE TRIGGER IF NOT EXISTS is not
+    // universally supported — the exec will throw if the trigger already exists.
+    const triggers = [
+      `CREATE TRIGGER events_ai AFTER INSERT ON events BEGIN
+        INSERT INTO events_fts(rowid, type, payload)
+        VALUES (new.rowid, new.type, new.payload);
+      END;`,
+      `CREATE TRIGGER events_ad AFTER DELETE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, type, payload)
+        VALUES ('delete', old.rowid, old.type, old.payload);
+      END;`,
+      `CREATE TRIGGER events_au AFTER UPDATE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, type, payload)
+        VALUES ('delete', old.rowid, old.type, old.payload);
+        INSERT INTO events_fts(rowid, type, payload)
+        VALUES (new.rowid, new.type, new.payload);
+      END;`,
+    ]
+
+    for (const sql of triggers) {
+      try {
+        await this.db.exec(sql)
+      } catch (_) {
+        // Trigger already exists — safe to ignore
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // ID generation — lexicographically sortable by time
+  // -------------------------------------------------------------------------
+
+  private generateId(): string {
+    // 9-char base36 timestamp gives us sortability through ~2060
+    const ts = Date.now().toString(36).padStart(9, '0')
+    // 8-char random suffix for uniqueness within the same millisecond
+    const rand = Math.random().toString(36).substring(2, 10)
+    return `${ts}-${rand}`
+  }
+
+  // -------------------------------------------------------------------------
+  // Write side — append only (async)
+  // -------------------------------------------------------------------------
+
+  /** Append a new event to the log. Returns the complete event with id and timestamp. */
+  async append(event: NewEvent): Promise<MoaEvent> {
+    const id = this.generateId()
+    const timestamp = Date.now()
+    const payloadJson = JSON.stringify(event.payload)
+
+    const stmt = this.db.prepare(`
+      INSERT INTO events (id, type, payload, actor, session_id, causation_id, correlation_id, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `)
+
+    await stmt.run(
+      id,
+      event.type,
+      payloadJson,
+      event.actor,
+      event.sessionId ?? null,
+      event.causationId ?? null,
+      event.correlationId ?? null,
+      timestamp,
+    )
+
+    return {
+      id,
+      type: event.type,
+      payload: event.payload,
+      actor: event.actor,
+      sessionId: event.sessionId,
+      causationId: event.causationId,
+      correlationId: event.correlationId,
+      timestamp,
+    }
+  }
+
+  /** Append multiple events sequentially. Browser SQLite may not support transactions the same way. */
+  async appendBatch(events: NewEvent[]): Promise<MoaEvent[]> {
+    const results: MoaEvent[] = []
+    for (const evt of events) {
+      results.push(await this.append(evt))
+    }
+    return results
+  }
+
+  // -------------------------------------------------------------------------
+  // Read side — queries (async)
+  // -------------------------------------------------------------------------
+
+  /** Query events with flexible filters. Returns events sorted by timestamp ASC. */
+  async query(opts: QueryOpts = {}): Promise<MoaEvent[]> {
+    const clauses: string[] = []
+    const params: any[] = []
+
+    if (opts.type) {
+      if (opts.type.includes('*')) {
+        // Glob pattern: 'message.*' -> LIKE 'message.%'
+        clauses.push('type LIKE ?')
+        params.push(opts.type.replace(/\*/g, '%'))
+      } else {
+        clauses.push('type = ?')
+        params.push(opts.type)
+      }
+    }
+
+    if (opts.sessionId) {
+      clauses.push('session_id = ?')
+      params.push(opts.sessionId)
+    }
+
+    if (opts.actor) {
+      clauses.push('actor = ?')
+      params.push(opts.actor)
+    }
+
+    if (opts.since != null) {
+      clauses.push('timestamp >= ?')
+      params.push(opts.since)
+    }
+
+    if (opts.until != null) {
+      clauses.push('timestamp <= ?')
+      params.push(opts.until)
+    }
+
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''
+    const limit = opts.limit ?? 100
+    const offset = opts.offset ?? 0
+
+    const sql = `
+      SELECT * FROM events
+      ${where}
+      ORDER BY timestamp ASC, id ASC
+      LIMIT ? OFFSET ?
+    `
+    params.push(limit, offset)
+
+    const rows = await this.db.prepare(sql).all(...params)
+    return rows.map(rowToEvent)
+  }
+
+  /** Full-text search over event type and payload JSON text. */
+  async search(query: string, opts?: { limit?: number; sessionId?: string }): Promise<MoaEvent[]> {
+    const limit = opts?.limit ?? 50
+    const sessionFilter = opts?.sessionId
+
+    // FTS5 MATCH requires the query to be non-empty
+    if (!query.trim()) return []
+
+    let sql: string
+    const params: any[] = []
+
+    if (sessionFilter) {
+      sql = `
+        SELECT e.* FROM events e
+        INNER JOIN events_fts f ON e.rowid = f.rowid
+        WHERE events_fts MATCH ? AND e.session_id = ?
+        ORDER BY rank
+        LIMIT ?
+      `
+      params.push(query, sessionFilter, limit)
+    } else {
+      sql = `
+        SELECT e.* FROM events e
+        INNER JOIN events_fts f ON e.rowid = f.rowid
+        WHERE events_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `
+      params.push(query, limit)
+    }
+
+    try {
+      const rows = await this.db.prepare(sql).all(...params)
+      return rows.map(rowToEvent)
+    } catch (_) {
+      // FTS query syntax errors should not crash the app
+      console.warn('[EventStore] FTS search failed for query:', query)
+      return []
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Projections (Read Models) — async
+  // -------------------------------------------------------------------------
+
+  /**
+   * Left-fold all events for a session into a materialized read model.
+   * Returns a categorized snapshot of the session's current state.
+   */
+  async materialize(sessionId: string): Promise<{
+    messages: MoaEvent[]
+    intents: MoaEvent[]
+    fileOps: MoaEvent[]
+    commands: MoaEvent[]
+    sessions: MoaEvent[]
+    other: MoaEvent[]
+  }> {
+    const events = await this.query({ sessionId, limit: 10_000 })
+
+    const result = {
+      messages: [] as MoaEvent[],
+      intents: [] as MoaEvent[],
+      fileOps: [] as MoaEvent[],
+      commands: [] as MoaEvent[],
+      sessions: [] as MoaEvent[],
+      other: [] as MoaEvent[],
+    }
+
+    for (const evt of events) {
+      if (evt.type.startsWith('message.')) {
+        result.messages.push(evt)
+      } else if (evt.type.startsWith('intent.')) {
+        result.intents.push(evt)
+      } else if (evt.type.startsWith('file.')) {
+        result.fileOps.push(evt)
+      } else if (evt.type.startsWith('command.')) {
+        result.commands.push(evt)
+      } else if (evt.type.startsWith('session.')) {
+        result.sessions.push(evt)
+      } else {
+        result.other.push(evt)
+      }
+    }
+
+    return result
+  }
+
+  /** Get the most recent event of a given type, optionally within a session. */
+  async getLatest(type: string, sessionId?: string): Promise<MoaEvent | null> {
+    const clauses = ['type = ?']
+    const params: any[] = [type]
+
+    if (sessionId) {
+      clauses.push('session_id = ?')
+      params.push(sessionId)
+    }
+
+    const sql = `
+      SELECT * FROM events
+      WHERE ${clauses.join(' AND ')}
+      ORDER BY timestamp DESC, id DESC
+      LIMIT 1
+    `
+
+    const row = await this.db.prepare(sql).get(...params)
+    return row ? rowToEvent(row) : null
+  }
+
+  /** Get a single event by its ID. */
+  async getById(id: string): Promise<MoaEvent | null> {
+    const row = await this.db.prepare('SELECT * FROM events WHERE id = ?').get(id)
+    return row ? rowToEvent(row) : null
+  }
+
+  /** Count events, optionally filtered by type and/or session. */
+  async count(type?: string, sessionId?: string): Promise<number> {
+    const clauses: string[] = []
+    const params: any[] = []
+
+    if (type) {
+      if (type.includes('*')) {
+        clauses.push('type LIKE ?')
+        params.push(type.replace(/\*/g, '%'))
+      } else {
+        clauses.push('type = ?')
+        params.push(type)
+      }
+    }
+
+    if (sessionId) {
+      clauses.push('session_id = ?')
+      params.push(sessionId)
+    }
+
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''
+    const sql = `SELECT COUNT(*) as cnt FROM events ${where}`
+
+    const row = await this.db.prepare(sql).get(...params) as { cnt: number }
+    return row.cnt
+  }
+
+  // -------------------------------------------------------------------------
+  // Utility (async)
+  // -------------------------------------------------------------------------
+
+  /** Get all distinct event types in the store. */
+  async types(): Promise<string[]> {
+    const rows = await this.db.prepare('SELECT DISTINCT type FROM events ORDER BY type').all()
+    return rows.map((r: any) => r.type)
+  }
+
+  /** Get all distinct session IDs. */
+  async sessions(): Promise<string[]> {
+    const rows = await this.db
+      .prepare('SELECT DISTINCT session_id FROM events WHERE session_id IS NOT NULL ORDER BY session_id')
+      .all()
+    return rows.map((r: any) => r.session_id)
+  }
+
+  /**
+   * Replay events through a reducer function.
+   * This is the generic left-fold — callers supply the fold logic.
+   */
+  async replay<T>(
+    reducer: (state: T, event: MoaEvent) => T,
+    initialState: T,
+    opts?: QueryOpts,
+  ): Promise<T> {
+    const events = await this.query({ ...opts, limit: opts?.limit ?? 100_000 })
+    let state = initialState
+    for (const evt of events) {
+      state = reducer(state, evt)
+    }
+    return state
+  }
+
+  /** Close the database connection. Call on app shutdown. */
+  async close(): Promise<void> {
+    try {
+      await this.db.close()
+    } catch (_) {
+      // Already closed or never opened
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Singleton — async initialization
+// ---------------------------------------------------------------------------
+
+let _eventStore: EventStore | null = null
+
+export async function getEventStore(): Promise<EventStore> {
+  if (!_eventStore) {
+    _eventStore = await EventStore.create()
+  }
+  return _eventStore
+}

moav2/src/core/services/google-auth.ts

@@ -0,0 +1,226 @@
+/**
+ * Google OAuth 2.0 for Vertex AI (Gemini models).
+ *
+ * Flow (same pattern as Anthropic OAuth):
+ * 1. Build auth URL → open in browser
+ * 2. User authorizes → gets code
+ * 3. User pastes code → exchange for tokens
+ * 4. Use access_token for Vertex AI API calls
+ * 5. Refresh automatically when expired
+ *
+ * Requires a Google OAuth Client ID (Desktop type) configured in
+ * Google Cloud Console. The client_id and client_secret are stored
+ * in env/config — for desktop OAuth clients, the secret is not
+ * truly secret (shipped in binaries, same as gcloud CLI).
+ */
+
+// Google OAuth endpoints
+const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth'
+const TOKEN_URL = 'https://oauth2.googleapis.com/token'
+const PROJECTS_URL = 'https://cloudresourcemanager.googleapis.com/v1/projects'
+
+// Scopes needed for Vertex AI + project listing
+const SCOPES = [
+  'https://www.googleapis.com/auth/cloud-platform',
+].join(' ')
+
+// PKCE: generate code verifier + challenge
+function generateCodeVerifier(): string {
+  const array = new Uint8Array(32)
+  crypto.getRandomValues(array)
+  return base64UrlEncode(array)
+}
+
+async function generateCodeChallenge(verifier: string): Promise<string> {
+  const encoder = new TextEncoder()
+  const data = encoder.encode(verifier)
+  const hash = await crypto.subtle.digest('SHA-256', data)
+  return base64UrlEncode(new Uint8Array(hash))
+}
+
+function base64UrlEncode(bytes: Uint8Array): string {
+  let binary = ''
+  for (const b of bytes) binary += String.fromCharCode(b)
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+export interface GoogleOAuthConfig {
+  clientId: string
+  clientSecret: string
+}
+
+export interface GoogleOAuthTokens {
+  access_token: string
+  refresh_token: string
+  expires_at: number  // Unix ms
+  token_type: string
+}
+
+export interface GcpProject {
+  projectId: string
+  name: string
+  projectNumber: string
+}
+
+// In-memory state for the current OAuth flow
+let _codeVerifier: string | null = null
+
+/**
+ * Get the configured OAuth client credentials.
+ * Reads from environment or hardcoded config.
+ */
+export function getOAuthConfig(): GoogleOAuthConfig | null {
+  // Check environment first (for development)
+  const clientId = (import.meta as any).env?.VITE_GOOGLE_OAUTH_CLIENT_ID
+  const clientSecret = (import.meta as any).env?.VITE_GOOGLE_OAUTH_CLIENT_SECRET
+
+  if (clientId && clientSecret) {
+    return { clientId, clientSecret }
+  }
+
+  return null
+}
+
+/**
+ * Build the Google OAuth authorization URL.
+ * Opens this in the browser for the user to authorize.
+ */
+export async function buildAuthUrl(config: GoogleOAuthConfig): Promise<{ url: string }> {
+  _codeVerifier = generateCodeVerifier()
+  const codeChallenge = await generateCodeChallenge(_codeVerifier)
+
+  const params = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: 'urn:ietf:wg:oauth:2.0:oob',
+    response_type: 'code',
+    scope: SCOPES,
+    code_challenge: codeChallenge,
+    code_challenge_method: 'S256',
+    access_type: 'offline',
+    prompt: 'consent',
+  })
+
+  return { url: `${AUTH_URL}?${params.toString()}` }
+}
+
+/**
+ * Exchange the authorization code for tokens.
+ */
+export async function exchangeCode(
+  config: GoogleOAuthConfig,
+  code: string
+): Promise<GoogleOAuthTokens> {
+  if (!_codeVerifier) {
+    throw new Error('No code verifier found — did you call buildAuthUrl first?')
+  }
+
+  const body = new URLSearchParams({
+    client_id: config.clientId,
+    client_secret: config.clientSecret,
+    code,
+    code_verifier: _codeVerifier,
+    grant_type: 'authorization_code',
+    redirect_uri: 'urn:ietf:wg:oauth:2.0:oob',
+  })
+
+  const res = await fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: body.toString(),
+  })
+
+  if (!res.ok) {
+    const err = await res.text()
+    throw new Error(`Token exchange failed (${res.status}): ${err}`)
+  }
+
+  const data = await res.json()
+  _codeVerifier = null
+
+  return {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + (data.expires_in * 1000),
+    token_type: data.token_type || 'Bearer',
+  }
+}
+
+/**
+ * Refresh an expired access token using the refresh token.
+ */
+export async function refreshAccessToken(
+  config: GoogleOAuthConfig,
+  refreshToken: string
+): Promise<{ access_token: string; expires_at: number }> {
+  const body = new URLSearchParams({
+    client_id: config.clientId,
+    client_secret: config.clientSecret,
+    refresh_token: refreshToken,
+    grant_type: 'refresh_token',
+  })
+
+  const res = await fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: body.toString(),
+  })
+
+  if (!res.ok) {
+    const err = await res.text()
+    throw new Error(`Token refresh failed (${res.status}): ${err}`)
+  }
+
+  const data = await res.json()
+  return {
+    access_token: data.access_token,
+    expires_at: Date.now() + (data.expires_in * 1000),
+  }
+}
+
+/**
+ * Get a valid access token, refreshing if needed.
+ * Returns the token string ready for Authorization header.
+ */
+export async function getValidAccessToken(
+  config: GoogleOAuthConfig,
+  stored: { refresh: string; access: string; expires: number }
+): Promise<{ accessToken: string; newCreds: { refresh: string; access: string; expires: number } }> {
+  // Token still valid (with 60s buffer)
+  if (stored.expires > Date.now() + 60_000) {
+    return {
+      accessToken: stored.access,
+      newCreds: stored,
+    }
+  }
+
+  // Need to refresh
+  const refreshed = await refreshAccessToken(config, stored.refresh)
+  const newCreds = {
+    refresh: stored.refresh,
+    access: refreshed.access_token,
+    expires: refreshed.expires_at,
+  }
+
+  return { accessToken: refreshed.access_token, newCreds }
+}
+
+/**
+ * List GCP projects the authenticated user has access to.
+ */
+export async function listProjects(accessToken: string): Promise<GcpProject[]> {
+  const res = await fetch(`${PROJECTS_URL}?filter=lifecycleState:ACTIVE`, {
+    headers: { 'Authorization': `Bearer ${accessToken}` },
+  })
+
+  if (!res.ok) {
+    const err = await res.text()
+    throw new Error(`Failed to list projects (${res.status}): ${err}`)
+  }
+
+  const data = await res.json()
+  return (data.projects || []).map((p: any) => ({
+    projectId: p.projectId,
+    name: p.name,
+    projectNumber: p.projectNumber,
+  }))
+}

moav2/src/core/services/google-vertex-express.ts

@@ -0,0 +1,372 @@
+/**
+ * Vertex AI Express mode streaming provider.
+ *
+ * Uses a simple API key with `vertexai: true` in the @google/genai SDK,
+ * which triggers the Express endpoint (aiplatform.googleapis.com) without
+ * requiring a GCP project or location.
+ */
+
+import { GoogleGenAI, ThinkingLevel } from '@google/genai'
+import { calculateCost } from '../../../node_modules/@mariozechner/pi-ai/dist/models.js'
+import { AssistantMessageEventStream } from '../../../node_modules/@mariozechner/pi-ai/dist/utils/event-stream.js'
+import { sanitizeSurrogates } from '../../../node_modules/@mariozechner/pi-ai/dist/utils/sanitize-unicode.js'
+import {
+  convertMessages,
+  convertTools,
+  isThinkingPart,
+  mapStopReason,
+  mapToolChoice,
+  retainThoughtSignature,
+} from '../../../node_modules/@mariozechner/pi-ai/dist/providers/google-shared.js'
+import { buildBaseOptions, clampReasoning } from '../../../node_modules/@mariozechner/pi-ai/dist/providers/simple-options.js'
+import { withRetry } from './retry'
+
+const API_VERSION = 'v1'
+
+const THINKING_LEVEL_MAP: Record<string, any> = {
+  THINKING_LEVEL_UNSPECIFIED: ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
+  MINIMAL: ThinkingLevel.MINIMAL,
+  LOW: ThinkingLevel.LOW,
+  MEDIUM: ThinkingLevel.MEDIUM,
+  HIGH: ThinkingLevel.HIGH,
+}
+
+let toolCallCounter = 0
+
+function createClient(apiKey: string, optionsHeaders?: Record<string, string>) {
+  const httpOptions: any = {}
+  if (optionsHeaders) {
+    httpOptions.headers = { ...optionsHeaders }
+  }
+  const hasHttpOptions = Object.values(httpOptions).some(Boolean)
+  return new GoogleGenAI({
+    apiKey,
+    vertexai: true,
+    // No project or location — SDK enters Express mode automatically
+    apiVersion: API_VERSION,
+    httpOptions: hasHttpOptions ? httpOptions : undefined,
+  })
+}
+
+function buildParams(model: any, context: any, options: any = {}) {
+  const contents = convertMessages(model, context)
+  const generationConfig: any = {}
+  if (options.temperature !== undefined) {
+    generationConfig.temperature = options.temperature
+  }
+  if (options.maxTokens !== undefined) {
+    generationConfig.maxOutputTokens = options.maxTokens
+  }
+  const config: any = {
+    ...(Object.keys(generationConfig).length > 0 && generationConfig),
+    ...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
+    ...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
+  }
+  if (context.tools && context.tools.length > 0 && options.toolChoice) {
+    config.toolConfig = {
+      functionCallingConfig: {
+        mode: mapToolChoice(options.toolChoice),
+      },
+    }
+  } else {
+    config.toolConfig = undefined
+  }
+  if (options.thinking?.enabled && model.reasoning) {
+    const thinkingConfig: any = { includeThoughts: true }
+    if (options.thinking.level !== undefined) {
+      thinkingConfig.thinkingLevel = THINKING_LEVEL_MAP[options.thinking.level]
+    } else if (options.thinking.budgetTokens !== undefined) {
+      thinkingConfig.thinkingBudget = options.thinking.budgetTokens
+    }
+    config.thinkingConfig = thinkingConfig
+  }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      throw new Error('Request aborted')
+    }
+    config.abortSignal = options.signal
+  }
+  return { model: model.id, contents, config }
+}
+
+export const streamGoogleVertexExpress = (model: any, context: any, options: any) => {
+  const stream = new AssistantMessageEventStream()
+  ;(async () => {
+    const output: any = {
+      role: 'assistant',
+      content: [],
+      api: 'google-vertex-express',
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: 'stop',
+      timestamp: Date.now(),
+    }
+    try {
+      const apiKey = options?.apiKey
+      if (!apiKey) {
+        throw new Error('Vertex AI Express requires an API key. Go to Settings > Vertex AI and add your Express API key.')
+      }
+      const client = createClient(apiKey, options?.headers)
+      const params = buildParams(model, context, options)
+      options?.onPayload?.(params)
+      const googleStream = await withRetry(
+        () => client.models.generateContentStream(params),
+        {
+          signal: options?.signal,
+          onRetry: ({ attempt, maxRetries, delayMs, error }) => {
+            const message = error instanceof Error ? error.message : String(error)
+            console.warn(`[vertex-express] Retry ${attempt}/${maxRetries} after ${delayMs}ms:`, message)
+          },
+        }
+      )
+      stream.push({ type: 'start', partial: output })
+      let currentBlock: any = null
+      const blocks = output.content
+      const blockIndex = () => blocks.length - 1
+      for await (const chunk of googleStream) {
+        const candidate = (chunk as any).candidates?.[0]
+        if (candidate?.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.text !== undefined) {
+              const isThinking = isThinkingPart(part)
+              if (
+                !currentBlock ||
+                (isThinking && currentBlock.type !== 'thinking') ||
+                (!isThinking && currentBlock.type !== 'text')
+              ) {
+                if (currentBlock) {
+                  if (currentBlock.type === 'text') {
+                    stream.push({
+                      type: 'text_end',
+                      contentIndex: blocks.length - 1,
+                      content: currentBlock.text,
+                      partial: output,
+                    })
+                  } else {
+                    stream.push({
+                      type: 'thinking_end',
+                      contentIndex: blockIndex(),
+                      content: currentBlock.thinking,
+                      partial: output,
+                    })
+                  }
+                }
+                if (isThinking) {
+                  currentBlock = { type: 'thinking', thinking: '', thinkingSignature: undefined }
+                  output.content.push(currentBlock)
+                  stream.push({ type: 'thinking_start', contentIndex: blockIndex(), partial: output })
+                } else {
+                  currentBlock = { type: 'text', text: '' }
+                  output.content.push(currentBlock)
+                  stream.push({ type: 'text_start', contentIndex: blockIndex(), partial: output })
+                }
+              }
+              if (currentBlock.type === 'thinking') {
+                currentBlock.thinking += part.text
+                currentBlock.thinkingSignature = retainThoughtSignature(
+                  currentBlock.thinkingSignature,
+                  (part as any).thoughtSignature
+                )
+                stream.push({
+                  type: 'thinking_delta',
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output,
+                })
+              } else {
+                currentBlock.text += part.text
+                currentBlock.textSignature = retainThoughtSignature(
+                  currentBlock.textSignature,
+                  (part as any).thoughtSignature
+                )
+                stream.push({
+                  type: 'text_delta',
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output,
+                })
+              }
+            }
+            if ((part as any).functionCall) {
+              if (currentBlock) {
+                if (currentBlock.type === 'text') {
+                  stream.push({
+                    type: 'text_end',
+                    contentIndex: blockIndex(),
+                    content: currentBlock.text,
+                    partial: output,
+                  })
+                } else {
+                  stream.push({
+                    type: 'thinking_end',
+                    contentIndex: blockIndex(),
+                    content: currentBlock.thinking,
+                    partial: output,
+                  })
+                }
+                currentBlock = null
+              }
+              const fc = (part as any).functionCall
+              const providedId = fc.id
+              const needsNewId =
+                !providedId || output.content.some((b: any) => b.type === 'toolCall' && b.id === providedId)
+              const toolCallId = needsNewId ? `${fc.name}_${Date.now()}_${++toolCallCounter}` : providedId
+              const toolCall = {
+                type: 'toolCall' as const,
+                id: toolCallId,
+                name: fc.name || '',
+                arguments: fc.args ?? {},
+                ...((part as any).thoughtSignature && { thoughtSignature: (part as any).thoughtSignature }),
+              }
+              output.content.push(toolCall)
+              stream.push({ type: 'toolcall_start', contentIndex: blockIndex(), partial: output })
+              stream.push({
+                type: 'toolcall_delta',
+                contentIndex: blockIndex(),
+                delta: JSON.stringify(toolCall.arguments),
+                partial: output,
+              })
+              stream.push({ type: 'toolcall_end', contentIndex: blockIndex(), toolCall, partial: output })
+            }
+          }
+        }
+        if (candidate?.finishReason) {
+          output.stopReason = mapStopReason(candidate.finishReason)
+          if (output.content.some((b: any) => b.type === 'toolCall')) {
+            output.stopReason = 'toolUse'
+          }
+        }
+        if ((chunk as any).usageMetadata) {
+          const um = (chunk as any).usageMetadata
+          output.usage = {
+            input: um.promptTokenCount || 0,
+            output: (um.candidatesTokenCount || 0) + (um.thoughtsTokenCount || 0),
+            cacheRead: um.cachedContentTokenCount || 0,
+            cacheWrite: 0,
+            totalTokens: um.totalTokenCount || 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+          }
+          calculateCost(model, output.usage)
+        }
+      }
+      if (currentBlock) {
+        if (currentBlock.type === 'text') {
+          stream.push({
+            type: 'text_end',
+            contentIndex: blockIndex(),
+            content: currentBlock.text,
+            partial: output,
+          })
+        } else {
+          stream.push({
+            type: 'thinking_end',
+            contentIndex: blockIndex(),
+            content: currentBlock.thinking,
+            partial: output,
+          })
+        }
+      }
+      if (options?.signal?.aborted) {
+        throw new Error('Request was aborted')
+      }
+      if (output.stopReason === 'aborted' || output.stopReason === 'error') {
+        throw new Error('An unknown error occurred')
+      }
+      stream.push({ type: 'done', reason: output.stopReason, message: output })
+      stream.end()
+    } catch (error: any) {
+      for (const block of output.content) {
+        if ('index' in block) {
+          delete block.index
+        }
+      }
+      output.stopReason = options?.signal?.aborted ? 'aborted' : 'error'
+      output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error)
+      stream.push({ type: 'error', reason: output.stopReason, error: output })
+      stream.end()
+    }
+  })()
+  return stream
+}
+
+function isGemini3ProModel(model: any) {
+  return model.id.includes('3-pro')
+}
+
+function isGemini3FlashModel(model: any) {
+  return model.id.includes('3-flash')
+}
+
+function getGemini3ThinkingLevel(effort: string, model: any): string {
+  if (isGemini3ProModel(model)) {
+    switch (effort) {
+      case 'minimal':
+      case 'low':
+        return 'LOW'
+      case 'medium':
+      case 'high':
+        return 'HIGH'
+    }
+  }
+  switch (effort) {
+    case 'minimal':
+      return 'MINIMAL'
+    case 'low':
+      return 'LOW'
+    case 'medium':
+      return 'MEDIUM'
+    case 'high':
+      return 'HIGH'
+  }
+  return 'MEDIUM'
+}
+
+function getGoogleBudget(model: any, effort: string, customBudgets: any): number {
+  if (customBudgets?.[effort] !== undefined) {
+    return customBudgets[effort]
+  }
+  if (model.id.includes('2.5-pro')) {
+    const budgets: Record<string, number> = { minimal: 128, low: 2048, medium: 8192, high: 32768 }
+    return budgets[effort] ?? -1
+  }
+  if (model.id.includes('2.5-flash')) {
+    const budgets: Record<string, number> = { minimal: 128, low: 2048, medium: 8192, high: 24576 }
+    return budgets[effort] ?? -1
+  }
+  return -1
+}
+
+export const streamSimpleGoogleVertexExpress = (model: any, context: any, options: any) => {
+  const base = buildBaseOptions(model, options, undefined)
+  if (!options?.reasoning) {
+    return streamGoogleVertexExpress(model, context, {
+      ...base,
+      thinking: { enabled: false },
+    })
+  }
+  const effort = clampReasoning(options.reasoning) as string
+  if (isGemini3ProModel(model) || isGemini3FlashModel(model)) {
+    return streamGoogleVertexExpress(model, context, {
+      ...base,
+      thinking: {
+        enabled: true,
+        level: getGemini3ThinkingLevel(effort, model),
+      },
+    })
+  }
+  return streamGoogleVertexExpress(model, context, {
+    ...base,
+    thinking: {
+      enabled: true,
+      budgetTokens: getGoogleBudget(model, effort, options.thinkingBudgets),
+    },
+  })
+}

moav2/src/core/services/model-resolver.ts

@@ -0,0 +1,91 @@
+import type { Model } from '@mariozechner/pi-ai'
+
+export type AuthMethod = 'anthropic-key' | 'anthropic-oauth' | 'openai-oauth' | 'vertex' | 'vertex-express' | string
+
+interface ResolveModelParams {
+  modelId: string
+  authMethod: AuthMethod
+  providerBaseUrl?: string
+}
+
+export async function resolveModel(params: ResolveModelParams): Promise<Model<any>> {
+  const piAi = await import('@mariozechner/pi-ai')
+  const { modelId, authMethod } = params
+
+  // Anthropic (both API key and OAuth use the same model objects)
+  if (authMethod === 'anthropic-key' || authMethod === 'anthropic-oauth') {
+    try {
+      const found = piAi.getModel('anthropic', modelId as any)
+      if (found) return found
+    } catch {
+      // Not in registry, fall through
+    }
+  }
+
+  // Vertex AI
+  if (authMethod === 'vertex') {
+    try {
+      const found = piAi.getModel('google-vertex', modelId as any)
+      if (found) return found
+    } catch {
+      // Not in registry, fall through
+    }
+  }
+
+  // Vertex AI Express (API key auth, global endpoint)
+  if (authMethod === 'vertex-express') {
+    try {
+      const found = piAi.getModel('google-vertex', modelId as any)
+      if (found) return found
+    } catch {
+      // Not in registry, fall through
+    }
+  }
+
+  // OpenAI OAuth (Codex)
+  if (authMethod === 'openai-oauth') {
+    try {
+      const found = piAi.getModel('openai-codex', modelId as any)
+      if (found) return found
+    } catch {
+      // Not in registry, fall through
+    }
+  }
+
+  // Custom provider — scan all known registries then fall back
+  const knownProviders = piAi.getProviders()
+  for (const p of knownProviders) {
+    try {
+      const models = piAi.getModels(p)
+      const found = models.find((m: any) => m.id === modelId)
+      if (found) return found
+    } catch {
+      // Skip
+    }
+  }
+
+  // Fall back to a custom model config
+  const providerBaseUrl = params.providerBaseUrl || ''
+  return {
+    id: modelId,
+    name: modelId,
+    api: 'openai-completions',
+    provider: authMethod || 'custom',
+    baseUrl: providerBaseUrl,
+    reasoning: false,
+    input: ['text', 'image'] as ('text' | 'image')[],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 16384,
+  } as Model<any>
+}
+
+/** Get all models for a known provider from pi-ai registry */
+export async function getProviderModels(provider: string): Promise<Model<any>[]> {
+  const piAi = await import('@mariozechner/pi-ai')
+  try {
+    return piAi.getModels(provider as any)
+  } catch {
+    return []
+  }
+}

moav2/src/core/services/oauth-code-bridge.ts

@@ -0,0 +1,42 @@
+interface OAuthCodeResolver {
+  resolve: (code: string) => void
+  reject: (error: Error) => void
+}
+
+export class OAuthCodeBridge {
+  private resolver: OAuthCodeResolver | null = null
+  private pendingCode: string | null = null
+
+  cancel(reason: string) {
+    const error = new Error(reason)
+    this.resolver?.reject(error)
+    this.resolver = null
+    this.pendingCode = null
+  }
+
+  attachResolver(resolver: OAuthCodeResolver) {
+    this.resolver = resolver
+    if (this.pendingCode) {
+      const code = this.pendingCode
+      this.pendingCode = null
+      this.resolver.resolve(code)
+      this.resolver = null
+      return true
+    }
+    return false
+  }
+
+  submitCode(code: string) {
+    const trimmed = code.trim()
+    if (!trimmed) return { accepted: false, queued: false }
+
+    if (this.resolver) {
+      this.resolver.resolve(trimmed)
+      this.resolver = null
+      return { accepted: true, queued: false }
+    }
+
+    this.pendingCode = trimmed
+    return { accepted: false, queued: true }
+  }
+}

moav2/src/core/services/provider-guards.ts

@@ -0,0 +1,43 @@
+import type { AuthMethod } from './model-resolver'
+
+export interface ResolvedProviderModel {
+  authMethod: AuthMethod
+  modelId: string
+}
+
+export function parseProviderModel(model: string): ResolvedProviderModel {
+  const sepIdx = model.indexOf(':')
+  if (sepIdx === -1) {
+    return { authMethod: 'anthropic-key', modelId: model }
+  }
+  return {
+    authMethod: model.substring(0, sepIdx),
+    modelId: model.substring(sepIdx + 1),
+  }
+}
+
+export function resolveVertexFallback(
+  model: string,
+  vertexProject: string | null,
+  vertexLocation: string | null,
+  vertexExpressApiKey: string | null,
+): ResolvedProviderModel {
+  const parsed = parseProviderModel(model)
+  if (parsed.authMethod !== 'vertex') return parsed
+
+  const hasFullVertexConfig = Boolean(vertexProject && vertexLocation)
+  if (hasFullVertexConfig) return parsed
+
+  if (vertexExpressApiKey) {
+    return { authMethod: 'vertex-express', modelId: parsed.modelId }
+  }
+
+  throw new Error('Vertex AI is not configured. Add Vertex project/location or set a Vertex Express API key in Settings > Vertex AI.')
+}
+
+export function getAnthropicBrowserAuthError(authMethod: AuthMethod, platformType: 'browser' | 'electron' | 'capacitor'): string | null {
+  if (platformType === 'browser' && authMethod === 'anthropic-key') {
+    return 'Anthropic API keys are blocked by browser CORS policy. In Settings > Anthropic, switch to OAuth and sign in with Claude.'
+  }
+  return null
+}

moav2/src/core/services/retry.ts

@@ -0,0 +1,134 @@
+export const DEFAULT_MAX_RETRIES = 4
+export const DEFAULT_INITIAL_DELAY_MS = 500
+export const DEFAULT_MAX_DELAY_MS = 30_000
+export const DEFAULT_JITTER_RATIO = 0.25
+
+export interface RetryAttemptInfo {
+  attempt: number
+  maxRetries: number
+  delayMs: number
+  error: unknown
+}
+
+export interface WithRetryOptions {
+  maxRetries?: number
+  initialDelayMs?: number
+  maxDelayMs?: number
+  jitterRatio?: number
+  signal?: AbortSignal
+  onRetry?: (info: RetryAttemptInfo) => void
+}
+
+function toNumber(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string') {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return null
+}
+
+function createAbortError() {
+  return new Error('Request was aborted')
+}
+
+export function isRetryableError(error: unknown): boolean {
+  const err = error as any
+  const statusCandidates = [err?.status, err?.statusCode, err?.response?.status, err?.code]
+  for (const candidate of statusCandidates) {
+    const status = toNumber(candidate)
+    if (status === 429 || (status !== null && status >= 500 && status < 600)) {
+      return true
+    }
+  }
+
+  const message = [
+    err?.message,
+    err?.name,
+    err?.code,
+    err?.statusText,
+    err?.cause?.message,
+    typeof error === 'string' ? error : undefined,
+  ]
+    .filter((part): part is string => typeof part === 'string' && part.length > 0)
+    .join(' ')
+    .toLowerCase()
+
+  if (/\b429\b/.test(message) || /\b5\d\d\b/.test(message)) {
+    return true
+  }
+
+  const retryableKeywords = [
+    'resource_exhausted',
+    'internal',
+    'unavailable',
+    'deadline_exceeded',
+    'econnreset',
+    'econnrefused',
+    'fetch failed',
+    'timeout',
+    'timed out',
+    'rate limit',
+    'overloaded',
+    'capacity',
+  ]
+
+  return retryableKeywords.some(keyword => message.includes(keyword))
+}
+
+export async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) {
+    throw createAbortError()
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort)
+      resolve()
+    }, Math.max(0, ms))
+
+    const onAbort = () => {
+      clearTimeout(timeout)
+      signal?.removeEventListener('abort', onAbort)
+      reject(createAbortError())
+    }
+
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+export async function withRetry<T>(fn: () => Promise<T>, options: WithRetryOptions = {}): Promise<T> {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES
+  const initialDelayMs = options.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS
+  const jitterRatio = options.jitterRatio ?? DEFAULT_JITTER_RATIO
+
+  for (let attempt = 0; ; attempt++) {
+    if (options.signal?.aborted) {
+      throw createAbortError()
+    }
+
+    try {
+      return await fn()
+    } catch (error) {
+      if (options.signal?.aborted) {
+        throw createAbortError()
+      }
+      if (attempt >= maxRetries || !isRetryableError(error)) {
+        throw error
+      }
+
+      const baseDelay = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs)
+      const jitteredDelay = Math.min(maxDelayMs, Math.round(baseDelay * (1 + Math.random() * jitterRatio)))
+
+      options.onRetry?.({
+        attempt: attempt + 1,
+        maxRetries,
+        delayMs: jitteredDelay,
+        error,
+      })
+
+      await sleep(jitteredDelay, options.signal)
+    }
+  }
+}

moav2/src/core/services/runtime-pack.ts

@@ -0,0 +1,348 @@
+import { getPlatform } from '../platform'
+
+export interface RuntimeAgentConfig {
+  systemPromptAppendix?: string
+  toolAllowlist?: string[]
+  scripts?: Record<string, RuntimeScript>
+}
+
+export interface RuntimeScript {
+  type: 'bash'
+  command: string
+  description?: string
+}
+
+interface RuntimePackManifest {
+  id: string
+  version: string
+  createdAt: number
+  configChecksum: string
+}
+
+interface RuntimePackState {
+  activePackId: string
+  previousPackId?: string
+}
+
+export interface RuntimePackInfo {
+  enabled: boolean
+  runtimeRoot: string
+  activePackId: string | null
+  previousPackId: string | null
+  availablePacks: string[]
+}
+
+const DEFAULT_PACK_ID = 'builtin-v1'
+
+function runtimePackEnabled(): boolean {
+  const type = getPlatform().type
+  return type === 'electron' || type === 'capacitor'
+}
+
+function runtimeRoot(): string {
+  const platform = getPlatform()
+  if (platform.type === 'electron') {
+    return platform.path.join(platform.process.homedir(), '.moa-runtime')
+  }
+  return '/moa-runtime'
+}
+
+function packsDir(): string {
+  return `${runtimeRoot()}/packs`
+}
+
+function stateFile(): string {
+  return `${runtimeRoot()}/state.json`
+}
+
+function normalizeAllowlist(config: RuntimeAgentConfig): string[] {
+  const list = config.toolAllowlist && config.toolAllowlist.length > 0
+    ? config.toolAllowlist
+    : ['bash']
+  return list.filter(Boolean)
+}
+
+function checksumFnv1a(input: string): string {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i)
+    hash +=
+      (hash << 1) +
+      (hash << 4) +
+      (hash << 7) +
+      (hash << 8) +
+      (hash << 24)
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0')
+}
+
+function packDir(packId: string): string {
+  return `${packsDir()}/${packId}`
+}
+
+function manifestPath(packId: string): string {
+  return `${packDir(packId)}/manifest.json`
+}
+
+function configPath(packId: string): string {
+  return `${packDir(packId)}/agent-config.json`
+}
+
+function ensureDir(path: string): void {
+  const { fs } = getPlatform()
+  if (!fs.existsSync(path)) {
+    fs.mkdirSync(path, { recursive: true })
+  }
+}
+
+function readJsonSync<T>(path: string): T | null {
+  const { fs } = getPlatform()
+  if (!fs.existsSync(path)) return null
+  try {
+    const raw = fs.readFileSync(path, 'utf-8')
+    return JSON.parse(raw) as T
+  } catch {
+    return null
+  }
+}
+
+function writeJsonSync(path: string, value: unknown): void {
+  const { fs, path: pathApi } = getPlatform()
+  ensureDir(pathApi.dirname(path))
+  fs.writeFileSync(path, JSON.stringify(value, null, 2))
+}
+
+function defaultAgentConfig(): RuntimeAgentConfig {
+  return {
+    systemPromptAppendix: [
+      'Runtime Pack active.',
+      'Prefer editing only approved runtime scripts/config in the runtime packs store before touching host code.',
+      'Treat host app shell as immutable runtime unless explicitly requested.',
+    ].join('\n'),
+    toolAllowlist: ['bash'],
+    scripts: {},
+  }
+}
+
+function isRuntimeScript(value: unknown): value is RuntimeScript {
+  if (!value || typeof value !== 'object') return false
+  const record = value as Record<string, unknown>
+  if (record.type !== 'bash') return false
+  if (typeof record.command !== 'string' || record.command.trim().length === 0) return false
+  if (record.description !== undefined && typeof record.description !== 'string') return false
+  return true
+}
+
+function validateConfig(config: RuntimeAgentConfig): boolean {
+  if (config.systemPromptAppendix !== undefined && typeof config.systemPromptAppendix !== 'string') return false
+  if (config.toolAllowlist !== undefined) {
+    if (!Array.isArray(config.toolAllowlist)) return false
+    if (!config.toolAllowlist.every((item) => typeof item === 'string')) return false
+  }
+  if (config.scripts !== undefined) {
+    if (typeof config.scripts !== 'object' || config.scripts === null) return false
+    for (const script of Object.values(config.scripts)) {
+      if (!isRuntimeScript(script)) return false
+    }
+  }
+  return true
+}
+
+class RuntimePackService {
+  private initialized = false
+
+  initializeSync(): void {
+    if (this.initialized) return
+    if (!runtimePackEnabled()) {
+      this.initialized = true
+      return
+    }
+
+    ensureDir(runtimeRoot())
+    ensureDir(packsDir())
+
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    if (!state) {
+      const initialConfig = defaultAgentConfig()
+      const serializedConfig = JSON.stringify(initialConfig, null, 2)
+      const checksum = checksumFnv1a(serializedConfig)
+      writeJsonSync(configPath(DEFAULT_PACK_ID), initialConfig)
+      writeJsonSync(manifestPath(DEFAULT_PACK_ID), {
+        id: DEFAULT_PACK_ID,
+        version: '1.0.0',
+        createdAt: Date.now(),
+        configChecksum: checksum,
+      } satisfies RuntimePackManifest)
+      writeJsonSync(stateFile(), { activePackId: DEFAULT_PACK_ID } satisfies RuntimePackState)
+    }
+
+    this.initialized = true
+  }
+
+  async initialize(): Promise<void> {
+    this.initializeSync()
+  }
+
+  getActiveConfigSync(): RuntimeAgentConfig | null {
+    if (!runtimePackEnabled()) return null
+    this.initializeSync()
+
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    if (!state?.activePackId) return null
+
+    return this.loadPackConfigSync(state.activePackId)
+  }
+
+  getInfoSync(): RuntimePackInfo {
+    if (!runtimePackEnabled()) {
+      return {
+        enabled: false,
+        runtimeRoot: runtimeRoot(),
+        activePackId: null,
+        previousPackId: null,
+        availablePacks: [],
+      }
+    }
+
+    this.initializeSync()
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    return {
+      enabled: true,
+      runtimeRoot: runtimeRoot(),
+      activePackId: state?.activePackId ?? null,
+      previousPackId: state?.previousPackId ?? null,
+      availablePacks: this.listPackIdsSync(),
+    }
+  }
+
+  listPackIdsSync(): string[] {
+    if (!runtimePackEnabled()) return []
+    this.initializeSync()
+    const { fs } = getPlatform()
+    if (!fs.existsSync(packsDir())) return []
+    return fs.readdirSync(packsDir())
+  }
+
+  activatePackSync(packId: string): boolean {
+    if (!runtimePackEnabled()) return false
+    this.initializeSync()
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    if (!state) return false
+
+    const config = this.loadPackConfigSync(packId)
+    if (!config) return false
+
+    const nextState = {
+      activePackId: packId,
+      previousPackId: state.activePackId,
+    } satisfies RuntimePackState
+
+    writeJsonSync(stateFile(), nextState)
+
+    const activationCheck = this.getActiveConfigSync()
+    if (!activationCheck) {
+      writeJsonSync(stateFile(), state)
+      return false
+    }
+
+    return true
+  }
+
+  rollbackSync(): boolean {
+    if (!runtimePackEnabled()) return false
+    this.initializeSync()
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    if (!state?.previousPackId) return false
+    return this.activatePackSync(state.previousPackId)
+  }
+
+  writePackSync(packId: string, version: string, config: RuntimeAgentConfig): void {
+    if (!runtimePackEnabled()) return
+    this.initializeSync()
+    if (!validateConfig(config)) {
+      throw new Error(`Invalid runtime pack config for ${packId}`)
+    }
+
+    const serializedConfig = JSON.stringify(config, null, 2)
+    const checksum = checksumFnv1a(serializedConfig)
+
+    writeJsonSync(configPath(packId), config)
+    writeJsonSync(manifestPath(packId), {
+      id: packId,
+      version,
+      createdAt: Date.now(),
+      configChecksum: checksum,
+    } satisfies RuntimePackManifest)
+  }
+
+  private loadPackConfigSync(packId: string): RuntimeAgentConfig | null {
+    const manifest = readJsonSync<RuntimePackManifest>(manifestPath(packId))
+    const config = readJsonSync<RuntimeAgentConfig>(configPath(packId))
+    if (!manifest || !config) return null
+
+    const serializedConfig = JSON.stringify(config, null, 2)
+    const checksum = checksumFnv1a(serializedConfig)
+    if (checksum !== manifest.configChecksum) return null
+    if (!validateConfig(config)) return null
+
+    return config
+  }
+
+  async executeScript(scriptName: string): Promise<{ ok: boolean; output: string; packId: string | null }> {
+    if (!runtimePackEnabled()) {
+      return { ok: false, output: 'Runtime packs are disabled on this platform.', packId: null }
+    }
+    this.initializeSync()
+
+    const state = readJsonSync<RuntimePackState>(stateFile())
+    if (!state?.activePackId) {
+      return { ok: false, output: 'No active runtime pack.', packId: null }
+    }
+
+    const config = this.loadPackConfigSync(state.activePackId)
+    if (!config) {
+      const rolledBack = this.rollbackSync()
+      return {
+        ok: false,
+        output: rolledBack
+          ? `Active runtime pack is invalid. Rolled back to previous pack.`
+          : 'Active runtime pack is invalid and no rollback target is available.',
+        packId: state.activePackId,
+      }
+    }
+
+    const script = config.scripts?.[scriptName]
+    if (!script) {
+      return { ok: false, output: `Script not found: ${scriptName}`, packId: state.activePackId }
+    }
+
+    const allowlist = normalizeAllowlist(config)
+    if (!allowlist.includes(script.type)) {
+      return {
+        ok: false,
+        output: `Script type '${script.type}' is blocked by allowlist. Allowed: ${allowlist.join(', ')}`,
+        packId: state.activePackId,
+      }
+    }
+
+    const { process } = getPlatform()
+    const result = await process.exec(script.command, {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024,
+      cwd: process.cwd(),
+    })
+
+    if (result.exitCode !== 0) {
+      const message = `Script '${scriptName}' failed (exit ${result.exitCode}).\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`
+      return { ok: false, output: message, packId: state.activePackId }
+    }
+
+    return {
+      ok: true,
+      output: result.stdout || `Script '${scriptName}' completed successfully.`,
+      packId: state.activePackId,
+    }
+  }
+}
+
+export const runtimePackService = new RuntimePackService()

moav2/src/core/services/session-store.ts

@@ -0,0 +1,911 @@
+import { getPlatform } from '../platform'
+import { AgentEvent } from '@mariozechner/pi-agent-core'
+import { getOAuthApiKey } from '@mariozechner/pi-ai'
+import { agentService, StreamingBlock } from './agent-service'
+import { db, dbReady } from './db'
+import { resolveModel, type AuthMethod } from './model-resolver'
+import { getOAuthConfig, getValidAccessToken } from './google-auth'
+import { logAction } from './action-logger'
+import { runtimePackService } from './runtime-pack'
+import { isRetryableError, withRetry } from './retry'
+import { hasAssistantResponseStarted } from './session-waiting'
+import { getAnthropicBrowserAuthError, resolveVertexFallback } from './provider-guards'
+import { createAllTools, createSetSystemPromptTool } from '../tools'
+
+export type DisplayBlock = StreamingBlock
+
+export interface DisplayMessage {
+  id: string
+  role: 'user' | 'assistant' | 'system'
+  blocks: DisplayBlock[]
+  createdAt: number
+}
+
+export interface SessionState {
+  messages: DisplayMessage[]
+  streamingBlocks: DisplayBlock[]
+  input: string
+  isStreaming: boolean
+  isWaitingForResponse: boolean
+  expandedTools: Set<string>
+  agentReady: boolean
+  isLoading: boolean
+  model: string
+  /** Last send error, cleared on next successful send or manual dismiss */
+  sendError: string | null
+}
+
+const DEFAULT_STATE: SessionState = Object.freeze({
+  messages: [],
+  streamingBlocks: [],
+  input: '',
+  isStreaming: false,
+  isWaitingForResponse: false,
+  expandedTools: new Set<string>(),
+  agentReady: false,
+  isLoading: true,
+  model: '',
+  sendError: null,
+})
+
+/** Builds a user-friendly error message from a raw error */
+function friendlyErrorMessage(error: any): string {
+  const msg = error?.message || String(error)
+  const lower = msg.toLowerCase()
+
+  // API key issues
+  if (lower.includes('401') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('authentication'))
+    return `Authentication failed. Check your API key or re-authenticate.\n\nDetails: ${msg}`
+  if (lower.includes('403') || lower.includes('forbidden') || lower.includes('permission'))
+    return `Access denied. Your API key may lack permissions for this model.\n\nDetails: ${msg}`
+
+  // Rate limits
+  if (lower.includes('429') || lower.includes('rate limit') || lower.includes('too many requests'))
+    return `Rate limited by the provider. Retrying automatically...`
+
+  // Server issues
+  if (lower.includes('500') || lower.includes('internal server error'))
+    return `Provider server error (500). Retrying...`
+  if (lower.includes('502') || lower.includes('bad gateway'))
+    return `Provider temporarily unavailable (502). Retrying...`
+  if (lower.includes('503') || lower.includes('service unavailable') || lower.includes('overloaded'))
+    return `Provider is overloaded or unavailable. Retrying...`
+
+  // Network
+  if (lower.includes('network') || lower.includes('econnrefused') || lower.includes('econnreset'))
+    return `Network error. Check your internet connection.\n\nDetails: ${msg}`
+  if (lower.includes('timeout') || lower.includes('timed out'))
+    return `Request timed out. The provider may be slow or unreachable.`
+
+  // Model issues
+  if (lower.includes('model') && (lower.includes('not found') || lower.includes('does not exist')))
+    return `Model not found. The selected model may not be available for your account.\n\nDetails: ${msg}`
+
+  return msg
+}
+
+// Notify Vite dev server about streaming state so HMR gate can defer updates
+function notifyHmrStreamingState(streaming: boolean) {
+  try {
+    const hot = (import.meta as any).hot
+    if (hot) {
+      hot.send('moa:streaming-state', { streaming })
+    }
+  } catch {
+    // Not critical
+  }
+}
+
+function isE2EMockVertexResponseEnabled(): boolean {
+  return typeof window !== 'undefined' && (window as any).__MOA_E2E_MOCK_VERTEX_RESPONSE__ === true
+}
+
+function buildDefaultSystemPrompt(cwd: string): string {
+  return `You are MOA (Malleable Operating Agent) — a self-editing AI operating in a Ralph loop.
+
+You run inside an Electron app with three integrated surfaces:
+- Agent buffer (this chat — text editing and code generation)
+- Terminal buffer (full PTY shell access via bash tool)
+- Browser buffer (web browsing via web_fetch tool)
+
+Working directory: ${cwd}
+MOA source: ${cwd}/src
+
+== Core Primitives ==
+- HISTORY: Search and browse past conversations (history tool). Your memory spans sessions.
+- SEARCH: Search files, code, and history (search tool). Find anything in the codebase or past work.
+- INTENT: Track goals and progress (intent tool). Declare what you're working on, update progress, mark complete.
+
+== Self-Modification ==
+You can edit your own source code at ${cwd}/src/. When you do:
+1. Vite HMR detects changes and hot-reloads the UI immediately
+2. Use self_inspect to map your codebase before making changes
+3. Use intent to track multi-step self-modification goals
+
+== Tools ==
+File I/O: read, write, edit
+Shell: bash (30s timeout, use for git, npm, system commands)
+Web: web_fetch (fetch and read web pages)
+Search: search (rg/grep across files, filename glob, or history)
+Memory: intent (declare/update/recall/complete/abandon goals)
+History: history (list sessions, get messages, search across conversations)
+Meta: self_inspect (map source tree, read own code, list tools, architecture, runtime state)
+
+When asked to make changes, always read the relevant files first, then make targeted edits.
+Use intent to track complex multi-step goals. Use history to recall past context.`
+}
+
+export class SessionStore {
+  private sessions = new Map<string, SessionState>()
+  private listeners = new Set<() => void>()
+  private activeSubscriptions = new Map<string, () => void>()
+  /** RAF handle for throttled notify — null when no frame is pending */
+  private notifyRAF: number | null = null
+
+  constructor() {
+    // Bind methods to ensure 'this' context
+    this.initSession = this.initSession.bind(this)
+    this.getSession = this.getSession.bind(this)
+    this.sendMessage = this.sendMessage.bind(this)
+    this.setInput = this.setInput.bind(this)
+    this.toggleTool = this.toggleTool.bind(this)
+    this.subscribe = this.subscribe.bind(this)
+  }
+
+  getSnapshot(): Map<string, SessionState> {
+    return this.sessions
+  }
+
+  getSession(sessionId: string): SessionState {
+    return this.sessions.get(sessionId) || DEFAULT_STATE
+  }
+
+  updateSession(sessionId: string, update: Partial<SessionState>, sync = false) {
+    const current = this.getSession(sessionId)
+    const next = { ...current, ...update }
+    // Notify Vite HMR gate when streaming state changes
+    if ('isStreaming' in update && update.isStreaming !== current.isStreaming) {
+      notifyHmrStreamingState(!!update.isStreaming)
+    }
+    this.sessions.set(sessionId, next)
+    // Use synchronous notify for critical user-facing changes (input, send,
+    // streaming end, errors). Streaming content updates use throttled RAF.
+    if (sync) {
+      this.notifySync()
+    } else {
+      this.notify()
+    }
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  /**
+   * Throttled notify — batches React re-renders to at most once per animation
+   * frame (~60fps). During streaming, dozens of text_delta events fire per
+   * second; without throttling each one triggers a full React reconciliation.
+   */
+  private notify() {
+    if (this.notifyRAF !== null) return // already scheduled
+    this.notifyRAF = requestAnimationFrame(() => {
+      this.notifyRAF = null
+      for (const listener of this.listeners) {
+        listener()
+      }
+    })
+  }
+
+  /** Bypass RAF and notify synchronously — used for critical state changes
+   *  like session init, send, and streaming end where we want immediate UI. */
+  private notifySync() {
+    if (this.notifyRAF !== null) {
+      cancelAnimationFrame(this.notifyRAF)
+      this.notifyRAF = null
+    }
+    for (const listener of this.listeners) {
+      listener()
+    }
+  }
+
+  /**
+   * Resolve model string to a Model object and build the getApiKey callback.
+   * Shared by initSession (first-time creation) and updateModel (hot-swap).
+   */
+  private async resolveModelAndAuth(model: string) {
+    const vertexProject = localStorage.getItem('vertex_project')
+    const vertexLocation = localStorage.getItem('vertex_location')
+    const vertexExpressApiKey = localStorage.getItem('vertex_express_api_key')
+
+    const resolvedProvider = resolveVertexFallback(model, vertexProject, vertexLocation, vertexExpressApiKey)
+    const authMethod: AuthMethod = resolvedProvider.authMethod
+    const modelId = resolvedProvider.modelId
+
+    // For Vertex AI, set env vars before model resolution
+    if (authMethod === 'vertex') {
+      const platform = getPlatform()
+      if (vertexProject) platform.process.env.GOOGLE_CLOUD_PROJECT = vertexProject
+      if (vertexLocation) platform.process.env.GOOGLE_CLOUD_LOCATION = vertexLocation
+    }
+
+    // For custom providers, look up base URL
+    let providerBaseUrl = ''
+    if (authMethod !== 'anthropic-key' && authMethod !== 'anthropic-oauth' && authMethod !== 'openai-oauth' && authMethod !== 'vertex' && authMethod !== 'vertex-express') {
+      const provider = await db.getProvider(authMethod)
+      if (provider) providerBaseUrl = provider.baseUrl
+    }
+
+    const resolvedModel = await resolveModel({
+      modelId,
+      authMethod,
+      providerBaseUrl,
+    })
+
+    const getApiKey = async (providerName: string) => {
+      // Anthropic API key
+      if (authMethod === 'anthropic-key') {
+        const browserAuthError = getAnthropicBrowserAuthError(authMethod, getPlatform().type)
+        if (browserAuthError) {
+          throw new Error(browserAuthError)
+        }
+        const key = localStorage.getItem('anthropic_key')
+        if (!key) {
+          throw new Error('No Anthropic API key configured. Go to Settings and add your API key.')
+        }
+        return key
+      }
+      // Anthropic OAuth (Plan)
+      if (authMethod === 'anthropic-oauth') {
+        const creds = await db.getOAuthCredentials('anthropic')
+        if (!creds) {
+          throw new Error('Anthropic OAuth not configured. Go to Settings and sign in with your Anthropic account.')
+        }
+        try {
+          const result = await getOAuthApiKey('anthropic', { anthropic: creds as any })
+          if (result) {
+            // Persist refreshed credentials
+            await db.setOAuthCredentials('anthropic', result.newCredentials)
+            return result.apiKey
+          }
+        } catch (e: any) {
+          throw new Error(`Anthropic OAuth token refresh failed: ${e.message || e}. Try re-authenticating in Settings.`)
+        }
+        throw new Error('Anthropic OAuth: failed to obtain API key. Try re-authenticating in Settings.')
+      }
+      // OpenAI OAuth (ChatGPT Plan)
+      if (authMethod === 'openai-oauth') {
+        const creds = await db.getOAuthCredentials('openai')
+        if (!creds) {
+          throw new Error('OpenAI OAuth not configured. Go to Settings and sign in with your OpenAI account.')
+        }
+        try {
+          // DB key is "openai" while OAuth provider key is "openai-codex".
+          const result = await getOAuthApiKey('openai-codex', {
+            'openai-codex': creds as any,
+          })
+          if (result) {
+            await db.setOAuthCredentials('openai', result.newCredentials as any)
+            return result.apiKey
+          }
+        } catch (e: any) {
+          throw new Error(`OpenAI OAuth token refresh failed: ${e.message || e}. Try re-authenticating in Settings.`)
+        }
+        throw new Error('OpenAI OAuth: failed to obtain API key. Try re-authenticating in Settings.')
+      }
+      // Vertex AI — either ADC or Google OAuth
+      if (authMethod === 'vertex') {
+        const vertexAuthMethod = localStorage.getItem('vertex_auth_method')
+        if (vertexAuthMethod === 'google-oauth') {
+          // Google OAuth: get/refresh access token and set as model header
+          const googleCreds = await db.getOAuthCredentials('google')
+          const oauthConfig = getOAuthConfig()
+          if (!googleCreds) {
+            throw new Error('Google OAuth not configured for Vertex AI. Go to Settings and sign in with Google.')
+          }
+          if (!oauthConfig) {
+            throw new Error('Google OAuth client not configured. Set VITE_GOOGLE_OAUTH_CLIENT_ID and VITE_GOOGLE_OAUTH_CLIENT_SECRET.')
+          }
+          try {
+            const { accessToken, newCreds } = await getValidAccessToken(oauthConfig, googleCreds)
+            await db.setOAuthCredentials('google', newCreds)
+            // Set Authorization header on the resolved model so @google/genai uses it
+            ;(resolvedModel as any).headers = {
+              ...(resolvedModel as any).headers,
+              'Authorization': `Bearer ${accessToken}`,
+            }
+            return '<authenticated>'
+          } catch (e: any) {
+            throw new Error(`Google OAuth token refresh failed: ${e.message || e}. Try re-authenticating in Settings.`)
+          }
+        }
+        // ADC handles auth
+        return '<authenticated>'
+      }
+      // Vertex AI Express — simple API key
+      if (authMethod === 'vertex-express') {
+        const key = localStorage.getItem('vertex_express_api_key')
+        if (!key) {
+          throw new Error('No Vertex AI Express API key configured. Go to Settings > Vertex AI and add your API key.')
+        }
+        return key
+      }
+      // Custom provider — look up API key from DB
+      const storedProvider = await db.getProvider(authMethod)
+      if (storedProvider?.apiKey) return storedProvider.apiKey
+      // Fallback: search by name
+      const storedProviders = await db.listProviders()
+      const match = storedProviders.find(p =>
+        p.name.toLowerCase() === providerName.toLowerCase() ||
+        p.name.toLowerCase().includes(providerName.toLowerCase())
+      )
+      if (!match?.apiKey) {
+        throw new Error(`No API key found for provider "${authMethod}". Go to Settings and add the provider with an API key.`)
+      }
+      return match.apiKey
+    }
+
+    // Eagerly validate that we can obtain an API key. This catches
+    // missing keys before any streaming attempt so the user sees a
+    // clear error immediately instead of a cryptic 401 mid-stream.
+    try {
+      await getApiKey(resolvedModel.provider)
+    } catch (e: any) {
+      // Re-throw so callers can surface the message. The lazy
+      // callback will throw the same error when the agent loop
+      // calls it, so this doesn't hide anything.
+      throw e
+    }
+
+    return { resolvedModel, getApiKey, authMethod, modelId }
+  }
+
+  /**
+   * Hot-swap the model on an existing session without destroying the agent.
+   * Preserves conversation history, tools, subscriptions, and streaming state.
+   * Also persists the new model to the DB.
+   */
+  async updateModel(sessionId: string, newModel: string) {
+    await dbReady
+
+    const { resolvedModel, getApiKey } = await this.resolveModelAndAuth(newModel)
+
+    agentService.updateModel(sessionId, resolvedModel, getApiKey)
+
+    // Update in-memory state
+    this.updateSession(sessionId, { model: newModel })
+
+    // Persist to DB
+    db.updateSession(sessionId, { model: newModel }).catch(console.error)
+  }
+
+  private composeSystemPrompt(basePrompt: string): string {
+    const runtimeInfo = runtimePackService.getInfoSync()
+    const runtimeConfig = runtimePackService.getActiveConfigSync()
+    const runtimeOverlay = runtimeConfig?.systemPromptAppendix
+      ? `Runtime root: ${runtimeInfo.runtimeRoot}\nActive pack: ${runtimeInfo.activePackId ?? '(none)'}\n\n${runtimeConfig.systemPromptAppendix}`
+      : null
+    return runtimeOverlay
+      ? `${basePrompt}\n\n== Runtime Pack Overlay ==\n${runtimeOverlay}`
+      : basePrompt
+  }
+
+  async setSystemPrompt(sessionId: string, prompt: string): Promise<void> {
+    const nextPrompt = prompt.trim()
+    if (!nextPrompt) throw new Error('System prompt cannot be empty.')
+
+    await dbReady
+    const updated = await db.updateSession(sessionId, { systemPrompt: nextPrompt })
+    if (!updated) throw new Error(`Session ${sessionId} not found.`)
+
+    const agent = agentService.getAgent(sessionId)
+    if (agent) {
+      agent.setSystemPrompt(this.composeSystemPrompt(nextPrompt))
+    }
+
+    const now = Date.now()
+    const id = `sys-${now}`
+    const content = 'System prompt updated for this session.'
+    const s = this.getSession(sessionId)
+    this.updateSession(sessionId, {
+      messages: [...s.messages, {
+        id,
+        role: 'system',
+        blocks: [{ id: `sys-blk-${now}`, type: 'text', content }],
+        createdAt: now,
+      }],
+    }, true)
+
+    db.addMessage(sessionId, 'system', content, { id }).catch(() => {})
+    logAction('session.system_prompt.updated', { sessionId, length: nextPrompt.length }, { actor: 'agent', sessionId })
+  }
+
+  async initSession(sessionId: string, model: string) {
+    // If we already have state for this session and the model matches (or isn't set yet), don't reload
+    // BUT if the component re-mounted, we might need to re-verify streaming state
+    const existing = this.sessions.get(sessionId)
+    if (existing && existing.agentReady && existing.model === model) {
+        // Just sync streaming state in case it drifted
+        this.syncStreamingState(sessionId)
+        return
+    }
+
+    // If agent already exists but model changed, hot-swap the model instead of recreating
+    if (existing && existing.agentReady && existing.model !== model && agentService.getAgent(sessionId)) {
+        try {
+          await this.updateModel(sessionId, model)
+          this.syncStreamingState(sessionId)
+          return
+        } catch (e: any) {
+          console.error('Failed to hot-swap model, falling back to full reinit:', e)
+          // Fall through to full re-initialization below
+          agentService.destroyAgent(sessionId)
+        }
+    }
+
+    // Initialize with default if new
+    if (!existing) {
+        this.sessions.set(sessionId, { ...DEFAULT_STATE, model })
+    } else {
+        // Update model if changed
+        this.updateSession(sessionId, { model })
+    }
+
+    try {
+      await dbReady
+      const sessionRecord = await db.getSession(sessionId)
+
+      // Model-less session: load history but skip agent initialization.
+      if (!model) {
+        const msgs = await db.getMessages(sessionId)
+        const loaded: DisplayMessage[] = msgs.map((m: any) => ({
+          id: m.id,
+          role: m.role,
+          blocks: m.blocks
+            ? (m.blocks as DisplayBlock[])
+            : [{ id: `loaded-${m.id}`, type: 'text' as const, content: m.content }],
+          createdAt: m.createdAt,
+        }))
+        this.updateSession(sessionId, {
+          messages: loaded,
+          isLoading: false,
+          agentReady: false,
+          model: '',
+        }, true)
+        return
+      }
+
+      // 1. Create Agent
+      const { resolvedModel, getApiKey } = await this.resolveModelAndAuth(model)
+
+      const cwd = getPlatform().process.cwd()
+      const baseSystemPrompt = sessionRecord?.systemPrompt?.trim() || buildDefaultSystemPrompt(cwd)
+      const composedSystemPrompt = this.composeSystemPrompt(baseSystemPrompt)
+      const tools = createAllTools('/src')
+      tools.push(createSetSystemPromptTool({
+        applySystemPrompt: async (prompt) => {
+          await this.setSystemPrompt(sessionId, prompt)
+        },
+      }))
+
+      agentService.createAgent(sessionId, {
+        model: resolvedModel,
+        tools,
+        systemPrompt: composedSystemPrompt,
+        getApiKey,
+      })
+
+      this.updateSession(sessionId, { agentReady: true })
+
+      // 2. Load Messages from DB
+      const msgs = await db.getMessages(sessionId)
+
+      // Check if we are streaming NOW (survived HMR)
+      const isStreaming = agentService.isStreaming(sessionId)
+
+      const loaded: DisplayMessage[] = msgs
+        .filter((m: any) => !m.partial || !isStreaming) // Don't show partials if we are about to show live blocks
+        .map((m: any) => ({
+          id: m.id,
+          role: m.role,
+          blocks: m.blocks
+            ? (m.blocks as DisplayBlock[])
+            : [{ id: `loaded-${m.id}`, type: 'text' as const, content: m.content }],
+          createdAt: m.createdAt,
+        }))
+
+      this.updateSession(sessionId, {
+          messages: loaded,
+          isLoading: false
+      })
+
+      // 3. Hydrate Agent History
+      const nonPartial = msgs.filter((m: any) => !m.partial)
+      agentService.hydrateFromMessages(sessionId, nonPartial)
+
+      // 4. Sync Streaming State
+      this.syncStreamingState(sessionId)
+
+      // 5. Subscribe to Agent Events
+      // Ensure we don't double-subscribe
+      if (this.activeSubscriptions.has(sessionId)) {
+          this.activeSubscriptions.get(sessionId)!()
+      }
+
+      const unsub = agentService.subscribe(sessionId, (event) => this.handleAgentEvent(sessionId, event))
+      this.activeSubscriptions.set(sessionId, unsub)
+
+    } catch (e: any) {
+        console.error('Failed to init session:', e)
+        this.updateSession(sessionId, {
+            isLoading: false,
+            messages: [...(this.getSession(sessionId).messages), {
+                id: `err-${Date.now()}`,
+                role: 'system',
+                blocks: [{ id: `err-blk-${Date.now()}`, type: 'text', content: `Failed to create agent: ${e.message || e}` }],
+                createdAt: Date.now(),
+            }]
+        })
+    }
+  }
+
+  private syncStreamingState(sessionId: string) {
+      if (agentService.isStreaming(sessionId)) {
+          const blocks = agentService.getStreamingBlocks(sessionId)
+          this.updateSession(sessionId, {
+              isStreaming: true,
+              streamingBlocks: [...blocks]
+          })
+      } else {
+          this.updateSession(sessionId, { isStreaming: false })
+      }
+  }
+
+  private handleAgentEvent(sessionId: string, agentEvent: AgentEvent) {
+      const eventType = agentEvent.type as string
+
+      switch (eventType) {
+        case 'agent_start': {
+            // Create partial message
+            const pId = `partial-${sessionId}-${Date.now()}`
+            agentService.setPartialMsgId(sessionId, pId)
+            db.addMessage(sessionId, 'assistant', '', {
+                id: pId,
+                blocks: [],
+                partial: true,
+            }).catch(e => console.error('Failed to create partial message:', e))
+
+            this.updateSession(sessionId, {
+                isStreaming: true,
+                streamingBlocks: [],
+            })
+            break
+        }
+
+        case 'message_start':
+            this.updateSession(sessionId, { isStreaming: true })
+            break
+
+        case 'steer_interrupt':
+            this.updateSession(sessionId, { streamingBlocks: [] })
+            break
+
+        case 'message_update':
+        case 'tool_execution_start':
+        case 'tool_execution_end':
+        case 'message_end':
+        {
+            const waitingUpdate: Partial<SessionState> = {}
+            if (this.getSession(sessionId).isWaitingForResponse && hasAssistantResponseStarted(agentEvent)) {
+              waitingUpdate.isWaitingForResponse = false
+            }
+            this.updateSession(sessionId, {
+                streamingBlocks: [...agentService.getStreamingBlocks(sessionId)],
+                ...waitingUpdate,
+            })
+
+            if (agentEvent.type === 'tool_execution_end' || agentEvent.type === 'message_end') {
+                const pmId = agentService.getPartialMsgId(sessionId)
+                if (pmId) {
+                    const blocks = agentService.getStreamingBlocks(sessionId)
+                    const text = blocks.filter(b => b.type === 'text' && b.content).map(b => b.content).join('')
+                    db.updateMessage(pmId, { content: text, blocks: blocks as any }).catch(() => {})
+                }
+            }
+            break
+        }
+
+        case 'agent_end': {
+            const pmId = agentService.getPartialMsgId(sessionId)
+            const blocks = agentService.getStreamingBlocks(sessionId)
+            const session = this.getSession(sessionId)
+
+            // Check if the agent ended with an error (from pi-agent-core's catch block).
+            // The agent appends an error message with stopReason: 'error' and errorMessage.
+            const agentEndEvent = agentEvent as any
+            const agentEndMessages: any[] = agentEndEvent.messages || []
+            const errorMsg = agentEndMessages.find((m: any) =>
+              m.role === 'assistant' && (m.stopReason === 'error' || m.errorMessage)
+            )
+
+            if (blocks.length > 0) {
+                const finalMsg: DisplayMessage = {
+                    id: pmId || `assistant-${Date.now()}`,
+                    role: 'assistant',
+                    blocks: [...blocks],
+                    createdAt: Date.now(),
+                }
+
+                const newMessages = [...session.messages, finalMsg]
+
+                // If there was an error, also add a system message so the user sees it
+                if (errorMsg?.errorMessage) {
+                    const friendly = friendlyErrorMessage({ message: errorMsg.errorMessage })
+                    newMessages.push({
+                        id: `err-${Date.now()}`,
+                        role: 'system',
+                        blocks: [{ id: `err-blk-${Date.now()}`, type: 'text', content: friendly }],
+                        createdAt: Date.now(),
+                    })
+                    this.updateSession(sessionId, {
+                        messages: newMessages,
+                        streamingBlocks: [],
+                        isStreaming: false,
+                        isWaitingForResponse: false,
+                        sendError: friendly,
+                    }, true) // sync: streaming end
+                } else {
+                    this.updateSession(sessionId, {
+                        messages: newMessages,
+                        streamingBlocks: [],
+                        isStreaming: false,
+                        isWaitingForResponse: false,
+                        sendError: null,
+                    }, true) // sync: streaming end
+                }
+
+                const textContent = blocks.filter(b => b.type === 'text' && b.content).map(b => b.content).join('')
+                if (pmId) {
+                    db.updateMessage(pmId, {
+                        content: textContent,
+                        blocks: blocks as any,
+                        partial: false,
+                    }).catch(e => console.error('Failed to finalize message:', e))
+                } else if (textContent) {
+                    db.addMessage(sessionId, 'assistant', textContent, {
+                        blocks: blocks as any,
+                    }).catch(e => console.error('Failed to save assistant message:', e))
+                }
+            } else {
+                if (pmId) db.removeMessage(pmId).catch(() => {})
+
+                // No blocks produced — if there was an error, surface it to the user
+                if (errorMsg?.errorMessage) {
+                    const friendly = friendlyErrorMessage({ message: errorMsg.errorMessage })
+                    this.updateSession(sessionId, {
+                        messages: [...session.messages, {
+                            id: `err-${Date.now()}`,
+                            role: 'system',
+                            blocks: [{ id: `err-blk-${Date.now()}`, type: 'text', content: friendly }],
+                            createdAt: Date.now(),
+                        }],
+                        streamingBlocks: [],
+                        isStreaming: false,
+                        isWaitingForResponse: false,
+                        sendError: friendly,
+                    }, true) // sync: streaming end
+                } else {
+                    this.updateSession(sessionId, {
+                        streamingBlocks: [],
+                        isStreaming: false,
+                        isWaitingForResponse: false,
+                    }, true) // sync: streaming end
+                }
+            }
+            agentService.clearPartialMsgId(sessionId)
+            break
+        }
+      }
+  }
+
+  /** Clear the sendError for a session (e.g., user dismissed the error banner) */
+  clearSendError(sessionId: string) {
+    this.updateSession(sessionId, { sendError: null }, true) // sync: user action
+  }
+
+  /** Add a system error message to the chat and update sendError state */
+  private addErrorToChat(sessionId: string, message: string, timestamp?: number) {
+    const ts = timestamp || Date.now()
+    const s = this.getSession(sessionId)
+    const errorMsg: DisplayMessage = {
+      id: `err-${ts}-${Math.random().toString(36).slice(2, 6)}`,
+      role: 'system',
+      blocks: [{ id: `err-blk-${ts}`, type: 'text', content: message }],
+      createdAt: ts,
+    }
+    this.updateSession(sessionId, {
+      messages: [...s.messages, errorMsg],
+      isStreaming: false,
+      isWaitingForResponse: false,
+      sendError: message,
+    }, true) // sync: error display
+    // Also persist the error to DB so it survives reloads
+    db.addMessage(sessionId, 'system', message, {
+      id: errorMsg.id,
+    }).catch(() => {})
+  }
+
+  async sendMessage(sessionId: string) {
+      const session = this.getSession(sessionId)
+      const input = session.input.trim()
+
+      // Guard: no empty input
+      if (!input) return
+
+      // Guard: agent not ready — show visible feedback instead of silently failing
+      if (!session.agentReady) {
+          this.addErrorToChat(sessionId, 'Agent is not ready yet. Please wait for initialization to complete, or check if there was an initialization error above.')
+          return
+      }
+
+      // Guard: verify the agent instance actually exists
+      if (!agentService.getAgent(sessionId)) {
+          this.addErrorToChat(sessionId, 'Agent instance not found. Try refreshing or switching sessions.')
+          return
+      }
+
+      // Clear any previous error
+      this.updateSession(sessionId, { sendError: null }, true) // sync: user action
+
+      const userMsgTime = Date.now()
+      this.updateSession(sessionId, { input: '' }, true) // sync: clear input
+
+      logAction('message.sent', { sessionId, contentPreview: input.slice(0, 100) }, { actor: 'user', sessionId })
+
+      db.addMessage(sessionId, 'user', input).catch(console.error)
+
+      // Auto-title
+      if (session.messages.length === 0) {
+          const title = input.substring(0, 30).trim() || 'New Chat'
+          db.updateSession(sessionId, { title }).catch(console.error)
+      }
+
+      if (session.isStreaming) {
+          // Steer logic
+          const currentBlocks = agentService.getStreamingBlocks(sessionId)
+          const pmId = agentService.getPartialMsgId(sessionId)
+
+          const newMessages = [...session.messages]
+          if (currentBlocks.length > 0) {
+              newMessages.push({
+                  id: pmId || `assistant-interrupted-${userMsgTime - 1}`,
+                  role: 'assistant',
+                  blocks: [...currentBlocks],
+                  createdAt: userMsgTime - 1,
+              })
+          }
+          newMessages.push({
+              id: `user-${userMsgTime}`,
+              role: 'user',
+              blocks: [{ id: `ublk-${userMsgTime}`, type: 'text', content: input }],
+              createdAt: userMsgTime,
+          })
+
+          this.updateSession(sessionId, {
+              messages: newMessages,
+              streamingBlocks: []
+          }, true) // sync: steer — user sees message immediately
+
+          if (currentBlocks.length > 0) {
+              const textContent = currentBlocks.filter(b => b.type === 'text' && b.content).map(b => b.content).join('')
+              if (pmId) {
+                  db.updateMessage(pmId, {
+                      content: textContent,
+                      blocks: currentBlocks as any,
+                      partial: false,
+                  }).catch(console.error)
+              }
+          }
+
+          agentService.clearPartialMsgId(sessionId)
+
+          try {
+              agentService.steer(sessionId, input)
+          } catch (e: any) {
+              const friendly = friendlyErrorMessage(e)
+               this.updateSession(sessionId, {
+                   messages: [...newMessages, {
+                       id: `err-${userMsgTime}`,
+                       role: 'system',
+                       blocks: [{ id: `err-blk-${userMsgTime}`, type: 'text', content: friendly }],
+                       createdAt: userMsgTime,
+                   }],
+                   isWaitingForResponse: false,
+                   sendError: friendly,
+               }, true) // sync: error display
+           }
+
+      } else {
+          // Normal flow
+          this.updateSession(sessionId, {
+              messages: [...session.messages, {
+                  id: `user-${userMsgTime}`,
+                  role: 'user',
+                  blocks: [{ id: `ublk-${userMsgTime}`, type: 'text', content: input }],
+                  createdAt: userMsgTime,
+              }],
+              isStreaming: true,
+               isWaitingForResponse: true,
+           }, true) // sync: user message send
+
+          if (isE2EMockVertexResponseEnabled() && session.model.startsWith('vertex-express:')) {
+            const assistantTime = Date.now()
+            const assistantMessage: DisplayMessage = {
+              id: `assistant-${assistantTime}`,
+              role: 'assistant',
+              blocks: [{ id: `ablk-${assistantTime}`, type: 'text', content: 'Mock Vertex Express response.' }],
+              createdAt: assistantTime,
+            }
+            const current = this.getSession(sessionId)
+            this.updateSession(sessionId, {
+              messages: [...current.messages, assistantMessage],
+              isStreaming: false,
+              isWaitingForResponse: false,
+              sendError: null,
+            }, true)
+            db.addMessage(sessionId, 'assistant', 'Mock Vertex Express response.', {
+              id: assistantMessage.id,
+              blocks: assistantMessage.blocks as any,
+            }).catch(() => {})
+            return
+          }
+
+           try {
+              await withRetry(
+                async () => {
+                  await agentService.prompt(sessionId, input)
+                },
+                {
+                  onRetry: ({ attempt, maxRetries, error }) => {
+                    if (!isRetryableError(error)) return
+                    console.error(`Send attempt ${attempt} failed:`, error)
+                    const s = this.getSession(sessionId)
+                    const retryMsg: DisplayMessage = {
+                      id: `retry-${userMsgTime}-${attempt}`,
+                      role: 'system',
+                      blocks: [{ id: `retry-blk-${userMsgTime}-${attempt}`, type: 'text', content: `Retrying... (attempt ${attempt}/${maxRetries})` }],
+                      createdAt: Date.now(),
+                    }
+                    this.updateSession(sessionId, {
+                      messages: [...s.messages, retryMsg],
+                      isStreaming: true,
+                      isWaitingForResponse: true,
+                    })
+                  },
+                }
+              )
+
+              // Success — clear any send error
+              this.updateSession(sessionId, { sendError: null })
+          } catch (e: any) {
+              const friendly = friendlyErrorMessage(e)
+              this.addErrorToChat(sessionId, friendly, userMsgTime)
+          }
+      }
+  }
+
+  setInput(sessionId: string, value: string) {
+      this.updateSession(sessionId, { input: value }, true) // sync: user typing
+  }
+
+  toggleTool(sessionId: string, toolId: string) {
+      const session = this.getSession(sessionId)
+      const next = new Set(session.expandedTools)
+      if (next.has(toolId)) next.delete(toolId)
+      else next.add(toolId)
+      this.updateSession(sessionId, { expandedTools: next }, true) // sync: user click
+  }
+}
+
+// Singleton instance — in moav2, entry point manages lifecycle instead of window.__sessionStore
+export const sessionStore = new SessionStore()

moav2/src/core/services/session-waiting.ts

@@ -0,0 +1,14 @@
+import type { AgentEvent } from '@mariozechner/pi-agent-core'
+
+export function hasAssistantResponseStarted(agentEvent: AgentEvent): boolean {
+  if (agentEvent.type === 'tool_execution_start' || agentEvent.type === 'message_end') {
+    return true
+  }
+
+  if (agentEvent.type !== 'message_update') {
+    return false
+  }
+
+  const assistantEvent = (agentEvent as any).assistantMessageEvent
+  return !!assistantEvent
+}

moav2/src/core/services/terminal-service.ts

@@ -0,0 +1,225 @@
+// Terminal service - manages shell processes for terminal buffers.
+// Uses node-pty for full PTY support in Electron, with a child_process fallback.
+// In browser mode, all create() calls throw an error (terminal unavailable).
+
+import { getPlatform } from '../platform'
+
+export interface TerminalInstance {
+  id: string
+  write(data: string): void
+  onData(callback: (data: string) => void): void
+  onExit(callback: (code: number) => void): void
+  onTitleChange(callback: (title: string) => void): void
+  resize(cols: number, rows: number): void
+  kill(): void
+}
+
+// ---------- node-pty backend ----------
+
+function createPtyTerminal(
+  id: string,
+  shellPath: string,
+  cwd: string
+): TerminalInstance {
+  const _require = (window as any).require
+  const pty = _require('node-pty')
+  const proc = pty.spawn(shellPath, [], {
+    name: 'xterm-256color',
+    cols: 80,
+    rows: 24,
+    cwd,
+    env: (window as any).process?.env || {},
+  })
+
+  const dataCallbacks: Array<(data: string) => void> = []
+  const exitCallbacks: Array<(code: number) => void> = []
+  const titleCallbacks: Array<(title: string) => void> = []
+
+  proc.onData((data: string) => {
+    for (const cb of dataCallbacks) cb(data)
+  })
+
+  proc.onExit(({ exitCode }: { exitCode: number }) => {
+    for (const cb of exitCallbacks) cb(exitCode)
+  })
+
+  return {
+    id,
+    write(data: string) {
+      proc.write(data)
+    },
+    onData(callback: (data: string) => void) {
+      dataCallbacks.push(callback)
+    },
+    onExit(callback: (code: number) => void) {
+      exitCallbacks.push(callback)
+    },
+    onTitleChange(callback: (title: string) => void) {
+      titleCallbacks.push(callback)
+    },
+    resize(cols: number, rows: number) {
+      try {
+        proc.resize(cols, rows)
+      } catch {
+        // Resize can fail if process already exited
+      }
+    },
+    kill() {
+      try {
+        proc.kill()
+      } catch {
+        // Already dead
+      }
+    },
+  }
+}
+
+// ---------- child_process.spawn fallback ----------
+
+function createSpawnTerminal(
+  id: string,
+  shellPath: string,
+  cwd: string
+): TerminalInstance {
+  const _require = (window as any).require
+  const cp = _require('child_process') as typeof import('child_process')
+  const proc = cp.spawn(shellPath, [], {
+    cwd,
+    env: { ...((window as any).process?.env || {}), TERM: 'xterm-256color' },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+
+  const dataCallbacks: Array<(data: string) => void> = []
+  const exitCallbacks: Array<(code: number) => void> = []
+  const titleCallbacks: Array<(title: string) => void> = []
+
+  proc.stdout?.on('data', (chunk: Buffer) => {
+    const text = chunk.toString('utf-8')
+    for (const cb of dataCallbacks) cb(text)
+  })
+
+  proc.stderr?.on('data', (chunk: Buffer) => {
+    const text = chunk.toString('utf-8')
+    for (const cb of dataCallbacks) cb(text)
+  })
+
+  proc.on('exit', (code: number | null) => {
+    for (const cb of exitCallbacks) cb(code ?? 1)
+  })
+
+  return {
+    id,
+    write(data: string) {
+      try {
+        proc.stdin?.write(data)
+      } catch {
+        // stdin may be closed
+      }
+    },
+    onData(callback: (data: string) => void) {
+      dataCallbacks.push(callback)
+    },
+    onExit(callback: (code: number) => void) {
+      exitCallbacks.push(callback)
+    },
+    onTitleChange(callback: (title: string) => void) {
+      titleCallbacks.push(callback)
+    },
+    resize(_cols: number, _rows: number) {
+      // child_process.spawn does not support resize — no-op
+    },
+    kill() {
+      try {
+        proc.kill()
+      } catch {
+        // Already dead
+      }
+    },
+  }
+}
+
+// ---------- Detection ----------
+
+let _hasPty: boolean | null = null
+
+function hasPty(): boolean {
+  if (_hasPty !== null) return _hasPty
+  try {
+    const _require = (window as any).require
+    _require('node-pty')
+    _hasPty = true
+  } catch {
+    console.warn(
+      '[terminal-service] node-pty not available, falling back to child_process.spawn (no resize, no raw PTY)'
+    )
+    _hasPty = false
+  }
+  return _hasPty
+}
+
+// ---------- Resolve default shell and cwd ----------
+
+function defaultShell(): string {
+  return getPlatform().process.env['SHELL'] || '/bin/zsh'
+}
+
+function defaultCwd(): string {
+  return getPlatform().process.homedir()
+}
+
+// ---------- TerminalService ----------
+
+export class TerminalService {
+  private terminals: Map<string, TerminalInstance> = new Map()
+
+  create(id: string, opts?: { cwd?: string; shell?: string }): TerminalInstance {
+    if (getPlatform().type !== 'electron') {
+      throw new Error('Terminal requires desktop mode (Electron). Shell commands are available via the agent bash tool.')
+    }
+
+    // Return existing instance if already created (HMR survival)
+    const existing = this.terminals.get(id)
+    if (existing) return existing
+
+    const shellPath = opts?.shell || defaultShell()
+    const cwd = opts?.cwd || defaultCwd()
+
+    let instance: TerminalInstance
+    if (hasPty()) {
+      try {
+        instance = createPtyTerminal(id, shellPath, cwd)
+      } catch (e) {
+        console.warn('[terminal-service] node-pty spawn failed, falling back to child_process:', e)
+        instance = createSpawnTerminal(id, shellPath, cwd)
+      }
+    } else {
+      instance = createSpawnTerminal(id, shellPath, cwd)
+    }
+
+    this.terminals.set(id, instance)
+    return instance
+  }
+
+  get(id: string): TerminalInstance | undefined {
+    return this.terminals.get(id)
+  }
+
+  destroy(id: string): void {
+    const inst = this.terminals.get(id)
+    if (inst) {
+      inst.kill()
+      this.terminals.delete(id)
+    }
+  }
+
+  destroyAll(): void {
+    for (const [id] of this.terminals) {
+      this.destroy(id)
+    }
+  }
+}
+
+// HMR-safe singleton — survives Vite hot-module replacement
+const _w = window as any
+if (!_w.__terminalService) _w.__terminalService = new TerminalService()
+export const terminalService: TerminalService = _w.__terminalService

moav2/src/core/services/tools/index.ts

@@ -0,0 +1,9 @@
+// Stub — tools will be implemented in a later task.
+// This module provides the createAllTools function that agent-service.ts imports.
+
+import type { AgentTool } from '@mariozechner/pi-agent-core'
+
+export function createAllTools(): AgentTool<any, any>[] {
+  // Tools will be registered here once implemented
+  return []
+}

moav2/src/core/tools/bash-tool.ts

@@ -0,0 +1,42 @@
+import { getPlatform } from '../platform'
+import { Type } from '@sinclair/typebox'
+import type { AgentTool } from '@mariozechner/pi-agent-core'
+import { logAction } from '../services/action-logger'
+
+export function createBashTool(): AgentTool<any, any> {
+  return {
+    name: 'bash',
+    label: 'Execute Command',
+    description: 'Execute a shell command and return its output.',
+    parameters: Type.Object({
+      command: Type.String({ description: 'The shell command to execute' }),
+    }),
+    execute: async (toolCallId, params) => {
+      try {
+        const { process: proc } = getPlatform()
+        const result = await proc.exec(params.command, { timeout: 30000, maxBuffer: 1024 * 1024 })
+        logAction('tool.bash', {
+          command: params.command,
+          exitCode: result.exitCode,
+          outputLength: result.stdout.length,
+        }, { actor: 'agent' })
+
+        if (result.exitCode !== 0) {
+          return {
+            content: [{ type: 'text', text: `stdout:\n${result.stdout}\nstderr:\n${result.stderr}` }],
+            details: { command: params.command, exitCode: result.exitCode, error: result.stderr },
+          }
+        }
+        return {
+          content: [{ type: 'text', text: result.stdout }],
+          details: { command: params.command, exitCode: 0 },
+        }
+      } catch (e: any) {
+        return {
+          content: [{ type: 'text', text: `Error: ${e.message}` }],
+          details: { command: params.command, exitCode: 1, error: e.message },
+        }
+      }
+    },
+  }
+}

moav2/src/core/tools/edit-tool.ts

@@ -0,0 +1,46 @@
+import { getPlatform } from '../platform'
+import { Type } from '@sinclair/typebox'
+import type { AgentTool } from '@mariozechner/pi-agent-core'
+import { logAction } from '../services/action-logger'
+
+export function createEditTool(): AgentTool<any, any> {
+  return {
+    name: 'edit',
+    label: 'Edit File',
+    description: 'Replace a specific string in a file with a new string.',
+    parameters: Type.Object({
+      path: Type.String({ description: 'Absolute path to the file to edit' }),
+      old_string: Type.String({ description: 'The exact string to find and replace' }),
+      new_string: Type.String({ description: 'The replacement string' }),
+    }),
+    execute: async (toolCallId, params) => {
+      try {
+        const { fs } = getPlatform()
+        const content = fs.readFileSync(params.path, 'utf-8')
+        const idx = content.indexOf(params.old_string)
+        if (idx === -1) {
+          return {
+            content: [{ type: 'text', text: `Error: old_string not found in ${params.path}` }],
+            details: { error: 'old_string not found' },
+          }
+        }
+        const newContent = content.substring(0, idx) + params.new_string + content.substring(idx + params.old_string.length)
+        fs.writeFileSync(params.path, newContent)
+        logAction('tool.edit', {
+          path: params.path,
+          oldLength: params.old_string.length,
+          newLength: params.new_string.length,
+        }, { actor: 'agent' })
+        return {
+          content: [{ type: 'text', text: `Edited ${params.path}: replaced ${params.old_string.length} chars with ${params.new_string.length} chars` }],
+          details: { path: params.path },
+        }
+      } catch (e: any) {
+        return {
+          content: [{ type: 'text', text: `Error editing file: ${e.message}` }],
+          details: { error: e.message },
+        }
+      }
+    },
+  }
+}

moav2/src/core/tools/history-tool.ts

@@ -0,0 +1,199 @@
+import { Type } from '@sinclair/typebox'
+import type { AgentTool } from '@mariozechner/pi-agent-core'
+import { db, dbReady } from '../services/db'
+
+export function createHistoryTool(): AgentTool<any, any> {
+  return {
+    name: 'history',
+    label: 'Conversation History',
+    description:
+      'Browse and search conversation history across all sessions. ' +
+      'Actions: "list_sessions" (list all sessions with titles/dates), ' +
+      '"get_session" (get messages from a specific session by sessionId), ' +
+      '"search_all" (search across all session messages for a query), ' +
+      '"get_recent" (get the N most recent messages across all sessions).',
+    parameters: Type.Object({
+      action: Type.String({
+        description: 'Action: "list_sessions", "get_session", "search_all", "get_recent"',
+      }),
+      sessionId: Type.Optional(Type.String({ description: 'Session ID (required for get_session)' })),
+      query: Type.Optional(Type.String({ description: 'Search query (required for search_all)' })),
+      count: Type.Optional(Type.Number({ description: 'Number of results to return (default: 20, used by get_recent and search_all)' })),
+    }),
+    execute: async (_toolCallId, params) => {
+      try {
+        await dbReady
+
+        switch (params.action) {
+          case 'list_sessions': {
+            const sessions = await db.listSessions()
+            if (sessions.length === 0) {
+              return {
+                content: [{ type: 'text', text: 'No conversation sessions found.' }],
+                details: { count: 0 },
+              }
+            }
+
+            const lines = sessions.map((s) => {
+              const created = new Date(s.createdAt).toISOString().slice(0, 16)
+              const updated = new Date(s.updatedAt).toISOString().slice(0, 16)
+              return `[${s.id}] "${s.title}" (model: ${s.model || 'unknown'})\n  Created: ${created}  Updated: ${updated}`
+            })
+
+            return {
+              content: [{ type: 'text', text: `${sessions.length} session(s):\n\n${lines.join('\n\n')}` }],
+              details: { count: sessions.length },
+            }
+          }
+
+          case 'get_session': {
+            if (!params.sessionId) {
+              return {
+                content: [{ type: 'text', text: 'Error: "sessionId" is required for get_session action.' }],
+                details: {},
+              }
+            }
+
+            const session = await db.getSession(params.sessionId)
+            if (!session) {
+              return {
+                content: [{ type: 'text', text: `Session not found: ${params.sessionId}` }],
+                details: {},
+              }
+            }
+
+            const messages = await db.getMessages(params.sessionId)
+            if (messages.length === 0) {
+              return {
+                content: [{ type: 'text', text: `Session "${session.title}" exists but has no messages.` }],
+                details: { session },
+              }
+            }
+
+            const lines = messages
+              .filter((m) => !m.partial)
+              .map((m) => {
+                const time = new Date(m.createdAt).toISOString().slice(0, 16)
+                const content = m.content || ''
+                const snippet = content.length > 500 ? content.substring(0, 500) + '...' : content
+                return `[${time}] ${m.role}: ${snippet}`
+              })
+
+            return {
+              content: [{
+                type: 'text',
+                text: `Session "${session.title}" (${messages.length} messages):\n\n${lines.join('\n\n')}`,
+              }],
+              details: { session, messageCount: messages.length },
+            }
+          }
+
+          case 'search_all': {
+            if (!params.query) {
+              return {
+                content: [{ type: 'text', text: 'Error: "query" is required for search_all action.' }],
+                details: {},
+              }
+            }
+
+            const maxResults = params.count || 20
+            const query = params.query.toLowerCase()
+            const sessions = await db.listSessions()
+            const results: string[] = []
+
+            for (const session of sessions) {
+              if (results.length >= maxResults) break
+              const messages = await db.getMessages(session.id)
+              for (const msg of messages) {
+                if (results.length >= maxResults) break
+                if (msg.partial) continue
+                const content = msg.content || ''
+                if (content.toLowerCase().includes(query)) {
+                  const date = new Date(msg.createdAt).toISOString().slice(0, 16)
+                  const snippet = content.length > 300 ? content.substring(0, 300) + '...' : content
+                  results.push(`[${date}] Session "${session.title}" (${session.id}) [${msg.role}]:\n  ${snippet}`)
+                }
+              }
+            }
+
+            if (results.length === 0) {
+              return {
+                content: [{ type: 'text', text: `No matches for "${params.query}" across all sessions.` }],
+                details: { query: params.query, matchCount: 0 },
+              }
+            }
+
+            return {
+              content: [{
+                type: 'text',
+                text: `Found ${results.length} match(es) for "${params.query}":\n\n${results.join('\n\n')}`,
+              }],
+              details: { query: params.query, matchCount: results.length },
+            }
+          }
+
+          case 'get_recent': {
+            const count = params.count || 20
+            const sessions = await db.listSessions()
+
+            // Collect all non-partial messages across sessions, then sort by time and take most recent
+            const allMessages: Array<{ sessionTitle: string; sessionId: string; role: string; content: string; createdAt: number }> = []
+
+            for (const session of sessions) {
+              const messages = await db.getMessages(session.id)
+              for (const msg of messages) {
+                if (msg.partial) continue
+                allMessages.push({
+                  sessionTitle: session.title,
+                  sessionId: session.id,
+                  role: msg.role,
+                  content: msg.content || '',
+                  createdAt: msg.createdAt,
+                })
+              }
+            }
+
+            // Sort by most recent first
+            allMessages.sort((a, b) => b.createdAt - a.createdAt)
+            const recent = allMessages.slice(0, count)
+
+            if (recent.length === 0) {
+              return {
+                content: [{ type: 'text', text: 'No messages found across any sessions.' }],
+                details: { count: 0 },
+              }
+            }
+
+            const lines = recent.map((m) => {
+              const date = new Date(m.createdAt).toISOString().slice(0, 16)
+              const snippet = m.content.length > 300 ? m.content.substring(0, 300) + '...' : m.content
+              return `[${date}] Session "${m.sessionTitle}" [${m.role}]:\n  ${snippet}`
+            })
+
+            return {
+              content: [{
+                type: 'text',
+                text: `${recent.length} most recent message(s):\n\n${lines.join('\n\n')}`,
+              }],
+              details: { count: recent.length },
+            }
+          }
+
+          default:
+            return {
+              content: [{
+                type: 'text',
+                text: `Unknown action: "${params.action}". Valid actions: list_sessions, get_session, search_all, get_recent`,
+              }],
+              details: {},
+            }
+        }
+      } catch (e: any) {
+        return {
+          content: [{ type: 'text', text: `History error: ${e.message}` }],
+          details: { error: e.message },
+        }
+      }
+    },
+  }
+}

moav2/src/core/tools/index.ts

@@ -0,0 +1,41 @@
+import { createReadTool } from './read-tool'
+import { createWriteTool } from './write-tool'
+import { createEditTool } from './edit-tool'
+import { createBashTool } from './bash-tool'
+import { createSearchTool } from './search-tool'
+import { createSelfEditTool } from './self-edit-tool'
+import { createWebFetchTool } from './web-fetch-tool'
+import { createIntentTool } from './intent-tool'
+import { createHistoryTool } from './history-tool'
+import { createRuntimePackTool } from './runtime-pack-tool'
+import { createSetSystemPromptTool } from './set-system-prompt-tool'
+import type { AgentTool } from '@mariozechner/pi-agent-core'
+
+export function createAllTools(moaSrcPath: string = '/src'): AgentTool<any, any>[] {
+  return [
+    createReadTool(),
+    createWriteTool(),
+    createEditTool(),
+    createBashTool(),
+    createSearchTool(),
+    createSelfEditTool(moaSrcPath),
+    createWebFetchTool(),
+    createIntentTool(),
+    createHistoryTool(),
+    createRuntimePackTool(),
+  ]
+}
+
+export {
+  createReadTool,
+  createWriteTool,
+  createEditTool,
+  createBashTool,
+  createSearchTool,
+  createSelfEditTool,
+  createWebFetchTool,
+  createIntentTool,
+  createHistoryTool,
+  createRuntimePackTool,
+  createSetSystemPromptTool,
+}