@ai-devkit/agent-manager 0.31.0 → 0.33.0

package/dist/__tests__/adapters/ClaudeCodeAdapter.test.js

@@ -1,14 +1,14 @@
 /**
  * Tests for ClaudeCodeAdapter
- */ import * as fs from 'fs';
-import * as path from 'path';
-import { ClaudeCodeAdapter } from '../../providers/claude/ClaudeCodeAdapter.js';
-import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
-import { batchGetSessionFileBirthtimes } from '../../utils/session.js';
-import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
-import * as os from 'os';
-vi.mock('../../utils/process.js', async (importOriginal)=>{
+ */ import * as fs from "fs";
+import * as path from "path";
+import { ClaudeCodeAdapter } from "../../providers/claude/ClaudeCodeAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from "../../utils/process.js";
+import { batchGetSessionFileBirthtimes } from "../../utils/session.js";
+import { matchProcessesToSessions, generateAgentName } from "../../utils/matching.js";
+import * as os from "os";
+vi.mock("../../utils/process.js", async (importOriginal)=>{
     const actual = await importOriginal();
     return {
         ...actual,
@@ -17,14 +17,14 @@ vi.mock('../../utils/process.js', async (importOriginal)=>{
         captureProcessSnapshot: vi.fn()
     };
 });
-vi.mock('../../utils/session.js', async ()=>{
-    const actual = await vi.importActual('../../utils/session');
+vi.mock("../../utils/session.js", async ()=>{
+    const actual = await vi.importActual("../../utils/session");
     return {
         ...actual,
         batchGetSessionFileBirthtimes: vi.fn()
     };
 });
-vi.mock('../../utils/matching.js', ()=>({
+vi.mock("../../utils/matching.js", ()=>({
         matchProcessesToSessions: vi.fn(),
         generateAgentName: vi.fn()
     }));
@@ -34,7 +34,7 @@ const mockedCaptureProcessSnapshot = captureProcessSnapshot;
 const mockedBatchGetSessionFileBirthtimes = batchGetSessionFileBirthtimes;
 const mockedMatchProcessesToSessions = matchProcessesToSessions;
 const mockedGenerateAgentName = generateAgentName;
-describe('ClaudeCodeAdapter', ()=>{
+describe("ClaudeCodeAdapter", ()=>{
     let adapter;
     beforeEach(()=>{
         adapter = new ClaudeCodeAdapter();
@@ -50,137 +50,137 @@ describe('ClaudeCodeAdapter', ()=>{
         mockedCaptureProcessSnapshot.mockImplementation(async (names)=>enrichProcesses(names.flatMap((name)=>listAgentProcesses(name))));
         // Default: generateAgentName returns "folder (pid)"
         mockedGenerateAgentName.mockImplementation((cwd, pid)=>{
-            const folder = path.basename(cwd) || 'unknown';
+            const folder = path.basename(cwd) || "unknown";
             return `${folder} (${pid})`;
         });
     });
-    describe('initialization', ()=>{
-        it('should create adapter with correct type', ()=>{
-            expect(adapter.type).toBe('claude');
+    describe("initialization", ()=>{
+        it("should create adapter with correct type", ()=>{
+            expect(adapter.type).toBe("claude");
         });
     });
-    describe('canHandle', ()=>{
-        it('should return true for claude processes', ()=>{
+    describe("canHandle", ()=>{
+        it("should return true for claude processes", ()=>{
             const processInfo = {
                 pid: 12345,
-                command: 'claude',
-                cwd: '/test',
-                tty: 'ttys001'
+                command: "claude",
+                cwd: "/test",
+                tty: "ttys001"
             };
             expect(adapter.canHandle(processInfo)).toBe(true);
         });
-        it('should return true for claude executable with full path', ()=>{
+        it("should return true for claude executable with full path", ()=>{
             const processInfo = {
                 pid: 12345,
-                command: '/usr/local/bin/claude --some-flag',
-                cwd: '/test',
-                tty: 'ttys001'
+                command: "/usr/local/bin/claude --some-flag",
+                cwd: "/test",
+                tty: "ttys001"
             };
             expect(adapter.canHandle(processInfo)).toBe(true);
         });
-        it('should return true for CLAUDE (case-insensitive)', ()=>{
+        it("should return true for CLAUDE (case-insensitive)", ()=>{
             const processInfo = {
                 pid: 12345,
-                command: '/usr/local/bin/CLAUDE --continue',
-                cwd: '/test',
-                tty: 'ttys001'
+                command: "/usr/local/bin/CLAUDE --continue",
+                cwd: "/test",
+                tty: "ttys001"
             };
             expect(adapter.canHandle(processInfo)).toBe(true);
         });
-        it('should return false for non-claude processes', ()=>{
+        it("should return false for non-claude processes", ()=>{
             const processInfo = {
                 pid: 12345,
-                command: 'node',
-                cwd: '/test',
-                tty: 'ttys001'
+                command: "node",
+                cwd: "/test",
+                tty: "ttys001"
             };
             expect(adapter.canHandle(processInfo)).toBe(false);
         });
         it('should return false for processes with "claude" only in path arguments', ()=>{
             const processInfo = {
                 pid: 12345,
-                command: '/usr/local/bin/node /path/to/claude-worktree/node_modules/nx/start.js',
-                cwd: '/test',
-                tty: 'ttys001'
+                command: "/usr/local/bin/node /path/to/claude-worktree/node_modules/nx/start.js",
+                cwd: "/test",
+                tty: "ttys001"
             };
             expect(adapter.canHandle(processInfo)).toBe(false);
         });
     });
-    describe('detectAgents', ()=>{
-        it('should return empty array if no claude processes running', async ()=>{
+    describe("detectAgents", ()=>{
+        it("should return empty array if no claude processes running", async ()=>{
             mockedListAgentProcesses.mockReturnValue([]);
             const agents = await adapter.detectAgents();
             expect(agents).toEqual([]);
-            expect(mockedListAgentProcesses).toHaveBeenCalledWith('claude');
+            expect(mockedListAgentProcesses).toHaveBeenCalledWith("claude");
         });
-        it('should return process-only agents when no sessions discovered', async ()=>{
+        it("should return process-only agents when no sessions discovered", async ()=>{
             const processes = [
                 {
                     pid: 777,
-                    command: 'claude',
-                    cwd: '/project/app',
-                    tty: 'ttys001'
+                    command: "claude",
+                    cwd: "/project/app",
+                    tty: "ttys001"
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
             // No projects dir → discoverSessions returns []
-            adapter.projectsDir = '/nonexistent/path';
+            adapter.projectsDir = "/nonexistent/path";
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'claude',
+                type: "claude",
                 status: AgentStatus.IDLE,
                 pid: 777,
-                projectPath: '/project/app',
-                sessionId: 'pid-777',
-                summary: 'Unknown'
+                projectPath: "/project/app",
+                sessionId: "pid-777",
+                summary: "Unknown"
             });
         });
-        it('should detect agents with matched sessions', async ()=>{
+        it("should detect agents with matched sessions", async ()=>{
             const processes = [
                 {
                     pid: 12345,
-                    command: 'claude',
-                    cwd: '/Users/test/my-project',
-                    tty: 'ttys001',
-                    startTime: new Date('2026-03-18T23:18:01.000Z')
+                    command: "claude",
+                    cwd: "/Users/test/my-project",
+                    tty: "ttys001",
+                    startTime: new Date("2026-03-18T23:18:01.000Z")
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
             // Set up projects dir with encoded directory name
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-test-'));
-            const projectsDir = path.join(tmpDir, 'projects');
+            const tmpDir = fs.mkdtempSync(path.join(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');
+            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');
+            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',
+                    type: "user",
+                    timestamp: "2026-03-18T23:18:44Z",
+                    cwd: "/Users/test/my-project",
                     message: {
-                        content: 'Investigate failing tests'
+                        content: "Investigate failing tests"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
-                    timestamp: '2026-03-18T23:19:00Z'
+                    type: "assistant",
+                    timestamp: "2026-03-18T23:19:00Z"
                 })
-            ].join('\n'));
+            ].join("\n"));
             adapter.projectsDir = projectsDir;
             const sessionFiles = [
                 {
-                    sessionId: 'session-1',
+                    sessionId: "session-1",
                     filePath: sessionFile,
                     projectDir: projDir,
-                    birthtimeMs: new Date('2026-03-18T23:18:44Z').getTime(),
-                    resolvedCwd: ''
+                    birthtimeMs: new Date("2026-03-18T23:18:44Z").getTime(),
+                    resolvedCwd: ""
                 }
             ];
             mockedBatchGetSessionFileBirthtimes.mockReturnValue(sessionFiles);
@@ -189,7 +189,7 @@ describe('ClaudeCodeAdapter', ()=>{
                     process: processes[0],
                     session: {
                         ...sessionFiles[0],
-                        resolvedCwd: '/Users/test/my-project'
+                        resolvedCwd: "/Users/test/my-project"
                     },
                     deltaMs: 43000
                 }
@@ -198,62 +198,62 @@ describe('ClaudeCodeAdapter', ()=>{
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'claude',
+                type: "claude",
                 status: AgentStatus.WAITING,
                 pid: 12345,
-                projectPath: '/Users/test/my-project',
-                sessionId: 'session-1'
+                projectPath: "/Users/test/my-project",
+                sessionId: "session-1"
             });
-            expect(agents[0].summary).toContain('Investigate failing tests');
+            expect(agents[0].summary).toContain("Investigate failing tests");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
             });
         });
-        it('should fall back to process-only for unmatched processes', async ()=>{
+        it("should fall back to process-only for unmatched processes", async ()=>{
             const processes = [
                 {
                     pid: 100,
-                    command: 'claude',
-                    cwd: '/project-a',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project-a",
+                    tty: "ttys001",
                     startTime: new Date()
                 },
                 {
                     pid: 200,
-                    command: 'claude',
-                    cwd: '/project-b',
-                    tty: 'ttys002',
+                    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(os.tmpdir(), 'claude-test-'));
-            const projectsDir = path.join(tmpDir, 'projects');
+            const tmpDir = fs.mkdtempSync(path.join(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');
+            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');
+            const sessionFile = path.join(projDirA, "only-session.jsonl");
             fs.writeFileSync(sessionFile, JSON.stringify({
-                type: 'assistant',
-                timestamp: '2026-03-18T23:19:00Z'
+                type: "assistant",
+                timestamp: "2026-03-18T23:19:00Z"
             }));
             adapter.projectsDir = projectsDir;
             const sessionFiles = [
                 {
-                    sessionId: 'only-session',
+                    sessionId: "only-session",
                     filePath: sessionFile,
                     projectDir: projDirA,
                     birthtimeMs: Date.now(),
-                    resolvedCwd: ''
+                    resolvedCwd: ""
                 }
             ];
             mockedBatchGetSessionFileBirthtimes.mockReturnValue(sessionFiles);
@@ -263,7 +263,7 @@ describe('ClaudeCodeAdapter', ()=>{
                     process: processes[0],
                     session: {
                         ...sessionFiles[0],
-                        resolvedCwd: '/project-a'
+                        resolvedCwd: "/project-a"
                     },
                     deltaMs: 5000
                 }
@@ -273,154 +273,154 @@ describe('ClaudeCodeAdapter', ()=>{
             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(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 handle process with empty cwd in process-only fallback', async ()=>{
+        it("should handle process with empty cwd in process-only fallback", async ()=>{
             const processes = [
                 {
                     pid: 300,
-                    command: 'claude',
-                    cwd: '',
-                    tty: 'ttys003'
+                    command: "claude",
+                    cwd: "",
+                    tty: "ttys003"
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            adapter.projectsDir = '/nonexistent';
+            adapter.projectsDir = "/nonexistent";
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
                 pid: 300,
-                sessionId: 'pid-300',
-                summary: 'Unknown',
-                projectPath: ''
+                sessionId: "pid-300",
+                summary: "Unknown",
+                projectPath: ""
             });
         });
-        it('should match via --resume <uuid> in command line and skip PID-file/legacy', async ()=>{
-            const sessionId = '0555f803-7eca-4fc6-a1e0-34dbf86b33b2';
+        it("should match via --resume <uuid> in command line and skip PID-file/legacy", async ()=>{
+            const sessionId = "0555f803-7eca-4fc6-a1e0-34dbf86b33b2";
             const processes = [
                 {
                     pid: 41920,
                     command: `claude --resume ${sessionId}`,
-                    cwd: '/project/resumed',
-                    tty: 'ttys001',
+                    cwd: "/project/resumed",
+                    tty: "ttys001",
                     startTime: new Date()
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-resume-'));
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-resumed');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-resume-"));
+            const projectsDir = path.join(tmpDir, "projects");
+            const projDir = path.join(projectsDir, "-project-resumed");
             fs.mkdirSync(projDir, {
                 recursive: true
             });
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/resumed',
+                    cwd: "/project/resumed",
                     message: {
-                        content: 'resumed conversation'
+                        content: "resumed conversation"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
+                    type: "assistant",
                     timestamp: new Date().toISOString()
                 })
-            ].join('\n'));
+            ].join("\n"));
             adapter.projectsDir = projectsDir;
-            adapter.sessionsDir = path.join(tmpDir, 'sessions'); // empty — no PID file
+            adapter.sessionsDir = path.join(tmpDir, "sessions"); // empty — no PID file
             const agents = await adapter.detectAgents();
             // Legacy matching helpers must NOT have been consulted — resume match was authoritative
             expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
             expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'claude',
+                type: "claude",
                 pid: 41920,
                 sessionId,
-                projectPath: '/project/resumed'
+                projectPath: "/project/resumed"
             });
-            expect(agents[0].summary).toContain('resumed conversation');
+            expect(agents[0].summary).toContain("resumed conversation");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
             });
         });
-        it('should fall through when --resume points to a JSONL that does not exist', async ()=>{
+        it("should fall through when --resume points to a JSONL that does not exist", async ()=>{
             const processes = [
                 {
                     pid: 41921,
-                    command: 'claude --resume aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
-                    cwd: '/project/missing',
-                    tty: 'ttys001',
+                    command: "claude --resume aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+                    cwd: "/project/missing",
+                    tty: "ttys001",
                     startTime: new Date()
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
             // No projects dir, no PID file → both matchers fail → process-only
-            adapter.projectsDir = '/nonexistent';
-            adapter.sessionsDir = '/nonexistent';
+            adapter.projectsDir = "/nonexistent";
+            adapter.sessionsDir = "/nonexistent";
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
-            expect(agents[0].sessionId).toBe('pid-41921');
+            expect(agents[0].sessionId).toBe("pid-41921");
             expect(agents[0].status).toBe(AgentStatus.IDLE);
         });
-        it('should use PID file for direct match and skip legacy matching for that process', async ()=>{
+        it("should use PID file for direct match and skip legacy matching for that process", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 55001,
-                    command: 'claude',
-                    cwd: '/project/direct',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/direct",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-pid-test-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-direct');
+            const tmpDir = fs.mkdtempSync(path.join(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 sessionId = "pid-file-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/direct',
+                    cwd: "/project/direct",
                     message: {
-                        content: 'hello from pid file'
+                        content: "hello from pid file"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
+                    type: "assistant",
                     timestamp: new Date().toISOString()
                 })
-            ].join('\n'));
-            fs.writeFileSync(path.join(sessionsDir, '55001.json'), JSON.stringify({
+            ].join("\n"));
+            fs.writeFileSync(path.join(sessionsDir, "55001.json"), JSON.stringify({
                 pid: 55001,
                 sessionId,
-                cwd: '/project/direct',
+                cwd: "/project/direct",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli'
+                kind: "interactive",
+                entrypoint: "cli"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
@@ -430,76 +430,76 @@ describe('ClaudeCodeAdapter', ()=>{
             expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'claude',
+                type: "claude",
                 pid: 55001,
                 sessionId,
-                projectPath: '/project/direct',
+                projectPath: "/project/direct",
                 status: AgentStatus.WAITING
             });
-            expect(agents[0].summary).toContain('hello from pid file');
+            expect(agents[0].summary).toContain("hello from pid file");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
             });
         });
-        it('should prefer PID-file live status over JSONL-derived status and surface waitingFor in summary', async ()=>{
+        it("should prefer PID-file live status over JSONL-derived status and surface waitingFor in summary", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 55050,
-                    command: 'claude',
-                    cwd: '/project/wait',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/wait",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-pid-wait-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-wait');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-pid-wait-"));
+            const sessionsDir = path.join(tmpDir, "sessions");
+            const projectsDir = path.join(tmpDir, "projects");
+            const projDir = path.join(projectsDir, "-project-wait");
             fs.mkdirSync(sessionsDir, {
                 recursive: true
             });
             fs.mkdirSync(projDir, {
                 recursive: true
             });
-            const sessionId = 'wait-session';
+            const sessionId = "wait-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             // PID file's live status must win over JSONL-derived status.
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/wait',
+                    cwd: "/project/wait",
                     message: {
-                        content: '/reddit-commenter'
+                        content: "/reddit-commenter"
                     }
                 }),
                 JSON.stringify({
-                    type: 'permission-mode',
+                    type: "permission-mode",
                     timestamp: new Date().toISOString(),
-                    permissionMode: 'default'
+                    permissionMode: "default"
                 })
-            ].join('\n'));
-            fs.writeFileSync(path.join(sessionsDir, '55050.json'), JSON.stringify({
+            ].join("\n"));
+            fs.writeFileSync(path.join(sessionsDir, "55050.json"), JSON.stringify({
                 pid: 55050,
                 sessionId,
-                cwd: '/project/wait',
+                cwd: "/project/wait",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli',
-                status: 'waiting',
-                waitingFor: 'approve Read'
+                kind: "interactive",
+                entrypoint: "cli",
+                status: "waiting",
+                waitingFor: "approve Read"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0].status).toBe(AgentStatus.WAITING);
-            expect(agents[0].summary).toContain('/reddit-commenter');
-            expect(agents[0].summary).toContain('waiting for approve Read');
+            expect(agents[0].summary).toContain("/reddit-commenter");
+            expect(agents[0].summary).toContain("waiting for approve Read");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
@@ -510,49 +510,49 @@ describe('ClaudeCodeAdapter', ()=>{
             const processes = [
                 {
                     pid: 55051,
-                    command: 'claude',
-                    cwd: '/project/idle',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/idle",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-pid-idle-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-idle');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-pid-idle-"));
+            const sessionsDir = path.join(tmpDir, "sessions");
+            const projectsDir = path.join(tmpDir, "projects");
+            const projDir = path.join(projectsDir, "-project-idle");
             fs.mkdirSync(sessionsDir, {
                 recursive: true
             });
             fs.mkdirSync(projDir, {
                 recursive: true
             });
-            const sessionId = 'idle-session';
+            const sessionId = "idle-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/idle',
+                    cwd: "/project/idle",
                     message: {
-                        content: 'hello'
+                        content: "hello"
                     }
                 }),
                 JSON.stringify({
-                    type: 'permission-mode',
+                    type: "permission-mode",
                     timestamp: new Date().toISOString(),
-                    permissionMode: 'default'
+                    permissionMode: "default"
                 })
-            ].join('\n'));
-            fs.writeFileSync(path.join(sessionsDir, '55051.json'), JSON.stringify({
+            ].join("\n"));
+            fs.writeFileSync(path.join(sessionsDir, "55051.json"), JSON.stringify({
                 pid: 55051,
                 sessionId,
-                cwd: '/project/idle',
+                cwd: "/project/idle",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli',
-                status: 'idle'
+                kind: "interactive",
+                entrypoint: "cli",
+                status: "idle"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
@@ -560,61 +560,61 @@ describe('ClaudeCodeAdapter', ()=>{
             expect(agents).toHaveLength(1);
             expect(agents[0].status).toBe(AgentStatus.IDLE);
             // No waitingFor in PID file → summary is just the last user message
-            expect(agents[0].summary).toBe('hello');
+            expect(agents[0].summary).toBe("hello");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
             });
         });
-        it('should fall back to JSONL-derived status when PID-file status is missing or unrecognized', async ()=>{
+        it("should fall back to JSONL-derived status when PID-file status is missing or unrecognized", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 55052,
-                    command: 'claude',
-                    cwd: '/project/legacy',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/legacy",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-pid-nostat-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-legacy');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-pid-nostat-"));
+            const sessionsDir = path.join(tmpDir, "sessions");
+            const projectsDir = path.join(tmpDir, "projects");
+            const projDir = path.join(projectsDir, "-project-legacy");
             fs.mkdirSync(sessionsDir, {
                 recursive: true
             });
             fs.mkdirSync(projDir, {
                 recursive: true
             });
-            const sessionId = 'legacy-session';
+            const sessionId = "legacy-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             // Last entry is assistant → JSONL parser yields WAITING.
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/legacy',
+                    cwd: "/project/legacy",
                     message: {
-                        content: 'do the thing'
+                        content: "do the thing"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
+                    type: "assistant",
                     timestamp: new Date().toISOString()
                 })
-            ].join('\n'));
+            ].join("\n"));
             // PID file with unrecognized status string — adapter must ignore it and use parser
-            fs.writeFileSync(path.join(sessionsDir, '55052.json'), JSON.stringify({
+            fs.writeFileSync(path.join(sessionsDir, "55052.json"), JSON.stringify({
                 pid: 55052,
                 sessionId,
-                cwd: '/project/legacy',
+                cwd: "/project/legacy",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli',
-                status: 'fantastical-future-state'
+                kind: "interactive",
+                entrypoint: "cli",
+                status: "fantastical-future-state"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
@@ -626,24 +626,24 @@ describe('ClaudeCodeAdapter', ()=>{
                 force: true
             });
         });
-        it('should pick up live status from PID file even when matched via --resume', async ()=>{
-            const sessionId = 'aaaaaaaa-1111-2222-3333-444444444444';
+        it("should pick up live status from PID file even when matched via --resume", async ()=>{
+            const sessionId = "aaaaaaaa-1111-2222-3333-444444444444";
             const startTime = new Date();
             const processes = [
                 {
                     pid: 55053,
                     command: `claude --resume ${sessionId}`,
-                    cwd: '/project/resume-wait',
-                    tty: 'ttys001',
+                    cwd: "/project/resume-wait",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-resume-wait-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-resume-wait');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-resume-wait-"));
+            const sessionsDir = path.join(tmpDir, "sessions");
+            const projectsDir = path.join(tmpDir, "projects");
+            const projDir = path.join(projectsDir, "-project-resume-wait");
             fs.mkdirSync(sessionsDir, {
                 recursive: true
             });
@@ -653,86 +653,86 @@ describe('ClaudeCodeAdapter', ()=>{
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/resume-wait',
+                    cwd: "/project/resume-wait",
                     message: {
-                        content: 'resumed work'
+                        content: "resumed work"
                     }
                 }),
                 JSON.stringify({
-                    type: 'permission-mode',
+                    type: "permission-mode",
                     timestamp: new Date().toISOString(),
-                    permissionMode: 'default'
+                    permissionMode: "default"
                 })
-            ].join('\n'));
-            fs.writeFileSync(path.join(sessionsDir, '55053.json'), JSON.stringify({
+            ].join("\n"));
+            fs.writeFileSync(path.join(sessionsDir, "55053.json"), JSON.stringify({
                 pid: 55053,
                 sessionId,
-                cwd: '/project/resume-wait',
+                cwd: "/project/resume-wait",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli',
-                status: 'waiting',
-                waitingFor: 'approve Bash'
+                kind: "interactive",
+                entrypoint: "cli",
+                status: "waiting",
+                waitingFor: "approve Bash"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0].status).toBe(AgentStatus.WAITING);
-            expect(agents[0].summary).toContain('resumed work');
-            expect(agents[0].summary).toContain('waiting for approve Bash');
+            expect(agents[0].summary).toContain("resumed work");
+            expect(agents[0].summary).toContain("waiting for approve Bash");
             fs.rmSync(tmpDir, {
                 recursive: true,
                 force: true
             });
         });
-        it('should fall back to process-only when direct-matched JSONL becomes unreadable', async ()=>{
+        it("should fall back to process-only when direct-matched JSONL becomes unreadable", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 66001,
-                    command: 'claude',
-                    cwd: '/project/gone',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/gone",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-gone-'));
-            const sessionsDir = path.join(tmpDir, 'sessions');
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-gone');
+            const tmpDir = fs.mkdtempSync(path.join(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 sessionId = "gone-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, JSON.stringify({
-                type: 'assistant',
+                type: "assistant",
                 timestamp: new Date().toISOString()
             }));
-            fs.writeFileSync(path.join(sessionsDir, '66001.json'), JSON.stringify({
+            fs.writeFileSync(path.join(sessionsDir, "66001.json"), JSON.stringify({
                 pid: 66001,
                 sessionId,
-                cwd: '/project/gone',
+                cwd: "/project/gone",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli'
+                kind: "interactive",
+                entrypoint: "cli"
             }));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
             // Simulate JSONL disappearing between existence check and read
-            vi.spyOn(adapter.parser, 'readSession').mockReturnValueOnce(null);
+            vi.spyOn(adapter.parser, "readSession").mockReturnValueOnce(null);
             const agents = await adapter.detectAgents();
             // matchedPids.delete called → process falls back to IDLE
             expect(agents).toHaveLength(1);
-            expect(agents[0].sessionId).toBe('pid-66001');
+            expect(agents[0].sessionId).toBe("pid-66001");
             expect(agents[0].status).toBe(AgentStatus.IDLE);
             fs.rmSync(tmpDir, {
                 recursive: true,
@@ -740,40 +740,40 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             vi.restoreAllMocks();
         });
-        it('should fall back to process-only when legacy-matched JSONL becomes unreadable', async ()=>{
+        it("should fall back to process-only when legacy-matched JSONL becomes unreadable", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 66002,
-                    command: 'claude',
-                    cwd: '/project/legacy-gone',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/legacy-gone",
+                    tty: "ttys001",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-lgone-'));
-            const projectsDir = path.join(tmpDir, 'projects');
-            const projDir = path.join(projectsDir, '-project-legacy-gone');
+            const tmpDir = fs.mkdtempSync(path.join(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 sessionId = "legacy-gone-session";
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
             fs.writeFileSync(jsonlPath, JSON.stringify({
-                type: 'assistant',
+                type: "assistant",
                 timestamp: new Date().toISOString()
             }));
             // No PID file → process goes to legacy fallback
-            adapter.sessionsDir = path.join(tmpDir, 'no-sessions');
+            adapter.sessionsDir = path.join(tmpDir, "no-sessions");
             adapter.projectsDir = projectsDir;
             const legacySessionFile = {
                 sessionId,
                 filePath: jsonlPath,
                 projectDir: projDir,
                 birthtimeMs: startTime.getTime(),
-                resolvedCwd: '/project/legacy-gone'
+                resolvedCwd: "/project/legacy-gone"
             };
             mockedBatchGetSessionFileBirthtimes.mockReturnValue([
                 legacySessionFile
@@ -786,10 +786,10 @@ describe('ClaudeCodeAdapter', ()=>{
                 }
             ]);
             // Simulate JSONL disappearing between match and read
-            vi.spyOn(adapter.parser, 'readSession').mockReturnValueOnce(null);
+            vi.spyOn(adapter.parser, "readSession").mockReturnValueOnce(null);
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
-            expect(agents[0].sessionId).toBe('pid-66002');
+            expect(agents[0].sessionId).toBe("pid-66002");
             expect(agents[0].status).toBe(AgentStatus.IDLE);
             fs.rmSync(tmpDir, {
                 recursive: true,
@@ -797,31 +797,31 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             vi.restoreAllMocks();
         });
-        it('should mix direct PID-file matches and legacy matches across processes', async ()=>{
+        it("should mix direct PID-file matches and legacy matches across processes", async ()=>{
             const startTime = new Date();
             const processes = [
                 {
                     pid: 55002,
-                    command: 'claude',
-                    cwd: '/project/alpha',
-                    tty: 'ttys001',
+                    command: "claude",
+                    cwd: "/project/alpha",
+                    tty: "ttys001",
                     startTime
                 },
                 {
                     pid: 55003,
-                    command: 'claude',
-                    cwd: '/project/beta',
-                    tty: 'ttys002',
+                    command: "claude",
+                    cwd: "/project/beta",
+                    tty: "ttys002",
                     startTime
                 }
             ];
             mockedListAgentProcesses.mockReturnValue(processes);
             mockedEnrichProcesses.mockReturnValue(processes);
-            const tmpDir = fs.mkdtempSync(path.join(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');
+            const tmpDir = fs.mkdtempSync(path.join(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
             });
@@ -832,47 +832,47 @@ describe('ClaudeCodeAdapter', ()=>{
                 recursive: true
             });
             // PID file only for process 55002
-            const directSessionId = 'direct-session';
+            const directSessionId = "direct-session";
             const directJsonl = path.join(projAlpha, `${directSessionId}.jsonl`);
             fs.writeFileSync(directJsonl, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/alpha',
+                    cwd: "/project/alpha",
                     message: {
-                        content: 'direct question'
+                        content: "direct question"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
+                    type: "assistant",
                     timestamp: new Date().toISOString()
                 })
-            ].join('\n'));
-            fs.writeFileSync(path.join(sessionsDir, '55002.json'), JSON.stringify({
+            ].join("\n"));
+            fs.writeFileSync(path.join(sessionsDir, "55002.json"), JSON.stringify({
                 pid: 55002,
                 sessionId: directSessionId,
-                cwd: '/project/alpha',
+                cwd: "/project/alpha",
                 startedAt: startTime.getTime(),
-                kind: 'interactive',
-                entrypoint: 'cli'
+                kind: "interactive",
+                entrypoint: "cli"
             }));
             // Legacy session file for process 55003
-            const legacySessionId = 'legacy-session';
+            const legacySessionId = "legacy-session";
             const legacyJsonl = path.join(projBeta, `${legacySessionId}.jsonl`);
             fs.writeFileSync(legacyJsonl, [
                 JSON.stringify({
-                    type: 'user',
+                    type: "user",
                     timestamp: new Date().toISOString(),
-                    cwd: '/project/beta',
+                    cwd: "/project/beta",
                     message: {
-                        content: 'legacy question'
+                        content: "legacy question"
                     }
                 }),
                 JSON.stringify({
-                    type: 'assistant',
+                    type: "assistant",
                     timestamp: new Date().toISOString()
                 })
-            ].join('\n'));
+            ].join("\n"));
             adapter.sessionsDir = sessionsDir;
             adapter.projectsDir = projectsDir;
             // Mock legacy matching for process 55003
@@ -881,7 +881,7 @@ describe('ClaudeCodeAdapter', ()=>{
                 filePath: legacyJsonl,
                 projectDir: projBeta,
                 birthtimeMs: startTime.getTime(),
-                resolvedCwd: '/project/beta'
+                resolvedCwd: "/project/beta"
             };
             mockedBatchGetSessionFileBirthtimes.mockReturnValue([
                 legacySessionFile
@@ -910,13 +910,13 @@ describe('ClaudeCodeAdapter', ()=>{
             });
         });
     });
-    describe('helper methods', ()=>{
-        describe('determineStatus', ()=>{
+    describe("helper methods", ()=>{
+        describe("determineStatus", ()=>{
             it('should return "unknown" for sessions with no last entry type', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
                     isInterrupted: false
@@ -926,11 +926,11 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "waiting" for assistant entries', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'assistant',
+                    lastEntryType: "assistant",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.WAITING);
@@ -938,11 +938,11 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "waiting" for user interruption', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'user',
+                    lastEntryType: "user",
                     isInterrupted: true
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.WAITING);
@@ -950,24 +950,24 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "running" for user/progress entries', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'user',
+                    lastEntryType: "user",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
             });
-            it('should not override status based on age (process is running)', ()=>{
+            it("should not override status based on age (process is running)", ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const oldDate = new Date(Date.now() - 10 * 60 * 1000);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: oldDate,
                     lastActive: oldDate,
-                    lastEntryType: 'assistant',
+                    lastEntryType: "assistant",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.WAITING);
@@ -975,11 +975,11 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "idle" for system entries', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'system',
+                    lastEntryType: "system",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.IDLE);
@@ -987,11 +987,11 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "running" for thinking entries', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'thinking',
+                    lastEntryType: "thinking",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
@@ -999,11 +999,11 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "running" for progress entries', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'progress',
+                    lastEntryType: "progress",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.RUNNING);
@@ -1011,80 +1011,80 @@ describe('ClaudeCodeAdapter', ()=>{
             it('should return "unknown" for unrecognized entry types', ()=>{
                 const determineStatus = adapter.parser.determineStatus.bind(adapter.parser);
                 const session = {
-                    sessionId: 'test',
-                    projectPath: '/test',
+                    sessionId: "test",
+                    projectPath: "/test",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastEntryType: 'some_other_type',
+                    lastEntryType: "some_other_type",
                     isInterrupted: false
                 };
                 expect(determineStatus(session)).toBe(AgentStatus.UNKNOWN);
             });
         });
-        describe('extractUserMessageText', ()=>{
-            it('should extract plain string content', ()=>{
-                const extract = adapter.parser['extractUserMessageText'].bind(adapter.parser);
-                expect(extract('hello world')).toBe('hello world');
+        describe("extractUserMessageText", ()=>{
+            it("should extract plain string content", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.parser);
+                expect(extract("hello world")).toBe("hello world");
             });
-            it('should extract text from array content blocks', ()=>{
-                const extract = adapter.parser['extractUserMessageText'].bind(adapter.parser);
+            it("should extract text from array content blocks", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.parser);
                 const content = [
                     {
-                        type: 'tool_result',
-                        content: 'some result'
+                        type: "tool_result",
+                        content: "some result"
                     },
                     {
-                        type: 'text',
-                        text: 'user question'
+                        type: "text",
+                        text: "user question"
                     }
                 ];
-                expect(extract(content)).toBe('user question');
+                expect(extract(content)).toBe("user question");
             });
-            it('should return undefined for empty/null content', ()=>{
-                const extract = adapter.parser['extractUserMessageText'].bind(adapter.parser);
+            it("should return undefined for empty/null content", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.parser);
                 expect(extract(undefined)).toBeUndefined();
-                expect(extract('')).toBeUndefined();
+                expect(extract("")).toBeUndefined();
                 expect(extract([])).toBeUndefined();
             });
-            it('should parse command-message tags', ()=>{
-                const extract = adapter.parser['extractUserMessageText'].bind(adapter.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 tags", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.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.parser['extractUserMessageText'].bind(adapter.parser);
-                const msg = '<command-message><command-name>help</command-name></command-message>';
-                expect(extract(msg)).toBe('help');
+            it("should parse command-message without args", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.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.parser['extractUserMessageText'].bind(adapter.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 extract ARGUMENTS from skill expansion", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.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.parser['extractUserMessageText'].bind(adapter.parser);
-                const msg = 'Base directory for this skill: /some/path\n\nSome instructions only';
+            it("should return undefined for skill expansion without ARGUMENTS", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.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.parser['extractUserMessageText'].bind(adapter.parser);
-                expect(extract('[Request interrupted by user]')).toBeUndefined();
-                expect(extract('Tool loaded.')).toBeUndefined();
-                expect(extract('This session is being continued from a previous conversation')).toBeUndefined();
+            it("should filter noise messages", ()=>{
+                const extract = adapter.parser["extractUserMessageText"].bind(adapter.parser);
+                expect(extract("[Request interrupted by user]")).toBeUndefined();
+                expect(extract("Tool loaded.")).toBeUndefined();
+                expect(extract("This session is being continued from a previous conversation")).toBeUndefined();
             });
         });
-        describe('parseCommandMessage', ()=>{
-            it('should return undefined for malformed command-message', ()=>{
-                const parse = adapter.parser['parseCommandMessage'].bind(adapter.parser);
-                expect(parse('<command-message>no tags</command-message>')).toBeUndefined();
+        describe("parseCommandMessage", ()=>{
+            it("should return undefined for malformed command-message", ()=>{
+                const parse = adapter.parser["parseCommandMessage"].bind(adapter.parser);
+                expect(parse("<command-message>no tags</command-message>")).toBeUndefined();
             });
         });
     });
-    describe('file I/O methods', ()=>{
+    describe("file I/O methods", ()=>{
         let tmpDir;
         beforeEach(()=>{
-            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-test-'));
-            adapter.projectsDir = path.join(tmpDir, 'projects');
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-test-"));
+            adapter.projectsDir = path.join(tmpDir, "projects");
         });
         afterEach(()=>{
             fs.rmSync(tmpDir, {
@@ -1092,197 +1092,197 @@ describe('ClaudeCodeAdapter', ()=>{
                 force: true
             });
         });
-        describe('readSession', ()=>{
-            it('should parse session file with timestamps, cwd, and entry type', ()=>{
+        describe("readSession", ()=>{
+            it("should parse session file with timestamps, cwd, and entry type", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'test-session.jsonl');
+                const filePath = path.join(tmpDir, "test-session.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
-                        cwd: '/my/project'
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
+                        cwd: "/my/project"
                     }),
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:01:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:01:00Z"
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/my/project');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/my/project");
                 expect(session).toMatchObject({
-                    sessionId: 'test-session',
-                    projectPath: '/my/project',
-                    lastCwd: '/my/project',
-                    lastEntryType: 'assistant',
+                    sessionId: "test-session",
+                    projectPath: "/my/project",
+                    lastCwd: "/my/project",
+                    lastEntryType: "assistant",
                     isInterrupted: false
                 });
-                expect(session.sessionStart.toISOString()).toBe('2026-03-10T10:00:00.000Z');
-                expect(session.lastActive.toISOString()).toBe('2026-03-10T10:01:00.000Z');
+                expect(session.sessionStart.toISOString()).toBe("2026-03-10T10:00:00.000Z");
+                expect(session.lastActive.toISOString()).toBe("2026-03-10T10:01:00.000Z");
             });
-            it('should detect user interruption', ()=>{
+            it("should detect user interruption", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'interrupted.jsonl');
+                const filePath = path.join(tmpDir, "interrupted.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
                         message: {
                             content: [
                                 {
-                                    type: 'text',
-                                    text: '[Request interrupted by user for tool use]'
+                                    type: "text",
+                                    text: "[Request interrupted by user for tool use]"
                                 }
                             ]
                         }
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/test');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/test");
                 expect(session.isInterrupted).toBe(true);
-                expect(session.lastEntryType).toBe('user');
+                expect(session.lastEntryType).toBe("user");
             });
-            it('should return session with defaults for empty file', ()=>{
+            it("should return session with defaults for empty file", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'empty.jsonl');
-                fs.writeFileSync(filePath, '');
-                const session = readSession(filePath, '/test');
+                const filePath = path.join(tmpDir, "empty.jsonl");
+                fs.writeFileSync(filePath, "");
+                const session = readSession(filePath, "/test");
                 expect(session).not.toBeNull();
                 expect(session.lastEntryType).toBeUndefined();
             });
-            it('should return null for non-existent file', ()=>{
+            it("should return null for non-existent file", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                expect(readSession(path.join(tmpDir, 'nonexistent.jsonl'), '/test')).toBeNull();
+                expect(readSession(path.join(tmpDir, "nonexistent.jsonl"), "/test")).toBeNull();
             });
-            it('should skip metadata entry types for lastEntryType', ()=>{
+            it("should skip metadata entry types for lastEntryType", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'metadata-test.jsonl');
+                const filePath = path.join(tmpDir, "metadata-test.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
                         message: {
-                            content: 'hello'
+                            content: "hello"
                         }
                     }),
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:01:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:01:00Z"
                     }),
                     JSON.stringify({
-                        type: 'last-prompt',
-                        timestamp: '2026-03-10T10:02:00Z'
+                        type: "last-prompt",
+                        timestamp: "2026-03-10T10:02:00Z"
                     }),
                     JSON.stringify({
-                        type: 'file-history-snapshot',
-                        timestamp: '2026-03-10T10:03:00Z'
+                        type: "file-history-snapshot",
+                        timestamp: "2026-03-10T10:03:00Z"
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/test');
-                expect(session.lastEntryType).toBe('assistant');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/test");
+                expect(session.lastEntryType).toBe("assistant");
             });
-            it('should parse snapshot.timestamp from file-history-snapshot first entry', ()=>{
+            it("should parse snapshot.timestamp from file-history-snapshot first entry", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'snapshot-ts.jsonl');
+                const filePath = path.join(tmpDir, "snapshot-ts.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'file-history-snapshot',
+                        type: "file-history-snapshot",
                         snapshot: {
-                            timestamp: '2026-03-10T09:55:00Z',
+                            timestamp: "2026-03-10T09:55:00Z",
                             files: []
                         }
                     }),
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
                         message: {
-                            content: 'test'
+                            content: "test"
                         }
                     }),
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:01:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:01:00Z"
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/test');
-                expect(session.sessionStart.toISOString()).toBe('2026-03-10T09:55:00.000Z');
-                expect(session.lastActive.toISOString()).toBe('2026-03-10T10:01:00.000Z');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/test");
+                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', ()=>{
+            it("should extract lastUserMessage from session entries", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'user-msg.jsonl');
+                const filePath = path.join(tmpDir, "user-msg.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
                         message: {
-                            content: 'first question'
+                            content: "first question"
                         }
                     }),
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:01:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:01:00Z"
                     }),
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:02:00Z',
+                        type: "user",
+                        timestamp: "2026-03-10T10:02:00Z",
                         message: {
                             content: [
                                 {
-                                    type: 'text',
-                                    text: 'second question'
+                                    type: "text",
+                                    text: "second question"
                                 }
                             ]
                         }
                     }),
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:03:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:03:00Z"
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/test');
-                expect(session.lastUserMessage).toBe('second question');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/test");
+                expect(session.lastUserMessage).toBe("second question");
             });
-            it('should use lastCwd as projectPath when projectPath is empty', ()=>{
+            it("should use lastCwd as projectPath when projectPath is empty", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'no-project.jsonl');
+                const filePath = path.join(tmpDir, "no-project.jsonl");
                 const lines = [
                     JSON.stringify({
-                        type: 'user',
-                        timestamp: '2026-03-10T10:00:00Z',
-                        cwd: '/derived/path',
+                        type: "user",
+                        timestamp: "2026-03-10T10:00:00Z",
+                        cwd: "/derived/path",
                         message: {
-                            content: 'test'
+                            content: "test"
                         }
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '');
-                expect(session.projectPath).toBe('/derived/path');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "");
+                expect(session.projectPath).toBe("/derived/path");
             });
-            it('should handle malformed JSON lines gracefully', ()=>{
+            it("should handle malformed JSON lines gracefully", ()=>{
                 const readSession = adapter.parser.readSession.bind(adapter.parser);
-                const filePath = path.join(tmpDir, 'malformed.jsonl');
+                const filePath = path.join(tmpDir, "malformed.jsonl");
                 const lines = [
-                    'not json',
+                    "not json",
                     JSON.stringify({
-                        type: 'assistant',
-                        timestamp: '2026-03-10T10:00:00Z'
+                        type: "assistant",
+                        timestamp: "2026-03-10T10:00:00Z"
                     })
                 ];
-                fs.writeFileSync(filePath, lines.join('\n'));
-                const session = readSession(filePath, '/test');
+                fs.writeFileSync(filePath, lines.join("\n"));
+                const session = readSession(filePath, "/test");
                 expect(session).not.toBeNull();
-                expect(session.lastEntryType).toBe('assistant');
+                expect(session.lastEntryType).toBe("assistant");
             });
         });
     });
-    describe('getConversation', ()=>{
+    describe("getConversation", ()=>{
         let tmpDir;
         beforeEach(()=>{
-            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-conv-'));
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-conv-"));
         });
         afterEach(()=>{
             fs.rmSync(tmpDir, {
@@ -1291,27 +1291,27 @@ describe('ClaudeCodeAdapter', ()=>{
             });
         });
         function writeJsonl(lines) {
-            const filePath = path.join(tmpDir, 'session.jsonl');
-            fs.writeFileSync(filePath, lines.map((l)=>JSON.stringify(l)).join('\n'));
+            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', ()=>{
+        it("should parse user and assistant text messages", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
-                        content: 'Hello'
+                        content: "Hello"
                     }
                 },
                 {
-                    type: 'assistant',
-                    timestamp: '2026-03-27T10:00:05Z',
+                    type: "assistant",
+                    timestamp: "2026-03-27T10:00:05Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: 'Hi there!'
+                                type: "text",
+                                text: "Hi there!"
                             }
                         ]
                     }
@@ -1320,65 +1320,65 @@ describe('ClaudeCodeAdapter', ()=>{
             const messages = adapter.getConversation(filePath);
             expect(messages).toHaveLength(2);
             expect(messages[0]).toEqual({
-                role: 'user',
-                content: 'Hello',
-                timestamp: '2026-03-27T10:00:00Z'
+                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'
+                role: "assistant",
+                content: "Hi there!",
+                timestamp: "2026-03-27T10:00:05Z"
             });
         });
-        it('should skip metadata entry types', ()=>{
+        it("should skip metadata entry types", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'file-history-snapshot',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "file-history-snapshot",
+                    timestamp: "2026-03-27T10:00:00Z",
                     snapshot: {}
                 },
                 {
-                    type: 'last-prompt',
-                    timestamp: '2026-03-27T10:00:00Z'
+                    type: "last-prompt",
+                    timestamp: "2026-03-27T10:00:00Z"
                 },
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:01Z",
                     message: {
-                        content: 'Fix bug'
+                        content: "Fix bug"
                     }
                 }
             ]);
             const messages = adapter.getConversation(filePath);
             expect(messages).toHaveLength(1);
-            expect(messages[0].content).toBe('Fix bug');
+            expect(messages[0].content).toBe("Fix bug");
         });
-        it('should skip progress and thinking entries', ()=>{
+        it("should skip progress and thinking entries", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
-                        content: 'Hello'
+                        content: "Hello"
                     }
                 },
                 {
-                    type: 'progress',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "progress",
+                    timestamp: "2026-03-27T10:00:01Z",
                     data: {}
                 },
                 {
-                    type: 'thinking',
-                    timestamp: '2026-03-27T10:00:02Z'
+                    type: "thinking",
+                    timestamp: "2026-03-27T10:00:02Z"
                 },
                 {
-                    type: 'assistant',
-                    timestamp: '2026-03-27T10:00:03Z',
+                    type: "assistant",
+                    timestamp: "2026-03-27T10:00:03Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: 'Done'
+                                type: "text",
+                                text: "Done"
                             }
                         ]
                     }
@@ -1386,57 +1386,57 @@ describe('ClaudeCodeAdapter', ()=>{
             ]);
             const messages = adapter.getConversation(filePath);
             expect(messages).toHaveLength(2);
-            expect(messages[0].role).toBe('user');
-            expect(messages[1].role).toBe('assistant');
+            expect(messages[0].role).toBe("user");
+            expect(messages[1].role).toBe("assistant");
         });
-        it('should include system messages', ()=>{
+        it("should include system messages", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'system',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "system",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
-                        content: 'System initialized'
+                        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'
+                role: "system",
+                content: "System initialized",
+                timestamp: "2026-03-27T10:00:00Z"
             });
         });
-        it('should skip tool_use and tool_result blocks in default mode', ()=>{
+        it("should skip tool_use and tool_result blocks in default mode", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'assistant',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "assistant",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: 'Let me read the file.'
+                                type: "text",
+                                text: "Let me read the file."
                             },
                             {
-                                type: 'tool_use',
-                                name: 'Read',
+                                type: "tool_use",
+                                name: "Read",
                                 input: {
-                                    file_path: '/src/app.ts'
+                                    file_path: "/src/app.ts"
                                 }
                             }
                         ]
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:01Z",
                     message: {
                         content: [
                             {
-                                type: 'tool_result',
-                                tool_use_id: 'toolu_1',
-                                content: 'file contents here'
+                                type: "tool_result",
+                                tool_use_id: "toolu_1",
+                                content: "file contents here"
                             }
                         ]
                     }
@@ -1444,38 +1444,38 @@ describe('ClaudeCodeAdapter', ()=>{
             ]);
             const messages = adapter.getConversation(filePath);
             expect(messages).toHaveLength(1);
-            expect(messages[0].content).toBe('Let me read the file.');
+            expect(messages[0].content).toBe("Let me read the file.");
         });
-        it('should include tool_use and tool_result blocks in verbose mode', ()=>{
+        it("should include tool_use and tool_result blocks in verbose mode", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'assistant',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "assistant",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: 'Let me read the file.'
+                                type: "text",
+                                text: "Let me read the file."
                             },
                             {
-                                type: 'tool_use',
-                                name: 'Read',
+                                type: "tool_use",
+                                name: "Read",
                                 input: {
-                                    file_path: '/src/app.ts'
+                                    file_path: "/src/app.ts"
                                 }
                             }
                         ]
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:01Z",
                     message: {
                         content: [
                             {
-                                type: 'tool_result',
-                                tool_use_id: 'toolu_1',
-                                content: 'file contents here'
+                                type: "tool_result",
+                                tool_use_id: "toolu_1",
+                                content: "file contents here"
                             }
                         ]
                     }
@@ -1485,21 +1485,21 @@ describe('ClaudeCodeAdapter', ()=>{
                 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]');
+            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', ()=>{
+        it("should handle tool_result errors in verbose mode", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
                         content: [
                             {
-                                type: 'tool_result',
-                                tool_use_id: 'toolu_1',
-                                content: 'Something went wrong',
+                                type: "tool_result",
+                                tool_use_id: "toolu_1",
+                                content: "Something went wrong",
                                 is_error: true
                             }
                         ]
@@ -1510,85 +1510,85 @@ describe('ClaudeCodeAdapter', ()=>{
                 verbose: true
             });
             expect(messages).toHaveLength(1);
-            expect(messages[0].content).toContain('[Tool Error]');
+            expect(messages[0].content).toContain("[Tool Error]");
         });
-        it('should handle malformed JSON lines gracefully', ()=>{
-            const filePath = path.join(tmpDir, 'malformed.jsonl');
+        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',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
-                        content: 'Hello'
+                        content: "Hello"
                     }
                 }),
-                'this is not valid json',
+                "this is not valid json",
                 JSON.stringify({
-                    type: 'assistant',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "assistant",
+                    timestamp: "2026-03-27T10:00:01Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: 'World'
+                                type: "text",
+                                text: "World"
                             }
                         ]
                     }
                 })
-            ].join('\n'));
+            ].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');
+        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, '');
+        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', ()=>{
+        it("should filter noise messages from user entries", ()=>{
             const filePath = writeJsonl([
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:00Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:00Z",
                     message: {
                         content: [
                             {
-                                type: 'text',
-                                text: '[Request interrupted by user]'
+                                type: "text",
+                                text: "[Request interrupted by user]"
                             }
                         ]
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:01Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:01Z",
                     message: {
-                        content: 'Tool loaded.'
+                        content: "Tool loaded."
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2026-03-27T10:00:02Z',
+                    type: "user",
+                    timestamp: "2026-03-27T10:00:02Z",
                     message: {
-                        content: 'Real question'
+                        content: "Real question"
                     }
                 }
             ]);
             const messages = adapter.getConversation(filePath);
             expect(messages).toHaveLength(1);
-            expect(messages[0].content).toBe('Real question');
+            expect(messages[0].content).toBe("Real question");
         });
     });
-    describe('listSessions', ()=>{
+    describe("listSessions", ()=>{
         let tmpDir;
         let projectsDir;
         beforeEach(()=>{
-            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-list-'));
-            projectsDir = path.join(tmpDir, 'projects');
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-list-"));
+            projectsDir = path.join(tmpDir, "projects");
             fs.mkdirSync(projectsDir, {
                 recursive: true
             });
@@ -1605,10 +1605,10 @@ describe('ClaudeCodeAdapter', ()=>{
                 recursive: true
             });
             const filePath = path.join(projectDir, `${sessionId}.jsonl`);
-            fs.writeFileSync(filePath, lines.map((l)=>JSON.stringify(l)).join('\n'));
+            fs.writeFileSync(filePath, lines.map((l)=>JSON.stringify(l)).join("\n"));
             return filePath;
         }
-        it('returns empty when projects dir does not exist', async ()=>{
+        it("returns empty when projects dir does not exist", async ()=>{
             fs.rmSync(projectsDir, {
                 recursive: true,
                 force: true
@@ -1616,21 +1616,21 @@ describe('ClaudeCodeAdapter', ()=>{
             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', [
+        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',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd,
                     message: {
-                        content: 'first prompt'
+                        content: "first prompt"
                     }
                 },
                 {
-                    type: 'assistant',
-                    timestamp: '2025-01-01T00:01:00Z'
+                    type: "assistant",
+                    timestamp: "2025-01-01T00:01:00Z"
                 }
             ]);
             const result = await adapter.listSessions({
@@ -1638,43 +1638,43 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             expect(result).toHaveLength(1);
             expect(result[0]).toMatchObject({
-                type: 'claude',
-                sessionId: 'sess-1',
+                type: "claude",
+                sessionId: "sess-1",
                 cwd,
-                firstUserMessage: 'first prompt',
+                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', [
+        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',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd: cwdA,
                     message: {
-                        content: 'msg-a'
+                        content: "msg-a"
                     }
                 }
             ]);
-            writeSession(path.join(projectsDir, '-Users-test-proj-b'), 'b', [
+            writeSession(path.join(projectsDir, "-Users-test-proj-b"), "b", [
                 {
-                    type: 'user',
-                    timestamp: '2025-01-02T00:00:00Z',
+                    type: "user",
+                    timestamp: "2025-01-02T00:00:00Z",
                     cwd: cwdB,
                     message: {
-                        content: 'msg-b'
+                        content: "msg-b"
                     }
                 }
             ]);
             const result = await adapter.listSessions();
             expect(result).toHaveLength(2);
             expect(result.map((r)=>r.sessionId).sort()).toEqual([
-                'a',
-                'b'
+                "a",
+                "b"
             ]);
             const cwds = result.map((r)=>r.cwd).sort();
             expect(cwds).toEqual([
@@ -1682,16 +1682,16 @@ describe('ClaudeCodeAdapter', ()=>{
                 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', [
+        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',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd: cwdReal,
                     message: {
-                        content: 'hi'
+                        content: "hi"
                     }
                 }
             ]);
@@ -1701,18 +1701,18 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             expect(result).toEqual([]);
         });
-        it('drops sessions whose recorded cwd disagrees with the encoded dir', async ()=>{
+        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', [
+            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',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
+                    cwd: "/different/path",
                     message: {
-                        content: 'mismatch'
+                        content: "mismatch"
                     }
                 }
             ]);
@@ -1721,20 +1721,20 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             expect(result).toEqual([]);
         });
-        it('finds sessions whose recorded cwd lives in a different encoded dir (worktree case)', async ()=>{
+        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', [
+            const launchDir = path.join(projectsDir, "-repo");
+            const worktreeCwd = "/repo/.worktrees/feature";
+            writeSession(launchDir, "wt", [
                 {
-                    type: 'user',
-                    timestamp: '2025-01-01T00:00:00Z',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd: worktreeCwd,
                     message: {
-                        content: 'in worktree'
+                        content: "in worktree"
                     }
                 }
             ]);
@@ -1743,25 +1743,25 @@ describe('ClaudeCodeAdapter', ()=>{
             });
             expect(result).toHaveLength(1);
             expect(result[0]).toMatchObject({
-                sessionId: 'wt',
+                sessionId: "wt",
                 cwd: worktreeCwd,
-                firstUserMessage: 'in worktree'
+                firstUserMessage: "in worktree"
             });
         });
-        it('skips malformed session files', async ()=>{
-            const cwd = '/Users/test/p';
-            const projDir = path.join(projectsDir, '-Users-test-p');
+        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', [
+            fs.writeFileSync(path.join(projDir, "bad.jsonl"), "not valid json");
+            writeSession(projDir, "good", [
                 {
-                    type: 'user',
-                    timestamp: '2025-01-01T00:00:00Z',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd,
                     message: {
-                        content: 'ok'
+                        content: "ok"
                     }
                 }
             ]);
@@ -1769,33 +1769,33 @@ describe('ClaudeCodeAdapter', ()=>{
                 cwd
             });
             expect(result).toHaveLength(1);
-            expect(result[0].sessionId).toBe('good');
+            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', [
+        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',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:00Z",
                     cwd,
                     message: {
-                        content: 'Tool loaded.'
+                        content: "Tool loaded."
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2025-01-01T00:00:01Z',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:01Z",
                     cwd,
                     message: {
-                        content: 'real first prompt'
+                        content: "real first prompt"
                     }
                 },
                 {
-                    type: 'user',
-                    timestamp: '2025-01-01T00:00:02Z',
+                    type: "user",
+                    timestamp: "2025-01-01T00:00:02Z",
                     cwd,
                     message: {
-                        content: 'second prompt'
+                        content: "second prompt"
                     }
                 }
             ]);
@@ -1803,21 +1803,21 @@ describe('ClaudeCodeAdapter', ()=>{
                 cwd
             });
             expect(result).toHaveLength(1);
-            expect(result[0].firstUserMessage).toBe('real first prompt');
+            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', [
+        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'
+                    type: "assistant",
+                    timestamp: "2025-01-01T00:00:00Z"
                 }
             ]);
             const result = await adapter.listSessions({
                 cwd
             });
             expect(result).toHaveLength(1);
-            expect(result[0].firstUserMessage).toBe('');
+            expect(result[0].firstUserMessage).toBe("");
         });
     });
 });