@ai-devkit/agent-manager 0.4.0 → 0.6.0

package/src/__tests__/adapters/ClaudeCodeAdapter.test.ts

@@ -6,28 +6,49 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
 import { ClaudeCodeAdapter } from '../../adapters/ClaudeCodeAdapter';
-import type { AgentInfo, ProcessInfo } from '../../adapters/AgentAdapter';
+import type { ProcessInfo } from '../../adapters/AgentAdapter';
 import { AgentStatus } from '../../adapters/AgentAdapter';
-import { listProcesses } from '../../utils/process';
-
+import { listAgentProcesses, enrichProcesses } from '../../utils/process';
+import { batchGetSessionFileBirthtimes } from '../../utils/session';
+import type { SessionFile } from '../../utils/session';
+import { matchProcessesToSessions, generateAgentName } from '../../utils/matching';
+import type { MatchResult } from '../../utils/matching';
 jest.mock('../../utils/process', () => ({
-    listProcesses: jest.fn(),
+    listAgentProcesses: jest.fn(),
+    enrichProcesses: jest.fn(),
 }));
 
-const mockedListProcesses = listProcesses as jest.MockedFunction<typeof listProcesses>;
-
-type PrivateMethod<T extends (...args: never[]) => unknown> = T;
+jest.mock('../../utils/session', () => ({
+    batchGetSessionFileBirthtimes: jest.fn(),
+}));
 
-interface AdapterPrivates {
-    readSessions: PrivateMethod<(limit: number) => unknown[]>;
-}
+jest.mock('../../utils/matching', () => ({
+    matchProcessesToSessions: jest.fn(),
+    generateAgentName: jest.fn(),
+}));
 
+const mockedListAgentProcesses = listAgentProcesses as jest.MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as jest.MockedFunction<typeof enrichProcesses>;
+const mockedBatchGetSessionFileBirthtimes = batchGetSessionFileBirthtimes as jest.MockedFunction<typeof batchGetSessionFileBirthtimes>;
+const mockedMatchProcessesToSessions = matchProcessesToSessions as jest.MockedFunction<typeof matchProcessesToSessions>;
+const mockedGenerateAgentName = generateAgentName as jest.MockedFunction<typeof generateAgentName>;
 describe('ClaudeCodeAdapter', () => {
     let adapter: ClaudeCodeAdapter;
 
     beforeEach(() => {
         adapter = new ClaudeCodeAdapter();
-        mockedListProcesses.mockReset();
+        mockedListAgentProcesses.mockReset();
+        mockedEnrichProcesses.mockReset();
+        mockedBatchGetSessionFileBirthtimes.mockReset();
+        mockedMatchProcessesToSessions.mockReset();
+        mockedGenerateAgentName.mockReset();
+        // Default: enrichProcesses returns what it receives
+        mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Default: generateAgentName returns "folder (pid)"
+        mockedGenerateAgentName.mockImplementation((cwd, pid) => {
+            const folder = path.basename(cwd) || 'unknown';
+            return `${folder} (${pid})`;
+        });
     });
 
     describe('initialization', () => {
@@ -95,303 +116,491 @@ describe('ClaudeCodeAdapter', () => {
 
     describe('detectAgents', () => {
         it('should return empty array if no claude processes running', async () => {
-            mockedListProcesses.mockReturnValue([]);
+            mockedListAgentProcesses.mockReturnValue([]);
 
             const agents = await adapter.detectAgents();
             expect(agents).toEqual([]);
+            expect(mockedListAgentProcesses).toHaveBeenCalledWith('claude');
         });
 
-        it('should detect agents using mocked process/session data', async () => {
-            const processData: ProcessInfo[] = [
+        it('should return process-only agents when no sessions discovered', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 777, command: 'claude', cwd: '/project/app', tty: 'ttys001' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            // No projects dir → discoverSessions returns []
+            (adapter as any).projectsDir = '/nonexistent/path';
+
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                status: AgentStatus.IDLE,
+                pid: 777,
+                projectPath: '/project/app',
+                sessionId: 'pid-777',
+                summary: 'Unknown',
+            });
+        });
+
+        it('should detect agents with matched sessions', async () => {
+            const processes: ProcessInfo[] = [
                 {
                     pid: 12345,
-                    command: 'claude --continue',
+                    command: 'claude',
                     cwd: '/Users/test/my-project',
                     tty: 'ttys001',
+                    startTime: new Date('2026-03-18T23:18:01.000Z'),
                 },
             ];
-
-            const sessionData = [
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            // Set up projects dir with encoded directory name
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-test-'));
+            const projectsDir = path.join(tmpDir, 'projects');
+            // Claude encodes /Users/test/my-project → -Users-test-my-project
+            const projDir = path.join(projectsDir, '-Users-test-my-project');
+            fs.mkdirSync(projDir, { recursive: true });
+
+            // Create session file
+            const sessionFile = path.join(projDir, 'session-1.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'user', timestamp: '2026-03-18T23:18:44Z', cwd: '/Users/test/my-project', message: { content: 'Investigate failing tests' } }),
+                JSON.stringify({ type: 'assistant', timestamp: '2026-03-18T23:19:00Z' }),
+            ].join('\n'));
+
+            (adapter as any).projectsDir = projectsDir;
+
+            const sessionFiles: SessionFile[] = [
                 {
                     sessionId: 'session-1',
-                    projectPath: '/Users/test/my-project',
-                    slug: 'merry-dog',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                    lastUserMessage: 'Investigate failing tests in package',
+                    filePath: sessionFile,
+                    projectDir: projDir,
+                    birthtimeMs: new Date('2026-03-18T23:18:44Z').getTime(),
+                    resolvedCwd: '',
                 },
             ];
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue(sessionFiles);
 
-            mockedListProcesses.mockReturnValue(processData);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue(sessionData);
+            const matches: MatchResult[] = [
+                {
+                    process: processes[0],
+                    session: { ...sessionFiles[0], resolvedCwd: '/Users/test/my-project' },
+                    deltaMs: 43000,
+                },
+            ];
+            mockedMatchProcessesToSessions.mockReturnValue(matches);
 
             const agents = await adapter.detectAgents();
 
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                name: 'my-project',
                 type: 'claude',
                 status: AgentStatus.WAITING,
                 pid: 12345,
                 projectPath: '/Users/test/my-project',
                 sessionId: 'session-1',
-                slug: 'merry-dog',
             });
-            expect(agents[0].summary).toContain('Investigate failing tests in package');
+            expect(agents[0].summary).toContain('Investigate failing tests');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
-        it('should include process-only entry when no sessions exist', async () => {
-            mockedListProcesses.mockReturnValue([
+        it('should fall back to process-only for unmatched processes', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'claude', cwd: '/project-a', tty: 'ttys001', startTime: new Date() },
+                { pid: 200, command: 'claude', cwd: '/project-b', tty: 'ttys002', startTime: new Date() },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            // Set up projects dir with encoded directory names
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-test-'));
+            const projectsDir = path.join(tmpDir, 'projects');
+            // /project-a → -project-a, /project-b → -project-b
+            const projDirA = path.join(projectsDir, '-project-a');
+            const projDirB = path.join(projectsDir, '-project-b');
+            fs.mkdirSync(projDirA, { recursive: true });
+            fs.mkdirSync(projDirB, { recursive: true });
+
+            const sessionFile = path.join(projDirA, 'only-session.jsonl');
+            fs.writeFileSync(sessionFile,
+                JSON.stringify({ type: 'assistant', timestamp: '2026-03-18T23:19:00Z' }),
+            );
+
+            (adapter as any).projectsDir = projectsDir;
+
+            const sessionFiles: SessionFile[] = [
                 {
-                    pid: 777,
-                    command: 'claude',
-                    cwd: '/project/without-session',
-                    tty: 'ttys008',
+                    sessionId: 'only-session',
+                    filePath: sessionFile,
+                    projectDir: projDirA,
+                    birthtimeMs: Date.now(),
+                    resolvedCwd: '',
                 },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([]);
+            ];
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue(sessionFiles);
 
+            // Only process 100 matches
+            const matches: MatchResult[] = [
+                {
+                    process: processes[0],
+                    session: { ...sessionFiles[0], resolvedCwd: '/project-a' },
+                    deltaMs: 5000,
+                },
+            ];
+            mockedMatchProcessesToSessions.mockReturnValue(matches);
 
             const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                type: 'claude',
-                status: AgentStatus.IDLE,
-                pid: 777,
-                projectPath: '/project/without-session',
-                sessionId: 'pid-777',
-                summary: 'Unknown',
-            });
+            expect(agents).toHaveLength(2);
+
+            const matched = agents.find(a => a.pid === 100);
+            const unmatched = agents.find(a => a.pid === 200);
+            expect(matched?.sessionId).toBe('only-session');
+            expect(unmatched?.sessionId).toBe('pid-200');
+            expect(unmatched?.status).toBe(AgentStatus.IDLE);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
-        it('should not match process to unrelated session from different project', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 777,
-                    command: 'claude',
-                    cwd: '/project/without-session',
-                    tty: 'ttys008',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
-                {
-                    sessionId: 'session-2',
-                    projectPath: '/other/project',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                },
-            ]);
+        it('should handle process with empty cwd in process-only fallback', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 300, command: 'claude', cwd: '', tty: 'ttys003' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
 
+            (adapter as any).projectsDir = '/nonexistent';
 
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
-            // Unrelated session should NOT match — falls to process-only
             expect(agents[0]).toMatchObject({
-                type: 'claude',
-                pid: 777,
-                sessionId: 'pid-777',
-                projectPath: '/project/without-session',
-                status: AgentStatus.IDLE,
+                pid: 300,
+                sessionId: 'pid-300',
+                summary: 'Unknown',
+                projectPath: '',
             });
         });
 
-        it('should match process in subdirectory to project-root session via parent-child mode', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 888,
-                    command: 'claude',
-                    cwd: '/Users/test/my-project/packages/cli',
-                    tty: 'ttys009',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
-                {
-                    sessionId: 'session-3',
-                    projectPath: '/Users/test/my-project',
-                    slug: 'gentle-otter',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                },
-            ]);
+        it('should use PID file for direct match and skip legacy matching for that process', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 55001, command: 'claude', cwd: '/project/direct', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-pid-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-direct');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const sessionId = 'pid-file-session';
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(jsonlPath, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/direct', message: { content: 'hello from pid file' } }),
+                JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }),
+            ].join('\n'));
+
+            fs.writeFileSync(
+                path.join(sessionsDir, '55001.json'),
+                JSON.stringify({ pid: 55001, sessionId, cwd: '/project/direct', startedAt: startTime.getTime(), kind: 'interactive', entrypoint: 'cli' }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
 
             const agents = await adapter.detectAgents();
+
+            // Legacy matching utilities should NOT have been called (all processes matched via PID file)
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
                 type: 'claude',
-                pid: 888,
-                sessionId: 'session-3',
-                projectPath: '/Users/test/my-project',
+                pid: 55001,
+                sessionId,
+                projectPath: '/project/direct',
+                status: AgentStatus.WAITING,
             });
+            expect(agents[0].summary).toContain('hello from pid file');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
-        it('should show idle status with Unknown summary for process-only fallback when no sessions exist', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 97529,
-                    command: 'claude',
-                    cwd: '/Users/test/my-project/packages/cli',
-                    tty: 'ttys021',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([]);
+        it('should fall back to process-only when direct-matched JSONL becomes unreadable', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 66001, command: 'claude', cwd: '/project/gone', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-gone-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-gone');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const sessionId = 'gone-session';
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(jsonlPath, JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }));
+            fs.writeFileSync(
+                path.join(sessionsDir, '66001.json'),
+                JSON.stringify({ pid: 66001, sessionId, cwd: '/project/gone', startedAt: startTime.getTime(), kind: 'interactive', entrypoint: 'cli' }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            // Simulate JSONL disappearing between existence check and read
+            jest.spyOn(adapter as any, 'readSession').mockReturnValueOnce(null);
 
             const agents = await adapter.detectAgents();
+
+            // matchedPids.delete called → process falls back to IDLE
             expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                type: 'claude',
-                pid: 97529,
-                projectPath: '/Users/test/my-project/packages/cli',
-                sessionId: 'pid-97529',
-                summary: 'Unknown',
-                status: AgentStatus.IDLE,
-            });
+            expect(agents[0].sessionId).toBe('pid-66001');
+            expect(agents[0].status).toBe(AgentStatus.IDLE);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            jest.restoreAllMocks();
         });
 
-        it('should match session via parent-child mode when process cwd is under session project path', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 97529,
-                    command: 'claude',
-                    cwd: '/Users/test/my-project/packages/cli',
-                    tty: 'ttys021',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
-                {
-                    sessionId: 'parent-session',
-                    projectPath: '/Users/test/my-project',
-                    slug: 'fluffy-brewing-kazoo',
-                    sessionStart: new Date('2026-02-23T17:24:50.996Z'),
-                    lastActive: new Date('2026-02-23T17:24:50.996Z'),
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                },
+        it('should fall back to process-only when legacy-matched JSONL becomes unreadable', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 66002, command: 'claude', cwd: '/project/legacy-gone', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-lgone-'));
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-legacy-gone');
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const sessionId = 'legacy-gone-session';
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(jsonlPath, JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }));
+
+            // No PID file → process goes to legacy fallback
+            (adapter as any).sessionsDir = path.join(tmpDir, 'no-sessions');
+            (adapter as any).projectsDir = projectsDir;
+
+            const legacySessionFile = {
+                sessionId,
+                filePath: jsonlPath,
+                projectDir: projDir,
+                birthtimeMs: startTime.getTime(),
+                resolvedCwd: '/project/legacy-gone',
+            };
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([legacySessionFile]);
+            mockedMatchProcessesToSessions.mockReturnValue([
+                { process: processes[0], session: legacySessionFile, deltaMs: 500 },
             ]);
 
+            // Simulate JSONL disappearing between match and read
+            jest.spyOn(adapter as any, 'readSession').mockReturnValueOnce(null);
+
             const agents = await adapter.detectAgents();
+
             expect(agents).toHaveLength(1);
-            // Session matched via parent-child mode
-            expect(agents[0]).toMatchObject({
-                type: 'claude',
-                pid: 97529,
-                sessionId: 'parent-session',
-                projectPath: '/Users/test/my-project',
-            });
+            expect(agents[0].sessionId).toBe('pid-66002');
+            expect(agents[0].status).toBe(AgentStatus.IDLE);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            jest.restoreAllMocks();
         });
 
-        it('should fall back to process-only when sessions exist but all are used', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 100,
-                    command: 'claude',
-                    cwd: '/project-a',
-                    tty: 'ttys001',
-                },
-                {
-                    pid: 200,
-                    command: 'claude',
-                    cwd: '/project-b',
-                    tty: 'ttys002',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
-                {
-                    sessionId: 'only-session',
-                    projectPath: '/project-a',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                },
+        it('should mix direct PID-file matches and legacy matches across processes', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 55002, command: 'claude', cwd: '/project/alpha', tty: 'ttys001', startTime },
+                { pid: 55003, command: 'claude', cwd: '/project/beta', tty: 'ttys002', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-mix-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projAlpha = path.join(projectsDir, '-project-alpha');
+            const projBeta = path.join(projectsDir, '-project-beta');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projAlpha, { recursive: true });
+            fs.mkdirSync(projBeta, { recursive: true });
+
+            // PID file only for process 55002
+            const directSessionId = 'direct-session';
+            const directJsonl = path.join(projAlpha, `${directSessionId}.jsonl`);
+            fs.writeFileSync(directJsonl, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/alpha', message: { content: 'direct question' } }),
+                JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }),
+            ].join('\n'));
+            fs.writeFileSync(
+                path.join(sessionsDir, '55002.json'),
+                JSON.stringify({ pid: 55002, sessionId: directSessionId, cwd: '/project/alpha', startedAt: startTime.getTime(), kind: 'interactive', entrypoint: 'cli' }),
+            );
+
+            // Legacy session file for process 55003
+            const legacySessionId = 'legacy-session';
+            const legacyJsonl = path.join(projBeta, `${legacySessionId}.jsonl`);
+            fs.writeFileSync(legacyJsonl, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/beta', message: { content: 'legacy question' } }),
+                JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }),
+            ].join('\n'));
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            // Mock legacy matching for process 55003
+            const legacySessionFile = {
+                sessionId: legacySessionId,
+                filePath: legacyJsonl,
+                projectDir: projBeta,
+                birthtimeMs: startTime.getTime(),
+                resolvedCwd: '/project/beta',
+            };
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([legacySessionFile]);
+            mockedMatchProcessesToSessions.mockReturnValue([
+                { process: processes[1], session: legacySessionFile, deltaMs: 1000 },
             ]);
 
-
             const agents = await adapter.detectAgents();
+
+            // Legacy matching called only for fallback process (55003)
+            expect(mockedMatchProcessesToSessions).toHaveBeenCalledTimes(1);
+            expect(mockedMatchProcessesToSessions.mock.calls[0][0]).toEqual([processes[1]]);
+
             expect(agents).toHaveLength(2);
-            // First process matched via cwd
-            expect(agents[0]).toMatchObject({
-                pid: 100,
-                sessionId: 'only-session',
-            });
-            // Second process: session used, falls to process-only
-            expect(agents[1]).toMatchObject({
-                pid: 200,
-                sessionId: 'pid-200',
-                status: AgentStatus.IDLE,
-                summary: 'Unknown',
-            });
+            const alpha = agents.find(a => a.pid === 55002);
+            const beta = agents.find(a => a.pid === 55003);
+            expect(alpha?.sessionId).toBe(directSessionId);
+            expect(beta?.sessionId).toBe(legacySessionId);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
         });
+    });
 
-        it('should handle process with empty cwd in process-only fallback', async () => {
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 300,
-                    command: 'claude',
-                    cwd: '',
-                    tty: 'ttys003',
-                },
-            ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([]);
+    describe('discoverSessions', () => {
+        let tmpDir: string;
 
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                pid: 300,
-                sessionId: 'pid-300',
-                summary: 'Unknown',
-                projectPath: '',
-            });
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-test-'));
         });
 
-        it('should prefer cwd-matched session over any-mode session', async () => {
-            const now = new Date();
-            mockedListProcesses.mockReturnValue([
-                {
-                    pid: 100,
-                    command: 'claude',
-                    cwd: '/Users/test/project-a',
-                    tty: 'ttys001',
-                },
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should return empty when projects dir does not exist', () => {
+            (adapter as any).projectsDir = path.join(tmpDir, 'nonexistent');
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const result = discoverSessions([
+                { pid: 1, command: 'claude', cwd: '/test', tty: '' },
             ]);
-            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
-                {
-                    sessionId: 'exact-match',
-                    projectPath: '/Users/test/project-a',
-                    sessionStart: now,
-                    lastActive: now,
-                    lastEntryType: 'assistant',
-                    isInterrupted: false,
-                },
+            expect(result).toEqual([]);
+        });
+
+        it('should scan only directories matching process CWDs', () => {
+            const projectsDir = path.join(tmpDir, 'projects');
+            (adapter as any).projectsDir = projectsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            // /my/project → -my-project (encoded dir)
+            const encodedDir = path.join(projectsDir, '-my-project');
+            fs.mkdirSync(encodedDir, { recursive: true });
+
+            // Also create another dir that should NOT be scanned
+            const otherDir = path.join(projectsDir, '-other-project');
+            fs.mkdirSync(otherDir, { recursive: true });
+
+            const mockFiles: SessionFile[] = [
                 {
-                    sessionId: 'other-project',
-                    projectPath: '/Users/test/project-b',
-                    sessionStart: now,
-                    lastActive: new Date(now.getTime() + 1000), // more recent
-                    lastEntryType: 'user',
-                    isInterrupted: false,
+                    sessionId: 's1',
+                    filePath: path.join(encodedDir, 's1.jsonl'),
+                    projectDir: encodedDir,
+                    birthtimeMs: 1710800324000,
+                    resolvedCwd: '',
                 },
+            ];
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue(mockFiles);
+
+            const processes = [
+                { pid: 1, command: 'claude', cwd: '/my/project', tty: '' },
+            ];
+
+            const result = discoverSessions(processes);
+            expect(result).toHaveLength(1);
+            expect(result[0].resolvedCwd).toBe('/my/project');
+            // batchGetSessionFileBirthtimes called once with all dirs
+            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
+            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
+        });
+
+        it('should return empty when encoded dir does not exist', () => {
+            const projectsDir = path.join(tmpDir, 'projects');
+            fs.mkdirSync(projectsDir, { recursive: true });
+            (adapter as any).projectsDir = projectsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            // Process CWD /test encodes to -test, but that dir doesn't exist
+            const result = discoverSessions([
+                { pid: 1, command: 'claude', cwd: '/test', tty: '' },
             ]);
+            expect(result).toEqual([]);
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+        });
 
+        it('should deduplicate when multiple processes share same CWD', () => {
+            const projectsDir = path.join(tmpDir, 'projects');
+            (adapter as any).projectsDir = projectsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
 
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                sessionId: 'exact-match',
-                projectPath: '/Users/test/project-a',
-            });
+            const encodedDir = path.join(projectsDir, '-my-project');
+            fs.mkdirSync(encodedDir, { recursive: true });
+
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                { sessionId: 's1', filePath: path.join(encodedDir, 's1.jsonl'), projectDir: encodedDir, birthtimeMs: 1710800324000, resolvedCwd: '' },
+            ]);
+
+            const processes = [
+                { pid: 1, command: 'claude', cwd: '/my/project', tty: '' },
+                { pid: 2, command: 'claude', cwd: '/my/project', tty: '' },
+            ];
+
+            const result = discoverSessions(processes);
+            // Should only call batch once with deduplicated dir
+            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
+            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
+            expect(result).toHaveLength(1);
+        });
+
+        it('should skip processes with empty cwd', () => {
+            const projectsDir = path.join(tmpDir, 'projects');
+            fs.mkdirSync(projectsDir, { recursive: true });
+            (adapter as any).projectsDir = projectsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const result = discoverSessions([
+                { pid: 1, command: 'claude', cwd: '', tty: '' },
+            ]);
+            expect(result).toEqual([]);
         });
     });
 
     describe('helper methods', () => {
         describe('determineStatus', () => {
             it('should return "unknown" for sessions with no last entry type', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -402,12 +611,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.UNKNOWN);
+                expect(determineStatus(session)).toBe(AgentStatus.UNKNOWN);
             });
 
             it('should return "waiting" for assistant entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -419,12 +626,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.WAITING);
+                expect(determineStatus(session)).toBe(AgentStatus.WAITING);
             });
 
             it('should return "waiting" for user interruption', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -436,12 +641,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: true,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.WAITING);
+                expect(determineStatus(session)).toBe(AgentStatus.WAITING);
             });
 
             it('should return "running" for user/progress entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -453,16 +656,13 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.RUNNING);
+                expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
             });
 
             it('should not override status based on age (process is running)', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const oldDate = new Date(Date.now() - 10 * 60 * 1000);
-
                 const session = {
                     sessionId: 'test',
                     projectPath: '/test',
@@ -472,14 +672,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                // Even with old lastActive, entry type determines status
-                // because the process is known to be running
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.WAITING);
+                expect(determineStatus(session)).toBe(AgentStatus.WAITING);
             });
 
             it('should return "idle" for system entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -491,12 +687,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.IDLE);
+                expect(determineStatus(session)).toBe(AgentStatus.IDLE);
             });
 
             it('should return "running" for thinking entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -508,12 +702,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.RUNNING);
+                expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
             });
 
             it('should return "running" for progress entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -525,12 +717,10 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.RUNNING);
+                expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
             });
 
             it('should return "unknown" for unrecognized entry types', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const determineStatus = (adapter as any).determineStatus.bind(adapter);
 
                 const session = {
@@ -542,380 +732,17 @@ describe('ClaudeCodeAdapter', () => {
                     isInterrupted: false,
                 };
 
-                const status = determineStatus(session);
-                expect(status).toBe(AgentStatus.UNKNOWN);
-            });
-        });
-
-        describe('generateAgentName', () => {
-            it('should use project name for first session', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const generateAgentName = (adapter as any).generateAgentName.bind(adapter);
-
-                const session = {
-                    sessionId: 'test-123',
-                    projectPath: '/Users/test/my-project',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    isInterrupted: false,
-                };
-
-                const name = generateAgentName(session, []);
-                expect(name).toBe('my-project');
-            });
-
-            it('should append slug for duplicate projects', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const generateAgentName = (adapter as any).generateAgentName.bind(adapter);
-
-                const existingAgent: AgentInfo = {
-                    name: 'my-project',
-                    projectPath: '/Users/test/my-project',
-                    type: 'claude',
-                    status: AgentStatus.RUNNING,
-                    summary: 'Test',
-                    pid: 123,
-                    sessionId: 'existing-123',
-                    slug: 'happy-cat',
-                    lastActive: new Date(),
-                };
-
-                const session = {
-                    sessionId: 'test-456',
-                    projectPath: '/Users/test/my-project',
-                    slug: 'merry-dog',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    isInterrupted: false,
-                };
-
-                const name = generateAgentName(session, [existingAgent]);
-                expect(name).toBe('my-project (merry)');
-            });
-
-            it('should use session ID prefix when no slug available', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const generateAgentName = (adapter as any).generateAgentName.bind(adapter);
-
-                const existingAgent: AgentInfo = {
-                    name: 'my-project',
-                    projectPath: '/Users/test/my-project',
-                    type: 'claude',
-                    status: AgentStatus.RUNNING,
-                    summary: 'Test',
-                    pid: 123,
-                    sessionId: 'existing-123',
-                    lastActive: new Date(),
-                };
-
-                const session = {
-                    sessionId: 'abcdef12-3456-7890',
-                    projectPath: '/Users/test/my-project',
-                    sessionStart: new Date(),
-                    lastActive: new Date(),
-                    isInterrupted: false,
-                };
-
-                const name = generateAgentName(session, [existingAgent]);
-                expect(name).toBe('my-project (abcdef12)');
-            });
-        });
-
-        describe('parseElapsedSeconds', () => {
-            it('should parse MM:SS format', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const parseElapsedSeconds = (adapter as any).parseElapsedSeconds.bind(adapter);
-
-                expect(parseElapsedSeconds('05:30')).toBe(330);
-            });
-
-            it('should parse HH:MM:SS format', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const parseElapsedSeconds = (adapter as any).parseElapsedSeconds.bind(adapter);
-
-                expect(parseElapsedSeconds('02:30:15')).toBe(9015);
-            });
-
-            it('should parse D-HH:MM:SS format', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const parseElapsedSeconds = (adapter as any).parseElapsedSeconds.bind(adapter);
-
-                expect(parseElapsedSeconds('3-12:00:00')).toBe(302400);
-            });
-
-            it('should return null for invalid format', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const parseElapsedSeconds = (adapter as any).parseElapsedSeconds.bind(adapter);
-
-                expect(parseElapsedSeconds('invalid')).toBeNull();
-            });
-        });
-
-        describe('calculateSessionScanLimit', () => {
-            it('should return minimum for small process count', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const calculateSessionScanLimit = (adapter as any).calculateSessionScanLimit.bind(adapter);
-
-                // 1 process * 4 = 4, min(max(4, 12), 40) = 12
-                expect(calculateSessionScanLimit(1)).toBe(12);
-            });
-
-            it('should scale with process count', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const calculateSessionScanLimit = (adapter as any).calculateSessionScanLimit.bind(adapter);
-
-                // 5 processes * 4 = 20, min(max(20, 12), 40) = 20
-                expect(calculateSessionScanLimit(5)).toBe(20);
-            });
-
-            it('should cap at maximum', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const calculateSessionScanLimit = (adapter as any).calculateSessionScanLimit.bind(adapter);
-
-                // 15 processes * 4 = 60, min(max(60, 12), 40) = 40
-                expect(calculateSessionScanLimit(15)).toBe(40);
-            });
-        });
-
-        describe('rankCandidatesByStartTime', () => {
-            it('should prefer sessions within tolerance window', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const rankCandidatesByStartTime = (adapter as any).rankCandidatesByStartTime.bind(adapter);
-
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const candidates = [
-                    {
-                        sessionId: 'far',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T09:50:00Z'), // 10 min diff
-                        lastActive: new Date('2026-03-10T10:05:00Z'),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'close',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T10:00:30Z'), // 30s diff
-                        lastActive: new Date('2026-03-10T10:03:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const ranked = rankCandidatesByStartTime(candidates, processStart);
-                expect(ranked[0].sessionId).toBe('close');
-                expect(ranked[1].sessionId).toBe('far');
-            });
-
-            it('should prefer recency over diffMs when both within tolerance', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const rankCandidatesByStartTime = (adapter as any).rankCandidatesByStartTime.bind(adapter);
-
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const candidates = [
-                    {
-                        sessionId: 'closer-but-stale',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T10:00:06Z'), // 6s diff
-                        lastActive: new Date('2026-03-10T10:00:10Z'),  // older activity
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'farther-but-active',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T10:00:45Z'), // 45s diff
-                        lastActive: new Date('2026-03-10T10:30:00Z'),  // much more recent
-                        isInterrupted: false,
-                    },
-                ];
-
-                const ranked = rankCandidatesByStartTime(candidates, processStart);
-                // Both within tolerance — recency wins over smaller diffMs
-                expect(ranked[0].sessionId).toBe('farther-but-active');
-                expect(ranked[1].sessionId).toBe('closer-but-stale');
-            });
-
-            it('should break ties by recency when outside tolerance with same diffMs', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const rankCandidatesByStartTime = (adapter as any).rankCandidatesByStartTime.bind(adapter);
-
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const candidates = [
-                    {
-                        sessionId: 'older-activity',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T09:50:00Z'), // 10min diff
-                        lastActive: new Date('2026-03-10T10:01:00Z'),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'newer-activity',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T10:10:00Z'), // 10min diff (same abs)
-                        lastActive: new Date('2026-03-10T10:30:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const ranked = rankCandidatesByStartTime(candidates, processStart);
-                // Both outside tolerance, same diffMs — recency wins
-                expect(ranked[0].sessionId).toBe('newer-activity');
-            });
-
-            it('should fall back to recency when both outside tolerance', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const rankCandidatesByStartTime = (adapter as any).rankCandidatesByStartTime.bind(adapter);
-
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const candidates = [
-                    {
-                        sessionId: 'older',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T09:30:00Z'),
-                        lastActive: new Date('2026-03-10T10:01:00Z'),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'newer',
-                        projectPath: '/test',
-                        sessionStart: new Date('2026-03-10T09:40:00Z'),
-                        lastActive: new Date('2026-03-10T10:05:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const ranked = rankCandidatesByStartTime(candidates, processStart);
-                // Both outside tolerance (rank=1), newer has smaller diffMs
-                expect(ranked[0].sessionId).toBe('newer');
-            });
-        });
-
-        describe('filterCandidateSessions', () => {
-            it('should match by lastCwd in cwd mode', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const filterCandidateSessions = (adapter as any).filterCandidateSessions.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const sessions = [
-                    {
-                        sessionId: 's1',
-                        projectPath: '/different/path',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const result = filterCandidateSessions(processInfo, sessions, new Set(), 'cwd');
-                expect(result).toHaveLength(1);
-                expect(result[0].sessionId).toBe('s1');
-            });
-
-            it('should match sessions with no projectPath in missing-cwd mode', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const filterCandidateSessions = (adapter as any).filterCandidateSessions.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const sessions = [
-                    {
-                        sessionId: 's1',
-                        projectPath: '',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 's2',
-                        projectPath: '/has/path',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const result = filterCandidateSessions(processInfo, sessions, new Set(), 'missing-cwd');
-                expect(result).toHaveLength(1);
-                expect(result[0].sessionId).toBe('s1');
-            });
-
-            it('should include exact CWD matches in parent-child mode', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const filterCandidateSessions = (adapter as any).filterCandidateSessions.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const sessions = [
-                    {
-                        sessionId: 's1',
-                        projectPath: '/my/project',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const result = filterCandidateSessions(processInfo, sessions, new Set(), 'parent-child');
-                expect(result).toHaveLength(1);
-                expect(result[0].sessionId).toBe('s1');
-            });
-
-            it('should match parent-child relationships', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const filterCandidateSessions = (adapter as any).filterCandidateSessions.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const sessions = [
-                    {
-                        sessionId: 'child-session',
-                        projectPath: '/my/project/packages/sub',
-                        lastCwd: '/my/project/packages/sub',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'parent-session',
-                        projectPath: '/my',
-                        lastCwd: '/my',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const result = filterCandidateSessions(processInfo, sessions, new Set(), 'parent-child');
-                expect(result).toHaveLength(2);
-            });
-
-            it('should skip used sessions', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const filterCandidateSessions = (adapter as any).filterCandidateSessions.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const sessions = [
-                    {
-                        sessionId: 's1',
-                        projectPath: '/my/project',
-                        sessionStart: new Date(),
-                        lastActive: new Date(),
-                        isInterrupted: false,
-                    },
-                ];
-
-                const result = filterCandidateSessions(processInfo, sessions, new Set(['s1']), 'cwd');
-                expect(result).toHaveLength(0);
+                expect(determineStatus(session)).toBe(AgentStatus.UNKNOWN);
             });
         });
 
         describe('extractUserMessageText', () => {
             it('should extract plain string content', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
-
                 expect(extract('hello world')).toBe('hello world');
             });
 
             it('should extract text from array content blocks', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 const content = [
@@ -926,7 +753,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return undefined for empty/null content', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 expect(extract(undefined)).toBeUndefined();
@@ -935,7 +761,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should parse command-message tags', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 const msg = '<command-message><command-name>commit</command-name><command-args>fix bug</command-args></command-message>';
@@ -943,7 +768,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should parse command-message without args', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 const msg = '<command-message><command-name>help</command-name></command-message>';
@@ -951,7 +775,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should extract ARGUMENTS from skill expansion', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 const msg = 'Base directory for this skill: /some/path\n\nSome instructions\n\nARGUMENTS: implement the feature';
@@ -959,7 +782,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return undefined for skill expansion without ARGUMENTS', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 const msg = 'Base directory for this skill: /some/path\n\nSome instructions only';
@@ -967,7 +789,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should filter noise messages', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const extract = (adapter as any).extractUserMessageText.bind(adapter);
 
                 expect(extract('[Request interrupted by user]')).toBeUndefined();
@@ -978,119 +799,189 @@ describe('ClaudeCodeAdapter', () => {
 
         describe('parseCommandMessage', () => {
             it('should return undefined for malformed command-message', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const parse = (adapter as any).parseCommandMessage.bind(adapter);
-
                 expect(parse('<command-message>no tags</command-message>')).toBeUndefined();
             });
         });
     });
 
-    describe('selectBestSession', () => {
-            it('should defer in cwd mode when best candidate is outside tolerance', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const selectBestSession = (adapter as any).selectBestSession.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const processStartByPid = new Map([[1, processStart]]);
-
-                const sessions = [
-                    {
-                        sessionId: 'stale-exact-cwd',
-                        projectPath: '/my/project',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date('2026-03-07T10:00:00Z'), // 3 days old — outside tolerance
-                        lastActive: new Date('2026-03-10T10:05:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
+    describe('file I/O methods', () => {
+        let tmpDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-test-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
 
-                // In cwd mode, should defer (return undefined) because outside tolerance
-                const cwdResult = selectBestSession(processInfo, sessions, new Set(), processStartByPid, 'cwd');
-                expect(cwdResult).toBeUndefined();
+        describe('tryPidFileMatching', () => {
+            let sessionsDir: string;
+            let projectsDir: string;
 
-                // In parent-child mode, should accept the same candidate (no tolerance gate)
-                const parentChildResult = selectBestSession(processInfo, sessions, new Set(), processStartByPid, 'parent-child');
-                expect(parentChildResult).toBeDefined();
-                expect(parentChildResult.sessionId).toBe('stale-exact-cwd');
+            beforeEach(() => {
+                sessionsDir = path.join(tmpDir, 'sessions');
+                projectsDir = path.join(tmpDir, 'projects');
+                fs.mkdirSync(sessionsDir, { recursive: true });
+                (adapter as any).sessionsDir = sessionsDir;
+                (adapter as any).projectsDir = projectsDir;
             });
 
-            it('should fall back to recency when no processStart available', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const selectBestSession = (adapter as any).selectBestSession.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const processStartByPid = new Map<number, Date>(); // empty — no start time
-
-                const sessions = [
-                    {
-                        sessionId: 'older',
-                        projectPath: '/my/project',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date('2026-03-10T09:00:00Z'),
-                        lastActive: new Date('2026-03-10T09:30:00Z'),
-                        isInterrupted: false,
-                    },
-                    {
-                        sessionId: 'newer',
-                        projectPath: '/my/project',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date('2026-03-10T10:00:00Z'),
-                        lastActive: new Date('2026-03-10T10:30:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
+            const makeProc = (pid: number, cwd = '/project/test', startTime?: Date): ProcessInfo => ({
+                pid, command: 'claude', cwd, tty: 'ttys001', startTime,
+            });
 
-                const result = selectBestSession(processInfo, sessions, new Set(), processStartByPid, 'cwd');
-                expect(result).toBeDefined();
-                expect(result.sessionId).toBe('newer');
+            const writePidFile = (pid: number, sessionId: string, cwd: string, startedAt: number) => {
+                fs.writeFileSync(
+                    path.join(sessionsDir, `${pid}.json`),
+                    JSON.stringify({ pid, sessionId, cwd, startedAt, kind: 'interactive', entrypoint: 'cli' }),
+                );
+            };
+
+            const writeJsonl = (cwd: string, sessionId: string) => {
+                const encoded = cwd.replace(/\//g, '-');
+                const projDir = path.join(projectsDir, encoded);
+                fs.mkdirSync(projDir, { recursive: true });
+                const filePath = path.join(projDir, `${sessionId}.jsonl`);
+                fs.writeFileSync(filePath, JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }));
+                return filePath;
+            };
+
+            it('should return direct match when PID file and JSONL both exist within time tolerance', () => {
+                const startTime = new Date();
+                const proc = makeProc(1001, '/project/test', startTime);
+                writePidFile(1001, 'session-abc', '/project/test', startTime.getTime());
+                writeJsonl('/project/test', 'session-abc');
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
+
+                expect(direct).toHaveLength(1);
+                expect(fallback).toHaveLength(0);
+                expect(direct[0].sessionFile.sessionId).toBe('session-abc');
+                expect(direct[0].sessionFile.resolvedCwd).toBe('/project/test');
+                expect(direct[0].process.pid).toBe(1001);
             });
 
-            it('should accept in cwd mode when best candidate is within tolerance', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const selectBestSession = (adapter as any).selectBestSession.bind(adapter);
-
-                const processInfo = { pid: 1, command: 'claude', cwd: '/my/project', tty: '' };
-                const processStart = new Date('2026-03-10T10:00:00Z');
-                const processStartByPid = new Map([[1, processStart]]);
-
-                const sessions = [
-                    {
-                        sessionId: 'fresh-exact-cwd',
-                        projectPath: '/my/project',
-                        lastCwd: '/my/project',
-                        sessionStart: new Date('2026-03-10T10:00:30Z'), // 30s — within tolerance
-                        lastActive: new Date('2026-03-10T10:05:00Z'),
-                        isInterrupted: false,
-                    },
-                ];
+            it('should fall back when PID file exists but JSONL is missing', () => {
+                const startTime = new Date();
+                const proc = makeProc(1002, '/project/test', startTime);
+                writePidFile(1002, 'nonexistent-session', '/project/test', startTime.getTime());
+                // No JSONL file written
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
 
-                const result = selectBestSession(processInfo, sessions, new Set(), processStartByPid, 'cwd');
-                expect(result).toBeDefined();
-                expect(result.sessionId).toBe('fresh-exact-cwd');
+                expect(direct).toHaveLength(0);
+                expect(fallback).toHaveLength(1);
+                expect(fallback[0].pid).toBe(1002);
             });
-        });
 
-    describe('file I/O methods', () => {
-        let tmpDir: string;
+            it('should fall back when startedAt is stale (>60s from proc.startTime)', () => {
+                const startTime = new Date();
+                const staleTime = startTime.getTime() - 90_000; // 90 seconds earlier
+                const proc = makeProc(1003, '/project/test', startTime);
+                writePidFile(1003, 'stale-session', '/project/test', staleTime);
+                writeJsonl('/project/test', 'stale-session');
 
-        beforeEach(() => {
-            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-test-'));
-        });
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
 
-        afterEach(() => {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
+                expect(direct).toHaveLength(0);
+                expect(fallback).toHaveLength(1);
+            });
+
+            it('should accept PID file when startedAt is within 60s tolerance', () => {
+                const startTime = new Date();
+                const closeTime = startTime.getTime() - 30_000; // 30 seconds earlier — within tolerance
+                const proc = makeProc(1004, '/project/test', startTime);
+                writePidFile(1004, 'close-session', '/project/test', closeTime);
+                writeJsonl('/project/test', 'close-session');
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
+
+                expect(direct).toHaveLength(1);
+                expect(fallback).toHaveLength(0);
+            });
+
+            it('should fall back when PID file is absent', () => {
+                const proc = makeProc(1005, '/project/test', new Date());
+                // No PID file written
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
+
+                expect(direct).toHaveLength(0);
+                expect(fallback).toHaveLength(1);
+            });
+
+            it('should fall back when PID file contains malformed JSON', () => {
+                const proc = makeProc(1006, '/project/test', new Date());
+                fs.writeFileSync(path.join(sessionsDir, '1006.json'), 'not valid json {{{');
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                expect(() => {
+                    const { direct, fallback } = tryMatch([proc]);
+                    expect(direct).toHaveLength(0);
+                    expect(fallback).toHaveLength(1);
+                }).not.toThrow();
+            });
+
+            it('should fall back for all processes when sessions dir does not exist', () => {
+                (adapter as any).sessionsDir = path.join(tmpDir, 'nonexistent-sessions');
+                const processes = [makeProc(2001, '/a', new Date()), makeProc(2002, '/b', new Date())];
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch(processes);
+
+                expect(direct).toHaveLength(0);
+                expect(fallback).toHaveLength(2);
+            });
+
+            it('should correctly split mixed processes (some with PID files, some without)', () => {
+                const startTime = new Date();
+                const proc1 = makeProc(3001, '/project/one', startTime);
+                const proc2 = makeProc(3002, '/project/two', startTime);
+                const proc3 = makeProc(3003, '/project/three', startTime);
+
+                writePidFile(3001, 'session-one', '/project/one', startTime.getTime());
+                writeJsonl('/project/one', 'session-one');
+                writePidFile(3003, 'session-three', '/project/three', startTime.getTime());
+                writeJsonl('/project/three', 'session-three');
+                // proc2 has no PID file
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc1, proc2, proc3]);
+
+                expect(direct).toHaveLength(2);
+                expect(fallback).toHaveLength(1);
+                expect(direct.map((d: any) => d.process.pid).sort()).toEqual([3001, 3003]);
+                expect(fallback[0].pid).toBe(3002);
+            });
+
+            it('should skip stale-file check when proc.startTime is undefined', () => {
+                const proc = makeProc(4001, '/project/test', undefined); // no startTime
+                writePidFile(4001, 'no-time-session', '/project/test', Date.now() - 999_999);
+                writeJsonl('/project/test', 'no-time-session');
+
+                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
+                const { direct, fallback } = tryMatch([proc]);
+
+                // startTime undefined → stale check skipped → direct match
+                expect(direct).toHaveLength(1);
+                expect(fallback).toHaveLength(0);
+            });
         });
 
         describe('readSession', () => {
-            it('should parse session file with timestamps, slug, cwd, and entry type', () => {
-                const adapter = new ClaudeCodeAdapter();
+            it('should parse session file with timestamps, cwd, and entry type', () => {
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'test-session.jsonl');
                 const lines = [
-                    JSON.stringify({ type: 'user', timestamp: '2026-03-10T10:00:00Z', cwd: '/my/project', slug: 'happy-dog' }),
+                    JSON.stringify({ type: 'user', timestamp: '2026-03-10T10:00:00Z', cwd: '/my/project' }),
                     JSON.stringify({ type: 'assistant', timestamp: '2026-03-10T10:01:00Z' }),
                 ];
                 fs.writeFileSync(filePath, lines.join('\n'));
@@ -1099,7 +990,6 @@ describe('ClaudeCodeAdapter', () => {
                 expect(session).toMatchObject({
                     sessionId: 'test-session',
                     projectPath: '/my/project',
-                    slug: 'happy-dog',
                     lastCwd: '/my/project',
                     lastEntryType: 'assistant',
                     isInterrupted: false,
@@ -1109,7 +999,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should detect user interruption', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'interrupted.jsonl');
@@ -1130,28 +1019,22 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return session with defaults for empty file', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'empty.jsonl');
                 fs.writeFileSync(filePath, '');
 
                 const session = readSession(filePath, '/test');
-                // Empty file content trims to '' which splits to [''] — no valid entries parsed
                 expect(session).not.toBeNull();
                 expect(session.lastEntryType).toBeUndefined();
-                expect(session.slug).toBeUndefined();
             });
 
             it('should return null for non-existent file', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
-
                 expect(readSession(path.join(tmpDir, 'nonexistent.jsonl'), '/test')).toBeNull();
             });
 
             it('should skip metadata entry types for lastEntryType', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'metadata-test.jsonl');
@@ -1164,12 +1047,10 @@ describe('ClaudeCodeAdapter', () => {
                 fs.writeFileSync(filePath, lines.join('\n'));
 
                 const session = readSession(filePath, '/test');
-                // lastEntryType should be 'assistant', not 'last-prompt' or 'file-history-snapshot'
                 expect(session.lastEntryType).toBe('assistant');
             });
 
             it('should parse snapshot.timestamp from file-history-snapshot first entry', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'snapshot-ts.jsonl');
@@ -1184,13 +1065,11 @@ describe('ClaudeCodeAdapter', () => {
                 fs.writeFileSync(filePath, lines.join('\n'));
 
                 const session = readSession(filePath, '/test');
-                // sessionStart should come from snapshot.timestamp, not lastActive
                 expect(session.sessionStart.toISOString()).toBe('2026-03-10T09:55:00.000Z');
                 expect(session.lastActive.toISOString()).toBe('2026-03-10T10:01:00.000Z');
             });
 
             it('should extract lastUserMessage from session entries', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'user-msg.jsonl');
@@ -1203,12 +1082,10 @@ describe('ClaudeCodeAdapter', () => {
                 fs.writeFileSync(filePath, lines.join('\n'));
 
                 const session = readSession(filePath, '/test');
-                // Last user message should be the most recent one
                 expect(session.lastUserMessage).toBe('second question');
             });
 
             it('should use lastCwd as projectPath when projectPath is empty', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'no-project.jsonl');
@@ -1222,7 +1099,6 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should handle malformed JSON lines gracefully', () => {
-                const adapter = new ClaudeCodeAdapter();
                 const readSession = (adapter as any).readSession.bind(adapter);
 
                 const filePath = path.join(tmpDir, 'malformed.jsonl');
@@ -1237,131 +1113,179 @@ describe('ClaudeCodeAdapter', () => {
                 expect(session.lastEntryType).toBe('assistant');
             });
         });
+    });
 
-        describe('findSessionFiles', () => {
-            it('should return empty when projects dir does not exist', () => {
-                const adapter = new ClaudeCodeAdapter();
-                (adapter as any).projectsDir = path.join(tmpDir, 'nonexistent');
-                const findSessionFiles = (adapter as any).findSessionFiles.bind(adapter);
+    describe('getConversation', () => {
+        let tmpDir: string;
 
-                expect(findSessionFiles(10)).toEqual([]);
-            });
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-conv-'));
+        });
 
-            it('should find and sort session files by mtime', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const projectsDir = path.join(tmpDir, 'projects');
-                (adapter as any).projectsDir = projectsDir;
-                const findSessionFiles = (adapter as any).findSessionFiles.bind(adapter);
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
 
-                // Create project dir with sessions-index.json and JSONL files
-                const projDir = path.join(projectsDir, 'encoded-path');
-                fs.mkdirSync(projDir, { recursive: true });
-                fs.writeFileSync(
-                    path.join(projDir, 'sessions-index.json'),
-                    JSON.stringify({ originalPath: '/my/project' }),
-                );
+        function writeJsonl(lines: object[]): string {
+            const filePath = path.join(tmpDir, 'session.jsonl');
+            fs.writeFileSync(filePath, lines.map(l => JSON.stringify(l)).join('\n'));
+            return filePath;
+        }
 
-                const file1 = path.join(projDir, 'session-old.jsonl');
-                const file2 = path.join(projDir, 'session-new.jsonl');
-                fs.writeFileSync(file1, '{}');
-                // Ensure different mtime
-                const past = new Date(Date.now() - 10000);
-                fs.utimesSync(file1, past, past);
-                fs.writeFileSync(file2, '{}');
-
-                const files = findSessionFiles(10);
-                expect(files).toHaveLength(2);
-                // Sorted by mtime desc — new first
-                expect(files[0].filePath).toContain('session-new');
-                expect(files[0].projectPath).toBe('/my/project');
-                expect(files[1].filePath).toContain('session-old');
-            });
+        it('should parse user and assistant text messages', () => {
+            const filePath = writeJsonl([
+                { type: 'user', timestamp: '2026-03-27T10:00:00Z', message: { content: 'Hello' } },
+                { type: 'assistant', timestamp: '2026-03-27T10:00:05Z', message: { content: [{ type: 'text', text: 'Hi there!' }] } },
+            ]);
 
-            it('should respect scan limit', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const projectsDir = path.join(tmpDir, 'projects');
-                (adapter as any).projectsDir = projectsDir;
-                const findSessionFiles = (adapter as any).findSessionFiles.bind(adapter);
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+            expect(messages[0]).toEqual({ role: 'user', content: 'Hello', timestamp: '2026-03-27T10:00:00Z' });
+            expect(messages[1]).toEqual({ role: 'assistant', content: 'Hi there!', timestamp: '2026-03-27T10:00:05Z' });
+        });
 
-                const projDir = path.join(projectsDir, 'proj');
-                fs.mkdirSync(projDir, { recursive: true });
-                fs.writeFileSync(
-                    path.join(projDir, 'sessions-index.json'),
-                    JSON.stringify({ originalPath: '/proj' }),
-                );
+        it('should skip metadata entry types', () => {
+            const filePath = writeJsonl([
+                { type: 'file-history-snapshot', timestamp: '2026-03-27T10:00:00Z', snapshot: {} },
+                { type: 'last-prompt', timestamp: '2026-03-27T10:00:00Z' },
+                { type: 'user', timestamp: '2026-03-27T10:00:01Z', message: { content: 'Fix bug' } },
+            ]);
 
-                for (let i = 0; i < 5; i++) {
-                    fs.writeFileSync(path.join(projDir, `session-${i}.jsonl`), '{}');
-                }
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Fix bug');
+        });
 
-                const files = findSessionFiles(3);
-                expect(files).toHaveLength(3);
-            });
+        it('should skip progress and thinking entries', () => {
+            const filePath = writeJsonl([
+                { type: 'user', timestamp: '2026-03-27T10:00:00Z', message: { content: 'Hello' } },
+                { type: 'progress', timestamp: '2026-03-27T10:00:01Z', data: {} },
+                { type: 'thinking', timestamp: '2026-03-27T10:00:02Z' },
+                { type: 'assistant', timestamp: '2026-03-27T10:00:03Z', message: { content: [{ type: 'text', text: 'Done' }] } },
+            ]);
 
-            it('should skip directories starting with dot', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const projectsDir = path.join(tmpDir, 'projects');
-                (adapter as any).projectsDir = projectsDir;
-                const findSessionFiles = (adapter as any).findSessionFiles.bind(adapter);
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+            expect(messages[0].role).toBe('user');
+            expect(messages[1].role).toBe('assistant');
+        });
 
-                const hiddenDir = path.join(projectsDir, '.hidden');
-                fs.mkdirSync(hiddenDir, { recursive: true });
-                fs.writeFileSync(
-                    path.join(hiddenDir, 'sessions-index.json'),
-                    JSON.stringify({ originalPath: '/hidden' }),
-                );
-                fs.writeFileSync(path.join(hiddenDir, 'session.jsonl'), '{}');
+        it('should include system messages', () => {
+            const filePath = writeJsonl([
+                { type: 'system', timestamp: '2026-03-27T10:00:00Z', message: { content: 'System initialized' } },
+            ]);
 
-                const files = findSessionFiles(10);
-                expect(files).toEqual([]);
-            });
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0]).toEqual({ role: 'system', content: 'System initialized', timestamp: '2026-03-27T10:00:00Z' });
+        });
 
-            it('should include project dirs without sessions-index.json using empty projectPath', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const projectsDir = path.join(tmpDir, 'projects');
-                (adapter as any).projectsDir = projectsDir;
-                const findSessionFiles = (adapter as any).findSessionFiles.bind(adapter);
+        it('should skip tool_use and tool_result blocks in default mode', () => {
+            const filePath = writeJsonl([
+                {
+                    type: 'assistant', timestamp: '2026-03-27T10:00:00Z',
+                    message: {
+                        content: [
+                            { type: 'text', text: 'Let me read the file.' },
+                            { type: 'tool_use', name: 'Read', input: { file_path: '/src/app.ts' } },
+                        ],
+                    },
+                },
+                {
+                    type: 'user', timestamp: '2026-03-27T10:00:01Z',
+                    message: {
+                        content: [
+                            { type: 'tool_result', tool_use_id: 'toolu_1', content: 'file contents here' },
+                        ],
+                    },
+                },
+            ]);
 
-                const projDir = path.join(projectsDir, 'no-index');
-                fs.mkdirSync(projDir, { recursive: true });
-                fs.writeFileSync(path.join(projDir, 'session.jsonl'), '{}');
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Let me read the file.');
+        });
 
-                const files = findSessionFiles(10);
-                expect(files).toHaveLength(1);
-                expect(files[0].projectPath).toBe('');
-                expect(files[0].filePath).toContain('session.jsonl');
-            });
+        it('should include tool_use and tool_result blocks in verbose mode', () => {
+            const filePath = writeJsonl([
+                {
+                    type: 'assistant', timestamp: '2026-03-27T10:00:00Z',
+                    message: {
+                        content: [
+                            { type: 'text', text: 'Let me read the file.' },
+                            { type: 'tool_use', name: 'Read', input: { file_path: '/src/app.ts' } },
+                        ],
+                    },
+                },
+                {
+                    type: 'user', timestamp: '2026-03-27T10:00:01Z',
+                    message: {
+                        content: [
+                            { type: 'tool_result', tool_use_id: 'toolu_1', content: 'file contents here' },
+                        ],
+                    },
+                },
+            ]);
+
+            const messages = adapter.getConversation(filePath, { verbose: true });
+            expect(messages).toHaveLength(2);
+            expect(messages[0].content).toContain('[Tool: Read]');
+            expect(messages[0].content).toContain('/src/app.ts');
+            expect(messages[1].content).toContain('[Tool Result]');
         });
 
-        describe('readSessions', () => {
-            it('should parse valid sessions and skip invalid ones', () => {
-                const adapter = new ClaudeCodeAdapter();
-                const projectsDir = path.join(tmpDir, 'projects');
-                (adapter as any).projectsDir = projectsDir;
-                const readSessions = (adapter as any).readSessions.bind(adapter);
+        it('should handle tool_result errors in verbose mode', () => {
+            const filePath = writeJsonl([
+                {
+                    type: 'user', timestamp: '2026-03-27T10:00:00Z',
+                    message: {
+                        content: [
+                            { type: 'tool_result', tool_use_id: 'toolu_1', content: 'Something went wrong', is_error: true },
+                        ],
+                    },
+                },
+            ]);
 
-                const projDir = path.join(projectsDir, 'proj');
-                fs.mkdirSync(projDir, { recursive: true });
-                fs.writeFileSync(
-                    path.join(projDir, 'sessions-index.json'),
-                    JSON.stringify({ originalPath: '/my/project' }),
-                );
+            const messages = adapter.getConversation(filePath, { verbose: true });
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toContain('[Tool Error]');
+        });
 
-                // Valid session
-                fs.writeFileSync(
-                    path.join(projDir, 'valid.jsonl'),
-                    JSON.stringify({ type: 'assistant', timestamp: '2026-03-10T10:00:00Z' }),
-                );
-                // Empty session (will return null from readSession)
-                fs.writeFileSync(path.join(projDir, 'empty.jsonl'), '');
-
-                const sessions = readSessions(10);
-                expect(sessions).toHaveLength(2);
-                // Both are valid (empty file still produces a session with defaults)
-                const validSession = sessions.find((s: any) => s.sessionId === 'valid');
-                expect(validSession).toBeDefined();
-                expect(validSession.lastEntryType).toBe('assistant');
-            });
+        it('should handle malformed JSON lines gracefully', () => {
+            const filePath = path.join(tmpDir, 'malformed.jsonl');
+            fs.writeFileSync(filePath, [
+                JSON.stringify({ type: 'user', timestamp: '2026-03-27T10:00:00Z', message: { content: 'Hello' } }),
+                'this is not valid json',
+                JSON.stringify({ type: 'assistant', timestamp: '2026-03-27T10:00:01Z', message: { content: [{ type: 'text', text: 'World' }] } }),
+            ].join('\n'));
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+        });
+
+        it('should return empty array for missing file', () => {
+            const messages = adapter.getConversation('/nonexistent/path.jsonl');
+            expect(messages).toEqual([]);
+        });
+
+        it('should return empty array for empty file', () => {
+            const filePath = path.join(tmpDir, 'empty.jsonl');
+            fs.writeFileSync(filePath, '');
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toEqual([]);
+        });
+
+        it('should filter noise messages from user entries', () => {
+            const filePath = writeJsonl([
+                { type: 'user', timestamp: '2026-03-27T10:00:00Z', message: { content: [{ type: 'text', text: '[Request interrupted by user]' }] } },
+                { type: 'user', timestamp: '2026-03-27T10:00:01Z', message: { content: 'Tool loaded.' } },
+                { type: 'user', timestamp: '2026-03-27T10:00:02Z', message: { content: 'Real question' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Real question');
         });
     });
 });