shennian 0.2.4 → 0.2.5

package/dist/src/__tests__/session-manager.test.js

@@ -1,685 +0,0 @@
-// @covers src/session/manager.ts
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { EventEmitter } from 'node:events';
-import fs from 'node:fs';
-import os from 'node:os';
-vi.mock('node:fs', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        statSync: vi.fn((_p) => ({ size: 1024 * 100 })), // default: 100 KB
-        mkdirSync: vi.fn(),
-        writeFileSync: vi.fn(),
-        readFileSync: vi.fn(() => Buffer.from('')),
-        readdirSync: vi.fn(() => []),
-    };
-});
-const mockAdapter = () => {
-    const adapter = Object.assign(new EventEmitter(), {
-        type: 'claude',
-        start: vi.fn(async () => { }),
-        send: vi.fn(async (_text, _modelId) => { }),
-        resume: vi.fn(async () => { }),
-        stop: vi.fn(async () => { }),
-    });
-    return adapter;
-};
-const { mockCreateAgent } = vi.hoisted(() => ({
-    mockCreateAgent: vi.fn(),
-}));
-const { mockLookupClaudeTranscriptCwd } = vi.hoisted(() => ({
-    mockLookupClaudeTranscriptCwd: vi.fn(),
-}));
-vi.mock('../agents/adapter.js', async (importOriginal) => {
-    const orig = await importOriginal();
-    return { ...orig, createAgent: mockCreateAgent };
-});
-vi.mock('../agents/claude.js', () => ({}));
-vi.mock('../agents/codex.js', () => ({}));
-vi.mock('../agents/gemini.js', () => ({}));
-vi.mock('../agents/cursor.js', () => ({}));
-vi.mock('../agents/openclaw.js', () => ({}));
-vi.mock('../agents/pi.js', () => ({}));
-vi.mock('../native-fusion/parsers.js', () => ({
-    lookupClaudeTranscriptCwd: mockLookupClaudeTranscriptCwd,
-}));
-import { SessionManager } from '../session/manager.js';
-function createMockClient() {
-    return {
-        sendRes: vi.fn(),
-        sendEvent: vi.fn(),
-        sendAgentEvent: vi.fn(),
-    };
-}
-describe('SessionManager', () => {
-    let client;
-    let manager;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockLookupClaudeTranscriptCwd.mockReturnValue(null);
-        client = createMockClient();
-        manager = new SessionManager(client);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('agent events include sessionId', () => {
-        it('includes sessionId in agentEvent payloads', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: { sessionId: 'sess-abc', text: 'hello', agentType: 'claude', workDir: '/tmp' },
-            });
-            // Simulate adapter emitting text and then ending the run.
-            const agentEvent = { state: 'delta', runId: 'run1', seq: 0, text: 'Hi' };
-            adapter.emit('agentEvent', agentEvent);
-            adapter.emit('agentEvent', { state: 'final', runId: 'run1', seq: 1 });
-            expect(client.sendAgentEvent).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'event',
-                event: 'agent',
-                id: 'agent-evt-run1-0',
-                payload: expect.objectContaining({
-                    state: 'delta',
-                    sessionId: 'sess-abc',
-                    text: 'Hi',
-                }),
-            }));
-        });
-        it('aggregates consecutive text deltas before sending them to the server', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: { sessionId: 'sess-abc', text: 'hello', agentType: 'claude', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', { state: 'delta', runId: 'run1', seq: 0, text: 'Hello' });
-            adapter.emit('agentEvent', { state: 'delta', runId: 'run1', seq: 1, text: ' world' });
-            expect(client.sendAgentEvent).not.toHaveBeenCalled();
-            adapter.emit('agentEvent', { state: 'final', runId: 'run1', seq: 2 });
-            expect(client.sendAgentEvent).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'event',
-                event: 'agent',
-                id: 'agent-evt-run1-1',
-                payload: expect.objectContaining({
-                    state: 'delta',
-                    sessionId: 'sess-abc',
-                    text: 'Hello world',
-                }),
-            }));
-            expect(client.sendAgentEvent).toHaveBeenCalledWith(expect.objectContaining({
-                id: 'agent-evt-run1-2',
-                payload: expect.objectContaining({
-                    state: 'final',
-                    sessionId: 'sess-abc',
-                }),
-            }));
-        });
-        it('flushes aggregated text before forwarding a tool call', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: { sessionId: 'sess-tool', text: 'hello', agentType: 'claude', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', { state: 'delta', runId: 'run1', seq: 0, text: 'Before ' });
-            adapter.emit('agentEvent', { state: 'delta', runId: 'run1', seq: 1, text: 'tool' });
-            adapter.emit('agentEvent', { state: 'tool-call', runId: 'run1', seq: 2, name: 'bash', args: { command: 'ls' } });
-            expect(client.sendAgentEvent).toHaveBeenNthCalledWith(1, expect.objectContaining({
-                id: 'agent-evt-run1-1',
-                payload: expect.objectContaining({
-                    state: 'delta',
-                    sessionId: 'sess-tool',
-                    text: 'Before tool',
-                }),
-            }));
-            expect(client.sendAgentEvent).toHaveBeenNthCalledWith(2, expect.objectContaining({
-                id: 'agent-evt-run1-2',
-                payload: expect.objectContaining({
-                    state: 'tool-call',
-                    sessionId: 'sess-tool',
-                    name: 'bash',
-                }),
-            }));
-        });
-        it('includes sessionId in error events', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: { sessionId: 'sess-xyz', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            adapter.emit('error', new Error('CLI crashed'));
-            expect(client.sendEvent).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    state: 'error',
-                    sessionId: 'sess-xyz',
-                    message: 'CLI crashed',
-                }),
-            }));
-        });
-        it('events from different sessions have correct sessionId', async () => {
-            const adapterA = mockAdapter();
-            const adapterB = mockAdapter();
-            mockCreateAgent.mockReturnValueOnce(adapterA).mockReturnValueOnce(adapterB);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-A', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            await manager.handleReq({
-                type: 'req', id: 'r2', method: 'chat.send',
-                params: { sessionId: 'sess-B', text: 'yo', agentType: 'codex', workDir: '/tmp' },
-            });
-            adapterA.emit('agentEvent', { state: 'delta', runId: 'rA', seq: 0, text: 'from A' });
-            adapterB.emit('agentEvent', { state: 'delta', runId: 'rB', seq: 0, text: 'from B' });
-            adapterA.emit('agentEvent', { state: 'final', runId: 'rA', seq: 1 });
-            adapterB.emit('agentEvent', { state: 'final', runId: 'rB', seq: 1 });
-            const calls = client.sendAgentEvent.mock.calls.map((c) => c[0].payload);
-            const aEvent = calls.find((p) => p.text === 'from A');
-            const bEvent = calls.find((p) => p.text === 'from B');
-            expect(aEvent?.sessionId).toBe('sess-A');
-            expect(bEvent?.sessionId).toBe('sess-B');
-        });
-    });
-    describe('attachments', () => {
-        it('无附件时直接传递原始文本', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-1', text: 'hello', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(adapter.send).toHaveBeenCalledWith('hello', undefined);
-        });
-        it('有附件时在文本前注入 [附件] 路径行', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: {
-                    sessionId: 'sess-2',
-                    text: '这是什么图？',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    attachments: [{ path: '/tmp/.uploads/shot.png', name: 'shot.png', mimeType: 'image/png' }],
-                },
-            });
-            const sentText = adapter.send.mock.calls[0][0];
-            expect(sentText).toBe('这是什么图？');
-        });
-        it('附件参数不再影响发送文本', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: {
-                    sessionId: 'sess-3',
-                    text: '帮我看看',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    attachments: [
-                        { path: '/tmp/a.png', name: 'a.png', mimeType: 'image/png' },
-                        { path: '/tmp/b.json', name: 'b.json', mimeType: 'application/json' },
-                    ],
-                },
-            });
-            const sentText = adapter.send.mock.calls[0][0];
-            expect(sentText).toBe('帮我看看');
-        });
-    });
-    describe('fs.ls roots navigation', () => {
-        it('returns Windows drive roots for __roots__', async () => {
-            vi.spyOn(os, 'platform').mockReturnValue('win32');
-            vi.spyOn(fs, 'existsSync')
-                .mockImplementation((target) => target === 'C:\\' || target === 'D:\\');
-            await manager.handleReq({
-                type: 'req',
-                id: 'fs-roots',
-                method: 'fs.ls',
-                params: { path: '__roots__' },
-            });
-            expect(client.sendRes).toHaveBeenCalledWith({
-                type: 'res',
-                id: 'fs-roots',
-                ok: true,
-                payload: {
-                    path: '__roots__',
-                    entries: [
-                        { name: 'C:\\', path: 'C:\\', isDir: true },
-                        { name: 'D:\\', path: 'D:\\', isDir: true },
-                    ],
-                },
-            });
-        });
-    });
-    describe('agentSessionId persistence', () => {
-        it('passes agentSessionId from chat.send params to adapter.start', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: {
-                    sessionId: 'sess-resume',
-                    text: 'hello',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    agentSessionId: 'claude-sid-123',
-                },
-            });
-            expect(adapter.start).toHaveBeenCalledWith('sess-resume', expect.any(String), 'claude-sid-123');
-        });
-        it('emits session.update when agent reports agentSessionId on final', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-new', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            const finalEvent = {
-                state: 'final',
-                runId: 'run1',
-                seq: 1,
-                agentSessionId: 'claude-sid-456',
-            };
-            adapter.emit('agentEvent', finalEvent);
-            const sessionUpdateCall = client.sendEvent.mock.calls.find((c) => c[0].event === 'session.update');
-            expect(sessionUpdateCall).toBeDefined();
-            expect(sessionUpdateCall[0]).toEqual(expect.objectContaining({
-                type: 'event',
-                event: 'session.update',
-                payload: {
-                    session: {
-                        id: 'sess-new',
-                        agentType: 'claude',
-                        agentSessionId: 'claude-sid-456',
-                    },
-                },
-            }));
-        });
-        it('does not emit session.update when final has no agentSessionId', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-no-sid', text: 'hi', agentType: 'codex', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', { state: 'final', runId: 'run1', seq: 1 });
-            const sessionUpdateCall = client.sendEvent.mock.calls.find((c) => c[0].event === 'session.update');
-            expect(sessionUpdateCall).toBeUndefined();
-        });
-        it('reuses existing adapter (with agentSessionId) for same session', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-reuse', text: 'first', agentType: 'claude', workDir: '/tmp' },
-            });
-            await manager.handleReq({
-                type: 'req', id: 'r2', method: 'chat.send',
-                params: { sessionId: 'sess-reuse', text: 'second', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(mockCreateAgent).toHaveBeenCalledTimes(1);
-            expect(adapter.send).toHaveBeenCalledTimes(2);
-            expect(adapter.send).toHaveBeenNthCalledWith(1, 'first', undefined);
-            expect(adapter.send).toHaveBeenNthCalledWith(2, 'second', undefined);
-        });
-        it('resumes an existing adapter when a newer agentSessionId arrives', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-resume-existing',
-                    text: 'first',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    agentSessionId: 'sid-1',
-                },
-            });
-            await manager.handleReq({
-                type: 'req',
-                id: 'r2',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-resume-existing',
-                    text: 'second',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    agentSessionId: 'sid-2',
-                },
-            });
-            expect(adapter.resume).toHaveBeenCalledWith('sid-2');
-            expect(adapter.send).toHaveBeenNthCalledWith(2, 'second', undefined);
-        });
-        it('rebuilds the cached adapter when the incoming session metadata drifts', async () => {
-            const firstAdapter = mockAdapter();
-            const secondAdapter = mockAdapter();
-            secondAdapter.type = 'codex';
-            mockCreateAgent.mockReturnValueOnce(firstAdapter).mockReturnValueOnce(secondAdapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-drift',
-                    text: 'first',
-                    agentType: 'claude',
-                    workDir: '/tmp/original',
-                },
-            });
-            await manager.handleReq({
-                type: 'req',
-                id: 'r2',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-drift',
-                    text: 'second',
-                    agentType: 'codex',
-                    workDir: '/tmp/next',
-                    agentSessionId: 'thread-2',
-                },
-            });
-            expect(firstAdapter.stop).toHaveBeenCalledTimes(1);
-            expect(secondAdapter.start).toHaveBeenCalledWith('sess-drift', '/tmp/next', 'thread-2');
-            expect(secondAdapter.send).toHaveBeenCalledWith('second', undefined);
-        });
-        it('passes modelId to adapter.send when provided', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-model',
-                    text: 'hello',
-                    agentType: 'claude',
-                    workDir: '/tmp',
-                    modelId: 'sonnet',
-                },
-            });
-            expect(adapter.send).toHaveBeenCalledWith('hello', 'sonnet');
-        });
-        it('repairs claude imported workDir from transcript cwd before starting the adapter', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            mockLookupClaudeTranscriptCwd.mockReturnValue('/Users/lichen/Documents/code/projects/shennian');
-            await manager.handleReq({
-                type: 'req',
-                id: 'r1',
-                method: 'chat.send',
-                params: {
-                    sessionId: 'sess-imported',
-                    text: 'continue',
-                    agentType: 'claude',
-                    workDir: '-Users-lichen-Documents-code-projects-shennian',
-                    agentSessionId: 'claude-sid-imported',
-                },
-            });
-            expect(adapter.start).toHaveBeenCalledWith('sess-imported', '/Users/lichen/Documents/code/projects/shennian', 'claude-sid-imported');
-            expect(adapter.send).toHaveBeenCalledWith('continue', undefined);
-        });
-    });
-    describe('codex resume flow', () => {
-        it('passes agentSessionId to codex adapter via start()', async () => {
-            const adapter = mockAdapter();
-            adapter.type = 'codex';
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: {
-                    sessionId: 'sess-codex',
-                    text: 'fix bug',
-                    agentType: 'codex',
-                    workDir: '/tmp',
-                    agentSessionId: 'thread-abc-123',
-                },
-            });
-            expect(adapter.start).toHaveBeenCalledWith('sess-codex', expect.any(String), 'thread-abc-123');
-        });
-        it('persists codex agentSessionId from final event', async () => {
-            const adapter = mockAdapter();
-            adapter.type = 'codex';
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-codex-new', text: 'hello', agentType: 'codex', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', {
-                state: 'final', runId: 'run1', seq: 1,
-                agentSessionId: 'thread-xyz-789',
-            });
-            const updateCall = client.sendEvent.mock.calls.find((c) => c[0].event === 'session.update');
-            expect(updateCall).toBeDefined();
-            expect(updateCall[0]).toEqual(expect.objectContaining({
-                payload: {
-                    session: {
-                        id: 'sess-codex-new',
-                        agentType: 'codex',
-                        agentSessionId: 'thread-xyz-789',
-                    },
-                },
-            }));
-        });
-    });
-    describe('custom agent agentSessionId', () => {
-        it('persists custom agent session ID from final event', async () => {
-            const adapter = mockAdapter();
-            adapter.type = 'custom:my-agent';
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-custom', text: 'hello', agentType: 'custom:my-agent', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', {
-                state: 'final', runId: 'run1', seq: 1,
-                agentSessionId: 'custom-session-456',
-            });
-            const updateCall = client.sendEvent.mock.calls.find((c) => c[0].event === 'session.update');
-            expect(updateCall).toBeDefined();
-            expect(updateCall[0]).toEqual(expect.objectContaining({
-                payload: {
-                    session: {
-                        id: 'sess-custom',
-                        agentType: 'custom:my-agent',
-                        agentSessionId: 'custom-session-456',
-                    },
-                },
-            }));
-        });
-    });
-    describe('error handling', () => {
-        it('waits for adapter.send to resolve before acknowledging chat.send success', async () => {
-            const adapter = mockAdapter();
-            let resolveSend = null;
-            adapter.send.mockReturnValue(new Promise((resolve) => {
-                resolveSend = resolve;
-            }));
-            mockCreateAgent.mockReturnValue(adapter);
-            const sendPromise = manager.handleReq({
-                type: 'req', id: 'r-wait', method: 'chat.send',
-                params: { sessionId: 'sess-wait', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            await Promise.resolve();
-            expect(client.sendRes).not.toHaveBeenCalled();
-            expect(resolveSend).toBeTypeOf('function');
-            resolveSend();
-            await sendPromise;
-            expect(client.sendRes).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'res',
-                id: 'r-wait',
-                ok: true,
-            }));
-        });
-        it('sends error with sessionId when agent not found', async () => {
-            mockCreateAgent.mockReturnValue(null);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-1', text: 'hi', agentType: 'unknown', workDir: '/tmp' },
-            });
-            expect(client.sendEvent).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    state: 'error',
-                    sessionId: 'sess-1',
-                }),
-            }));
-            expect(client.sendRes).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'res',
-                id: 'r1',
-                ok: false,
-                error: 'Unsupported agent: unknown',
-            }));
-        });
-        it('sends error with sessionId when adapter.start fails', async () => {
-            const adapter = mockAdapter();
-            adapter.start.mockRejectedValue(new Error('start failed'));
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-2', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(client.sendEvent).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    state: 'error',
-                    sessionId: 'sess-2',
-                    message: expect.stringContaining('start failed'),
-                }),
-            }));
-            expect(client.sendRes).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'res',
-                id: 'r1',
-                ok: false,
-                error: expect.stringContaining('start failed'),
-            }));
-        });
-        it('cleans up session and sends error when adapter.send fails', async () => {
-            const adapter = mockAdapter();
-            adapter.send.mockRejectedValue(new Error('send failed'));
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req', id: 'r1', method: 'chat.send',
-                params: { sessionId: 'sess-3', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(client.sendEvent).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    state: 'error',
-                    sessionId: 'sess-3',
-                    message: expect.stringContaining('send failed'),
-                }),
-            }));
-            expect(client.sendRes).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'res',
-                id: 'r1',
-                ok: false,
-                error: expect.stringContaining('send failed'),
-            }));
-        });
-        it('retries the same req.id after a failed send instead of silently deduping it', async () => {
-            const firstAdapter = mockAdapter();
-            firstAdapter.send.mockRejectedValueOnce(new Error('send failed'));
-            const secondAdapter = mockAdapter();
-            mockCreateAgent.mockReturnValueOnce(firstAdapter).mockReturnValueOnce(secondAdapter);
-            const frame = {
-                type: 'req',
-                id: 'req-retry',
-                method: 'chat.send',
-                params: { sessionId: 'sess-retry', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            };
-            await manager.handleReq(frame);
-            await manager.handleReq(frame);
-            expect(mockCreateAgent).toHaveBeenCalledTimes(2);
-            expect(firstAdapter.stop).toHaveBeenCalledTimes(1);
-            expect(secondAdapter.send).toHaveBeenCalledWith('hi', undefined);
-        });
-    });
-    describe('chat.abort', () => {
-        it('emits a synthetic aborted event for the active run after stop succeeds', async () => {
-            const adapter = mockAdapter();
-            mockCreateAgent.mockReturnValue(adapter);
-            await manager.handleReq({
-                type: 'req',
-                id: 'send-1',
-                method: 'chat.send',
-                params: { sessionId: 'sess-abort', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            adapter.emit('agentEvent', { state: 'delta', runId: 'run-abort', seq: 0, text: 'working' });
-            await manager.handleReq({
-                type: 'req',
-                id: 'abort-1',
-                method: 'chat.abort',
-                params: { sessionId: 'sess-abort' },
-            });
-            expect(adapter.stop).toHaveBeenCalledTimes(1);
-            expect(client.sendAgentEvent).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'event',
-                event: 'agent',
-                id: 'agent-evt-run-abort-1',
-                seq: 1,
-                payload: expect.objectContaining({
-                    state: 'aborted',
-                    sessionId: 'sess-abort',
-                    runId: 'run-abort',
-                    seq: 1,
-                }),
-            }));
-            expect(client.sendRes).toHaveBeenCalledWith(expect.objectContaining({ type: 'res', id: 'abort-1', ok: true }));
-        });
-    });
-    describe('session eviction', () => {
-        it('evicts oldest idle session when exceeding MAX_SESSIONS', async () => {
-            const adapters = [];
-            mockCreateAgent.mockImplementation(() => {
-                const a = mockAdapter();
-                adapters.push(a);
-                return a;
-            });
-            for (let i = 0; i < 50; i++) {
-                await manager.handleReq({
-                    type: 'req', id: `r-${i}`, method: 'chat.send',
-                    params: { sessionId: `sess-${i}`, text: 'hi', agentType: 'claude', workDir: '/tmp' },
-                });
-            }
-            expect(adapters).toHaveLength(50);
-            expect(adapters[0].stop).not.toHaveBeenCalled();
-            await manager.handleReq({
-                type: 'req', id: 'r-51', method: 'chat.send',
-                params: { sessionId: 'sess-new', text: 'hi', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(adapters[0].stop).toHaveBeenCalled();
-            expect(adapters).toHaveLength(51);
-        });
-        it('does not evict when reusing existing session', async () => {
-            const adapters = [];
-            mockCreateAgent.mockImplementation(() => {
-                const a = mockAdapter();
-                adapters.push(a);
-                return a;
-            });
-            for (let i = 0; i < 50; i++) {
-                await manager.handleReq({
-                    type: 'req', id: `r-${i}`, method: 'chat.send',
-                    params: { sessionId: `sess-${i}`, text: 'hi', agentType: 'claude', workDir: '/tmp' },
-                });
-            }
-            await manager.handleReq({
-                type: 'req', id: 'r-reuse', method: 'chat.send',
-                params: { sessionId: 'sess-0', text: 'second msg', agentType: 'claude', workDir: '/tmp' },
-            });
-            expect(adapters).toHaveLength(50);
-            for (const a of adapters) {
-                expect(a.stop).not.toHaveBeenCalled();
-            }
-        });
-    });
-});
-//# sourceMappingURL=session-manager.test.js.map