@ai-devkit/agent-manager 0.9.0 → 0.11.0

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

@@ -18,9 +18,13 @@ jest.mock('../../utils/process', () => ({
     enrichProcesses: jest.fn(),
 }));
 
-jest.mock('../../utils/session', () => ({
-    batchGetSessionFileBirthtimes: jest.fn(),
-}));
+jest.mock('../../utils/session', () => {
+    const actual = jest.requireActual('../../utils/session') as typeof import('../../utils/session');
+    return {
+        ...actual,
+        batchGetSessionFileBirthtimes: jest.fn(),
+    };
+});
 
 jest.mock('../../utils/matching', () => ({
     matchProcessesToSessions: jest.fn(),
@@ -361,7 +365,7 @@ describe('ClaudeCodeAdapter', () => {
             (adapter as any).projectsDir = projectsDir;
 
             // Simulate JSONL disappearing between existence check and read
-            jest.spyOn(adapter as any, 'readSession').mockReturnValueOnce(null);
+            jest.spyOn((adapter as any).parser, 'readSession').mockReturnValueOnce(null);
 
             const agents = await adapter.detectAgents();
 
@@ -408,7 +412,7 @@ describe('ClaudeCodeAdapter', () => {
             ]);
 
             // Simulate JSONL disappearing between match and read
-            jest.spyOn(adapter as any, 'readSession').mockReturnValueOnce(null);
+            jest.spyOn((adapter as any).parser, 'readSession').mockReturnValueOnce(null);
 
             const agents = await adapter.detectAgents();
 
@@ -601,7 +605,7 @@ describe('ClaudeCodeAdapter', () => {
     describe('helper methods', () => {
         describe('determineStatus', () => {
             it('should return "unknown" for sessions with no last entry type', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -615,7 +619,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "waiting" for assistant entries', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -630,7 +634,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "waiting" for user interruption', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -645,7 +649,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "running" for user/progress entries', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -660,7 +664,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should not override status based on age (process is running)', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const oldDate = new Date(Date.now() - 10 * 60 * 1000);
                 const session = {
@@ -676,7 +680,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "idle" for system entries', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -691,7 +695,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "running" for thinking entries', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -706,7 +710,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "running" for progress entries', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -721,7 +725,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return "unknown" for unrecognized entry types', () => {
-                const determineStatus = (adapter as any).determineStatus.bind(adapter);
+                const determineStatus = (adapter as any).parser.determineStatus.bind((adapter as any).parser);
 
                 const session = {
                     sessionId: 'test',
@@ -738,12 +742,12 @@ describe('ClaudeCodeAdapter', () => {
 
         describe('extractUserMessageText', () => {
             it('should extract plain string content', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
                 expect(extract('hello world')).toBe('hello world');
             });
 
             it('should extract text from array content blocks', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 const content = [
                     { type: 'tool_result', content: 'some result' },
@@ -753,7 +757,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return undefined for empty/null content', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 expect(extract(undefined)).toBeUndefined();
                 expect(extract('')).toBeUndefined();
@@ -761,35 +765,35 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should parse command-message tags', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 const msg = '<command-message><command-name>commit</command-name><command-args>fix bug</command-args></command-message>';
                 expect(extract(msg)).toBe('commit fix bug');
             });
 
             it('should parse command-message without args', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 const msg = '<command-message><command-name>help</command-name></command-message>';
                 expect(extract(msg)).toBe('help');
             });
 
             it('should extract ARGUMENTS from skill expansion', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 const msg = 'Base directory for this skill: /some/path\n\nSome instructions\n\nARGUMENTS: implement the feature';
                 expect(extract(msg)).toBe('implement the feature');
             });
 
             it('should return undefined for skill expansion without ARGUMENTS', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 const msg = 'Base directory for this skill: /some/path\n\nSome instructions only';
                 expect(extract(msg)).toBeUndefined();
             });
 
             it('should filter noise messages', () => {
-                const extract = (adapter as any).extractUserMessageText.bind(adapter);
+                const extract = (adapter as any).parser['extractUserMessageText'].bind((adapter as any).parser);
 
                 expect(extract('[Request interrupted by user]')).toBeUndefined();
                 expect(extract('Tool loaded.')).toBeUndefined();
@@ -799,7 +803,7 @@ describe('ClaudeCodeAdapter', () => {
 
         describe('parseCommandMessage', () => {
             it('should return undefined for malformed command-message', () => {
-                const parse = (adapter as any).parseCommandMessage.bind(adapter);
+                const parse = (adapter as any).parser['parseCommandMessage'].bind((adapter as any).parser);
                 expect(parse('<command-message>no tags</command-message>')).toBeUndefined();
             });
         });
@@ -977,7 +981,7 @@ describe('ClaudeCodeAdapter', () => {
 
         describe('readSession', () => {
             it('should parse session file with timestamps, cwd, and entry type', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'test-session.jsonl');
                 const lines = [
@@ -999,7 +1003,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should detect user interruption', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'interrupted.jsonl');
                 const lines = [
@@ -1019,7 +1023,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return session with defaults for empty file', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'empty.jsonl');
                 fs.writeFileSync(filePath, '');
@@ -1030,12 +1034,12 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should return null for non-existent file', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
                 expect(readSession(path.join(tmpDir, 'nonexistent.jsonl'), '/test')).toBeNull();
             });
 
             it('should skip metadata entry types for lastEntryType', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'metadata-test.jsonl');
                 const lines = [
@@ -1051,7 +1055,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should parse snapshot.timestamp from file-history-snapshot first entry', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'snapshot-ts.jsonl');
                 const lines = [
@@ -1070,7 +1074,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should extract lastUserMessage from session entries', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'user-msg.jsonl');
                 const lines = [
@@ -1086,7 +1090,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should use lastCwd as projectPath when projectPath is empty', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'no-project.jsonl');
                 const lines = [
@@ -1099,7 +1103,7 @@ describe('ClaudeCodeAdapter', () => {
             });
 
             it('should handle malformed JSON lines gracefully', () => {
-                const readSession = (adapter as any).readSession.bind(adapter);
+                const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);
 
                 const filePath = path.join(tmpDir, 'malformed.jsonl');
                 const lines = [
@@ -1288,4 +1292,156 @@ describe('ClaudeCodeAdapter', () => {
             expect(messages[0].content).toBe('Real question');
         });
     });
+
+    describe('listSessions', () => {
+        let tmpDir: string;
+        let projectsDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-list-'));
+            projectsDir = path.join(tmpDir, 'projects');
+            fs.mkdirSync(projectsDir, { recursive: true });
+            (adapter as any).projectsDir = projectsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeSession(projectDir: string, sessionId: string, lines: object[]): string {
+            fs.mkdirSync(projectDir, { recursive: true });
+            const filePath = path.join(projectDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n'));
+            return filePath;
+        }
+
+        it('returns empty when projects dir does not exist', async () => {
+            fs.rmSync(projectsDir, { recursive: true, force: true });
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('returns sessions from a single cwd-scoped project dir', async () => {
+            const cwd = '/Users/test/proj';
+            const projDir = path.join(projectsDir, '-Users-test-proj');
+            const filePath = writeSession(projDir, 'sess-1', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'first prompt' } },
+                { type: 'assistant', timestamp: '2025-01-01T00:01:00Z' },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                type: 'claude',
+                sessionId: 'sess-1',
+                cwd,
+                firstUserMessage: 'first prompt',
+                sessionFilePath: filePath,
+            });
+            expect(result[0].lastActive).toBeInstanceOf(Date);
+            expect(result[0].startedAt).toBeInstanceOf(Date);
+        });
+
+        it('lists sessions from all project dirs when no cwd filter', async () => {
+            const cwdA = '/Users/test/proj-a';
+            const cwdB = '/Users/test/proj-b';
+            writeSession(path.join(projectsDir, '-Users-test-proj-a'), 'a', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: cwdA, message: { content: 'msg-a' } },
+            ]);
+            writeSession(path.join(projectsDir, '-Users-test-proj-b'), 'b', [
+                { type: 'user', timestamp: '2025-01-02T00:00:00Z', cwd: cwdB, message: { content: 'msg-b' } },
+            ]);
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            expect(result.map((r) => r.sessionId).sort()).toEqual(['a', 'b']);
+            const cwds = result.map((r) => r.cwd).sort();
+            expect(cwds).toEqual([cwdA, cwdB]);
+        });
+
+        it('drops sessions whose recorded cwd does not match opts.cwd (strict equality)', async () => {
+            const cwdReal = '/Users/test/foo';
+            const cwdRequested = '/Users/test/foo/sub';
+            writeSession(path.join(projectsDir, '-Users-test-foo'), 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: cwdReal, message: { content: 'hi' } },
+            ]);
+
+            // Encoded dir for the requested cwd doesn't exist → return []
+            const result = await adapter.listSessions({ cwd: cwdRequested });
+            expect(result).toEqual([]);
+        });
+
+        it('drops sessions whose recorded cwd disagrees with the encoded dir', async () => {
+            // Edge case: encoded dir lookup matches, but session content
+            // records a different cwd. Strict-equality filter must reject.
+            const requested = '/Users/test/proj';
+            const projDir = path.join(projectsDir, '-Users-test-proj');
+            writeSession(projDir, 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: '/different/path', message: { content: 'mismatch' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: requested });
+            expect(result).toEqual([]);
+        });
+
+        it('finds sessions whose recorded cwd lives in a different encoded dir (worktree case)', async () => {
+            // Real-world case: Claude Code is launched in /repo, then chdirs into
+            // /repo/.worktrees/feature. The session file is stored under the
+            // ENCODED launch dir, but its content records the worktree path.
+            // listSessions({ cwd: worktree }) must still find it.
+            const launchDir = path.join(projectsDir, '-repo');
+            const worktreeCwd = '/repo/.worktrees/feature';
+            writeSession(launchDir, 'wt', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: worktreeCwd, message: { content: 'in worktree' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: worktreeCwd });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                sessionId: 'wt',
+                cwd: worktreeCwd,
+                firstUserMessage: 'in worktree',
+            });
+        });
+
+        it('skips malformed session files', async () => {
+            const cwd = '/Users/test/p';
+            const projDir = path.join(projectsDir, '-Users-test-p');
+            fs.mkdirSync(projDir, { recursive: true });
+            fs.writeFileSync(path.join(projDir, 'bad.jsonl'), 'not valid json');
+            writeSession(projDir, 'good', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'ok' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('captures first user message after filtering noise', async () => {
+            const cwd = '/Users/test/q';
+            writeSession(path.join(projectsDir, '-Users-test-q'), 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'Tool loaded.' } },
+                { type: 'user', timestamp: '2025-01-01T00:00:01Z', cwd, message: { content: 'real first prompt' } },
+                { type: 'user', timestamp: '2025-01-01T00:00:02Z', cwd, message: { content: 'second prompt' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('real first prompt');
+        });
+
+        it('returns empty firstUserMessage when no user message exists', async () => {
+            const cwd = '/Users/test/empty';
+            writeSession(path.join(projectsDir, '-Users-test-empty'), 's', [
+                { type: 'assistant', timestamp: '2025-01-01T00:00:00Z' },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });

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

@@ -19,9 +19,13 @@ jest.mock('../../utils/process', () => ({
     enrichProcesses: jest.fn(),
 }));
 
-jest.mock('../../utils/session', () => ({
-    batchGetSessionFileBirthtimes: jest.fn(),
-}));
+jest.mock('../../utils/session', () => {
+    const actual = jest.requireActual('../../utils/session') as typeof import('../../utils/session');
+    return {
+        ...actual,
+        batchGetSessionFileBirthtimes: jest.fn(),
+    };
+});
 
 jest.mock('../../utils/matching', () => ({
     matchProcessesToSessions: jest.fn(),
@@ -630,4 +634,120 @@ describe('CodexAdapter', () => {
             expect(messages[0].content).toBe('Response');
         });
     });
+
+    describe('listSessions', () => {
+        let tmpDir: string;
+        let sessionsDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'codex-list-'));
+            sessionsDir = path.join(tmpDir, 'sessions');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            (adapter as any).codexSessionsDir = sessionsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeCodexSession(dateDir: string, sessionId: string, lines: object[]): string {
+            fs.mkdirSync(dateDir, { recursive: true });
+            const filePath = path.join(dateDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n'));
+            return filePath;
+        }
+
+        it('returns empty when sessions dir does not exist', async () => {
+            fs.rmSync(sessionsDir, { recursive: true, force: true });
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('walks every YYYY/MM/DD dir and returns all sessions', async () => {
+            const dayA = path.join(sessionsDir, '2025', '01', '01');
+            const dayB = path.join(sessionsDir, '2025', '02', '03');
+            writeCodexSession(dayA, 'sess-a', [
+                { type: 'session_meta', payload: { id: 'sess-a', cwd: '/repo-a', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'msg-a' } },
+            ]);
+            writeCodexSession(dayB, 'sess-b', [
+                { type: 'session_meta', payload: { id: 'sess-b', cwd: '/repo-b', timestamp: '2025-02-03T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-02-03T00:00:01Z', payload: { type: 'user_message', message: 'msg-b' } },
+            ]);
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            const byId = Object.fromEntries(result.map((r) => [r.sessionId, r]));
+            expect(byId['sess-a']).toMatchObject({
+                type: 'codex',
+                cwd: '/repo-a',
+                firstUserMessage: 'msg-a',
+            });
+            expect(byId['sess-b']).toMatchObject({
+                type: 'codex',
+                cwd: '/repo-b',
+                firstUserMessage: 'msg-b',
+            });
+        });
+
+        it('applies strict-equality cwd filter against session_meta cwd', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'keep', [
+                { type: 'session_meta', payload: { id: 'keep', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'yes' } },
+            ]);
+            writeCodexSession(day, 'drop', [
+                { type: 'session_meta', payload: { id: 'drop', cwd: '/other', timestamp: '2025-01-01T00:01:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:01:01Z', payload: { type: 'user_message', message: 'no' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('keep');
+        });
+
+        it('skips files without a session_meta first line', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'bad', [
+                { type: 'event', timestamp: '2025-01-01T00:00:00Z', payload: { type: 'user_message', message: 'orphan' } },
+            ]);
+            writeCodexSession(day, 'good', [
+                { type: 'session_meta', payload: { id: 'good', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'ok' } },
+            ]);
+
+            const result = await adapter.listSessions();
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('captures the first user_message as firstUserMessage', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 's', [
+                { type: 'session_meta', payload: { id: 's', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'agent_message', message: 'preamble' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:02Z', payload: { type: 'user_message', message: 'first user' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:03Z', payload: { type: 'user_message', message: 'second user' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('first user');
+        });
+
+        it('returns empty firstUserMessage when no user_message exists', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 's', [
+                { type: 'session_meta', payload: { id: 's', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'agent_message', message: 'agent only' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });