@vibelet/cli 0.1.38 → 1.0.0

package/dist/session-manager.test.js

@@ -1,2861 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm, writeFile, mkdir } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { SessionManager } from './session-manager.js';
-import { config } from './config.js';
-import { __emitExternalInventoryBackfillForTests, __resetExternalInventoryStateForTests, } from './session-inventory.js';
-// ── Mock helpers ──────────────────────────────────────────────────────
-function mockWs(open = true) {
-    const sent = [];
-    return {
-        readyState: open ? 1 : 3, // 1 = OPEN, 3 = CLOSED
-        send(data) { sent.push(data); },
-        sent,
-    };
-}
-function mockDriver() {
-    const calls = {
-        start: [],
-        sendPrompt: [],
-        respondApproval: [],
-        interrupt: [],
-        stop: [],
-        setApprovalMode: [],
-    };
-    let messageHandler = null;
-    let exitHandler = null;
-    return {
-        async start(cwd, resumeSessionId, approvalMode) {
-            calls.start.push({ cwd, resumeSessionId, approvalMode });
-            return 'mock-session-id';
-        },
-        sendPrompt(text) { calls.sendPrompt.push(text); },
-        respondApproval(requestId, approved) {
-            calls.respondApproval.push({ requestId, approved });
-            return true;
-        },
-        interrupt() { calls.interrupt.push(true); },
-        stop() { calls.stop.push(true); },
-        setApprovalMode(mode) { calls.setApprovalMode.push(mode); },
-        onMessage(handler) { messageHandler = handler; },
-        onExit(handler) { exitHandler = handler; },
-        calls,
-        _emitMessage(msg) { messageHandler?.(msg); },
-        _emitExit(code) { exitHandler?.(code); },
-    };
-}
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
-async function flushAsyncWork() {
-    await Promise.resolve();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-}
-function createManager(pushSender) {
-    const manager = new SessionManager(pushSender ?? (() => { }));
-    // Avoid reading/writing from disk by replacing store internals
-    const store = manager.store;
-    store.records = [];
-    store.deletedSessionIds = new Set();
-    store.scheduleSave = () => { }; // no-op to prevent disk writes
-    store.saveToDisk = () => { }; // no-op to prevent disk writes
-    return manager;
-}
-function injectSession(manager, overrides) {
-    const session = {
-        agent: 'codex',
-        cwd: '/tmp',
-        driver: mockDriver(),
-        clients: new Set(),
-        title: 'Test session',
-        createdAt: '2026-03-20T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T00:00:00.000Z',
-        active: true,
-        lastActivityTs: Date.now(),
-        isResponding: false,
-        currentReplyText: '',
-        acceptedClientMessageIds: [],
-        syntheticApprovalRetries: {},
-        startupInProgress: false,
-        bufferedPrompts: [],
-        startupToken: 0,
-        pendingClaudeHookApprovals: new Map(),
-        ...overrides,
-    };
-    manager.sessions.set(session.sessionId, session);
-    return session;
-}
-function parseReply(ws, index = 0) {
-    return JSON.parse(ws.sent[index]);
-}
-test.beforeEach(() => {
-    __resetExternalInventoryStateForTests();
-});
-// ── broadcast ─────────────────────────────────────────────────────────
-test('broadcast: sends to all open clients', () => {
-    const manager = createManager();
-    const ws1 = mockWs();
-    const ws2 = mockWs();
-    injectSession(manager, {
-        sessionId: 's1',
-        clients: new Set([ws1, ws2]),
-    });
-    const msg = { type: 'text.delta', sessionId: 's1', content: 'hello' };
-    manager.broadcast('s1', msg);
-    assert.equal(ws1.sent.length, 1);
-    assert.equal(ws2.sent.length, 1);
-    assert.deepEqual(JSON.parse(ws1.sent[0]), msg);
-    assert.deepEqual(JSON.parse(ws2.sent[0]), msg);
-});
-test('broadcast: skips clients with readyState !== 1', () => {
-    const manager = createManager();
-    const wsOpen = mockWs(true);
-    const wsClosed = mockWs(false);
-    injectSession(manager, {
-        sessionId: 's1',
-        clients: new Set([wsOpen, wsClosed]),
-    });
-    manager.broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'x' });
-    assert.equal(wsOpen.sent.length, 1);
-    assert.equal(wsClosed.sent.length, 0);
-});
-test('broadcast: does nothing when session not found', () => {
-    const manager = createManager();
-    // Should not throw
-    manager.broadcast('nonexistent', { type: 'text.delta', sessionId: 'nonexistent', content: 'x' });
-});
-test('broadcast: session.done sends push with the accumulated assistant reply preview', () => {
-    const pushCalls = [];
-    const manager = createManager((title, body, data) => {
-        pushCalls.push({ title, body, data });
-    });
-    injectSession(manager, {
-        sessionId: 's1',
-        title: 'Fix login flow',
-    });
-    manager.broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'First line.\n' });
-    manager.broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'Second line.' });
-    manager.broadcast('s1', { type: 'session.done', sessionId: 's1' });
-    assert.deepEqual(pushCalls, [{
-            title: 'Fix login flow',
-            body: 'First line. Second line.',
-            data: { sessionId: 's1', agent: 'codex', eventType: 'reply_ready' },
-        }]);
-});
-test('broadcast: session.done falls back to a generic push body when the turn has no assistant text', () => {
-    const pushCalls = [];
-    const manager = createManager((title, body, data) => {
-        pushCalls.push({ title, body, data });
-    });
-    injectSession(manager, {
-        sessionId: 's1',
-        title: 'Tool-only session',
-    });
-    manager.broadcast('s1', { type: 'session.done', sessionId: 's1' });
-    assert.deepEqual(pushCalls, [{
-            title: 'Tool-only session',
-            body: 'Done.',
-            data: { sessionId: 's1', agent: 'codex', eventType: 'reply_ready' },
-        }]);
-});
-test('broadcast: approval.request sends to all globalClients, not just session clients', () => {
-    const manager = createManager();
-    const sessionClient = mockWs(); // subscribed to session s1
-    const globalOnly = mockWs(); // NOT subscribed to s1, but is a global client
-    injectSession(manager, {
-        sessionId: 's1',
-        clients: new Set([sessionClient]),
-    });
-    // Register both as global clients
-    manager.addGlobalClient(sessionClient);
-    manager.addGlobalClient(globalOnly);
-    // A normal text.delta should only go to session clients
-    manager.broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'x' });
-    assert.equal(sessionClient.sent.length, 1);
-    assert.equal(globalOnly.sent.length, 0, 'text.delta should not reach non-session clients');
-    // An approval.request should go to ALL global clients
-    const approvalMsg = {
-        type: 'approval.request',
-        sessionId: 's1',
-        requestId: 'req-1',
-        toolName: 'Write',
-        input: { file_path: '/tmp/test.ts' },
-        description: 'Write to /tmp/test.ts',
-    };
-    manager.broadcast('s1', approvalMsg);
-    assert.equal(sessionClient.sent.length, 2, 'session client should receive approval');
-    assert.equal(globalOnly.sent.length, 1, 'global-only client should also receive approval');
-    assert.deepEqual(JSON.parse(globalOnly.sent[0]), approvalMsg);
-});
-test('broadcast: approval.request skips closed globalClients', () => {
-    const manager = createManager();
-    const wsOpen = mockWs(true);
-    const wsClosed = mockWs(false);
-    injectSession(manager, { sessionId: 's1' });
-    manager.addGlobalClient(wsOpen);
-    manager.addGlobalClient(wsClosed);
-    manager.broadcast('s1', {
-        type: 'approval.request',
-        sessionId: 's1',
-        requestId: 'req-1',
-        toolName: 'Bash',
-        input: {},
-        description: 'Run command',
-    });
-    assert.equal(wsOpen.sent.length, 1);
-    assert.equal(wsClosed.sent.length, 0);
-});
-test('session.delete broadcasts a sessions.changed invalidation hint to global clients', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.addGlobalClient(ws);
-    injectSession(manager, {
-        sessionId: 'delete-broadcast',
-        driver: mockDriver(),
-    });
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req-delete-broadcast',
-        sessionId: 'delete-broadcast',
-    });
-    const messages = ws.sent.map((entry) => JSON.parse(entry));
-    assert.deepEqual(messages[0], {
-        type: 'sessions.changed',
-        version: 1,
-        reason: 'session_deleted',
-    });
-    assert.equal(messages[1].type, 'response');
-    assert.equal(messages[1].id, 'req-delete-broadcast');
-    assert.equal(messages[1].ok, true);
-});
-test('inventory backfill broadcasts a sessions.changed invalidation hint to global clients', () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.addGlobalClient(ws);
-    __emitExternalInventoryBackfillForTests();
-    assert.deepEqual(JSON.parse(ws.sent[0]), {
-        type: 'sessions.changed',
-        version: 1,
-        reason: 'inventory_backfilled',
-    });
-});
-// ── removeClient ──────────────────────────────────────────────────────
-test('removeClient: removes ws from all sessions and globalClients', () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const s1 = injectSession(manager, { sessionId: 's1', clients: new Set([ws]) });
-    const s2 = injectSession(manager, { sessionId: 's2', clients: new Set([ws]) });
-    manager.addGlobalClient(ws);
-    manager.removeClient(ws);
-    assert.equal(s1.clients.size, 0);
-    assert.equal(s2.clients.size, 0);
-    // Verify globalClients is also cleaned up: broadcast approval should not reach removed client
-    injectSession(manager, { sessionId: 's3' });
-    manager.broadcast('s3', {
-        type: 'approval.request', sessionId: 's3', requestId: 'r', toolName: 'X', input: {}, description: '',
-    });
-    assert.equal(ws.sent.length, 0, 'removed client should not receive broadcasts');
-});
-test('removeClient: does nothing if ws not in any session', () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, { sessionId: 's1' });
-    // Should not throw
-    manager.removeClient(ws);
-});
-// ── shutdown ──────────────────────────────────────────────────────────
-test('shutdown: stops all drivers and sets sessions inactive', () => {
-    const manager = createManager();
-    const driver1 = mockDriver();
-    const driver2 = mockDriver();
-    const ws = mockWs();
-    const s1 = injectSession(manager, { sessionId: 's1', driver: driver1, clients: new Set([ws]) });
-    const s2 = injectSession(manager, { sessionId: 's2', driver: driver2, clients: new Set([ws]) });
-    manager.shutdown();
-    assert.equal(driver1.calls.stop.length, 1);
-    assert.equal(driver2.calls.stop.length, 1);
-    assert.equal(s1.active, false);
-    assert.equal(s2.active, false);
-    assert.equal(s1.driver, null);
-    assert.equal(s2.driver, null);
-    assert.equal(s1.clients.size, 0);
-    assert.equal(s2.clients.size, 0);
-});
-test('shutdown: handles driver.stop() throwing without crashing', () => {
-    const manager = createManager();
-    const throwingDriver = mockDriver();
-    throwingDriver.stop = () => { throw new Error('boom'); };
-    injectSession(manager, { sessionId: 's1', driver: throwingDriver });
-    // Should not throw
-    manager.shutdown();
-});
-// ── handle: session.approve ───────────────────────────────────────────
-test('session.approve: calls driver.respondApproval and replies ok', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 's1', driver });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req1',
-        sessionId: 's1',
-        requestId: 'tool-1',
-        approved: true,
-    });
-    assert.deepEqual(driver.calls.respondApproval, [{ requestId: 'tool-1', approved: true }]);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.id, 'req1');
-});
-test('session.approve: retries Claude synthetic approval with one-turn acceptEdits even when driver is null', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        agent: 'claude',
-        driver: null,
-        active: false,
-        lastUserMessage: 'Please make the requested edit.',
-        syntheticApprovalRetries: {
-            'claude-permission-denial:toolu_1': { message: 'Please make the requested edit.', toolName: 'Write' },
-        },
-    });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req1',
-        sessionId: 's1',
-        requestId: 'claude-permission-denial:toolu_1',
-        approved: true,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.deepEqual(driver.calls.respondApproval, []);
-    assert.deepEqual(driver.calls.start, [{
-            cwd: '/tmp',
-            resumeSessionId: 's1',
-            approvalMode: 'acceptEdits',
-        }]);
-    assert.deepEqual(driver.calls.sendPrompt, ['Please make the requested edit.']);
-    assert.equal(session.driver, driver);
-    assert.equal(session.active, true);
-    assert.equal(session.isResponding, true);
-    assert.deepEqual(session.syntheticApprovalRetries, {});
-});
-test('session.approve: resolves Claude hook approval without driver.respondApproval', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'hook-approve-1',
-        agent: 'claude',
-        driver,
-        claudeHookSecret: 'secret-1',
-    });
-    manager.claudeHookSessions.set('secret-1', session);
-    const hookPromise = manager.handleClaudePermissionHook('secret-1', {
-        tool_name: 'Bash',
-        tool_input: { command: 'pwd' },
-        tool_use_id: 'toolu_1',
-    });
-    assert.deepEqual(session.pendingApproval, {
-        requestId: 'claude-hook:toolu_1',
-        toolName: 'Bash',
-        input: { command: 'pwd' },
-        description: 'Claude requested permissions to use Bash.',
-    });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req-hook-approve',
-        sessionId: 'hook-approve-1',
-        requestId: 'claude-hook:toolu_1',
-        approved: true,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.deepEqual(driver.calls.respondApproval, []);
-    assert.equal(session.pendingApproval, undefined);
-    assert.equal(session.isResponding, true);
-    assert.deepEqual(await hookPromise, {
-        continue: true,
-        suppressOutput: true,
-        hookSpecificOutput: {
-            hookEventName: 'PreToolUse',
-            permissionDecision: 'allow',
-        },
-    });
-});
-test('session.approve: Claude hook approval still resolves after switching to autoApprove during pending approval', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'hook-approve-yolo-1',
-        agent: 'claude',
-        approvalMode: 'normal',
-        driver,
-        claudeHookSecret: 'secret-yolo-1',
-    });
-    manager.claudeHookSessions.set('secret-yolo-1', session);
-    const hookPromise = manager.handleClaudePermissionHook('secret-yolo-1', {
-        tool_name: 'Bash',
-        tool_input: { command: 'pwd' },
-        tool_use_id: 'toolu_yolo_1',
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req-hook-mode',
-        sessionId: 'hook-approve-yolo-1',
-        approvalMode: 'autoApprove',
-    });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req-hook-approve-yolo',
-        sessionId: 'hook-approve-yolo-1',
-        requestId: 'claude-hook:toolu_yolo_1',
-        approved: true,
-    });
-    const modeReply = parseReply(ws, 0);
-    const approveReply = parseReply(ws, 1);
-    assert.equal(modeReply.ok, true);
-    assert.equal(approveReply.ok, true);
-    assert.equal(session.approvalMode, 'autoApprove');
-    assert.equal(session.driver, driver);
-    assert.equal(driver.calls.stop.length, 0);
-    assert.deepEqual(driver.calls.setApprovalMode, ['autoApprove']);
-    assert.deepEqual(driver.calls.respondApproval, []);
-    assert.equal(session.pendingApproval, undefined);
-    assert.equal(session.isResponding, true);
-    assert.deepEqual(await hookPromise, {
-        continue: true,
-        suppressOutput: true,
-        hookSpecificOutput: {
-            hookEventName: 'PreToolUse',
-            permissionDecision: 'allow',
-        },
-    });
-});
-test('handleClaudePermissionHook auto-approves autoApprove sessions', async () => {
-    const manager = createManager();
-    const session = injectSession(manager, {
-        sessionId: 'hook-auto-1',
-        agent: 'claude',
-        approvalMode: 'autoApprove',
-        claudeHookSecret: 'secret-auto',
-    });
-    manager.claudeHookSessions.set('secret-auto', session);
-    const response = await manager.handleClaudePermissionHook('secret-auto', {
-        tool_name: 'Write',
-        tool_input: { file_path: '/tmp/a.txt' },
-        tool_use_id: 'toolu_auto',
-    });
-    assert.deepEqual(response, {
-        continue: true,
-        suppressOutput: true,
-        hookSpecificOutput: {
-            hookEventName: 'PreToolUse',
-            permissionDecision: 'allow',
-        },
-    });
-    assert.equal(session.pendingApproval, undefined);
-    assert.equal(session.pendingClaudeHookApprovals.size, 0);
-});
-test('session.approve: returns error if session not found', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req1',
-        sessionId: 'nonexistent',
-        requestId: 'tool-1',
-        approved: true,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found or inactive');
-});
-test('session.approve: returns error if driver is null', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, { sessionId: 's1', driver: null });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req1',
-        sessionId: 's1',
-        requestId: 'tool-1',
-        approved: false,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found or inactive');
-});
-test('session.approve: returns error when respondApproval fails (stdin not writable)', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    // Override respondApproval to return false (simulates stdin not writable)
-    driver.respondApproval = (requestId, approved) => {
-        driver.calls.respondApproval.push({ requestId, approved });
-        return false;
-    };
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        driver,
-        pendingApproval: {
-            requestId: 'tool-1',
-            toolName: 'Bash',
-            input: {},
-            description: 'Need approval',
-        },
-    });
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'req1',
-        sessionId: 's1',
-        requestId: 'tool-1',
-        approved: true,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /not running/i);
-    assert.deepEqual(session.pendingApproval, {
-        requestId: 'tool-1',
-        toolName: 'Bash',
-        input: {},
-        description: 'Need approval',
-    });
-});
-// ── handle: session.interrupt ─────────────────────────────────────────
-test('session.interrupt: calls driver.interrupt and replies ok', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 's1', driver });
-    await manager.handle(ws, {
-        action: 'session.interrupt',
-        id: 'req1',
-        sessionId: 's1',
-    });
-    assert.equal(driver.calls.interrupt.length, 1);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('session.interrupt: returns error if session not found', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.interrupt',
-        id: 'req1',
-        sessionId: 'nonexistent',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found or inactive');
-});
-// ── handle: session.stop ──────────────────────────────────────────────
-test('session.stop: stops driver, sets active=false and driver=null', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, { sessionId: 's1', driver });
-    await manager.handle(ws, {
-        action: 'session.stop',
-        id: 'req1',
-        sessionId: 's1',
-    });
-    assert.equal(driver.calls.stop.length, 1);
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('session.stop: returns error if session not found', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.stop',
-        id: 'req1',
-        sessionId: 'nonexistent',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found');
-});
-test('session.stop: works when driver is already null', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const session = injectSession(manager, { sessionId: 's1', driver: null });
-    await manager.handle(ws, {
-        action: 'session.stop',
-        id: 'req1',
-        sessionId: 's1',
-    });
-    assert.equal(session.active, false);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-// ── handle: session.delete ────────────────────────────────────────────
-test('session.delete: stops driver and removes session from map', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 's1', driver });
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req1',
-        sessionId: 's1',
-    });
-    assert.equal(driver.calls.stop.length, 1);
-    assert.equal(manager.sessions.has('s1'), false);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('session.delete: replies ok even if session does not exist', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req1',
-        sessionId: 'nonexistent',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('session.delete: removes record from sessionRecords', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.store.records = [
-        { sessionId: 's1', agent: 'codex', cwd: '/tmp', title: 'T', createdAt: '', lastActivityAt: '' },
-        { sessionId: 's2', agent: 'codex', cwd: '/tmp', title: 'T', createdAt: '', lastActivityAt: '' },
-    ];
-    injectSession(manager, { sessionId: 's1' });
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req1',
-        sessionId: 's1',
-    });
-    const records = manager.store.records;
-    assert.equal(records.length, 1);
-    assert.equal(records[0].sessionId, 's2');
-    assert.equal(manager.store.isDeleted('s1'), true);
-});
-// ── sendHistory ───────────────────────────────────────────────────────
-test('sendHistory: adds ws to session.clients for reconnection', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const session = injectSession(manager, { sessionId: 's1' });
-    assert.equal(session.clients.has(ws), false);
-    await manager.handle(ws, {
-        action: 'session.history',
-        id: 'req1',
-        sessionId: 's1',
-        agent: 'codex',
-    });
-    assert.equal(session.clients.has(ws), true);
-});
-test('sendHistory: includes the current partial reply for active responding sessions', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 's1',
-        isResponding: true,
-        currentReplyText: 'still streaming',
-        acceptedClientMessageIds: ['cm-streaming'],
-    });
-    await manager.handle(ws, {
-        action: 'session.history',
-        id: 'req-partial',
-        sessionId: 's1',
-        agent: 'codex',
-    });
-    const historyMsg = JSON.parse(ws.sent[0]);
-    assert.equal(historyMsg.type, 'session.history');
-    assert.equal(historyMsg.partialReplyText, 'still streaming');
-    assert.deepEqual(historyMsg.acceptedClientMessageIds, ['cm-streaming']);
-});
-test('sendHistory: infers responding state for external Claude sessions from transcript history', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const tempHome = await mkdtemp(join(tmpdir(), 'vibelet-manager-home-'));
-    const projectDir = join(tempHome, '.claude', 'projects', '-test');
-    await mkdir(projectDir, { recursive: true });
-    await writeFile(join(projectDir, 'external-claude.jsonl'), [
-        JSON.stringify({ type: 'user', cwd: '/test', sessionId: 'external-claude', message: { role: 'user', content: 'Check types' } }),
-        JSON.stringify({
-            type: 'assistant',
-            message: {
-                role: 'assistant',
-                stop_reason: null,
-                content: [{ type: 'text', text: 'Typecheck is still running' }],
-            },
-        }),
-    ].join('\n') + '\n', 'utf-8');
-    const originalHome = process.env.HOME;
-    process.env.HOME = tempHome;
-    try {
-        manager.store.upsert({
-            sessionId: 'external-claude',
-            agent: 'claude',
-            cwd: '/test',
-            title: 'External Claude',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-        });
-        await manager.handle(ws, {
-            action: 'session.history',
-            id: 'req-external-history',
-            sessionId: 'external-claude',
-            agent: 'claude',
-        });
-        const historyMsg = JSON.parse(ws.sent[0]);
-        assert.equal(historyMsg.type, 'session.history');
-        assert.equal(historyMsg.isResponding, true);
-        assert.equal(historyMsg.partialReplyText, 'Typecheck is still running');
-    }
-    finally {
-        process.env.HOME = originalHome;
-        await rm(tempHome, { recursive: true, force: true });
-    }
-});
-test('reconnect.snapshot: returns active session state for the current session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'snap-1',
-        agent: 'codex',
-        approvalMode: 'autoApprove',
-        isResponding: true,
-        currentReplyText: 'half reply',
-        acceptedClientMessageIds: ['cm-snap-1'],
-        pendingApproval: {
-            requestId: 'approval-1',
-            toolName: 'Bash',
-            input: { command: 'pwd' },
-            description: 'Run pwd',
-        },
-    });
-    await manager.handle(ws, {
-        action: 'reconnect.snapshot',
-        id: 'snap-req',
-        activeSessionId: 'snap-1',
-        activeAgent: 'codex',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.ok(reply.data.snapshot);
-    assert.equal(reply.data.snapshot.activeSession.sessionId, 'snap-1');
-    assert.equal(reply.data.snapshot.activeSession.agent, 'codex');
-    assert.equal(reply.data.snapshot.activeSession.approvalMode, 'autoApprove');
-    assert.equal(reply.data.snapshot.activeSession.isResponding, true);
-    assert.equal(reply.data.snapshot.activeSession.partialReplyText, 'half reply');
-    assert.deepEqual(reply.data.snapshot.activeSession.acceptedClientMessageIds, ['cm-snap-1']);
-    assert.equal(reply.data.snapshot.activeSession.pendingApproval.requestId, 'approval-1');
-    assert.equal(reply.data.snapshot.pendingApprovals[0].requestId, 'approval-1');
-    assert.equal(reply.data.snapshot.inventoryVersion, 0);
-});
-test('reconnect.snapshot: restores external Claude running state from transcript history', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const tempHome = await mkdtemp(join(tmpdir(), 'vibelet-manager-home-'));
-    const projectDir = join(tempHome, '.claude', 'projects', '-test');
-    await mkdir(projectDir, { recursive: true });
-    await writeFile(join(projectDir, 'snapshot-claude.jsonl'), [
-        JSON.stringify({ type: 'user', cwd: '/test', sessionId: 'snapshot-claude', message: { role: 'user', content: 'Inspect upload flow' } }),
-        JSON.stringify({
-            type: 'assistant',
-            message: {
-                role: 'assistant',
-                stop_reason: null,
-                content: [{ type: 'text', text: 'Still inspecting upload flow' }],
-            },
-        }),
-    ].join('\n') + '\n', 'utf-8');
-    const originalHome = process.env.HOME;
-    process.env.HOME = tempHome;
-    try {
-        manager.store.upsert({
-            sessionId: 'snapshot-claude',
-            agent: 'claude',
-            cwd: '/test',
-            title: 'Snapshot Claude',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-        });
-        await manager.handle(ws, {
-            action: 'reconnect.snapshot',
-            id: 'snap-external',
-            activeSessionId: 'snapshot-claude',
-            activeAgent: 'claude',
-        });
-        const reply = parseReply(ws);
-        assert.equal(reply.ok, true);
-        assert.equal(reply.data.snapshot.activeSession.sessionId, 'snapshot-claude');
-        assert.equal(reply.data.snapshot.activeSession.isResponding, true);
-        assert.equal(reply.data.snapshot.activeSession.partialReplyText, 'Still inspecting upload flow');
-    }
-    finally {
-        process.env.HOME = originalHome;
-        await rm(tempHome, { recursive: true, force: true });
-    }
-});
-test('reconnect.snapshot: returns pending approvals for non-active and persisted sessions', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'live-approval',
-        agent: 'claude',
-        pendingApproval: {
-            requestId: 'req-live',
-            toolName: 'Bash',
-            input: { command: 'pwd' },
-            description: 'Run pwd',
-        },
-    });
-    manager.store.upsert({
-        sessionId: 'stored-approval',
-        agent: 'codex',
-        cwd: '/tmp',
-        title: 'Stored session',
-        createdAt: '2026-03-20T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T00:00:00.000Z',
-        pendingApproval: {
-            requestId: 'req-stored',
-            toolName: 'Bash',
-            input: { command: 'ls' },
-            description: 'Run ls',
-            approvalContext: {
-                provider: 'codex',
-                kind: 'command-execution',
-                rpcId: 77,
-            },
-        },
-    });
-    await manager.handle(ws, {
-        action: 'reconnect.snapshot',
-        id: 'snap-all',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    const pendingApprovals = reply.data.snapshot.pendingApprovals;
-    assert.ok(Array.isArray(pendingApprovals));
-    assert.ok(pendingApprovals.some((approval) => approval.requestId === 'req-live' && approval.sessionId === 'live-approval'));
-    assert.ok(pendingApprovals.some((approval) => approval.requestId === 'req-stored' && approval.sessionId === 'stored-approval'));
-});
-test('reconnect.snapshot: omits deleted activeSessionId', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.store.remove('deleted-active');
-    await manager.handle(ws, {
-        action: 'reconnect.snapshot',
-        id: 'snap-deleted',
-        activeSessionId: 'deleted-active',
-        activeAgent: 'codex',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.ok(reply.data.snapshot);
-    assert.equal(reply.data.snapshot.activeSession, undefined);
-});
-test('reconnect.snapshot: subscribes ws to active session broadcasts', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const session = injectSession(manager, {
-        sessionId: 'snap-sub',
-        agent: 'claude',
-        isResponding: true,
-        currentReplyText: 'streaming...',
-    });
-    // ws should NOT be in clients before snapshot
-    assert.equal(session.clients.has(ws), false);
-    await manager.handle(ws, {
-        action: 'reconnect.snapshot',
-        id: 'snap-sub-req',
-        activeSessionId: 'snap-sub',
-        activeAgent: 'claude',
-    });
-    // After snapshot, ws should be subscribed to the session's broadcast list
-    assert.equal(session.clients.has(ws), true);
-    // Verify broadcasts now reach the reconnected ws
-    ws.sent.length = 0; // clear snapshot reply
-    const delta = { type: 'text.delta', sessionId: 'snap-sub', content: 'more text' };
-    manager.broadcast('snap-sub', delta);
-    assert.equal(ws.sent.length, 1);
-    assert.deepEqual(JSON.parse(ws.sent[0]), delta);
-});
-test('sendHistory: works when session does not exist in sessions map', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    // Should not throw; will just send empty history + response
-    await manager.handle(ws, {
-        action: 'session.history',
-        id: 'req1',
-        sessionId: 'nonexistent',
-        agent: 'codex',
-    });
-    // Should have sent something (history msg + reply)
-    assert.ok(ws.sent.length >= 1);
-});
-test('sendHistory: rejects deleted sessions that are no longer active', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.store.remove('deleted-history');
-    await manager.handle(ws, {
-        action: 'session.history',
-        id: 'req-deleted-history',
-        sessionId: 'deleted-history',
-        agent: 'codex',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found');
-});
-// ── activeSessionSnapshots ────────────────────────────────────────────
-test('activeSessionSnapshots: excludes pending_ sessions', () => {
-    const manager = createManager();
-    injectSession(manager, { sessionId: 'pending_abc', title: 'Pending' });
-    injectSession(manager, { sessionId: 'real-session', title: 'Real' });
-    const snapshots = manager.activeSessionSnapshots();
-    assert.equal(snapshots.length, 1);
-    assert.equal(snapshots[0].sessionId, 'real-session');
-});
-test('activeSessionSnapshots: returns correct snapshot fields', () => {
-    const manager = createManager();
-    injectSession(manager, {
-        sessionId: 'sess-1',
-        agent: 'claude',
-        cwd: '/home/user/project',
-        title: 'My session',
-        createdAt: '2026-03-20T01:00:00.000Z',
-        lastActivityAt: '2026-03-20T02:00:00.000Z',
-    });
-    const snapshots = manager.activeSessionSnapshots();
-    assert.equal(snapshots.length, 1);
-    assert.deepEqual(snapshots[0], {
-        sessionId: 'sess-1',
-        agent: 'claude',
-        cwd: '/home/user/project',
-        approvalMode: undefined,
-        title: 'My session',
-        createdAt: '2026-03-20T01:00:00.000Z',
-        lastActivityAt: '2026-03-20T02:00:00.000Z',
-        managed: undefined,
-    });
-});
-// ── reply ─────────────────────────────────────────────────────────────
-test('reply: does not send if ws is closed', () => {
-    const manager = createManager();
-    const ws = mockWs(false); // readyState = 3
-    manager.reply(ws, 'req1', true, { some: 'data' });
-    assert.equal(ws.sent.length, 0);
-});
-test('reply: sends correct response structure', () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.reply(ws, 'req1', false, undefined, 'oops');
-    const msg = parseReply(ws);
-    assert.equal(msg.type, 'response');
-    assert.equal(msg.id, 'req1');
-    assert.equal(msg.ok, false);
-    assert.equal(msg.error, 'oops');
-});
-// ── bindDriverLifecycle ───────────────────────────────────────────────
-test('bindDriverLifecycle: onExit sets session inactive and driver null', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const session = injectSession(manager, { sessionId: 's1', driver });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    driver._emitExit(0);
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-});
-test('bindDriverLifecycle: onMessage broadcasts to clients', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const ws = mockWs();
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    const msg = { type: 'text.delta', sessionId: 's1', content: 'hi' };
-    driver._emitMessage(msg);
-    assert.equal(ws.sent.length, 1);
-    assert.deepEqual(JSON.parse(ws.sent[0]), msg);
-});
-test('bindDriverLifecycle: remaps session ID when driver reports a new one', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const ws = mockWs();
-    const session = injectSession(manager, {
-        sessionId: 'old-id',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'codex', '', ws);
-    // Driver reports a message with a different sessionId
-    driver._emitMessage({ type: 'session.done', sessionId: 'new-id' });
-    // Session should be remapped
-    assert.equal(manager.sessions.has('old-id'), false);
-    assert.equal(manager.sessions.has('new-id'), true);
-    assert.equal(session.sessionId, 'new-id');
-});
-test('bindDriverLifecycle: does not remap if new sessionId already exists', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 'existing-id' });
-    const session = injectSession(manager, { sessionId: 'current-id', driver });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    // Driver reports sessionId that already exists as another session
-    driver._emitMessage({ type: 'session.done', sessionId: 'existing-id' });
-    // Should NOT remap because existing-id already exists
-    assert.equal(manager.sessions.has('current-id'), true);
-    assert.equal(session.sessionId, 'current-id');
-});
-test('bindDriverLifecycle: does not remap for response type messages', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const session = injectSession(manager, { sessionId: 'my-id', driver });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    // response messages should not trigger remapping
-    driver._emitMessage({ type: 'response', id: 'r1', ok: true, sessionId: 'different-id' });
-    assert.equal(session.sessionId, 'my-id');
-});
-// ── sendMessage (direct, active session) ─────────────────────────────
-test('sendMessage: sends prompt to active session driver', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 's1', driver });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 's1',
-        message: 'hello',
-    });
-    assert.deepEqual(driver.calls.sendPrompt, ['hello']);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('sendMessage: appends attached image paths to the prompt', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, { sessionId: 's-images', driver });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req-images',
-        sessionId: 's-images',
-        message: 'Please review these screenshots',
-        images: ['/tmp/one.heic', '/tmp/two.png'],
-    });
-    assert.deepEqual(driver.calls.sendPrompt, [
-        'Please review these screenshots\n\n[Attached image: /tmp/one.heic]\n[Attached image: /tmp/two.png]',
-    ]);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('sendMessage: buffers follow-up prompts while the session is already responding', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 's-buffered',
-        driver,
-        isResponding: true,
-        currentReplyText: 'current reply',
-        lastUserMessage: 'current prompt',
-    });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req-buffered',
-        sessionId: 's-buffered',
-        message: 'follow-up prompt',
-        clientMessageId: 'cm-buffered',
-    });
-    assert.deepEqual(driver.calls.sendPrompt, []);
-    assert.deepEqual(session.bufferedPrompts, ['follow-up prompt']);
-    assert.equal(session.currentReplyText, 'current reply');
-    assert.equal(session.lastUserMessage, 'current prompt');
-    assert.deepEqual(session.acceptedClientMessageIds, ['cm-buffered']);
-    driver._emitMessage({ type: 'session.done', sessionId: 's-buffered' });
-    assert.deepEqual(driver.calls.sendPrompt, ['follow-up prompt']);
-    assert.equal(session.isResponding, true);
-    assert.equal(session.currentReplyText, '');
-    assert.equal(session.lastUserMessage, 'follow-up prompt');
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.deepEqual(reply.data, {
-        sessionId: 's-buffered',
-        clientMessageId: 'cm-buffered',
-    });
-});
-test('sendMessage: adds ws to session clients', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, { sessionId: 's1', driver });
-    assert.equal(session.clients.has(ws), false);
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 's1',
-        message: 'hello',
-    });
-    assert.equal(session.clients.has(ws), true);
-});
-test('sendMessage: updates fallback title from first message', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        driver,
-        title: 'New session', // fallback title
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 's1',
-        message: 'Fix the login bug in auth module',
-    });
-    assert.equal(session.title, 'Fix the login bug in auth module');
-});
-test('sendMessage: does not overwrite real title', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        driver,
-        title: 'My real title',
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 's1',
-        message: 'Some new message',
-    });
-    assert.equal(session.title, 'My real title');
-});
-test('sendMessage: returns error when session not found and no agent provided', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'nonexistent',
-        message: 'hello',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /not found/i);
-});
-test('sendMessage: reconnects from sessionRecords when session not in memory', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    // Put a record in sessionRecords
-    manager.store.records = [
-        {
-            sessionId: 'rec-1',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'Recorded',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-        },
-    ];
-    // Mock createDriver to return a mock driver
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'rec-1',
-        message: 'hello from reconnect',
-    });
-    assert.deepEqual(driver.calls.sendPrompt, ['hello from reconnect']);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    // Session should now be in memory
-    assert.equal(manager.sessions.has('rec-1'), true);
-});
-test('sendMessage: restores accepted client message ids from session records during auto-reconnect', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.store.records = [
-        {
-            sessionId: 'rec-dup',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'Recorded',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-            acceptedClientMessageIds: ['cm_saved'],
-        },
-    ];
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'rec-dup',
-        message: 'hello from reconnect',
-        clientMessageId: 'cm_saved',
-    });
-    assert.deepEqual(driver.calls.sendPrompt, []);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.duplicate, true);
-});
-test('sendMessage: dedupes replayed clientMessageId values', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        driver,
-        acceptedClientMessageIds: ['cm_1'],
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 's1',
-        message: 'hello',
-        clientMessageId: 'cm_1',
-    });
-    assert.deepEqual(driver.calls.sendPrompt, []);
-    assert.equal(session.acceptedClientMessageIds.length, 1);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.clientMessageId, 'cm_1');
-    assert.equal(reply.data.duplicate, true);
-});
-// ── touchSession ─────────────────────────────────────────────────────
-test('touchSession: updates lastActivityAt on active session', () => {
-    const manager = createManager();
-    const session = injectSession(manager, {
-        sessionId: 's1',
-        lastActivityAt: '2026-03-01T00:00:00.000Z',
-    });
-    const before = session.lastActivityAt;
-    manager.touchSession('s1');
-    assert.notEqual(session.lastActivityAt, before);
-});
-test('touchSession: updates lastActivityAt on session record', () => {
-    const manager = createManager();
-    manager.store.records = [
-        {
-            sessionId: 'rec-1',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'T',
-            createdAt: '2026-03-01T00:00:00.000Z',
-            lastActivityAt: '2026-03-01T00:00:00.000Z',
-        },
-    ];
-    manager.touchSession('rec-1');
-    const updated = manager.store.find('rec-1');
-    assert.notEqual(updated.lastActivityAt, '2026-03-01T00:00:00.000Z');
-});
-// ── persistRecord / removeRecord ─────────────────────────────────────
-test('store.upsert: adds new record to front of store', () => {
-    const manager = createManager();
-    const store = manager.store;
-    store.upsert({
-        sessionId: 's-new',
-        agent: 'claude',
-        cwd: '/project',
-        title: 'New Session',
-        createdAt: '2026-03-20T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T00:00:00.000Z',
-    });
-    const records = store.getAll();
-    assert.equal(records.length, 1);
-    assert.equal(records[0].sessionId, 's-new');
-    assert.equal(records[0].agent, 'claude');
-});
-test('store.upsert: updates existing record in place', () => {
-    const manager = createManager();
-    const store = manager.store;
-    store.records = [
-        { sessionId: 's1', agent: 'codex', cwd: '/old', title: 'Old', createdAt: '', lastActivityAt: '' },
-    ];
-    store.upsert({
-        sessionId: 's1',
-        agent: 'codex',
-        cwd: '/new',
-        title: 'Updated',
-        createdAt: '',
-        lastActivityAt: '',
-    });
-    const records = store.getAll();
-    assert.equal(records.length, 1);
-    assert.equal(records[0].cwd, '/new');
-    assert.equal(records[0].title, 'Updated');
-});
-test('store.remove: removes matching record', () => {
-    const manager = createManager();
-    const store = manager.store;
-    store.records = [
-        { sessionId: 's1', agent: 'codex', cwd: '/tmp', title: 'T1', createdAt: '', lastActivityAt: '' },
-        { sessionId: 's2', agent: 'codex', cwd: '/tmp', title: 'T2', createdAt: '', lastActivityAt: '' },
-    ];
-    store.remove('s1');
-    const records = store.getAll();
-    assert.equal(records.length, 1);
-    assert.equal(records[0].sessionId, 's2');
-});
-// ── createSession ────────────────────────────────────────────────────
-test('createSession: codex returns a pending session immediately', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const deferred = createDeferred();
-    const driver = mockDriver();
-    driver.start = async (cwd, resumeSessionId, approvalMode) => {
-        driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
-        return deferred.promise;
-    };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '/tmp',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.match(reply.data.sessionId, /^pending_/);
-    const session = manager.sessions.get(reply.data.sessionId);
-    assert.ok(session, 'session should be stored');
-    assert.equal(session.startupInProgress, true);
-    assert.deepEqual(driver.calls.start[0], { cwd: '/tmp', resumeSessionId: undefined, approvalMode: undefined });
-});
-test('createSession: stores approval mode', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/tmp',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    const session = manager.sessions.get(reply.data.sessionId);
-    assert.equal(session.approvalMode, 'autoApprove');
-});
-test('createSession: codex startup failure is reported inside the pending session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    driver.start = async () => { throw new Error('spawn failed'); };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '/tmp',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.match(reply.data.sessionId, /^pending_/);
-    await flushAsyncWork();
-    assert.equal(ws.sent.length, 2);
-    const errorMsg = JSON.parse(ws.sent[1]);
-    assert.equal(errorMsg.type, 'error');
-    assert.equal(errorMsg.sessionId, reply.data.sessionId);
-    assert.match(errorMsg.message, /spawn failed/);
-    const session = manager.sessions.get(reply.data.sessionId);
-    assert.ok(session, 'pending session should remain addressable');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-    assert.equal(session.startupInProgress, false);
-});
-test('createSession: adds ws to session clients', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const deferred = createDeferred();
-    const driver = mockDriver();
-    driver.start = async (cwd, resumeSessionId, approvalMode) => {
-        driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
-        return deferred.promise;
-    };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '/tmp',
-    });
-    const reply = parseReply(ws);
-    const session = manager.sessions.get(reply.data.sessionId);
-    assert.equal(session.clients.has(ws), true);
-});
-test('createSession: codex buffers the first prompt until startup completes, then remaps the session id', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const deferred = createDeferred();
-    const driver = mockDriver();
-    driver.start = async (cwd, resumeSessionId, approvalMode) => {
-        driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
-        return deferred.promise;
-    };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req-create',
-        agent: 'codex',
-        cwd: '/tmp',
-    });
-    const createReply = parseReply(ws);
-    const pendingSessionId = createReply.data.sessionId;
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req-send',
-        sessionId: pendingSessionId,
-        message: 'hello buffered codex',
-        clientMessageId: 'cm-buffered',
-    });
-    const sendReply = parseReply(ws, 1);
-    assert.equal(sendReply.ok, true);
-    assert.equal(sendReply.data.sessionId, pendingSessionId);
-    assert.deepEqual(driver.calls.sendPrompt, []);
-    const pendingSession = manager.sessions.get(pendingSessionId);
-    assert.deepEqual(pendingSession.bufferedPrompts, ['hello buffered codex']);
-    deferred.resolve('codex-thread-1');
-    await flushAsyncWork();
-    assert.equal(manager.sessions.has(pendingSessionId), false);
-    const liveSession = manager.sessions.get('codex-thread-1');
-    assert.ok(liveSession, 'resolved session should be stored under the real thread id');
-    assert.equal(liveSession.startupInProgress, false);
-    assert.deepEqual(driver.calls.sendPrompt, ['hello buffered codex']);
-    const idUpdate = JSON.parse(ws.sent[2]);
-    assert.equal(idUpdate.type, 'response');
-    assert.equal(idUpdate.ok, true);
-    assert.deepEqual(idUpdate.data, {
-        sessionId: 'codex-thread-1',
-        oldSessionId: pendingSessionId,
-    });
-});
-test('interrupt: clears buffered prompt while codex startup is still pending', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const deferred = createDeferred();
-    const driver = mockDriver();
-    driver.start = async (cwd, resumeSessionId, approvalMode) => {
-        driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
-        return deferred.promise;
-    };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req-create',
-        agent: 'codex',
-        cwd: '/tmp',
-    });
-    const createReply = parseReply(ws);
-    const pendingSessionId = createReply.data.sessionId;
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req-send',
-        sessionId: pendingSessionId,
-        message: 'stop me before startup finishes',
-        clientMessageId: 'cm-stop',
-    });
-    await manager.handle(ws, {
-        action: 'session.interrupt',
-        id: 'req-interrupt',
-        sessionId: pendingSessionId,
-    });
-    const pendingSession = manager.sessions.get(pendingSessionId);
-    assert.ok(pendingSession, 'pending session should still exist before startup resolves');
-    assert.deepEqual(pendingSession.bufferedPrompts, []);
-    assert.equal(pendingSession.isResponding, false);
-    assert.equal(pendingSession.currentReplyText, '');
-    assert.equal(pendingSession.lastUserMessage, undefined);
-    assert.deepEqual(driver.calls.interrupt, []);
-    const interruptReply = parseReply(ws, 2);
-    assert.equal(interruptReply.ok, true);
-    const interruptedEvent = parseReply(ws, 3);
-    assert.deepEqual(interruptedEvent, {
-        type: 'session.interrupted',
-        sessionId: pendingSessionId,
-    });
-    deferred.resolve('codex-thread-2');
-    await flushAsyncWork();
-    assert.deepEqual(driver.calls.sendPrompt, []);
-    assert.equal(manager.sessions.has(pendingSessionId), false);
-    const liveSession = manager.sessions.get('codex-thread-2');
-    assert.ok(liveSession, 'resolved session should still remap to the real thread id');
-    const idUpdate = parseReply(ws, 4);
-    assert.equal(idUpdate.type, 'response');
-    assert.equal(idUpdate.ok, true);
-    assert.deepEqual(idUpdate.data, {
-        sessionId: 'codex-thread-2',
-        oldSessionId: pendingSessionId,
-    });
-});
-test('createSession: continueSession=true creates new session when no previous sessions exist', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '/tmp',
-        continueSession: true,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.ok(reply.data.sessionId);
-});
-test('createSession: continueSession=true skips deleted recent sessions', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    manager.listRecentSessionsForContinue = async () => [
-        {
-            sessionId: 'deleted-recent',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'Deleted recent',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-21T00:00:00.000Z',
-            sources: ['scanner'],
-            runtime: { state: 'idle', confidence: 'high', resumeMode: 'resumeSession' },
-        },
-        {
-            sessionId: 'kept-recent',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'Kept recent',
-            createdAt: '2026-03-19T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-            sources: ['scanner'],
-            runtime: { state: 'idle', confidence: 'high', resumeMode: 'resumeSession' },
-        },
-    ];
-    manager.store.remove('deleted-recent');
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req-skip-deleted',
-        agent: 'codex',
-        cwd: '/tmp',
-        continueSession: true,
-    });
-    assert.deepEqual(driver.calls.start[0], {
-        cwd: '/tmp',
-        resumeSessionId: 'kept-recent',
-        approvalMode: undefined,
-    });
-});
-test('createSession: expands tilde in cwd', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    let capturedCwd = '';
-    driver.start = async (cwd) => { capturedCwd = cwd; return 'sess-1'; };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '~',
-    });
-    // cwd should be expanded from ~ to absolute home directory path
-    assert.ok(!capturedCwd.startsWith('~'));
-    assert.ok(capturedCwd.startsWith('/'));
-});
-test('createSession: returns error for nonexistent cwd', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/nonexistent/path/that/does/not/exist',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /does not exist/i);
-    assert.equal(driver.calls.start.length, 0, 'driver should not be started');
-});
-test('createSession: returns error when cwd is a file, not a directory', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    // Use a known file path
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/etc/hosts',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /not a directory/i);
-    assert.equal(driver.calls.start.length, 0, 'driver should not be started');
-});
-// ── resumeSession ────────────────────────────────────────────────────
-test('resumeSession: attaches to existing active session without creating new driver', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, { sessionId: 's1', driver, active: true });
-    let driverCreated = false;
-    manager.createDriver = () => { driverCreated = true; return mockDriver(); };
-    await manager.handle(ws, {
-        action: 'session.resume',
-        id: 'req1',
-        sessionId: 's1',
-        agent: 'codex',
-    });
-    assert.equal(driverCreated, false);
-    assert.equal(session.clients.has(ws), true);
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('resumeSession: creates new driver for inactive session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.resume',
-        id: 'req1',
-        sessionId: 'new-session',
-        agent: 'claude',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(manager.sessions.has(reply.data.sessionId), true);
-});
-test('resumeSession: replies error when driver.start fails', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.createDriver = () => ({
-        ...mockDriver(),
-        start: async () => { throw new Error('resume failed'); },
-    });
-    await manager.handle(ws, {
-        action: 'session.resume',
-        id: 'req1',
-        sessionId: 'fail-session',
-        agent: 'codex',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /resume failed/);
-});
-// listDirs tests removed — dirs.list is now handled directly in index.ts
-// ── Additional coverage tests ─────────────────────────────────────────
-test('createSession: expands fullwidth tilde ～ in cwd', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    let capturedCwd = '';
-    driver.start = async (cwd) => { capturedCwd = cwd; return 'sess-1'; };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'codex',
-        cwd: '～', // fullwidth tilde
-    });
-    assert.ok(!capturedCwd.startsWith('～'));
-    assert.ok(!capturedCwd.startsWith('~'));
-    assert.ok(capturedCwd.startsWith('/'));
-});
-test('touchSession: updates record when session is not in active sessions map', () => {
-    const manager = createManager();
-    manager.store.records = [
-        {
-            sessionId: 'rec-only',
-            agent: 'codex',
-            cwd: '/tmp',
-            title: 'T',
-            createdAt: '2026-03-01T00:00:00.000Z',
-            lastActivityAt: '2026-03-01T00:00:00.000Z',
-        },
-    ];
-    // No active session for 'rec-only'
-    manager.touchSession('rec-only');
-    const updated = manager.store.find('rec-only');
-    assert.notEqual(updated.lastActivityAt, '2026-03-01T00:00:00.000Z');
-});
-test('touchSession: does nothing when session not found anywhere', () => {
-    const manager = createManager();
-    manager.store.records = [];
-    // Should not throw
-    manager.touchSession('nonexistent');
-});
-test('sendMessage: auto-reconnect uses agent from client message as last resort', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    // No sessionRecords, no scanner results, but agent is provided
-    manager.store.records = [];
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'unknown-session',
-        message: 'hello',
-        agent: 'codex',
-    });
-    // Should have attempted to reconnect using the provided agent
-    const reply = parseReply(ws);
-    // It might fail at driver.start() but it should try
-    // mock driver.start returns 'mock-session-id', so it should succeed
-    assert.equal(reply.ok, true);
-    assert.equal(manager.sessions.has('unknown-session'), true);
-});
-test('resumeSession: uses cwd and approvalMode from persisted record', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    let startCwd = '';
-    let startApproval = '';
-    driver.start = async (cwd, _id, approval) => {
-        startCwd = cwd;
-        startApproval = approval ?? '';
-        return 'resumed-id';
-    };
-    manager.createDriver = () => driver;
-    manager.store.records = [
-        {
-            sessionId: 'persisted-1',
-            agent: 'claude',
-            cwd: '/saved-cwd',
-            approvalMode: 'acceptEdits',
-            title: 'Saved',
-            createdAt: '2026-03-01T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-        },
-    ];
-    await manager.handle(ws, {
-        action: 'session.resume',
-        id: 'req1',
-        sessionId: 'persisted-1',
-        agent: 'claude',
-    });
-    assert.equal(startCwd, '/saved-cwd');
-    assert.equal(startApproval, 'acceptEdits');
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-// ── setApprovalMode ──────────────────────────────────────────────────
-test('setApprovalMode: updates session approvalMode and persists', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    driver.setApprovalMode = (mode) => {
-        driver.calls.setApprovalMode = driver.calls.setApprovalMode || [];
-        driver.calls.setApprovalMode.push(mode);
-    };
-    injectSession(manager, {
-        sessionId: 'am-1',
-        agent: 'claude',
-        approvalMode: 'normal',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-1',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.approvalMode, 'autoApprove');
-    const session = manager.sessions.get('am-1');
-    assert.equal(session.approvalMode, 'autoApprove');
-    assert.deepEqual(driver.calls.setApprovalMode, ['autoApprove']);
-});
-test('setApprovalMode: succeeds for session not in memory and not in store (untracked)', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'nonexistent',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.approvalMode, 'autoApprove');
-});
-test('setApprovalMode: updates store record for session not in memory but in store', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const store = manager.store;
-    store.records.push({
-        sessionId: 'stored-only',
-        agent: 'claude',
-        cwd: '/tmp',
-        title: 'Stored session',
-        createdAt: '2026-03-20T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T00:00:00.000Z',
-        approvalMode: 'normal',
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'stored-only',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.approvalMode, 'autoApprove');
-    const record = store.records.find((r) => r.sessionId === 'stored-only');
-    assert.equal(record.approvalMode, 'autoApprove');
-});
-test('setApprovalMode: updates active codex driver without restarting it', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'am-codex-1',
-        agent: 'codex',
-        approvalMode: 'normal',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-codex-1',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(driver.calls.stop.length, 0, 'driver should not be restarted');
-    assert.deepEqual(driver.calls.setApprovalMode, ['autoApprove']);
-});
-test('setApprovalMode: does not restart codex if mode unchanged', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    driver.setApprovalMode = () => { };
-    injectSession(manager, {
-        sessionId: 'am-codex-2',
-        agent: 'codex',
-        approvalMode: 'autoApprove',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-codex-2',
-        approvalMode: 'autoApprove',
-    });
-    assert.equal(driver.calls.stop.length, 0, 'driver should not be restarted');
-});
-// ── pendingApproval resend ───────────────────────────────────────────
-test('pending approval is tracked and resent on resume attach', async () => {
-    const manager = createManager();
-    const ws1 = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-1',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws1]),
-        isResponding: true,
-    });
-    // Simulate driver emitting an approval.request
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-1',
-        requestId: 'req-abc',
-        toolName: 'Bash',
-        input: { command: 'rm -rf /' },
-        description: 'Run dangerous command',
-    });
-    // Verify pendingApproval is tracked
-    assert.ok(session.pendingApproval);
-    assert.equal(session.pendingApproval.requestId, 'req-abc');
-    assert.equal(session.isResponding, false, 'approval.request should clear isResponding');
-    // New client reconnects via resumeSession (attach to active)
-    const ws2 = mockWs();
-    await manager.handle(ws2, {
-        action: 'session.resume',
-        id: 'resume-1',
-        sessionId: 'pa-1',
-        agent: 'claude',
-    });
-    // ws2 should receive the pending approval inside session.history
-    const historyMsg = ws2.sent
-        .map((s) => JSON.parse(s))
-        .find((m) => m.type === 'session.history');
-    assert.ok(historyMsg, 'reconnected client should receive session.history');
-    assert.equal(historyMsg.pendingApproval?.requestId, 'req-abc');
-    assert.equal(historyMsg.pendingApproval?.toolName, 'Bash');
-});
-test('autoApprove mode immediately resolves follow-up codex approvals without surfacing another sheet', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'codex-auto-approval',
-        agent: 'codex',
-        driver,
-        approvalMode: 'autoApprove',
-        clients: new Set([ws]),
-        isResponding: true,
-    });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'codex-auto-approval',
-        requestId: 'req-auto',
-        toolName: 'Bash',
-        input: { command: 'git status' },
-        description: 'Run git status',
-    });
-    assert.deepEqual(driver.calls.respondApproval, [{ requestId: 'req-auto', approved: true }]);
-    assert.equal(session.pendingApproval, undefined);
-    assert.equal(session.isResponding, true);
-    assert.equal(ws.sent.length, 0, 'approval request should not be broadcast when the session is already autoApprove');
-});
-test('approval.request sends a push notification with session routing data', async () => {
-    const pushCalls = [];
-    const manager = createManager((title, body, data) => {
-        pushCalls.push({ title, body, data });
-    });
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'push-approval',
-        agent: 'codex',
-        title: 'Deploy context',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'push-approval',
-        requestId: 'req-push',
-        toolName: 'Bash',
-        input: { command: 'ps -Ao pid,ppid,etime,command' },
-        description: 'Inspect the build process',
-    });
-    assert.deepEqual(pushCalls, [{
-            title: 'Approval required',
-            body: 'Deploy context: Inspect the build process',
-            data: {
-                sessionId: 'push-approval',
-                agent: 'codex',
-                eventType: 'approval_request',
-                requestId: 'req-push',
-            },
-        }]);
-});
-test('pending approval is cleared after user responds', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-2',
-        agent: 'codex',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'codex', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-2',
-        requestId: 'req-xyz',
-        toolName: 'Write',
-        input: {},
-        description: 'Write file',
-    });
-    assert.ok(session.pendingApproval);
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'approve-1',
-        sessionId: 'pa-2',
-        requestId: 'req-xyz',
-        approved: true,
-    });
-    assert.equal(session.pendingApproval, undefined, 'pendingApproval should be cleared after response');
-});
-test('session.approve: revives an inactive codex session before sending the approval response', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const revivedDriver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'pa-revive',
-        agent: 'codex',
-        driver: null,
-        active: false,
-        pendingApproval: {
-            requestId: 'req-revive',
-            toolName: 'Bash',
-            input: { command: 'ps -Ao pid,ppid,etime,command' },
-            description: 'Inspect process list',
-        },
-    });
-    manager.createDriver = () => revivedDriver;
-    await manager.handle(ws, {
-        action: 'session.approve',
-        id: 'approve-revive',
-        sessionId: 'pa-revive',
-        requestId: 'req-revive',
-        approved: true,
-    });
-    const reply = parseReply(ws);
-    const session = manager.sessions.get('pa-revive');
-    assert.equal(reply.ok, true);
-    assert.equal(revivedDriver.calls.start.length, 1);
-    assert.deepEqual(revivedDriver.calls.respondApproval, [{ requestId: 'req-revive', approved: true }]);
-    assert.equal(session.pendingApproval, undefined);
-    assert.equal(session.driver, revivedDriver);
-});
-test('pending approval is cleared on session.done', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-3',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-3',
-        requestId: 'req-done',
-        toolName: 'Edit',
-        input: {},
-        description: 'Edit file',
-    });
-    assert.ok(session.pendingApproval);
-    driver._emitMessage({
-        type: 'session.done',
-        sessionId: 'pa-3',
-    });
-    assert.equal(session.pendingApproval, undefined, 'pendingApproval should be cleared on session.done');
-});
-test('synthetic pending approval survives session.done', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-3-synth',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-3-synth',
-        requestId: 'claude-permission-denial:tu-1',
-        toolName: 'Edit',
-        input: {},
-        description: 'Edit file',
-    });
-    assert.ok(session.pendingApproval);
-    driver._emitMessage({
-        type: 'session.done',
-        sessionId: 'pa-3-synth',
-    });
-    assert.ok(session.pendingApproval, 'synthetic pendingApproval should survive session.done');
-});
-test('pending approval is cleared on driver exit', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-4',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-4',
-        requestId: 'req-exit',
-        toolName: 'Bash',
-        input: {},
-        description: 'Run command',
-    });
-    assert.ok(session.pendingApproval);
-    driver._emitExit(0);
-    assert.equal(session.pendingApproval, undefined, 'pendingApproval should be cleared on driver exit');
-});
-test('synthetic pending approval survives a clean driver exit', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-4-synth',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-4-synth',
-        requestId: 'claude-permission-denial:tu-2',
-        toolName: 'Bash',
-        input: {},
-        description: 'Run command',
-    });
-    assert.ok(session.pendingApproval);
-    driver._emitExit(0);
-    assert.ok(session.pendingApproval, 'synthetic pendingApproval should survive a clean driver exit');
-});
-// ── auto-reconnect approvalMode recovery ─────────────────────────────
-test('auto-reconnect recovers approvalMode from existing in-memory session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    let startApproval = '';
-    const driver = mockDriver();
-    driver.start = async (_cwd, _id, approval) => {
-        startApproval = approval ?? '';
-        return 'reconnect-1';
-    };
-    // Create a session that's inactive (driver null) but still in memory
-    injectSession(manager, {
-        sessionId: 'reconnect-1',
-        agent: 'claude',
-        approvalMode: 'autoApprove',
-        driver: null,
-        active: false,
-    });
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'reconnect-1',
-        message: 'hello',
-        agent: 'claude',
-    });
-    assert.equal(startApproval, 'autoApprove', 'auto-reconnect should recover approvalMode from in-memory session');
-});
-// ── additional edge cases ────────────────────────────────────────────
-test('setApprovalMode: works on session with no active driver', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'am-nodriver',
-        agent: 'claude',
-        approvalMode: 'normal',
-        driver: null,
-        active: false,
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-nodriver',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    const session = manager.sessions.get('am-nodriver');
-    assert.equal(session.approvalMode, 'autoApprove');
-});
-test('setApprovalMode: persists to session store', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'am-persist',
-        agent: 'claude',
-        approvalMode: 'normal',
-        driver: null,
-        active: false,
-    });
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-persist',
-        approvalMode: 'acceptEdits',
-    });
-    const record = manager.store.find('am-persist');
-    assert.ok(record, 'store should have the session record');
-    assert.equal(record.approvalMode, 'acceptEdits', 'store record should reflect updated mode');
-});
-test('pending approval resent via sendHistory', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-history',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-        pendingApproval: {
-            requestId: 'req-hist',
-            toolName: 'Grep',
-            input: { pattern: 'foo' },
-            description: 'Search for foo',
-        },
-    });
-    const ws2 = mockWs();
-    await manager.handle(ws2, {
-        action: 'session.history',
-        id: 'hist-1',
-        sessionId: 'pa-history',
-        agent: 'claude',
-    });
-    const historyMsg = ws2.sent
-        .map((s) => JSON.parse(s))
-        .find((m) => m.type === 'session.history');
-    assert.ok(historyMsg, 'sendHistory should return session.history');
-    assert.equal(historyMsg.pendingApproval?.requestId, 'req-hist');
-    assert.equal(historyMsg.pendingApproval?.toolName, 'Grep');
-});
-test('sendHistory skips closed WebSocket clients', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'pa-closed',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-        pendingApproval: {
-            requestId: 'req-closed',
-            toolName: 'Bash',
-            input: {},
-            description: 'Run command',
-        },
-    });
-    const closedWs = mockWs(false);
-    await manager.handle(closedWs, {
-        action: 'session.history',
-        id: 'hist-closed',
-        sessionId: 'pa-closed',
-        agent: 'claude',
-    });
-    assert.equal(closedWs.sent.length, 0, 'should not send to closed WebSocket');
-});
-test('later approval.request overwrites previous pendingApproval', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-overwrite',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-overwrite',
-        requestId: 'req-first',
-        toolName: 'Bash',
-        input: {},
-        description: 'First request',
-    });
-    assert.equal(session.pendingApproval.requestId, 'req-first');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-overwrite',
-        requestId: 'req-second',
-        toolName: 'Write',
-        input: {},
-        description: 'Second request',
-    });
-    assert.equal(session.pendingApproval.requestId, 'req-second', 'should track only the latest approval');
-});
-test('pending approval cleared on session.interrupted', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    const session = injectSession(manager, {
-        sessionId: 'pa-interrupt',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    manager.bindDriverLifecycle(session, 'claude', '');
-    driver._emitMessage({
-        type: 'approval.request',
-        sessionId: 'pa-interrupt',
-        requestId: 'req-int',
-        toolName: 'Bash',
-        input: {},
-        description: 'Run command',
-    });
-    assert.ok(session.pendingApproval);
-    driver._emitMessage({
-        type: 'session.interrupted',
-        sessionId: 'pa-interrupt',
-    });
-    assert.equal(session.pendingApproval, undefined, 'pendingApproval should be cleared on session.interrupted');
-});
-test('setApprovalMode: codex mode change keeps the active session intact', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'am-fail',
-        agent: 'codex',
-        approvalMode: 'normal',
-        driver,
-    });
-    manager.createDriver = () => {
-        throw new Error('createDriver should not be called when switching codex approval mode');
-    };
-    await manager.handle(ws, {
-        action: 'session.setApprovalMode',
-        id: 'req1',
-        sessionId: 'am-fail',
-        approvalMode: 'autoApprove',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    const session = manager.sessions.get('am-fail');
-    assert.equal(session.active, true);
-    assert.equal(session.driver, driver);
-});
-// ── createSession via handle() ───────────────────────────────────────
-test('createSession: full flow via handle() creates session and replies', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/tmp',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(reply.data.sessionId, 'mock-session-id');
-    const session = manager.sessions.get('mock-session-id');
-    assert.ok(session, 'session should be stored');
-    assert.equal(session.agent, 'claude');
-    assert.equal(session.cwd, '/tmp');
-    assert.equal(session.active, true);
-});
-test('createSession: passes approvalMode to driver.start', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/tmp',
-        approvalMode: 'autoApprove',
-    });
-    assert.deepEqual(driver.calls.start[0], { cwd: '/tmp', resumeSessionId: undefined, approvalMode: 'autoApprove' });
-});
-test('createSession: driver.start failure returns error reply', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    driver.start = async () => { throw new Error('spawn failed'); };
-    manager.createDriver = () => driver;
-    await manager.handle(ws, {
-        action: 'session.create',
-        id: 'req1',
-        agent: 'claude',
-        cwd: '/tmp',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /spawn failed/);
-});
-// ── sendMessage via handle() ─────────────────────────────────────────
-test('sendMessage: sends prompt to active driver', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'sm-1',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'sm-1',
-        message: 'hello world',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.deepEqual(driver.calls.sendPrompt, ['hello world']);
-});
-test('sendMessage: sets isResponding and lastUserMessage', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'sm-2',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'sm-2',
-        message: 'test prompt',
-    });
-    const session = manager.sessions.get('sm-2');
-    assert.equal(session.isResponding, true);
-    assert.equal(session.lastUserMessage, 'test prompt');
-});
-test('sendMessage: deduplicates by clientMessageId', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'sm-dedup',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req1',
-        sessionId: 'sm-dedup',
-        message: 'hello',
-        clientMessageId: 'cmid-1',
-    });
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req2',
-        sessionId: 'sm-dedup',
-        message: 'hello',
-        clientMessageId: 'cmid-1',
-    });
-    assert.equal(driver.calls.sendPrompt.length, 1, 'duplicate message should not be sent');
-    const reply2 = parseReply(ws, 1);
-    assert.equal(reply2.data.duplicate, true);
-});
-test('sendMessage: rejects deleted sessions before reconnecting', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.store.remove('deleted-send');
-    await manager.handle(ws, {
-        action: 'session.send',
-        id: 'req-deleted-send',
-        sessionId: 'deleted-send',
-        agent: 'codex',
-        message: 'hello',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found');
-});
-test('sessions.list: filters deleted sessions at manager layer', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const cwd = '/tmp/session-list-test';
-    manager.store.records = [
-        {
-            sessionId: 'deleted-list',
-            agent: 'codex',
-            cwd,
-            title: 'Deleted list',
-            createdAt: '2026-03-20T00:00:00.000Z',
-            lastActivityAt: '2026-03-20T00:00:00.000Z',
-        },
-        {
-            sessionId: 'kept-list',
-            agent: 'codex',
-            cwd,
-            title: 'Kept list',
-            createdAt: '2026-03-19T00:00:00.000Z',
-            lastActivityAt: '2026-03-19T00:00:00.000Z',
-        },
-    ];
-    manager.store.deletedSessionIds.add('deleted-list');
-    await manager.handle(ws, {
-        action: 'sessions.list',
-        id: 'req-list',
-        cwd,
-        limit: 20,
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    const ids = reply.data.sessions.map((session) => session.sessionId);
-    assert.ok(ids.includes('kept-list'));
-    assert.ok(!ids.includes('deleted-list'));
-    assert.equal(reply.data.inventoryVersion, 0);
-});
-// ── stopSession ──────────────────────────────────────────────────────
-test('stopSession: stops driver and marks session inactive', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'stop-1',
-        agent: 'codex',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.stop',
-        id: 'req1',
-        sessionId: 'stop-1',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(driver.calls.stop.length, 1);
-    const session = manager.sessions.get('stop-1');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-});
-test('stopSession: returns error for unknown session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.stop',
-        id: 'req1',
-        sessionId: 'nonexistent',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.match(reply.error, /not found/i);
-});
-// ── deleteSession ────────────────────────────────────────────────────
-test('deleteSession: removes session from map and store', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'del-1',
-        agent: 'claude',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req1',
-        sessionId: 'del-1',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(driver.calls.stop.length, 1);
-    assert.equal(manager.sessions.has('del-1'), false, 'session should be removed from map');
-});
-test('deleteSession: succeeds even for unknown session', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    await manager.handle(ws, {
-        action: 'session.delete',
-        id: 'req1',
-        sessionId: 'nonexistent',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-});
-test('resumeSession: rejects deleted sessions', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    manager.store.remove('deleted-resume');
-    await manager.handle(ws, {
-        action: 'session.resume',
-        id: 'req1',
-        sessionId: 'deleted-resume',
-        agent: 'codex',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-    assert.equal(reply.error, 'Session not found');
-});
-// ── interrupt ────────────────────────────────────────────────────────
-test('interrupt: calls driver.interrupt()', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'int-1',
-        agent: 'claude',
-        driver,
-    });
-    await manager.handle(ws, {
-        action: 'session.interrupt',
-        id: 'req1',
-        sessionId: 'int-1',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, true);
-    assert.equal(driver.calls.interrupt.length, 1);
-});
-test('interrupt: returns error for session without driver', async () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'int-2',
-        agent: 'claude',
-        driver: null,
-        active: false,
-    });
-    await manager.handle(ws, {
-        action: 'session.interrupt',
-        id: 'req1',
-        sessionId: 'int-2',
-    });
-    const reply = parseReply(ws);
-    assert.equal(reply.ok, false);
-});
-// ── sweepIdleSessions ────────────────────────────────────────────────
-test('sweepIdleSessions: stops idle drivers beyond timeout', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'idle-1',
-        agent: 'claude',
-        driver,
-        lastActivityTs: Date.now() - 60 * 60 * 1000, // 1 hour ago
-        isResponding: false,
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 1, 'idle driver should be stopped');
-    const session = manager.sessions.get('idle-1');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-});
-test('sweepIdleSessions: does not stop sessions within timeout', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'active-1',
-        agent: 'claude',
-        driver,
-        lastActivityTs: Date.now() - 1000, // 1 second ago
-        isResponding: false,
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 0, 'recent session should not be stopped');
-});
-test('sweepIdleSessions: stops stalled responding sessions beyond timeout', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'responding-stalled-1',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-        lastActivityTs: Date.now() - 60 * 60 * 1000, // 1 hour ago
-        isResponding: true,
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 1, 'stalled responding session should be stopped');
-    const session = manager.sessions.get('responding-stalled-1');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-    const errorMsg = ws.sent
-        .map((entry) => JSON.parse(entry))
-        .find((msg) => msg.type === 'error');
-    assert.ok(errorMsg, 'stalled turn should broadcast an error');
-    assert.match(errorMsg.message, /stopped responding/i);
-});
-test('sweepIdleSessions: does not stop responding sessions waiting for approval', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'responding-approval-1',
-        agent: 'claude',
-        driver,
-        lastActivityTs: Date.now() - 60 * 60 * 1000, // 1 hour ago
-        isResponding: true,
-        pendingApproval: {
-            requestId: 'req-pending',
-            toolName: 'Write',
-            input: {},
-            description: 'Write file',
-        },
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 0, 'pending approval should not be treated as a stalled turn');
-});
-test('sweepIdleSessions: does not stop idle sessions waiting for approval', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'idle-approval-1',
-        agent: 'codex',
-        driver,
-        lastActivityTs: Date.now() - 60 * 60 * 1000,
-        isResponding: false,
-        pendingApproval: {
-            requestId: 'req-idle',
-            toolName: 'Bash',
-            input: { command: 'pwd' },
-            description: 'Run pwd',
-            approvalContext: {
-                provider: 'codex',
-                kind: 'command-execution',
-                rpcId: 88,
-            },
-        },
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 0, 'pending approval should bypass idle timeout');
-    const session = manager.sessions.get('idle-approval-1');
-    assert.equal(session.active, true);
-});
-test('sweepIdleSessions: honors disabled stall timeout', () => {
-    const originalTurnStallTimeoutMs = config.turnStallTimeoutMs;
-    config.turnStallTimeoutMs = 0;
-    try {
-        const manager = createManager();
-        const driver = mockDriver();
-        injectSession(manager, {
-            sessionId: 'responding-disabled-1',
-            agent: 'claude',
-            driver,
-            lastActivityTs: Date.now() - 60 * 60 * 1000, // 1 hour ago
-            isResponding: true,
-        });
-        manager.sweepIdleSessions();
-        assert.equal(driver.calls.stop.length, 0, 'disabled stall timeout should skip responding sessions');
-    }
-    finally {
-        config.turnStallTimeoutMs = originalTurnStallTimeoutMs;
-    }
-});
-test('sweepIdleSessions: skips sessions without driver', () => {
-    const manager = createManager();
-    injectSession(manager, {
-        sessionId: 'nodriver-1',
-        agent: 'claude',
-        driver: null,
-        active: false,
-        lastActivityTs: Date.now() - 60 * 60 * 1000,
-    });
-    // Should not throw
-    manager.sweepIdleSessions();
-});
-test('sweepIdleSessions: removes inactive sessions from map after 1 hour', () => {
-    const manager = createManager();
-    injectSession(manager, {
-        sessionId: 'inactive-1',
-        agent: 'claude',
-        active: false,
-        driver: null,
-        lastActivityTs: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago
-        clients: new Set(),
-    });
-    assert.ok(manager.sessions.has('inactive-1'), 'session should exist before sweep');
-    manager.sweepIdleSessions();
-    assert.ok(!manager.sessions.has('inactive-1'), 'inactive session should be removed from map');
-});
-test('sweepIdleSessions: does not remove inactive sessions with connected clients', () => {
-    const manager = createManager();
-    const ws = mockWs();
-    injectSession(manager, {
-        sessionId: 'inactive-with-client',
-        agent: 'claude',
-        active: false,
-        driver: null,
-        lastActivityTs: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago
-        clients: new Set([ws]),
-    });
-    manager.sweepIdleSessions();
-    assert.ok(manager.sessions.has('inactive-with-client'), 'inactive session with connected clients should NOT be removed');
-});
-test('sweepIdleSessions: stalled driver resolves pending claude hook approvals', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    const ws = mockWs();
-    const deferred = createDeferred();
-    const session = injectSession(manager, {
-        sessionId: 'stall-hooks-1',
-        agent: 'claude',
-        driver,
-        clients: new Set([ws]),
-        lastActivityTs: Date.now() - 60 * 60 * 1000,
-        isResponding: true,
-        pendingClaudeHookApprovals: new Map([
-            ['hook-req-1', { requestId: 'hook-req-1', promise: deferred.promise, resolve: deferred.resolve }],
-        ]),
-    });
-    manager.sweepIdleSessions();
-    assert.equal(driver.calls.stop.length, 1, 'stalled driver should be stopped');
-    assert.equal(session.pendingClaudeHookApprovals.size, 0, 'pending hook approvals should be resolved');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-    assert.equal(session.isResponding, false);
-});
-test('sweepIdleSessions: stalled session stays in map for reconnect', () => {
-    const manager = createManager();
-    const driver = mockDriver();
-    injectSession(manager, {
-        sessionId: 'stall-reconnect-1',
-        agent: 'claude',
-        driver,
-        lastActivityTs: Date.now() - 60 * 60 * 1000,
-        isResponding: true,
-    });
-    manager.sweepIdleSessions();
-    assert.ok(manager.sessions.has('stall-reconnect-1'), 'stalled session should remain in map so next message can auto-reconnect');
-    const session = manager.sessions.get('stall-reconnect-1');
-    assert.equal(session.active, false);
-    assert.equal(session.driver, null);
-});
-// ── buildPushBody ────────────────────────────────────────────────────
-test('buildPushBody: returns default for empty text', () => {
-    const manager = createManager();
-    assert.equal(manager.buildPushBody(''), 'Done.');
-    assert.equal(manager.buildPushBody('   '), 'Done.');
-});
-test('buildPushBody: returns short text as-is', () => {
-    const manager = createManager();
-    assert.equal(manager.buildPushBody('Hello world'), 'Hello world');
-});
-test('buildPushBody: collapses whitespace', () => {
-    const manager = createManager();
-    assert.equal(manager.buildPushBody('hello\n  world\t!'), 'hello world !');
-});
-test('buildPushBody: truncates long text with ellipsis', () => {
-    const manager = createManager();
-    const longText = 'a'.repeat(300);
-    const result = manager.buildPushBody(longText);
-    assert.ok(result.endsWith('...'), 'should end with ellipsis');
-    assert.ok(result.length <= 183, `should be at most 183 chars, got ${result.length}`);
-});
-// ── getActiveSessionCount / getDriverCounts ──────────────────────────
-test('getActiveSessionCount: counts only active sessions', () => {
-    const manager = createManager();
-    injectSession(manager, { sessionId: 'a1', active: true });
-    injectSession(manager, { sessionId: 'a2', active: true });
-    injectSession(manager, { sessionId: 'a3', active: false, driver: null });
-    assert.equal(manager.getActiveSessionCount(), 2);
-});
-test('getDriverCounts: groups by agent type', () => {
-    const manager = createManager();
-    injectSession(manager, { sessionId: 'c1', agent: 'claude', active: true });
-    injectSession(manager, { sessionId: 'c2', agent: 'claude', active: true });
-    injectSession(manager, { sessionId: 'x1', agent: 'codex', active: true });
-    injectSession(manager, { sessionId: 'x2', agent: 'codex', active: false, driver: null });
-    const counts = manager.getDriverCounts();
-    assert.equal(counts.claude, 2);
-    assert.equal(counts.codex, 1);
-});
-//# sourceMappingURL=session-manager.test.js.map