@ai-devkit/agent-manager 0.10.0 → 0.11.0

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('');
+        });
+    });
 });

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

@@ -760,6 +760,139 @@ describe('GeminiCliAdapter', () => {
             expect(adapter.getConversation(sessionPath)).toEqual([]);
         });
     });
+
+    describe('listSessions', () => {
+        it('returns empty when ~/.gemini/tmp does not exist', async () => {
+            // tmpHome has no .gemini dir by default
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('walks every shortId/chats dir and returns sessions', async () => {
+            writeSession(tmpHome, 'aaa', 'session-1', {
+                sessionId: 's-1',
+                projectHash: hashProjectRoot('/repo-a'),
+                startTime: '2025-01-01T00:00:00Z',
+                lastUpdated: '2025-01-01T00:01:00Z',
+                directories: ['/repo-a'],
+                messages: [
+                    { type: 'user', timestamp: '2025-01-01T00:00:00Z', content: [{ text: 'hello a' }] },
+                ],
+            });
+            writeSession(tmpHome, 'bbb', 'session-2', {
+                sessionId: 's-2',
+                projectHash: hashProjectRoot('/repo-b'),
+                startTime: '2025-01-02T00:00:00Z',
+                lastUpdated: '2025-01-02T00:01:00Z',
+                directories: ['/repo-b'],
+                messages: [
+                    { type: 'user', timestamp: '2025-01-02T00:00:00Z', content: [{ text: 'hello b' }] },
+                ],
+            });
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            const byId = Object.fromEntries(result.map((r) => [r.sessionId, r]));
+            expect(byId['s-1']).toMatchObject({
+                type: 'gemini_cli',
+                cwd: '/repo-a',
+                firstUserMessage: 'hello a',
+            });
+            expect(byId['s-2']).toMatchObject({
+                type: 'gemini_cli',
+                cwd: '/repo-b',
+                firstUserMessage: 'hello b',
+            });
+        });
+
+        it('applies strict-equality cwd filter against directories[0]', async () => {
+            writeSession(tmpHome, 'aaa', 'session-keep', {
+                sessionId: 'keep',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'yes' }],
+            });
+            writeSession(tmpHome, 'bbb', 'session-drop', {
+                sessionId: 'drop',
+                projectHash: hashProjectRoot('/other'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/other'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'no' }],
+            });
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('keep');
+        });
+
+        it('skips malformed JSON files', async () => {
+            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'aaa', 'chats');
+            fs.mkdirSync(chatsDir, { recursive: true });
+            fs.writeFileSync(path.join(chatsDir, 'session-bad.json'), '{ not json');
+            writeSession(tmpHome, 'aaa', 'session-good', {
+                sessionId: 'good',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'ok' }],
+            });
+
+            const result = await adapter.listSessions();
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('skips files missing sessionId', async () => {
+            writeSession(tmpHome, 'aaa', 'session-no-id', {
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [],
+            });
+
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('captures the first user-typed message as firstUserMessage', async () => {
+            writeSession(tmpHome, 'aaa', 'session-x', {
+                sessionId: 's',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [
+                    { type: 'gemini', timestamp: '2025-01-01T00:00:00Z', content: 'preamble' },
+                    { type: 'user', timestamp: '2025-01-01T00:00:01Z', content: [{ text: 'first user' }] },
+                    { type: 'user', timestamp: '2025-01-01T00:00:02Z', content: '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 () => {
+            writeSession(tmpHome, 'aaa', 'session-x', {
+                sessionId: 's',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [
+                    { type: 'gemini', timestamp: '2025-01-01T00:00:00Z', content: 'agent only' },
+                ],
+            });
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });
 
 /**

package/src/__tests__/utils/ClaudeSessionParser.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for utils/ClaudeSessionParser.ts — focused on stripping
+ * harness-injected XML tags from conversation content.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ClaudeSessionParser } from '../../utils/ClaudeSessionParser';
+
+interface JsonlEntry {
+    type: 'user' | 'assistant' | 'system';
+    message: { content: string | Array<{ type: string; text?: string; content?: string; name?: string; input?: unknown; is_error?: boolean }> };
+    timestamp?: string;
+}
+
+function writeSession(entries: JsonlEntry[]): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'parser-test-'));
+    const filePath = path.join(dir, 'session.jsonl');
+    fs.writeFileSync(filePath, entries.map(e => JSON.stringify(e)).join('\n'));
+    return filePath;
+}
+
+describe('ClaudeSessionParser.getConversation — harness tag stripping', () => {
+    let parser: ClaudeSessionParser;
+    const tempFiles: string[] = [];
+
+    beforeEach(() => {
+        parser = new ClaudeSessionParser();
+    });
+
+    afterEach(() => {
+        for (const f of tempFiles) {
+            try {
+                fs.rmSync(path.dirname(f), { recursive: true, force: true });
+            } catch { /* best effort */ }
+        }
+        tempFiles.length = 0;
+    });
+
+    function makeSession(entries: JsonlEntry[]): string {
+        const f = writeSession(entries);
+        tempFiles.push(f);
+        return f;
+    }
+
+    it('strips <system-reminder> blocks from text content', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: 'Real response here.\n<system-reminder>\nDo not mention this reminder.\n</system-reminder>\nMore response.',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv).toHaveLength(1);
+        expect(conv[0].content).toBe('Real response here.\n\nMore response.');
+    });
+
+    it('strips <local-command-stdout> blocks', () => {
+        const file = makeSession([
+            {
+                type: 'system',
+                message: { content: 'before <local-command-stdout>\nRunning...\nDone\n</local-command-stdout> after' },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('before  after');
+    });
+
+    it('strips <user-prompt-submit-hook> blocks', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: { content: '<user-prompt-submit-hook>hook output</user-prompt-submit-hook>\nactual question' },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('actual question');
+    });
+
+    it('strips bash and command stdout/stderr blocks', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: 'Output:\n<bash-input>ls</bash-input>\n<bash-stdout>file.txt</bash-stdout>\n<bash-stderr></bash-stderr>\n<command-stdout>x</command-stdout>\n<command-stderr>y</command-stderr>\nEnd.',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('Output:\n\n\n\n\n\nEnd.'.replace(/\n{3,}/g, '\n\n'));
+        expect(conv[0].content).not.toMatch(/<bash-/);
+        expect(conv[0].content).not.toMatch(/<command-stdout>|<command-stderr>/);
+    });
+
+    it('collapses <command-name>/<command-args> into "/name args" shorthand', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: '<command-message>debug</command-message>\n<command-name>/debug</command-name>\n<command-args>fix the bug</command-args>',
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/debug fix the bug');
+    });
+
+    it('handles <command-name> without <command-args>', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: '<command-message>clear</command-message>\n<command-name>/clear</command-name>',
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/clear');
+    });
+
+    it('handles multiple harness tags mixed together', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: '<system-reminder>ignore me</system-reminder>\n<command-message>build</command-message>\n<command-name>/build</command-name>\n<command-args>--watch</command-args>\n<local-command-stdout>build output here</local-command-stdout>',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/build --watch');
+    });
+
+    it('leaves text without harness tags unchanged', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: 'Hello, world!' }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('Hello, world!');
+    });
+
+    it('drops a message that becomes empty after stripping', () => {
+        const file = makeSession([
+            {
+                type: 'system',
+                message: { content: '<system-reminder>only this</system-reminder>' },
+            },
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: 'kept' }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv).toHaveLength(1);
+        expect(conv[0].content).toBe('kept');
+    });
+
+    it('strips tags spanning multiple lines', () => {
+        const multilineReminder = '<system-reminder>\nLine 1\nLine 2\nLine 3\n</system-reminder>';
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: `before\n${multilineReminder}\nafter` }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('before\n\nafter');
+    });
+});

package/src/__tests__/utils/session.test.ts

@@ -3,25 +3,31 @@
  */
 
 import { describe, it, expect, jest, beforeEach } from '@jest/globals';
-import { execSync } from 'child_process';
+import * as fs from 'fs';
 import { batchGetSessionFileBirthtimes } from '../../utils/session';
 
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
+jest.mock('fs', () => ({
+    readdirSync: jest.fn(),
+    statSync: jest.fn(),
 }));
 
-const mockedExecSync = execSync as jest.MockedFunction<typeof execSync>;
+const mockedReaddirSync = fs.readdirSync as jest.MockedFunction<typeof fs.readdirSync>;
+const mockedStatSync = fs.statSync as jest.MockedFunction<typeof fs.statSync>;
 
 describe('batchGetSessionFileBirthtimes', () => {
     beforeEach(() => {
-        mockedExecSync.mockReset();
+        mockedReaddirSync.mockReset();
+        mockedStatSync.mockReset();
     });
 
-    it('should parse stat output correctly', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /home/.claude/projects/my-app/abc123.jsonl\n' +
-            '1710800500 /home/.claude/projects/my-app/def456.jsonl\n',
-        );
+    it('should parse session files correctly', () => {
+        mockedReaddirSync.mockReturnValue([
+            'abc123.jsonl',
+            'def456.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/home/.claude/projects/my-app']);
 
@@ -39,49 +45,57 @@ describe('batchGetSessionFileBirthtimes', () => {
 
     it('should return empty array for empty dirs list', () => {
         expect(batchGetSessionFileBirthtimes([])).toEqual([]);
-        expect(mockedExecSync).not.toHaveBeenCalled();
+        expect(mockedReaddirSync).not.toHaveBeenCalled();
     });
 
-    it('should return empty array on command failure', () => {
-        mockedExecSync.mockImplementation(() => {
-            throw new Error('Command failed');
+    it('should return empty array on readdir failure', () => {
+        mockedReaddirSync.mockImplementation(() => {
+            throw new Error('ENOENT');
         });
 
         expect(batchGetSessionFileBirthtimes(['/some/dir'])).toEqual([]);
     });
 
-    it('should skip lines with invalid epoch (0 or negative)', () => {
-        mockedExecSync.mockReturnValue(
-            '0 /dir/bad.jsonl\n' +
-            '-1 /dir/negative.jsonl\n' +
-            '1710800324 /dir/good.jsonl\n',
-        );
+    it('should skip files with invalid birthtime (0 or negative)', () => {
+        mockedReaddirSync.mockReturnValue([
+            'bad.jsonl',
+            'negative.jsonl',
+            'good.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 0 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: -1 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
         expect(results[0].sessionId).toBe('good');
     });
 
-    it('should skip non-jsonl files in output', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /dir/sessions-index.json\n' +
-            '1710800500 /dir/abc123.jsonl\n',
-        );
+    it('should skip non-jsonl files', () => {
+        mockedReaddirSync.mockReturnValue([
+            'sessions-index.json',
+            'abc123.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
         expect(results[0].sessionId).toBe('abc123');
     });
 
-    it('should handle empty output', () => {
-        mockedExecSync.mockReturnValue('');
+    it('should handle empty directory', () => {
+        mockedReaddirSync.mockReturnValue([] as unknown as ReturnType<typeof fs.readdirSync>);
         expect(batchGetSessionFileBirthtimes(['/dir'])).toEqual([]);
     });
 
     it('should handle UUID session IDs', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /dir/068e7b1f-cff5-4c94-bf69-b9acd32d765c.jsonl\n',
-        );
+        mockedReaddirSync.mockReturnValue([
+            '068e7b1f-cff5-4c94-bf69-b9acd32d765c.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
@@ -89,29 +103,51 @@ describe('batchGetSessionFileBirthtimes', () => {
     });
 
     it('should leave resolvedCwd empty', () => {
-        mockedExecSync.mockReturnValue('1710800324 /dir/abc.jsonl\n');
+        mockedReaddirSync.mockReturnValue([
+            'abc.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results[0].resolvedCwd).toBe('');
     });
 
-    it('should combine multiple directories into a single stat call', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /projects/app-a/sess1.jsonl\n' +
-            '1710800400 /projects/app-b/sess2.jsonl\n' +
-            '1710800500 /projects/app-a/sess3.jsonl\n',
-        );
+    it('should enumerate multiple directories', () => {
+        mockedReaddirSync
+            .mockReturnValueOnce([
+                'sess1.jsonl',
+                'sess3.jsonl',
+            ] as unknown as ReturnType<typeof fs.readdirSync>)
+            .mockReturnValueOnce([
+                'sess2.jsonl',
+            ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800400000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/projects/app-a', '/projects/app-b']);
 
-        expect(mockedExecSync).toHaveBeenCalledTimes(1);
-        const cmd = mockedExecSync.mock.calls[0][0] as string;
-        expect(cmd).toContain('"/projects/app-a"/*.jsonl');
-        expect(cmd).toContain('"/projects/app-b"/*.jsonl');
+        expect(mockedReaddirSync).toHaveBeenCalledTimes(2);
 
         expect(results).toHaveLength(3);
         expect(results[0].projectDir).toBe('/projects/app-a');
-        expect(results[1].projectDir).toBe('/projects/app-b');
-        expect(results[2].projectDir).toBe('/projects/app-a');
+        expect(results[1].projectDir).toBe('/projects/app-a');
+        expect(results[2].projectDir).toBe('/projects/app-b');
+    });
+
+    it('should skip files where statSync fails', () => {
+        mockedReaddirSync.mockReturnValue([
+            'good.jsonl',
+            'gone.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockImplementationOnce(() => { throw new Error('ENOENT'); });
+
+        const results = batchGetSessionFileBirthtimes(['/dir']);
+        expect(results).toHaveLength(1);
+        expect(results[0].sessionId).toBe('good');
     });
 });