@ai-devkit/agent-manager 0.5.0 → 0.6.1

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

@@ -168,7 +168,7 @@ describe('ClaudeCodeAdapter', () => {
             // 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', slug: 'merry-dog', message: { content: 'Investigate failing tests' } }),
+                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'));
 
@@ -203,7 +203,6 @@ describe('ClaudeCodeAdapter', () => {
                 pid: 12345,
                 projectPath: '/Users/test/my-project',
                 sessionId: 'session-1',
-                slug: 'merry-dog',
             });
             expect(agents[0].summary).toContain('Investigate failing tests');
 
@@ -977,12 +976,12 @@ describe('ClaudeCodeAdapter', () => {
         });
 
         describe('readSession', () => {
-            it('should parse session file with timestamps, slug, cwd, and entry type', () => {
+            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'));
@@ -991,7 +990,6 @@ describe('ClaudeCodeAdapter', () => {
                 expect(session).toMatchObject({
                     sessionId: 'test-session',
                     projectPath: '/my/project',
-                    slug: 'happy-dog',
                     lastCwd: '/my/project',
                     lastEntryType: 'assistant',
                     isInterrupted: false,
@@ -1029,7 +1027,6 @@ describe('ClaudeCodeAdapter', () => {
                 const session = readSession(filePath, '/test');
                 expect(session).not.toBeNull();
                 expect(session.lastEntryType).toBeUndefined();
-                expect(session.slug).toBeUndefined();
             });
 
             it('should return null for non-existent file', () => {
@@ -1117,4 +1114,178 @@ describe('ClaudeCodeAdapter', () => {
             });
         });
     });
+
+    describe('getConversation', () => {
+        let tmpDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-conv-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        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;
+        }
+
+        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!' }] } },
+            ]);
+
+            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' });
+        });
+
+        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' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Fix bug');
+        });
+
+        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' }] } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+            expect(messages[0].role).toBe('user');
+            expect(messages[1].role).toBe('assistant');
+        });
+
+        it('should include system messages', () => {
+            const filePath = writeJsonl([
+                { type: 'system', timestamp: '2026-03-27T10:00:00Z', message: { content: 'System initialized' } },
+            ]);
+
+            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 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 messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Let me read the file.');
+        });
+
+        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]');
+        });
+
+        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 messages = adapter.getConversation(filePath, { verbose: true });
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toContain('[Tool Error]');
+        });
+
+        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');
+        });
+    });
 });

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

@@ -515,4 +515,119 @@ describe('CodexAdapter', () => {
             });
         });
     });
+
+    describe('getConversation', () => {
+        let tmpDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'codex-conv-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        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;
+        }
+
+        it('should parse user and agent messages', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:01Z', payload: { type: 'user_message', message: 'Fix the bug' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:05Z', payload: { type: 'agent_message', message: 'I found the issue' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+            expect(messages[0]).toEqual({ role: 'user', content: 'Fix the bug', timestamp: '2026-03-27T10:00:01Z' });
+            expect(messages[1]).toEqual({ role: 'assistant', content: 'I found the issue', timestamp: '2026-03-27T10:00:05Z' });
+        });
+
+        it('should skip session_meta entry', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:01Z', payload: { type: 'user_message', message: 'Hello' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('user');
+        });
+
+        it('should map task_complete to assistant role', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:05Z', payload: { type: 'task_complete', message: 'Task finished successfully' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('assistant');
+            expect(messages[0].content).toBe('Task finished successfully');
+        });
+
+        it('should skip non-conversation types in default mode', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:01Z', payload: { type: 'user_message', message: 'Hello' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:02Z', payload: { type: 'exec_command', message: 'Running npm test' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:03Z', payload: { type: 'agent_message', message: 'Done' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(2);
+        });
+
+        it('should include non-conversation types as system in verbose mode', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:02Z', payload: { type: 'exec_command', message: 'Running npm test' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath, { verbose: true });
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('system');
+            expect(messages[0].content).toBe('Running npm test');
+        });
+
+        it('should handle malformed JSON lines gracefully', () => {
+            const filePath = path.join(tmpDir, 'malformed.jsonl');
+            fs.writeFileSync(filePath, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } }),
+                'invalid json line',
+                JSON.stringify({ type: 'event', timestamp: '2026-03-27T10:00:01Z', payload: { type: 'user_message', message: 'Hello' } }),
+            ].join('\n'));
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+        });
+
+        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 skip entries with empty payload message', () => {
+            const filePath = writeJsonl([
+                { type: 'session_meta', payload: { id: 'sess-1', cwd: '/repo', timestamp: '2026-03-27T10:00:00Z' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:01Z', payload: { type: 'user_message', message: '' } },
+                { type: 'event', timestamp: '2026-03-27T10:00:02Z', payload: { type: 'agent_message', message: 'Response' } },
+            ]);
+
+            const messages = adapter.getConversation(filePath);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Response');
+        });
+    });
 });

package/src/__tests__/terminal/TtyWriter.test.ts

@@ -40,16 +40,22 @@ describe('TtyWriter', () => {
             tty: '/dev/ttys030',
         };
 
-        it('sends message via tmux send-keys', async () => {
+        it('sends message and Enter as separate tmux send-keys calls', async () => {
             mockExecFileSuccess();
 
             await TtyWriter.send(location, 'continue');
 
             expect(mockedExecFile).toHaveBeenCalledWith(
                 'tmux',
-                ['send-keys', '-t', 'main:0.1', 'continue', 'Enter'],
+                ['send-keys', '-t', 'main:0.1', '-l', 'continue'],
                 expect.any(Function),
             );
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['send-keys', '-t', 'main:0.1', 'Enter'],
+                expect.any(Function),
+            );
+            expect(mockedExecFile).toHaveBeenCalledTimes(2);
         });
 
         it('throws on tmux failure', async () => {
@@ -74,9 +80,12 @@ describe('TtyWriter', () => {
 
             expect(mockedExecFile).toHaveBeenCalledWith(
                 'osascript',
-                ['-e', expect.stringContaining('write text "hello"')],
+                ['-e', expect.stringContaining('write text "hello" newline no')],
                 expect.any(Function),
             );
+            const scriptArg = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
+            const script = scriptArg[1];
+            expect(script).toContain('key code 36');
         });
 
         it('escapes special characters in message', async () => {
@@ -86,7 +95,7 @@ describe('TtyWriter', () => {
 
             expect(mockedExecFile).toHaveBeenCalledWith(
                 'osascript',
-                ['-e', expect.stringContaining('write text "say \\"hi\\" \\\\ there"')],
+                ['-e', expect.stringContaining('write text "say \\"hi\\" \\\\ there" newline no')],
                 expect.any(Function),
             );
         });
@@ -113,24 +122,11 @@ describe('TtyWriter', () => {
 
             const scriptArg = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
             const script = scriptArg[1];
-            // Must use keystroke, NOT do script
             expect(script).toContain('keystroke "hello"');
             expect(script).toContain('key code 36');
             expect(script).not.toContain('do script');
         });
 
-        it('uses execFile to avoid shell injection', async () => {
-            mockExecFileSuccess('ok');
-
-            await TtyWriter.send(location, "don't stop");
-
-            expect(mockedExecFile).toHaveBeenCalledWith(
-                'osascript',
-                ['-e', expect.any(String)],
-                expect.any(Function),
-            );
-        });
-
         it('throws when tab not found', async () => {
             mockExecFileSuccess('not_found');
 

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

@@ -173,19 +173,27 @@ describe('matchProcessesToSessions', () => {
 });
 
 describe('generateAgentName', () => {
-    it('should return folderName (pid)', () => {
-        expect(generateAgentName('/projects/my-app', 12345)).toBe('my-app (12345)');
+    it('should return lowercase kebab-case name with pid', () => {
+        expect(generateAgentName('/projects/my-app', 12345)).toBe('my-app-12345');
     });
 
     it('should handle root path', () => {
-        expect(generateAgentName('/', 100)).toBe('unknown (100)');
+        expect(generateAgentName('/', 100)).toBe('unknown-100');
     });
 
     it('should handle empty cwd', () => {
-        expect(generateAgentName('', 100)).toBe('unknown (100)');
+        expect(generateAgentName('', 100)).toBe('unknown-100');
     });
 
     it('should handle nested paths', () => {
-        expect(generateAgentName('/home/user/projects/ai-devkit', 78070)).toBe('ai-devkit (78070)');
+        expect(generateAgentName('/home/user/projects/ai-devkit', 78070)).toBe('ai-devkit-78070');
+    });
+
+    it('should convert spaces and special chars to kebab-case', () => {
+        expect(generateAgentName('/projects/AI DevKit', 123)).toBe('ai-devkit-123');
+    });
+
+    it('should convert uppercase to lowercase', () => {
+        expect(generateAgentName('/projects/MyProject', 456)).toBe('myproject-456');
     });
 });

package/src/adapters/AgentAdapter.ts

@@ -45,12 +45,11 @@ export interface AgentInfo {
     /** Session UUID */
     sessionId: string;
 
-    /** Human-readable session name (e.g., "merry-wobbling-starlight"), may be undefined for new sessions */
-    slug?: string;
-
     /** Timestamp of last activity */
     lastActive: Date;
 
+    /** Path to the session JSONL file on disk */
+    sessionFilePath?: string;
 }
 
 /**
@@ -73,9 +72,18 @@ export interface ProcessInfo {
     startTime?: Date;
 }
 
+/**
+ * A single message in a conversation
+ */
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: string;
+}
+
 /**
  * Agent Adapter Interface
- * 
+ *
  * Implementations must provide detection logic for a specific agent type.
  */
 export interface AgentAdapter {
@@ -94,4 +102,12 @@ export interface AgentAdapter {
      * @returns True if this adapter can handle the process
      */
     canHandle(processInfo: ProcessInfo): boolean;
+
+    /**
+     * Read the full conversation from a session file
+     * @param sessionFilePath Path to the session JSONL file
+     * @param options.verbose Include tool call/result details
+     * @returns Array of conversation messages
+     */
+    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[];
 }

package/src/adapters/ClaudeCodeAdapter.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import type { AgentAdapter, AgentInfo, ProcessInfo } from './AgentAdapter';
+import type { AgentAdapter, AgentInfo, ProcessInfo, ConversationMessage } from './AgentAdapter';
 import { AgentStatus } from './AgentAdapter';
 import { listAgentProcesses, enrichProcesses } from '../utils/process';
 import { batchGetSessionFileBirthtimes } from '../utils/session';
@@ -9,17 +9,22 @@ import { matchProcessesToSessions, generateAgentName } from '../utils/matching';
 /**
  * Entry in session JSONL file
  */
+interface ContentBlock {
+    type?: string;
+    text?: string;
+    content?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    is_error?: boolean;
+}
+
 interface SessionEntry {
     type?: string;
     timestamp?: string;
-    slug?: string;
     cwd?: string;
     message?: {
-        content?: string | Array<{
-            type?: string;
-            text?: string;
-            content?: string;
-        }>;
+        content?: string | ContentBlock[];
     };
 }
 
@@ -50,7 +55,6 @@ interface ClaudeSession {
     sessionId: string;
     projectPath: string;
     lastCwd?: string;
-    slug?: string;
     sessionStart: Date;
     lastActive: Date;
     lastEntryType?: string;
@@ -275,8 +279,8 @@ export class ClaudeCodeAdapter implements AgentAdapter {
             pid: processInfo.pid,
             projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',
             sessionId: sessionFile.sessionId,
-            slug: session.slug,
             lastActive: session.lastActive,
+            sessionFilePath: sessionFile.filePath,
         };
     }
 
@@ -333,7 +337,6 @@ export class ClaudeCodeAdapter implements AgentAdapter {
         }
 
         // Parse all lines for session state (file already in memory)
-        let slug: string | undefined;
         let lastEntryType: string | undefined;
         let lastActive: Date | undefined;
         let lastCwd: string | undefined;
@@ -351,10 +354,6 @@ export class ClaudeCodeAdapter implements AgentAdapter {
                     }
                 }
 
-                if (entry.slug && !slug) {
-                    slug = entry.slug;
-                }
-
                 if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {
                     lastCwd = entry.cwd;
                 }
@@ -392,7 +391,6 @@ export class ClaudeCodeAdapter implements AgentAdapter {
             sessionId,
             projectPath: projectPath || lastCwd || '',
             lastCwd,
-            slug,
             sessionStart: sessionStart || lastActive || new Date(),
             lastActive: lastActive || new Date(),
             lastEntryType,
@@ -517,4 +515,102 @@ export class ClaudeCodeAdapter implements AgentAdapter {
         return type === 'last-prompt' || type === 'file-history-snapshot';
     }
 
+    /**
+     * Read the full conversation from a Claude Code session JSONL file.
+     *
+     * Default mode returns only text content from user/assistant/system messages.
+     * Verbose mode also includes tool_use and tool_result blocks.
+     */
+    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+        const verbose = options?.verbose ?? false;
+
+        let content: string;
+        try {
+            content = fs.readFileSync(sessionFilePath, 'utf-8');
+        } catch {
+            return [];
+        }
+
+        const lines = content.trim().split('\n');
+        const messages: ConversationMessage[] = [];
+
+        for (const line of lines) {
+            let entry: SessionEntry;
+            try {
+                entry = JSON.parse(line);
+            } catch {
+                continue;
+            }
+
+            const entryType = entry.type;
+            if (!entryType || this.isMetadataEntryType(entryType)) continue;
+            if (entryType === 'progress' || entryType === 'thinking') continue;
+
+            let role: ConversationMessage['role'];
+            if (entryType === 'user') {
+                role = 'user';
+            } else if (entryType === 'assistant') {
+                role = 'assistant';
+            } else if (entryType === 'system') {
+                role = 'system';
+            } else {
+                continue;
+            }
+
+            const text = this.extractConversationContent(entry.message?.content, role, verbose);
+            if (!text) continue;
+
+            messages.push({
+                role,
+                content: text,
+                timestamp: entry.timestamp,
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Extract displayable content from a message content field.
+     */
+    private extractConversationContent(
+        content: string | ContentBlock[] | undefined,
+        role: ConversationMessage['role'],
+        verbose: boolean,
+    ): string | undefined {
+        if (!content) return undefined;
+
+        if (typeof content === 'string') {
+            const trimmed = content.trim();
+            if (role === 'user' && this.isNoiseMessage(trimmed)) return undefined;
+            return trimmed || undefined;
+        }
+
+        if (!Array.isArray(content)) return undefined;
+
+        const parts: string[] = [];
+
+        for (const block of content) {
+            if (block.type === 'text' && block.text?.trim()) {
+                if (role === 'user' && this.isNoiseMessage(block.text.trim())) continue;
+                parts.push(block.text.trim());
+            } else if (block.type === 'tool_use' && verbose) {
+                const inputSummary = block.input?.file_path || block.input?.pattern || block.input?.command || '';
+                parts.push(`[Tool: ${block.name}]${inputSummary ? ' ' + inputSummary : ''}`);
+            } else if (block.type === 'tool_result' && verbose) {
+                const truncated = this.truncateToolResult(block.content || '');
+                const prefix = block.is_error ? '[Tool Error]' : '[Tool Result]';
+                parts.push(`${prefix} ${truncated}`);
+            }
+        }
+
+        return parts.length > 0 ? parts.join('\n') : undefined;
+    }
+
+    private truncateToolResult(content: string, maxLength = 200): string {
+        const firstLine = content.split('\n')[0] || '';
+        if (firstLine.length <= maxLength) return firstLine;
+        return firstLine.slice(0, maxLength - 3) + '...';
+    }
+
 }