@vibelet/cli 0.1.35 → 0.1.37

package/src/session-manager.test.ts

@@ -0,0 +1,3430 @@
+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 type { WebSocket } from 'ws';
+import type { AgentType, ServerMessage } from '@vibelet/shared';
+import type { Driver } from './drivers/types.js';
+import { SessionManager } from './session-manager.js';
+import { config } from './config.js';
+import {
+  __emitExternalInventoryBackfillForTests,
+  __resetExternalInventoryStateForTests,
+} from './session-inventory.js';
+
+// ── Mock helpers ──────────────────────────────────────────────────────
+
+function mockWs(open = true): WebSocket & { sent: string[] } {
+  const sent: string[] = [];
+  return {
+    readyState: open ? 1 : 3, // 1 = OPEN, 3 = CLOSED
+    send(data: string) { sent.push(data); },
+    sent,
+  } as any;
+}
+
+function mockDriver(): Driver & {
+  calls: Record<string, unknown[]>;
+  _emitMessage: (msg: ServerMessage) => void;
+  _emitExit: (code: number | null) => void;
+} {
+  const calls: Record<string, unknown[]> = {
+    start: [],
+    sendPrompt: [],
+    respondApproval: [],
+    interrupt: [],
+    stop: [],
+    setApprovalMode: [],
+  };
+  let messageHandler: ((msg: ServerMessage) => void) | null = null;
+  let exitHandler: ((code: number | null) => void) | null = null;
+  return {
+    async start(cwd?: string, resumeSessionId?: string, approvalMode?: string) {
+      calls.start.push({ cwd, resumeSessionId, approvalMode });
+      return 'mock-session-id';
+    },
+    sendPrompt(text: string) { calls.sendPrompt.push(text); },
+    respondApproval(requestId: string, approved: boolean) {
+      calls.respondApproval.push({ requestId, approved });
+      return true;
+    },
+    interrupt() { calls.interrupt.push(true); },
+    stop() { calls.stop.push(true); },
+    setApprovalMode(mode: string) { calls.setApprovalMode.push(mode); },
+    onMessage(handler: (msg: ServerMessage) => void) { messageHandler = handler; },
+    onExit(handler: (code: number | null) => void) { exitHandler = handler; },
+    calls,
+    _emitMessage(msg: ServerMessage) { messageHandler?.(msg); },
+    _emitExit(code: number | null) { exitHandler?.(code); },
+  } as any;
+}
+
+function createDeferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+async function flushAsyncWork(): Promise<void> {
+  await Promise.resolve();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+interface ActiveSession {
+  sessionId: string;
+  agent: AgentType;
+  cwd: string;
+  approvalMode?: string;
+  driver: Driver | null;
+  clients: Set<WebSocket>;
+  title: string;
+  createdAt: string;
+  lastActivityAt: string;
+  active: boolean;
+  lastActivityTs: number;
+  isResponding: boolean;
+  currentReplyText: string;
+  acceptedClientMessageIds: string[];
+  lastUserMessage?: string;
+  syntheticApprovalRetries: Record<string, { message: string; toolName: string }>;
+  pendingApproval?: {
+    requestId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    description: string;
+    approvalContext?: {
+      provider: 'codex';
+      kind: 'command-execution' | 'file-change' | 'request-user-input-approval' | 'exec-command-legacy' | 'apply-patch-legacy';
+      rpcId: number;
+      questionId?: string;
+      approveLabel?: string;
+      denyLabel?: string;
+    };
+  };
+  startupInProgress: boolean;
+  bufferedPrompts: string[];
+  startupToken: number;
+  managed?: boolean;
+  claudeHookSecret?: string;
+  pendingClaudeHookApprovals: Map<string, {
+    requestId: string;
+    promise: Promise<unknown>;
+    resolve: (response: unknown) => void;
+  }>;
+}
+
+function createManager(pushSender?: (title: string, body: string, data?: Record<string, unknown>) => Promise<void> | void): SessionManager {
+  const manager = new SessionManager(pushSender ?? (() => {}));
+  // Avoid reading/writing from disk by replacing store internals
+  const store = (manager as any).store;
+  store.records = [];
+  store.deletedSessionIds = new Set<string>();
+  store.scheduleSave = () => {};  // no-op to prevent disk writes
+  store.saveToDisk = () => {};    // no-op to prevent disk writes
+  return manager;
+}
+
+function injectSession(
+  manager: SessionManager,
+  overrides: Partial<ActiveSession> & { sessionId: string },
+): ActiveSession {
+  const session: ActiveSession = {
+    agent: 'codex',
+    cwd: '/tmp',
+    driver: mockDriver(),
+    clients: new Set<WebSocket>(),
+    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 as any).sessions.set(session.sessionId, session);
+  return session;
+}
+
+function parseReply(ws: WebSocket & { sent: string[] }, index = 0): any {
+  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<WebSocket>([ws1, ws2]),
+  });
+
+  const msg: ServerMessage = { type: 'text.delta', sessionId: 's1', content: 'hello' };
+  (manager as any).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<WebSocket>([wsOpen, wsClosed]),
+  });
+
+  (manager as any).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 as any).broadcast('nonexistent', { type: 'text.delta', sessionId: 'nonexistent', content: 'x' });
+});
+
+test('broadcast: session.done sends push with the accumulated assistant reply preview', () => {
+  const pushCalls: Array<{ title: string; body: string; data?: Record<string, unknown> }> = [];
+  const manager = createManager((title, body, data) => {
+    pushCalls.push({ title, body, data });
+  });
+  injectSession(manager, {
+    sessionId: 's1',
+    title: 'Fix login flow',
+  });
+
+  (manager as any).broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'First line.\n' });
+  (manager as any).broadcast('s1', { type: 'text.delta', sessionId: 's1', content: 'Second line.' });
+  (manager as any).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: Array<{ title: string; body: string; data?: Record<string, unknown> }> = [];
+  const manager = createManager((title, body, data) => {
+    pushCalls.push({ title, body, data });
+  });
+  injectSession(manager, {
+    sessionId: 's1',
+    title: 'Tool-only session',
+  });
+
+  (manager as any).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<WebSocket>([sessionClient]),
+  });
+
+  // Register both as global clients
+  manager.addGlobalClient(sessionClient);
+  manager.addGlobalClient(globalOnly);
+
+  // A normal text.delta should only go to session clients
+  (manager as any).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: ServerMessage = {
+    type: 'approval.request',
+    sessionId: 's1',
+    requestId: 'req-1',
+    toolName: 'Write',
+    input: { file_path: '/tmp/test.ts' },
+    description: 'Write to /tmp/test.ts',
+  };
+  (manager as any).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 as any).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<WebSocket>([ws]) });
+  const s2 = injectSession(manager, { sessionId: 's2', clients: new Set<WebSocket>([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 as any).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<WebSocket>([ws]) });
+  const s2 = injectSession(manager, { sessionId: 's2', driver: driver2, clients: new Set<WebSocket>([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 as any).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 as any).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 as any).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 as any).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: string, approved: boolean) => {
+    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 as any).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 as any).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 as any).store.records;
+  assert.equal(records.length, 1);
+  assert.equal(records[0].sessionId, 's2');
+  assert.equal((manager as any).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 as any).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 as any).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 as any).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: any) => approval.requestId === 'req-live' && approval.sessionId === 'live-approval'));
+  assert.ok(pendingApprovals.some((approval: any) => approval.requestId === 'req-stored' && approval.sessionId === 'stored-approval'));
+});
+
+test('reconnect.snapshot: omits deleted activeSessionId', async () => {
+  const manager = createManager();
+  const ws = mockWs();
+  (manager as any).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: ServerMessage = { type: 'text.delta', sessionId: 'snap-sub', content: 'more text' };
+  (manager as any).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 as any).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 as any).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 as any).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 as any).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 as any).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 as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).bindDriverLifecycle(session, 'codex', '');
+
+  const msg: ServerMessage = { 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<WebSocket>([ws]),
+  });
+
+  (manager as any).bindDriverLifecycle(session, 'codex', '', ws);
+
+  // Driver reports a message with a different sessionId
+  driver._emitMessage({ type: 'session.done', sessionId: 'new-id' } as ServerMessage);
+
+  // Session should be remapped
+  assert.equal((manager as any).sessions.has('old-id'), false);
+  assert.equal((manager as any).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 as any).bindDriverLifecycle(session, 'codex', '');
+
+  // Driver reports sessionId that already exists as another session
+  driver._emitMessage({ type: 'session.done', sessionId: 'existing-id' } as ServerMessage);
+
+  // Should NOT remap because existing-id already exists
+  assert.equal((manager as any).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 as any).bindDriverLifecycle(session, 'codex', '');
+
+  // response messages should not trigger remapping
+  driver._emitMessage({ type: 'response', id: 'r1', ok: true, sessionId: 'different-id' } as unknown as ServerMessage);
+
+  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 as any).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 as any).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 as any).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 as any).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 as any).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 as any).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 as any).touchSession('s1');
+  assert.notEqual(session.lastActivityAt, before);
+});
+
+test('touchSession: updates lastActivityAt on session record', () => {
+  const manager = createManager();
+  (manager as any).store.records = [
+    {
+      sessionId: 'rec-1',
+      agent: 'codex' as AgentType,
+      cwd: '/tmp',
+      title: 'T',
+      createdAt: '2026-03-01T00:00:00.000Z',
+      lastActivityAt: '2026-03-01T00:00:00.000Z',
+    },
+  ];
+
+  (manager as any).touchSession('rec-1');
+  const updated = (manager as any).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 as any).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 as any).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 as any).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<string>();
+  const driver = mockDriver();
+  driver.start = async (cwd?: string, resumeSessionId?: string, approvalMode?: string) => {
+    driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
+    return deferred.promise;
+  };
+  (manager as any).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 as any).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 as any).createDriver = () => driver;
+
+  await manager.handle(ws, {
+    action: 'session.create',
+    id: 'req1',
+    agent: 'claude',
+    cwd: '/tmp',
+    approvalMode: 'autoApprove',
+  });
+
+  const reply = parseReply(ws);
+  const session = (manager as any).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 as any).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 as any).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<string>();
+  const driver = mockDriver();
+  driver.start = async (cwd?: string, resumeSessionId?: string, approvalMode?: string) => {
+    driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
+    return deferred.promise;
+  };
+  (manager as any).createDriver = () => driver;
+
+  await manager.handle(ws, {
+    action: 'session.create',
+    id: 'req1',
+    agent: 'codex',
+    cwd: '/tmp',
+  });
+
+  const reply = parseReply(ws);
+  const session = (manager as any).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<string>();
+  const driver = mockDriver();
+  driver.start = async (cwd?: string, resumeSessionId?: string, approvalMode?: string) => {
+    driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
+    return deferred.promise;
+  };
+  (manager as any).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 as any).sessions.get(pendingSessionId);
+  assert.deepEqual(pendingSession.bufferedPrompts, ['hello buffered codex']);
+
+  deferred.resolve('codex-thread-1');
+  await flushAsyncWork();
+
+  assert.equal((manager as any).sessions.has(pendingSessionId), false);
+  const liveSession = (manager as any).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<string>();
+  const driver = mockDriver();
+  driver.start = async (cwd?: string, resumeSessionId?: string, approvalMode?: string) => {
+    driver.calls.start.push({ cwd, resumeSessionId, approvalMode });
+    return deferred.promise;
+  };
+  (manager as any).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 as any).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 as any).sessions.has(pendingSessionId), false);
+  const liveSession = (manager as any).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 as any).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 as any).createDriver = () => driver;
+  (manager as any).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 as any).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: string) => { capturedCwd = cwd; return 'sess-1'; };
+  (manager as any).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 as any).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 as any).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 as any).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 as any).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 as any).sessions.has(reply.data.sessionId), true);
+});
+
+test('resumeSession: replies error when driver.start fails', async () => {
+  const manager = createManager();
+  const ws = mockWs();
+  (manager as any).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: string) => { capturedCwd = cwd; return 'sess-1'; };
+  (manager as any).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 as any).store.records = [
+    {
+      sessionId: 'rec-only',
+      agent: 'codex' as AgentType,
+      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 as any).touchSession('rec-only');
+
+  const updated = (manager as any).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 as any).store.records = [];
+  // Should not throw
+  (manager as any).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 as any).createDriver = () => driver;
+  // No sessionRecords, no scanner results, but agent is provided
+  (manager as any).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 as any).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: string, _id?: string, approval?: string) => {
+    startCwd = cwd;
+    startApproval = approval ?? '';
+    return 'resumed-id';
+  };
+  (manager as any).createDriver = () => driver;
+  (manager as any).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 as any).setApprovalMode = (mode: string) => {
+    (driver as any).calls.setApprovalMode = (driver as any).calls.setApprovalMode || [];
+    (driver as any).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 as any).sessions.get('am-1');
+  assert.equal(session.approvalMode, 'autoApprove');
+  assert.deepEqual((driver as any).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 as any).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: any) => r.sessionId === 'stored-only');
+  assert.equal(record.approvalMode, 'autoApprove');
+});
+
+test('setApprovalMode: clears store override when switching back to Follow Remote', async () => {
+  const manager = createManager();
+  const ws = mockWs();
+  const store = (manager as any).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: 'autoApprove',
+  });
+
+  await manager.handle(ws, {
+    action: 'session.setApprovalMode',
+    id: 'req1',
+    sessionId: 'stored-only',
+    approvalMode: null,
+  });
+
+  const reply = parseReply(ws);
+  assert.equal(reply.ok, true);
+  assert.equal(reply.data.approvalMode, null);
+  const record = store.records.find((r: any) => r.sessionId === 'stored-only');
+  assert.equal(record.approvalMode, undefined);
+});
+
+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 as any).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<WebSocket>([ws1]),
+    isResponding: true,
+  });
+
+  // Simulate driver emitting an approval.request
+  (manager as any).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: string) => JSON.parse(s))
+    .find((m: any) => 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<WebSocket>([ws]),
+    isResponding: true,
+  });
+
+  (manager as any).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: Array<{ title: string; body: string; data?: Record<string, unknown> }> = [];
+  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<WebSocket>([ws]),
+  });
+
+  (manager as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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 as any).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 as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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: string, _id?: string, approval?: string) => {
+    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 as any).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 as any).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 as any).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<WebSocket>([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: string) => JSON.parse(s))
+    .find((m: any) => 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<WebSocket>([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<WebSocket>([ws]),
+  });
+
+  (manager as any).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<WebSocket>([ws]),
+  });
+
+  (manager as any).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 as any).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 as any).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 as any).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 as any).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 as any).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 as any).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<WebSocket>([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<WebSocket>([ws]),
+  });
+
+  await manager.handle(ws, {
+    action: 'session.send',
+    id: 'req1',
+    sessionId: 'sm-2',
+    message: 'test prompt',
+  });
+
+  const session = (manager as any).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<WebSocket>([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 as any).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 as any).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 as any).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: { sessionId: string }) => 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 as any).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 as any).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 as any).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 as any).sweepIdleSessions();
+
+  assert.equal(driver.calls.stop.length, 1, 'idle driver should be stopped');
+  const session = (manager as any).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 as any).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<WebSocket>([ws]),
+    lastActivityTs: Date.now() - 60 * 60 * 1000, // 1 hour ago
+    isResponding: true,
+  });
+
+  (manager as any).sweepIdleSessions();
+
+  assert.equal(driver.calls.stop.length, 1, 'stalled responding session should be stopped');
+  const session = (manager as any).sessions.get('responding-stalled-1');
+  assert.equal(session.active, false);
+  assert.equal(session.driver, null);
+  const errorMsg = ws.sent
+    .map((entry: string) => JSON.parse(entry))
+    .find((msg: any) => 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 as any).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 as any).sweepIdleSessions();
+
+  assert.equal(driver.calls.stop.length, 0, 'pending approval should bypass idle timeout');
+  const session = (manager as any).sessions.get('idle-approval-1');
+  assert.equal(session.active, true);
+});
+
+test('sweepIdleSessions: honors disabled stall timeout', () => {
+  const originalTurnStallTimeoutMs = config.turnStallTimeoutMs;
+  (config as { turnStallTimeoutMs: number }).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 as any).sweepIdleSessions();
+
+    assert.equal(driver.calls.stop.length, 0, 'disabled stall timeout should skip responding sessions');
+  } finally {
+    (config as { turnStallTimeoutMs: number }).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 as any).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 as any).sessions.has('inactive-1'), 'session should exist before sweep');
+
+  (manager as any).sweepIdleSessions();
+
+  assert.ok(!(manager as any).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 as any]),
+  });
+
+  (manager as any).sweepIdleSessions();
+
+  assert.ok(
+    (manager as any).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<unknown>();
+  const session = injectSession(manager, {
+    sessionId: 'stall-hooks-1',
+    agent: 'claude',
+    driver,
+    clients: new Set<WebSocket>([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 }],
+    ]) as any,
+  });
+
+  (manager as any).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 as any).sweepIdleSessions();
+
+  assert.ok(
+    (manager as any).sessions.has('stall-reconnect-1'),
+    'stalled session should remain in map so next message can auto-reconnect',
+  );
+  const session = (manager as any).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 as any).buildPushBody(''), 'Done.');
+  assert.equal((manager as any).buildPushBody('   '), 'Done.');
+});
+
+test('buildPushBody: returns short text as-is', () => {
+  const manager = createManager();
+  assert.equal((manager as any).buildPushBody('Hello world'), 'Hello world');
+});
+
+test('buildPushBody: collapses whitespace', () => {
+  const manager = createManager();
+  assert.equal((manager as any).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 as any).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);
+});