repoburg 1.3.188 → 1.3.196

package/agent-pane/frontend/src/store/store.test.ts

@@ -0,0 +1,1284 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { useStore } from './store.ts';
+
+// Shared test fixtures and helpers
+import { makeSession, makeDetail, makeTurn, makeItem, makeUsage, makeWorkspace } from '../test/fixtures.ts';
+import { resetStore } from '../test/component-helpers.ts';
+
+// Mock API modules — must be at top level for vitest hoisting
+vi.mock('../api/sessions.ts', () => ({
+  fetchSessions: vi.fn(),
+  fetchSessionDetail: vi.fn(),
+  createSession: vi.fn(),
+  deleteSession: vi.fn(),
+  submitPrompt: vi.fn(),
+  cancelTurn: vi.fn(),
+  renameSession: vi.fn(),
+  markFinished: vi.fn(),
+  reopenSession: vi.fn(),
+  clearUnreviewed: vi.fn(),
+  rewindSession: vi.fn(),
+  branchSession: vi.fn(),
+  updateModelConfig: vi.fn(),
+}));
+
+vi.mock('../api/workspaces.ts', () => ({
+  fetchWorkspaces: vi.fn(),
+  createWorkspace: vi.fn(),
+  hideWorkspace: vi.fn(),
+  deleteWorkspace: vi.fn(),
+  pickDirectory: vi.fn(),
+}));
+
+// Import mocked functions for assertions
+import {
+  fetchSessions,
+  fetchSessionDetail,
+  createSession as apiCreateSession,
+  deleteSession as apiDeleteSession,
+  submitPrompt,
+  cancelTurn,
+  renameSession as apiRenameSession,
+  markFinished as apiMarkFinished,
+  reopenSession as apiReopenSession,
+  clearUnreviewed,
+  rewindSession as apiRewindSession,
+  branchSession as apiBranchSession,
+  updateModelConfig as apiUpdateModelConfig,
+} from '../api/sessions.ts';
+import {
+  fetchWorkspaces,
+  createWorkspace as apiCreateWorkspace,
+  hideWorkspace as apiHideWorkspace,
+  pickDirectory as apiPickDirectory,
+} from '../api/workspaces.ts';
+
+// === Existing tests (unchanged) ===
+
+describe('upsertItem (via onItemStarted)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('inserts a new item when no match by external_item_id', () => {
+    const turn = makeTurn('t1', 's1');
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail } });
+
+    const item = makeItem('i1', 't1');
+    useStore.getState().onItemStarted('s1', 't1', item);
+
+    const updated = useStore.getState().sessionDetails['s1'];
+    expect(updated.turns[0].items).toHaveLength(1);
+    expect(updated.turns[0].items[0].external_item_id).toBe('ext-i1');
+  });
+
+  it('replaces existing item matching by external_item_id, keeps local id', () => {
+    const existingItem = makeItem('local-i1', 't1');
+    const turn = makeTurn('t1', 's1', { items: [existingItem] });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail } });
+
+    const updatedItem = {
+      ...makeItem('different-local-id', 't1'),
+      external_item_id: 'ext-local-i1',
+      data: { text: 'updated' },
+    };
+    useStore.getState().onItemStarted('s1', 't1', updatedItem);
+
+    const updated = useStore.getState().sessionDetails['s1'];
+    expect(updated.turns[0].items).toHaveLength(1);
+    expect(updated.turns[0].items[0].id).toBe('local-i1');
+    expect(updated.turns[0].items[0].data).toEqual({ text: 'updated' });
+  });
+});
+
+describe('submitPrompt', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets submittingPrompt and marks session as running', async () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    vi.mocked(submitPrompt).mockResolvedValue(makeTurn('t1', 's1', { status: 'pending', user_prompt: 'hello' }));
+
+    await useStore.getState().submitPrompt('hello');
+
+    const state = useStore.getState();
+    expect(state.submittingPrompt).toBeNull();
+    expect(state.sessionDetails['s1'].is_running).toBe(1);
+    expect(state.sessionDetails['s1'].status).toBe('running');
+    expect(state.sessionDetails['s1'].turns).toHaveLength(1);
+    expect(state.sessionDetails['s1'].turns[0].user_prompt).toBe('hello');
+  });
+
+  it('reverts running state on error', async () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    vi.mocked(submitPrompt).mockRejectedValue(new Error('Network error'));
+
+    await useStore.getState().submitPrompt('hello');
+
+    const state = useStore.getState();
+    expect(state.submittingPrompt).toBeNull();
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].status).toBe('active');
+    expect(state.error).toBe('Network error');
+  });
+
+  it('does nothing when no active session', async () => {
+    resetStore({ activeSessionId: null });
+    await useStore.getState().submitPrompt('hello');
+    expect(submitPrompt).not.toHaveBeenCalled();
+  });
+});
+
+describe('cancelTurn', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('calls apiCancelTurn with active session id', async () => {
+    resetStore({ activeSessionId: 's1' });
+    vi.mocked(cancelTurn).mockResolvedValue({ success: true });
+
+    await useStore.getState().cancelTurn();
+
+    expect(cancelTurn).toHaveBeenCalledWith('s1');
+  });
+
+  it('does nothing when no active session', async () => {
+    resetStore({ activeSessionId: null });
+    await useStore.getState().cancelTurn();
+    expect(cancelTurn).not.toHaveBeenCalled();
+  });
+});
+
+describe('onTurnCancelled', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('removes the cancelled turn and restores prompt', () => {
+    const turn = makeTurn('t1', 's1', { user_prompt: 'my prompt', status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      activeSessionId: 's1',
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+      activeTurnIndex: 0,
+    });
+
+    useStore.getState().onTurnCancelled('s1', 't1');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns).toHaveLength(0);
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].status).toBe('active');
+    expect(state.restoredPrompt).toBe('my prompt');
+  });
+});
+
+describe('selectSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('uses cached detail without fetching', async () => {
+    const detail = makeDetail('s1', [makeTurn('t1', 's1')]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    await useStore.getState().selectSession('s1');
+
+    expect(fetchSessionDetail).not.toHaveBeenCalled();
+    expect(useStore.getState().activeSessionId).toBe('s1');
+  });
+
+  it('fetches detail on cache miss', async () => {
+    const detail = makeDetail('s1', [makeTurn('t1', 's1')]);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(detail);
+    await useStore.getState().selectSession('s1');
+
+    expect(fetchSessionDetail).toHaveBeenCalledWith('s1');
+    expect(useStore.getState().sessionDetails['s1']).toEqual(detail);
+    expect(useStore.getState().activeSessionId).toBe('s1');
+    expect(useStore.getState().loading).toBe(false);
+  });
+
+  it('clears has_unreviewed when set', async () => {
+    const detail = makeDetail('s1', [], { has_unreviewed: 1 });
+    resetStore({ sessionDetails: { s1: detail }, sessions: [makeSession('s1', { has_unreviewed: 1 })] });
+    vi.mocked(clearUnreviewed).mockResolvedValue(makeSession('s1'));
+
+    await useStore.getState().selectSession('s1');
+
+    expect(clearUnreviewed).toHaveBeenCalledWith('s1');
+    expect(useStore.getState().sessionDetails['s1'].has_unreviewed).toBe(0);
+  });
+});
+
+describe('closeTab', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('removes tab and switches active to last remaining', () => {
+    resetStore({
+      openTabs: ['s1', 's2', 's3'],
+      activeSessionId: 's2',
+      sessionDetails: { s3: makeDetail('s3', [makeTurn('t1', 's3')]) },
+    });
+
+    useStore.getState().closeTab('s2');
+
+    const state = useStore.getState();
+    expect(state.openTabs).toEqual(['s1', 's3']);
+    expect(state.activeSessionId).toBe('s3');
+  });
+
+  it('sets activeSessionId to null when closing last tab', () => {
+    resetStore({ openTabs: ['s1'], activeSessionId: 's1' });
+
+    useStore.getState().closeTab('s1');
+
+    const state = useStore.getState();
+    expect(state.openTabs).toEqual([]);
+    expect(state.activeSessionId).toBeNull();
+  });
+});
+
+describe('deleteSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('removes session from sessions, sessionDetails, and openTabs', async () => {
+    const detail = makeDetail('s1', []);
+    const detail2 = makeDetail('s2', [makeTurn('t1', 's2')]);
+    resetStore({
+      sessions: [makeSession('s1'), makeSession('s2')],
+      sessionDetails: { s1: detail, s2: detail2 },
+      openTabs: ['s1', 's2'],
+      activeSessionId: 's1',
+    });
+    vi.mocked(cancelTurn).mockResolvedValue({ success: true });
+    vi.mocked(apiDeleteSession).mockResolvedValue({ success: true });
+
+    await useStore.getState().deleteSession('s1');
+
+    const state = useStore.getState();
+    expect(state.sessions).toHaveLength(1);
+    expect(state.sessions[0].id).toBe('s2');
+    expect(state.sessionDetails['s1']).toBeUndefined();
+    expect(state.openTabs).toEqual(['s2']);
+    expect(state.activeSessionId).toBe('s2');
+  });
+});
+
+// === New tests: WebSocket event handlers ===
+
+describe('onTurnStarted', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets session and turn to running state', () => {
+    const turn = makeTurn('t1', 's1', { status: 'pending' });
+    const detail = makeDetail('s1', [turn], { is_running: 0, status: 'active' });
+    resetStore({
+      activeSessionId: 's1',
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 0, status: 'active' })],
+    });
+
+    useStore.getState().onTurnStarted('s1', 't1');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].is_running).toBe(1);
+    expect(state.sessionDetails['s1'].status).toBe('running');
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('running');
+    expect(state.sessions[0].is_running).toBe(1);
+    expect(state.sessions[0].status).toBe('running');
+    expect(state.activeTurnIndex).toBe(0);
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onTurnStarted('s1', 't1');
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onItemUpdated', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates existing item data via upsertItem', () => {
+    const existingItem = makeItem('i1', 't1', 'command_execution');
+    const turn = makeTurn('t1', 's1', { items: [existingItem] });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const updatedItem = {
+      ...makeItem('i2', 't1', 'command_execution'),
+      external_item_id: 'ext-i1',
+      data: { command: 'ls -la', output: 'done' },
+    };
+    useStore.getState().onItemUpdated('s1', 't1', updatedItem);
+
+    const items = useStore.getState().sessionDetails['s1'].turns[0].items;
+    expect(items).toHaveLength(1);
+    expect(items[0].id).toBe('i1'); // local id preserved
+    expect(items[0].data).toEqual({ command: 'ls -la', output: 'done' });
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onItemUpdated('s1', 't1', makeItem('i1', 't1'));
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onItemCompleted', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates item and sets agent_response for agent_message type', () => {
+    const turn = makeTurn('t1', 's1', { agent_response: null });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const item = makeItem('i1', 't1', 'agent_message');
+    item.data = { text: 'Task completed successfully' };
+    useStore.getState().onItemCompleted('s1', 't1', item);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].agent_response).toBe('Task completed successfully');
+  });
+
+  it('appends to thoughts for reasoning type', () => {
+    const turn = makeTurn('t1', 's1', { thoughts: 'First thought' });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const item = makeItem('i1', 't1', 'reasoning');
+    item.data = { text: 'Second thought' };
+    useStore.getState().onItemCompleted('s1', 't1', item);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].thoughts).toBe('First thought\nSecond thought');
+  });
+
+  it('sets thoughts for reasoning when previously null', () => {
+    const turn = makeTurn('t1', 's1', { thoughts: null });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const item = makeItem('i1', 't1', 'reasoning');
+    item.data = { text: 'Initial thought' };
+    useStore.getState().onItemCompleted('s1', 't1', item);
+
+    expect(useStore.getState().sessionDetails['s1'].turns[0].thoughts).toBe('Initial thought');
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onItemCompleted('s1', 't1', makeItem('i1', 't1'));
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onTurnCompleted', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets turn to completed with usage and clears running state', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    const usage = makeUsage({ input_tokens: 500, output_tokens: 1000 });
+    useStore.getState().onTurnCompleted('s1', 't1', usage);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].status).toBe('active');
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('completed');
+    expect(state.sessionDetails['s1'].turns[0].token_usage).toEqual(usage);
+  });
+
+  it('sets has_unreviewed when hasUnreviewed=true', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, has_unreviewed: 0 });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, has_unreviewed: 0 })],
+    });
+
+    useStore.getState().onTurnCompleted('s1', 't1', makeUsage(), true);
+
+    expect(useStore.getState().sessionDetails['s1'].has_unreviewed).toBe(1);
+    expect(useStore.getState().sessions[0].has_unreviewed).toBe(1);
+  });
+
+  it('does not change has_unreviewed when hasUnreviewed is falsy', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { has_unreviewed: 1 });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { has_unreviewed: 1 })],
+    });
+
+    useStore.getState().onTurnCompleted('s1', 't1', makeUsage(), false);
+
+    expect(useStore.getState().sessionDetails['s1'].has_unreviewed).toBe(1);
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onTurnCompleted('s1', 't1', makeUsage());
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+
+  it('handles undefined usage without crashing', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running', token_usage: null });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    // Simulate real app-server: turn:completed broadcast WITHOUT usage
+    useStore.getState().onTurnCompleted('s1', 't1', undefined);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].status).toBe('active');
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('completed');
+    // When usage is undefined, existing token_usage is preserved (may have been set by onTokenUsageUpdated)
+    expect(state.sessionDetails['s1'].turns[0].token_usage).toBeNull();
+  });
+
+  it('preserves existing token_usage when usage is undefined', () => {
+    const existingUsage = makeUsage({ input_tokens: 500, output_tokens: 1000 });
+    const turn = makeTurn('t1', 's1', { status: 'running', token_usage: existingUsage });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    // Simulate real app-server: turn:completed broadcast WITHOUT usage
+    // but token_usage was already set by thread/tokenUsage/updated handler
+    useStore.getState().onTurnCompleted('s1', 't1', undefined);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].token_usage).toEqual(existingUsage);
+  });
+
+  it('handles null usage without crashing', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    useStore.getState().onTurnCompleted('s1', 't1', null);
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].turns[0].token_usage).toBeNull();
+  });
+});
+
+describe('onItemDelta', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('appends delta to existing agent_message item text', () => {
+    const item = makeItem('i1', 't1', 'agent_message');
+    item.data = { text: 'Hello' };
+    const turn = makeTurn('t1', 's1', { items: [item], agent_response: 'Hello' });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    useStore.getState().onItemDelta('s1', 't1', 'ext-i1', ' world');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].items[0].data).toEqual({ text: 'Hello world' });
+    expect(state.sessionDetails['s1'].turns[0].agent_response).toBe('Hello world');
+  });
+
+  it('creates new in-progress agent_message item when item not found', () => {
+    const turn = makeTurn('t1', 's1', { items: [] });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    useStore.getState().onItemDelta('s1', 't1', 'ext-new-item', 'Hello');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].items).toHaveLength(1);
+    expect(state.sessionDetails['s1'].turns[0].items[0].type).toBe('agent_message');
+    expect(state.sessionDetails['s1'].turns[0].items[0].status).toBe('in_progress');
+    expect(state.sessionDetails['s1'].turns[0].items[0].data).toEqual({ text: 'Hello' });
+    expect(state.sessionDetails['s1'].turns[0].items[0].external_item_id).toBe('ext-new-item');
+    expect(state.sessionDetails['s1'].turns[0].agent_response).toBe('Hello');
+  });
+
+  it('accumulates multiple deltas correctly', () => {
+    const turn = makeTurn('t1', 's1', { items: [] });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    useStore.getState().onItemDelta('s1', 't1', 'ext-d1', 'Hello');
+    useStore.getState().onItemDelta('s1', 't1', 'ext-d1', ' there');
+    useStore.getState().onItemDelta('s1', 't1', 'ext-d1', '!');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].items).toHaveLength(1);
+    expect(state.sessionDetails['s1'].turns[0].items[0].data).toEqual({ text: 'Hello there!' });
+    expect(state.sessionDetails['s1'].turns[0].agent_response).toBe('Hello there!');
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onItemDelta('s1', 't1', 'ext-i1', 'Hello');
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onTokenUsageUpdated', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets token_usage on matching turn', () => {
+    const turn = makeTurn('t1', 's1', { token_usage: null, status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const usage = makeUsage({ input_tokens: 500, output_tokens: 1000 });
+    useStore.getState().onTokenUsageUpdated('s1', 't1', usage);
+
+    expect(useStore.getState().sessionDetails['s1'].turns[0].token_usage).toEqual(usage);
+  });
+
+  it('overwrites previously null token_usage', () => {
+    const turn = makeTurn('t1', 's1', { token_usage: null });
+    const detail = makeDetail('s1', [turn]);
+    resetStore({ sessionDetails: { s1: detail } });
+
+    const usage = makeUsage({ input_tokens: 200, output_tokens: 300 });
+    useStore.getState().onTokenUsageUpdated('s1', 't1', usage);
+
+    expect(useStore.getState().sessionDetails['s1'].turns[0].token_usage).toEqual(usage);
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onTokenUsageUpdated('s1', 't1', makeUsage());
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onTurnFailed', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets turn to failed with error message', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    useStore.getState().onTurnFailed('s1', 't1', 'Something went wrong');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessionDetails['s1'].status).toBe('failed');
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('failed');
+    expect(state.sessionDetails['s1'].turns[0].error).toBe('Something went wrong');
+    expect(state.sessions[0].status).toBe('failed');
+  });
+
+  it('sets status to aborted when error contains "cancelled"', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    useStore.getState().onTurnFailed('s1', 't1', 'The operation was cancelled by user');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].status).toBe('active');
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('aborted');
+    expect(state.sessions[0].status).toBe('active');
+  });
+
+  it('sets status to aborted when error contains "aborted"', () => {
+    const turn = makeTurn('t1', 's1', { status: 'running' });
+    const detail = makeDetail('s1', [turn], { is_running: 1, status: 'running' });
+    resetStore({
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+    });
+
+    useStore.getState().onTurnFailed('s1', 't1', 'Turn aborted');
+
+    const state = useStore.getState();
+    expect(state.sessionDetails['s1'].turns[0].status).toBe('aborted');
+    expect(state.sessionDetails['s1'].status).toBe('active');
+  });
+
+  it('does nothing when session detail not found', () => {
+    resetStore({ sessionDetails: {} });
+    useStore.getState().onTurnFailed('s1', 't1', 'error');
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+describe('onSessionTitle', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates title in sessions array', () => {
+    resetStore({ sessions: [makeSession('s1', { title: null })] });
+    useStore.getState().onSessionTitle('s1', 'New Title');
+    expect(useStore.getState().sessions[0].title).toBe('New Title');
+  });
+
+  it('updates title in sessionDetails when cached', () => {
+    const detail = makeDetail('s1', [], { title: null });
+    resetStore({ sessions: [makeSession('s1')], sessionDetails: { s1: detail } });
+    useStore.getState().onSessionTitle('s1', 'New Title');
+    expect(useStore.getState().sessionDetails['s1'].title).toBe('New Title');
+  });
+
+  it('does not add sessionDetails when not cached', () => {
+    resetStore({ sessions: [makeSession('s1')], sessionDetails: {} });
+    useStore.getState().onSessionTitle('s1', 'New Title');
+    expect(useStore.getState().sessionDetails['s1']).toBeUndefined();
+  });
+});
+
+// === New tests: REST actions ===
+
+describe('createSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('creates session, adds to list, and selects it', async () => {
+    const newSession = makeSession('s1', { title: 'Test Session' });
+    vi.mocked(apiCreateSession).mockResolvedValue(newSession);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', []));
+
+    await useStore.getState().createSession({ title: 'Test Session' });
+
+    const state = useStore.getState();
+    expect(apiCreateSession).toHaveBeenCalledWith({ title: 'Test Session' });
+    expect(state.sessions[0].id).toBe('s1');
+    expect(state.showNewSessionDialog).toBe(false);
+    expect(state.activeSessionId).toBe('s1');
+    expect(state.lastModelConfig).toEqual({ provider: 'codex', model: '', reasoning: '' });
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiCreateSession).mockRejectedValue(new Error('API error'));
+    await useStore.getState().createSession({ title: 'Test' });
+    const state = useStore.getState();
+    expect(state.error).toBe('API error');
+    expect(state.toasts).toHaveLength(1);
+    expect(state.toasts[0].type).toBe('error');
+  });
+});
+
+describe('renameSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates session title in sessions and sessionDetails', async () => {
+    const detail = makeDetail('s1', []);
+    resetStore({
+      sessions: [makeSession('s1', { title: 'Old' })],
+      sessionDetails: { s1: detail },
+    });
+    vi.mocked(apiRenameSession).mockResolvedValue(makeSession('s1', { title: 'New' }));
+
+    await useStore.getState().renameSession('s1', 'New');
+
+    const state = useStore.getState();
+    expect(apiRenameSession).toHaveBeenCalledWith('s1', 'New');
+    expect(state.sessions[0].title).toBe('New');
+    expect(state.sessionDetails['s1'].title).toBe('New');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiRenameSession).mockRejectedValue(new Error('Rename failed'));
+    await useStore.getState().renameSession('s1', 'New');
+    expect(useStore.getState().error).toBe('Rename failed');
+  });
+});
+
+describe('markFinished', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates lifecycle to finished', async () => {
+    resetStore({ sessions: [makeSession('s1', { lifecycle: 'working' })] });
+    vi.mocked(apiMarkFinished).mockResolvedValue(makeSession('s1', { lifecycle: 'finished' }));
+
+    await useStore.getState().markFinished('s1');
+
+    expect(apiMarkFinished).toHaveBeenCalledWith('s1');
+    expect(useStore.getState().sessions[0].lifecycle).toBe('finished');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiMarkFinished).mockRejectedValue(new Error('Failed'));
+    await useStore.getState().markFinished('s1');
+    expect(useStore.getState().error).toBe('Failed');
+  });
+});
+
+describe('reopenSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('updates lifecycle to working', async () => {
+    resetStore({ sessions: [makeSession('s1', { lifecycle: 'finished' })] });
+    vi.mocked(apiReopenSession).mockResolvedValue(makeSession('s1', { lifecycle: 'working' }));
+
+    await useStore.getState().reopenSession('s1');
+
+    expect(apiReopenSession).toHaveBeenCalledWith('s1');
+    expect(useStore.getState().sessions[0].lifecycle).toBe('working');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiReopenSession).mockRejectedValue(new Error('Failed'));
+    await useStore.getState().reopenSession('s1');
+    expect(useStore.getState().error).toBe('Failed');
+  });
+});
+
+describe('rewindToTurn', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('calls api rewind and refreshes detail', async () => {
+    const turn1 = makeTurn('t1', 's1');
+    const turn2 = makeTurn('t2', 's1');
+    const detail = makeDetail('s1', [turn1, turn2], { external_thread_id: 'ext-1', is_running: 1 });
+    resetStore({
+      sessions: [makeSession('s1', { external_thread_id: 'ext-1', is_running: 1, status: 'running' })],
+      sessionDetails: { s1: detail },
+    });
+
+    vi.mocked(apiRewindSession).mockResolvedValue(makeSession('s1', { external_thread_id: null }));
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', [turn1], { external_thread_id: null }));
+
+    await useStore.getState().rewindToTurn('s1', 't1');
+
+    const state = useStore.getState();
+    expect(apiRewindSession).toHaveBeenCalledWith('s1', 't1');
+    expect(fetchSessionDetail).toHaveBeenCalledWith('s1');
+    expect(state.sessionDetails['s1'].turns).toHaveLength(1);
+    expect(state.sessions[0].external_thread_id).toBeNull();
+    expect(state.sessions[0].is_running).toBe(0);
+    expect(state.activeTurnIndex).toBe(0);
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiRewindSession).mockRejectedValue(new Error('Rewind failed'));
+    await useStore.getState().rewindToTurn('s1', 't1');
+    expect(useStore.getState().error).toBe('Rewind failed');
+  });
+});
+
+describe('branchFromTurn', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('creates branched session and selects it', async () => {
+    const newSession = makeSession('s2', { title: 'Branched' });
+    resetStore({ sessions: [makeSession('s1')] });
+    vi.mocked(apiBranchSession).mockResolvedValue(newSession);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s2', []));
+
+    await useStore.getState().branchFromTurn('s1', 't1');
+
+    const state = useStore.getState();
+    expect(apiBranchSession).toHaveBeenCalledWith('s1', 't1', undefined);
+    expect(state.sessions[0].id).toBe('s2'); // prepended
+    expect(state.activeSessionId).toBe('s2');
+  });
+
+  it('passes title when provided', async () => {
+    const newSession = makeSession('s2', { title: 'Custom Branch' });
+    vi.mocked(apiBranchSession).mockResolvedValue(newSession);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s2', []));
+
+    await useStore.getState().branchFromTurn('s1', 't1', 'Custom Branch');
+
+    expect(apiBranchSession).toHaveBeenCalledWith('s1', 't1', 'Custom Branch');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiBranchSession).mockRejectedValue(new Error('Branch failed'));
+    await useStore.getState().branchFromTurn('s1', 't1');
+    expect(useStore.getState().error).toBe('Branch failed');
+  });
+});
+
+describe('refreshActiveSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('re-fetches and updates session detail', async () => {
+    const oldDetail = makeDetail('s1', [makeTurn('t1', 's1')], { is_running: 1, status: 'running' });
+    const newDetail = makeDetail('s1', [makeTurn('t1', 's1'), makeTurn('t2', 's1')], { is_running: 0, status: 'active' });
+    resetStore({
+      activeSessionId: 's1',
+      sessionDetails: { s1: oldDetail },
+      sessions: [makeSession('s1', { is_running: 1, status: 'running' })],
+      activeTurnIndex: 0,
+    });
+    vi.mocked(fetchSessionDetail).mockResolvedValue(newDetail);
+
+    await useStore.getState().refreshActiveSession();
+
+    const state = useStore.getState();
+    expect(fetchSessionDetail).toHaveBeenCalledWith('s1');
+    expect(state.sessionDetails['s1'].turns).toHaveLength(2);
+    expect(state.sessionDetails['s1'].is_running).toBe(0);
+    expect(state.sessions[0].is_running).toBe(0);
+    expect(state.sessions[0].status).toBe('active');
+  });
+
+  it('does nothing when no active session', async () => {
+    resetStore({ activeSessionId: null });
+    await useStore.getState().refreshActiveSession();
+    expect(fetchSessionDetail).not.toHaveBeenCalled();
+  });
+
+  it('sets error on failure', async () => {
+    resetStore({ activeSessionId: 's1' });
+    vi.mocked(fetchSessionDetail).mockRejectedValue(new Error('Fetch failed'));
+    await useStore.getState().refreshActiveSession();
+    expect(useStore.getState().error).toBe('Fetch failed');
+  });
+});
+
+describe('updateModelConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('calls API and updates model fields in sessions + detail', async () => {
+    const detail = makeDetail('s1', [], { model: 'old-model', external_thread_id: 'ext-1' });
+    resetStore({
+      activeSessionId: 's1',
+      sessions: [makeSession('s1', { model: 'old-model', external_thread_id: 'ext-1' })],
+      sessionDetails: { s1: detail },
+    });
+
+    const updated = makeSession('s1', { model: 'new-model', model_reasoning_effort: 'high', external_thread_id: null });
+    vi.mocked(apiUpdateModelConfig).mockResolvedValue(updated);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', [], { model: 'new-model', external_thread_id: null }));
+
+    await useStore.getState().updateModelConfig('new-model', 'high');
+
+    const state = useStore.getState();
+    expect(apiUpdateModelConfig).toHaveBeenCalledWith('s1', 'new-model', 'high', undefined);
+    expect(state.sessions[0].model).toBe('new-model');
+    expect(state.lastModelConfig).toEqual({ provider: 'codex', model: 'new-model', reasoning: 'high' });
+  });
+
+  it('does nothing when no active session', async () => {
+    resetStore({ activeSessionId: null });
+    await useStore.getState().updateModelConfig('model', 'low');
+    expect(apiUpdateModelConfig).not.toHaveBeenCalled();
+  });
+
+  it('shows error toast on failure', async () => {
+    resetStore({ activeSessionId: 's1', sessions: [makeSession('s1')] });
+    vi.mocked(apiUpdateModelConfig).mockRejectedValue(new Error('Update failed'));
+    await useStore.getState().updateModelConfig('model', 'low');
+    expect(useStore.getState().error).toBe('Update failed');
+    expect(useStore.getState().toasts[0].type).toBe('error');
+  });
+
+  it('passes runtimeType to API when switching provider', async () => {
+    const detail = makeDetail('s1', [], { model: 'gpt-5.6-sol', runtime_type: 'codex' });
+    resetStore({
+      activeSessionId: 's1',
+      sessions: [makeSession('s1', { model: 'gpt-5.6-sol', runtime_type: 'codex' })],
+      sessionDetails: { s1: detail },
+    });
+
+    const updated = makeSession('s1', { runtime_type: 'claude', model: null, model_reasoning_effort: null });
+    vi.mocked(apiUpdateModelConfig).mockResolvedValue(updated);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', [], { runtime_type: 'claude' }));
+
+    await useStore.getState().updateModelConfig('', '', 'claude');
+
+    expect(apiUpdateModelConfig).toHaveBeenCalledWith('s1', '', '', 'claude');
+    expect(useStore.getState().sessions[0].runtime_type).toBe('claude');
+  });
+});
+
+// === New tests: Workspace actions ===
+
+describe('addWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('creates workspace and adds to list', async () => {
+    const ws = makeWorkspace('w1', '/path/to/project');
+    vi.mocked(apiCreateWorkspace).mockResolvedValue(ws);
+
+    await useStore.getState().addWorkspace('/path/to/project');
+
+    const state = useStore.getState();
+    expect(apiCreateWorkspace).toHaveBeenCalledWith('/path/to/project');
+    expect(state.workspaces).toHaveLength(1);
+    expect(state.workspaces[0].path).toBe('/path/to/project');
+    expect(state.toasts[0].type).toBe('success');
+  });
+
+  it('trims path before sending', async () => {
+    const ws = makeWorkspace('w1', '/path');
+    vi.mocked(apiCreateWorkspace).mockResolvedValue(ws);
+    await useStore.getState().addWorkspace('  /path  ');
+    expect(apiCreateWorkspace).toHaveBeenCalledWith('/path');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiCreateWorkspace).mockRejectedValue(new Error('Create failed'));
+    await useStore.getState().addWorkspace('/path');
+    expect(useStore.getState().toasts[0].type).toBe('error');
+  });
+});
+
+describe('removeWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('hides workspace and re-fetches list', async () => {
+    resetStore({ workspaces: [makeWorkspace('w1', '/path1'), makeWorkspace('w2', '/path2')] });
+    vi.mocked(apiHideWorkspace).mockResolvedValue({ success: true });
+    vi.mocked(fetchWorkspaces).mockResolvedValue([makeWorkspace('w2', '/path2')]);
+
+    await useStore.getState().removeWorkspace('/path1');
+
+    const state = useStore.getState();
+    expect(apiHideWorkspace).toHaveBeenCalledWith('/path1');
+    expect(fetchWorkspaces).toHaveBeenCalled();
+    expect(state.workspaces).toHaveLength(1);
+    expect(state.workspaces[0].path).toBe('/path2');
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiHideWorkspace).mockRejectedValue(new Error('Hide failed'));
+    await useStore.getState().removeWorkspace('/path');
+    expect(useStore.getState().toasts[0].type).toBe('error');
+  });
+});
+
+describe('createSessionInWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('creates session with cwd and selects it', async () => {
+    const newSession = makeSession('s1', { cwd: '/workspace' });
+    vi.mocked(apiCreateSession).mockResolvedValue(newSession);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', []));
+
+    await useStore.getState().createSessionInWorkspace('/workspace');
+
+    const state = useStore.getState();
+    expect(apiCreateSession).toHaveBeenCalledWith(expect.objectContaining({ cwd: '/workspace' }));
+    expect(state.sessions[0].id).toBe('s1');
+    expect(state.activeSessionId).toBe('s1');
+  });
+
+  it('uses lastModelConfig for runtime_type and model', async () => {
+    resetStore({ lastModelConfig: { provider: 'codex', model: 'gpt-5.6-sol', reasoning: 'high' } });
+    const newSession = makeSession('s1', { cwd: '/ws' });
+    vi.mocked(apiCreateSession).mockResolvedValue(newSession);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', []));
+
+    await useStore.getState().createSessionInWorkspace('/ws');
+
+    expect(apiCreateSession).toHaveBeenCalledWith(expect.objectContaining({
+      runtime_type: 'codex',
+      model: 'gpt-5.6-sol',
+      model_reasoning_effort: 'high',
+    }));
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiCreateSession).mockRejectedValue(new Error('Create failed'));
+    await useStore.getState().createSessionInWorkspace('/ws');
+    expect(useStore.getState().toasts[0].type).toBe('error');
+  });
+});
+
+describe('pickAndAddWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('picks directory and adds workspace', async () => {
+    vi.mocked(apiPickDirectory).mockResolvedValue({ path: '/selected/path' });
+    const ws = makeWorkspace('w1', '/selected/path');
+    vi.mocked(apiCreateWorkspace).mockResolvedValue(ws);
+
+    await useStore.getState().pickAndAddWorkspace();
+
+    expect(apiPickDirectory).toHaveBeenCalled();
+    expect(apiCreateWorkspace).toHaveBeenCalledWith('/selected/path');
+  });
+
+  it('does nothing when cancelled', async () => {
+    vi.mocked(apiPickDirectory).mockResolvedValue({ cancelled: true });
+
+    await useStore.getState().pickAndAddWorkspace();
+
+    expect(apiCreateWorkspace).not.toHaveBeenCalled();
+  });
+
+  it('does nothing when path is missing', async () => {
+    vi.mocked(apiPickDirectory).mockResolvedValue({});
+
+    await useStore.getState().pickAndAddWorkspace();
+
+    expect(apiCreateWorkspace).not.toHaveBeenCalled();
+  });
+
+  it('shows error toast on failure', async () => {
+    vi.mocked(apiPickDirectory).mockRejectedValue(new Error('Picker failed'));
+    await useStore.getState().pickAndAddWorkspace();
+    expect(useStore.getState().toasts[0].type).toBe('error');
+  });
+});
+
+// === New tests: UI state actions ===
+
+describe('addToast', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('adds a toast with a unique id', () => {
+    useStore.getState().addToast('info', 'Test message');
+    const toasts = useStore.getState().toasts;
+    expect(toasts).toHaveLength(1);
+    expect(toasts[0].type).toBe('info');
+    expect(toasts[0].message).toBe('Test message');
+    expect(toasts[0].id).toBeTruthy();
+  });
+
+  it('adds toast with undoAction and undoLabel', () => {
+    const undo = vi.fn();
+    useStore.getState().addToast('error', 'Deleted', undo, 'Undo delete');
+    const toast = useStore.getState().toasts[0];
+    expect(toast.undoAction).toBe(undo);
+    expect(toast.undoLabel).toBe('Undo delete');
+  });
+});
+
+describe('removeToast', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('removes toast by id', () => {
+    useStore.getState().addToast('info', 'Toast 1');
+    useStore.getState().addToast('info', 'Toast 2');
+    const id = useStore.getState().toasts[0].id;
+    useStore.getState().removeToast(id);
+    expect(useStore.getState().toasts).toHaveLength(1);
+    expect(useStore.getState().toasts[0].message).toBe('Toast 2');
+  });
+});
+
+describe('addLogEntry', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('adds entry to event log', () => {
+    useStore.getState().addLogEntry('INFO', 'Test log message');
+    const log = useStore.getState().eventLog;
+    expect(log).toHaveLength(1);
+    expect(log[0].level).toBe('INFO');
+    expect(log[0].message).toBe('Test log message');
+    expect(log[0].time).toBeTruthy();
+  });
+});
+
+describe('setWsConnected', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('sets wsConnected flag', () => {
+    useStore.getState().setWsConnected(true);
+    expect(useStore.getState().wsConnected).toBe(true);
+    useStore.getState().setWsConnected(false);
+    expect(useStore.getState().wsConnected).toBe(false);
+  });
+});
+
+describe('simple setters', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+  });
+
+  it('setActiveTurnIndex sets value', () => {
+    useStore.getState().setActiveTurnIndex(3);
+    expect(useStore.getState().activeTurnIndex).toBe(3);
+  });
+
+  it('switchRightTab sets value', () => {
+    useStore.getState().switchRightTab('metrics');
+    expect(useStore.getState().activeRightTab).toBe('metrics');
+  });
+
+  it('setChangesScope sets value', () => {
+    useStore.getState().setChangesScope('turngroup');
+    expect(useStore.getState().changesScope).toBe('turngroup');
+  });
+
+  it('setShowNewSessionDialog sets value', () => {
+    useStore.getState().setShowNewSessionDialog(true);
+    expect(useStore.getState().showNewSessionDialog).toBe(true);
+  });
+
+  it('setShowCommandPalette sets value', () => {
+    useStore.getState().setShowCommandPalette(true);
+    expect(useStore.getState().showCommandPalette).toBe(true);
+  });
+
+  it('setSelectedChangePath sets value', () => {
+    useStore.getState().setSelectedChangePath('/file.ts');
+    expect(useStore.getState().selectedChangePath).toBe('/file.ts');
+  });
+});
+
+// === New tests: init ===
+
+describe('init', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+    vi.spyOn(Storage.prototype, 'getItem').mockReturnValue(null);
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {});
+  });
+
+  it('loads sessions and workspaces', async () => {
+    const sessions = [makeSession('s1'), makeSession('s2')];
+    const workspaces = [makeWorkspace('w1', '/path')];
+    vi.mocked(fetchSessions).mockResolvedValue(sessions);
+    vi.mocked(fetchWorkspaces).mockResolvedValue(workspaces);
+    vi.mocked(fetchSessionDetail).mockResolvedValue(makeDetail('s1', []));
+
+    await useStore.getState().init();
+
+    const state = useStore.getState();
+    expect(fetchSessions).toHaveBeenCalled();
+    expect(fetchWorkspaces).toHaveBeenCalled();
+    expect(state.sessions).toHaveLength(2);
+    expect(state.workspaces).toHaveLength(1);
+    expect(state.loading).toBe(false);
+    // First session auto-selected
+    expect(state.activeSessionId).toBe('s1');
+  });
+
+  it('does not auto-select when no sessions', async () => {
+    vi.mocked(fetchSessions).mockResolvedValue([]);
+    vi.mocked(fetchWorkspaces).mockResolvedValue([]);
+
+    await useStore.getState().init();
+
+    expect(useStore.getState().activeSessionId).toBeNull();
+  });
+
+  it('loads lastModelConfig from localStorage', async () => {
+    const savedConfig = { provider: 'codex', model: 'gpt-5.6-sol', reasoning: 'high' };
+    vi.mocked(Storage.prototype.getItem).mockReturnValue(JSON.stringify(savedConfig));
+    vi.mocked(fetchSessions).mockResolvedValue([]);
+    vi.mocked(fetchWorkspaces).mockResolvedValue([]);
+
+    await useStore.getState().init();
+
+    expect(useStore.getState().lastModelConfig).toEqual(savedConfig);
+  });
+
+  it('sets error on failure', async () => {
+    vi.mocked(fetchSessions).mockRejectedValue(new Error('Network error'));
+
+    await useStore.getState().init();
+
+    expect(useStore.getState().error).toBe('Network error');
+    expect(useStore.getState().loading).toBe(false);
+  });
+});