@ai-devkit/agent-manager 0.32.0 → 0.33.0

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

@@ -1,15 +1,15 @@
 /**
  * Tests for GeminiCliAdapter
- */ import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { GeminiCliAdapter } from '../../adapters/GeminiCliAdapter.js';
-import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { AgentRegistry } from '../../utils/AgentRegistry.js';
-import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
-import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
-import * as crypto from 'crypto';
-vi.mock('../../utils/process.js', async (importOriginal)=>{
+ */ import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { GeminiCliAdapter } from "../../adapters/GeminiCliAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { AgentRegistry } from "../../utils/AgentRegistry.js";
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from "../../utils/process.js";
+import { matchProcessesToSessions, generateAgentName } from "../../utils/matching.js";
+import * as crypto from "crypto";
+vi.mock("../../utils/process.js", async (importOriginal)=>{
     const actual = await importOriginal();
     return {
         ...actual,
@@ -18,7 +18,7 @@ vi.mock('../../utils/process.js', async (importOriginal)=>{
         captureProcessSnapshot: vi.fn()
     };
 });
-vi.mock('../../utils/matching.js', ()=>({
+vi.mock("../../utils/matching.js", ()=>({
         matchProcessesToSessions: vi.fn(),
         generateAgentName: vi.fn()
     }));
@@ -27,13 +27,13 @@ const mockedEnrichProcesses = enrichProcesses;
 const mockedCaptureProcessSnapshot = captureProcessSnapshot;
 const mockedMatchProcessesToSessions = matchProcessesToSessions;
 const mockedGenerateAgentName = generateAgentName;
-describe('GeminiCliAdapter', ()=>{
+describe("GeminiCliAdapter", ()=>{
     let adapter;
     let tmpHome;
     beforeEach(()=>{
-        tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-adapter-test-'));
+        tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "gemini-adapter-test-"));
         process.env.HOME = tmpHome;
-        adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
+        adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, "agents.json")));
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
         mockedCaptureProcessSnapshot.mockReset();
@@ -44,7 +44,7 @@ describe('GeminiCliAdapter', ()=>{
         mockedCaptureProcessSnapshot.mockImplementation(async (names)=>enrichProcesses(names.flatMap((name)=>listAgentProcesses(name))));
         mockedMatchProcessesToSessions.mockReturnValue([]);
         mockedGenerateAgentName.mockImplementation((cwd, pid)=>{
-            const folder = path.basename(cwd) || 'unknown';
+            const folder = path.basename(cwd) || "unknown";
             return `${folder} (${pid})`;
         });
     });
@@ -54,89 +54,89 @@ describe('GeminiCliAdapter', ()=>{
             force: true
         });
     });
-    describe('initialization', ()=>{
-        it('should expose gemini_cli type', ()=>{
-            expect(adapter.type).toBe('gemini_cli');
+    describe("initialization", ()=>{
+        it("should expose gemini_cli type", ()=>{
+            expect(adapter.type).toBe("gemini_cli");
         });
     });
-    describe('canHandle', ()=>{
-        it('should return true for plain gemini command', ()=>{
+    describe("canHandle", ()=>{
+        it("should return true for plain gemini command", ()=>{
             expect(adapter.canHandle({
                 pid: 1,
-                command: 'gemini',
-                cwd: '/repo',
-                tty: 'ttys001'
+                command: "gemini",
+                cwd: "/repo",
+                tty: "ttys001"
             })).toBe(true);
         });
-        it('should return true for gemini with full path (case-insensitive)', ()=>{
+        it("should return true for gemini with full path (case-insensitive)", ()=>{
             expect(adapter.canHandle({
                 pid: 2,
-                command: '/usr/local/bin/GEMINI --yolo',
-                cwd: '/repo',
-                tty: 'ttys002'
+                command: "/usr/local/bin/GEMINI --yolo",
+                cwd: "/repo",
+                tty: "ttys002"
             })).toBe(true);
         });
-        it('should return false for non-gemini processes', ()=>{
+        it("should return false for non-gemini processes", ()=>{
             expect(adapter.canHandle({
                 pid: 3,
-                command: 'node app.js',
-                cwd: '/repo',
-                tty: 'ttys003'
+                command: "node app.js",
+                cwd: "/repo",
+                tty: "ttys003"
             })).toBe(false);
         });
         it('should return false when "gemini" appears only in path arguments', ()=>{
             expect(adapter.canHandle({
                 pid: 4,
-                command: 'node /path/to/gemini-runner.js',
-                cwd: '/repo',
-                tty: 'ttys004'
+                command: "node /path/to/gemini-runner.js",
+                cwd: "/repo",
+                tty: "ttys004"
             })).toBe(false);
         });
-        it('should return true for Node-invoked gemini script (real install layout)', ()=>{
+        it("should return true for Node-invoked gemini script (real install layout)", ()=>{
             expect(adapter.canHandle({
                 pid: 5,
-                command: 'node /Users/foo/.volta/tools/image/node/24.14.0/bin/gemini --help',
-                cwd: '/repo',
-                tty: 'ttys005'
+                command: "node /Users/foo/.volta/tools/image/node/24.14.0/bin/gemini --help",
+                cwd: "/repo",
+                tty: "ttys005"
             })).toBe(true);
         });
-        it('should return true for Node-invoked gemini.js bundle entrypoint', ()=>{
+        it("should return true for Node-invoked gemini.js bundle entrypoint", ()=>{
             expect(adapter.canHandle({
                 pid: 6,
-                command: 'node /opt/homebrew/lib/node_modules/@google/gemini-cli/bundle/gemini.js',
-                cwd: '/repo',
-                tty: 'ttys006'
+                command: "node /opt/homebrew/lib/node_modules/@google/gemini-cli/bundle/gemini.js",
+                cwd: "/repo",
+                tty: "ttys006"
             })).toBe(true);
         });
-        it('should recognize Windows executable and entrypoint paths', ()=>{
+        it("should recognize Windows executable and entrypoint paths", ()=>{
             expect(adapter.canHandle({
                 pid: 7,
-                command: 'C:\\tools\\node.exe C:\\lib\\gemini.js',
-                cwd: 'C:\\repo',
-                tty: ''
+                command: "C:\\tools\\node.exe C:\\lib\\gemini.js",
+                cwd: "C:\\repo",
+                tty: ""
             })).toBe(true);
         });
     });
-    describe('detectAgents', ()=>{
-        it('should return empty array when no gemini processes are running', async ()=>{
+    describe("detectAgents", ()=>{
+        it("should return empty array when no gemini processes are running", async ()=>{
             mockedListAgentProcesses.mockReturnValue([]);
             const agents = await adapter.detectAgents();
             expect(agents).toEqual([]);
         });
-        it('should filter non-gemini Node processes out of the node process pool', async ()=>{
+        it("should filter non-gemini Node processes out of the node process pool", async ()=>{
             const geminiProc = {
                 pid: 100,
-                command: 'node /Users/foo/.volta/tools/image/node/24.14.0/bin/gemini --help',
-                cwd: '/repo',
-                tty: 'ttys001',
-                startTime: new Date('2026-04-18T00:00:00Z')
+                command: "node /Users/foo/.volta/tools/image/node/24.14.0/bin/gemini --help",
+                cwd: "/repo",
+                tty: "ttys001",
+                startTime: new Date("2026-04-18T00:00:00Z")
             };
             const unrelatedNodeProc = {
                 pid: 200,
-                command: 'node /usr/local/bin/eslint src/',
-                cwd: '/other-repo',
-                tty: 'ttys002',
-                startTime: new Date('2026-04-18T00:00:00Z')
+                command: "node /usr/local/bin/eslint src/",
+                cwd: "/other-repo",
+                tty: "ttys002",
+                startTime: new Date("2026-04-18T00:00:00Z")
             };
             mockedListAgentProcesses.mockReturnValue([
                 geminiProc,
@@ -146,13 +146,13 @@ describe('GeminiCliAdapter', ()=>{
             expect(agents).toHaveLength(1);
             expect(agents[0].pid).toBe(100);
         });
-        it('should return process-only agents when no session files exist for the process', async ()=>{
+        it("should return process-only agents when no session files exist for the process", async ()=>{
             const proc = {
                 pid: 1234,
-                command: 'node /usr/local/bin/gemini',
-                cwd: '/repo',
-                tty: 'ttys001',
-                startTime: new Date('2026-04-18T00:00:00Z')
+                command: "node /usr/local/bin/gemini",
+                cwd: "/repo",
+                tty: "ttys001",
+                startTime: new Date("2026-04-18T00:00:00Z")
             };
             mockedListAgentProcesses.mockReturnValue([
                 proc
@@ -160,29 +160,29 @@ describe('GeminiCliAdapter', ()=>{
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'gemini_cli',
+                type: "gemini_cli",
                 pid: 1234,
-                projectPath: '/repo',
+                projectPath: "/repo",
                 status: AgentStatus.RUNNING,
-                sessionId: 'pid-1234'
+                sessionId: "pid-1234"
             });
         });
-        it('should suppress Gemini wrapper process-only agents before a session file exists', async ()=>{
+        it("should suppress Gemini wrapper process-only agents before a session file exists", async ()=>{
             const wrapperProc = {
                 pid: 20452,
                 ppid: 17530,
-                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
-                cwd: '/repo',
-                tty: 'ttys007',
-                startTime: new Date('2026-06-13T08:25:21Z')
+                command: "/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini",
+                cwd: "/repo",
+                tty: "ttys007",
+                startTime: new Date("2026-06-13T08:25:21Z")
             };
             const childProc = {
                 pid: 21373,
                 ppid: 20452,
-                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
-                cwd: '/repo',
-                tty: 'ttys007',
-                startTime: new Date('2026-06-13T08:25:26Z')
+                command: "/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini",
+                cwd: "/repo",
+                tty: "ttys007",
+                startTime: new Date("2026-06-13T08:25:26Z")
             };
             mockedListAgentProcesses.mockReturnValue([
                 wrapperProc,
@@ -192,39 +192,42 @@ describe('GeminiCliAdapter', ()=>{
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
                 pid: 21373,
-                sessionId: 'pid-21373',
-                summary: 'Gemini CLI process running'
+                sessionId: "pid-21373",
+                summary: "Gemini CLI process running"
             });
         });
-        it('should carry the managed wrapper name to a process-only child before a session file exists', async ()=>{
-            const regPath = path.join(tmpHome, 'agents.json');
+        it("should carry the managed wrapper name to a process-only child before a session file exists", async ()=>{
+            const regPath = path.join(tmpHome, "agents.json");
             const registry = new AgentRegistry(regPath);
             const namedAdapter = new GeminiCliAdapter(registry);
             const wrapperProc = {
                 pid: 35792,
                 ppid: 33068,
-                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
-                cwd: '/repo',
-                tty: 'ttys002',
-                startTime: new Date('2026-06-13T19:15:16Z')
+                command: "/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini",
+                cwd: "/repo",
+                tty: "ttys002",
+                startTime: new Date("2026-06-13T19:15:16Z")
             };
             const childProc = {
                 pid: 36514,
                 ppid: 35792,
-                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
-                cwd: '/repo',
-                tty: 'ttys002',
-                startTime: new Date('2026-06-13T19:15:18Z')
+                command: "/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini",
+                cwd: "/repo",
+                tty: "ttys002",
+                startTime: new Date("2026-06-13T19:15:18Z")
             };
             registry.register({
-                name: 'cli-mqcqj469',
-                type: 'gemini_cli',
+                name: "cli-mqcqj469",
+                type: "gemini_cli",
                 pid: wrapperProc.pid,
-                tmuxSession: 'cli-mqcqj469',
+                runtime: "tmux",
+                runtimeRef: {
+                    session: "cli-mqcqj469"
+                },
                 cwd: wrapperProc.cwd,
-                startedAt: '2026-06-13T19:15:16.211Z',
+                startedAt: "2026-06-13T19:15:16.211Z",
                 sessionId: `pid-${wrapperProc.pid}`,
-                sessionFilePath: ''
+                sessionFilePath: ""
             });
             mockedListAgentProcesses.mockReturnValue([
                 wrapperProc,
@@ -233,42 +236,42 @@ describe('GeminiCliAdapter', ()=>{
             const agents = await namedAdapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                name: 'cli-mqcqj469',
+                name: "cli-mqcqj469",
                 pid: childProc.pid,
                 sessionId: `pid-${childProc.pid}`
             });
         });
-        it('should map a process to its matching session file via projectHash', async ()=>{
-            const cwd = '/repo/project-a';
+        it("should map a process to its matching session file via projectHash", async ()=>{
+            const cwd = "/repo/project-a";
             const projectHash = hashProjectRoot(cwd);
-            const shortId = 'abc123';
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', shortId, 'chats');
+            const shortId = "abc123";
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", shortId, "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            const sessionPath = path.join(chatsDir, 'session-2026-04-18T00-00-session1.json');
-            const sessionStart = new Date('2026-04-18T00:00:00Z').toISOString();
+            const sessionPath = path.join(chatsDir, "session-2026-04-18T00-00-session1.json");
+            const sessionStart = new Date("2026-04-18T00:00:00Z").toISOString();
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'session1',
+                sessionId: "session1",
                 projectHash,
                 startTime: sessionStart,
                 lastUpdated: sessionStart,
-                kind: 'main',
+                kind: "main",
                 messages: [
                     {
-                        id: 'm1',
+                        id: "m1",
                         timestamp: sessionStart,
-                        type: 'user',
-                        content: 'hello gemini'
+                        type: "user",
+                        content: "hello gemini"
                     }
                 ]
             }));
             const proc = {
                 pid: 42,
-                command: 'node /usr/local/bin/gemini',
+                command: "node /usr/local/bin/gemini",
                 cwd,
-                tty: 'ttys001',
-                startTime: new Date('2026-04-18T00:00:00Z')
+                tty: "ttys001",
+                startTime: new Date("2026-04-18T00:00:00Z")
             };
             mockedListAgentProcesses.mockReturnValue([
                 proc
@@ -277,7 +280,7 @@ describe('GeminiCliAdapter', ()=>{
                 {
                     process: proc,
                     session: {
-                        sessionId: 'session1',
+                        sessionId: "session1",
                         filePath: sessionPath,
                         projectDir: chatsDir,
                         birthtimeMs: Date.now(),
@@ -289,55 +292,55 @@ describe('GeminiCliAdapter', ()=>{
             const agents = await adapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'gemini_cli',
+                type: "gemini_cli",
                 pid: 42,
                 projectPath: cwd,
-                sessionId: 'session1',
+                sessionId: "session1",
                 sessionFilePath: sessionPath
             });
-            expect(agents[0].summary).toContain('hello gemini');
+            expect(agents[0].summary).toContain("hello gemini");
         });
-        it('should collapse Gemini wrapper and child processes matched to the same session', async ()=>{
-            const cwd = '/repo/project-a';
+        it("should collapse Gemini wrapper and child processes matched to the same session", async ()=>{
+            const cwd = "/repo/project-a";
             const projectHash = hashProjectRoot(cwd);
-            const shortId = 'abc123';
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', shortId, 'chats');
+            const shortId = "abc123";
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", shortId, "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            const sessionPath = path.join(chatsDir, 'session-2026-04-18T00-00-session1.json');
-            const sessionStart = new Date('2026-04-18T00:00:00Z').toISOString();
+            const sessionPath = path.join(chatsDir, "session-2026-04-18T00-00-session1.json");
+            const sessionStart = new Date("2026-04-18T00:00:00Z").toISOString();
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'session1',
+                sessionId: "session1",
                 projectHash,
                 startTime: sessionStart,
                 lastUpdated: sessionStart,
-                kind: 'main',
+                kind: "main",
                 directories: [
                     cwd
                 ],
                 messages: [
                     {
-                        id: 'm1',
+                        id: "m1",
                         timestamp: sessionStart,
-                        type: 'user',
-                        content: 'hello gemini'
+                        type: "user",
+                        content: "hello gemini"
                     }
                 ]
             }));
             const wrapperProc = {
                 pid: 88394,
-                command: 'node /Users/foo/.nvm/versions/node/v23.9.0/bin/gemini',
+                command: "node /Users/foo/.nvm/versions/node/v23.9.0/bin/gemini",
                 cwd,
-                tty: 'ttys015',
-                startTime: new Date('2026-04-18T00:00:00Z')
+                tty: "ttys015",
+                startTime: new Date("2026-04-18T00:00:00Z")
             };
             const childProc = {
                 pid: 88460,
-                command: '/Users/foo/.nvm/versions/node/v24.13.1/bin/node /Users/foo/.nvm/versions/node/v23.9.0/bin/gemini',
+                command: "/Users/foo/.nvm/versions/node/v24.13.1/bin/node /Users/foo/.nvm/versions/node/v23.9.0/bin/gemini",
                 cwd,
-                tty: 'ttys015',
-                startTime: new Date('2026-04-18T00:00:01Z')
+                tty: "ttys015",
+                startTime: new Date("2026-04-18T00:00:01Z")
             };
             mockedListAgentProcesses.mockReturnValue([
                 wrapperProc,
@@ -347,7 +350,7 @@ describe('GeminiCliAdapter', ()=>{
                 {
                     process: wrapperProc,
                     session: {
-                        sessionId: 'session1',
+                        sessionId: "session1",
                         filePath: sessionPath,
                         projectDir: chatsDir,
                         birthtimeMs: Date.now(),
@@ -358,7 +361,7 @@ describe('GeminiCliAdapter', ()=>{
                 {
                     process: childProc,
                     session: {
-                        sessionId: 'session1',
+                        sessionId: "session1",
                         filePath: sessionPath,
                         projectDir: chatsDir,
                         birthtimeMs: Date.now(),
@@ -371,32 +374,32 @@ describe('GeminiCliAdapter', ()=>{
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
                 pid: 88460,
-                sessionId: 'session1',
+                sessionId: "session1",
                 sessionFilePath: sessionPath
             });
         });
-        it('should not match sessions from other projects', async ()=>{
-            const procCwd = '/repo/project-a';
-            const otherCwd = '/repo/project-b';
+        it("should not match sessions from other projects", async ()=>{
+            const procCwd = "/repo/project-a";
+            const otherCwd = "/repo/project-b";
             const otherHash = hashProjectRoot(otherCwd);
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'other', 'chats');
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", "other", "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            const sessionPath = path.join(chatsDir, 'session-2026-04-18T00-00-other.json');
+            const sessionPath = path.join(chatsDir, "session-2026-04-18T00-00-other.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'other-session',
+                sessionId: "other-session",
                 projectHash: otherHash,
                 startTime: new Date().toISOString(),
                 lastUpdated: new Date().toISOString(),
-                kind: 'main',
+                kind: "main",
                 messages: []
             }));
             const proc = {
                 pid: 7,
-                command: 'node /usr/local/bin/gemini',
+                command: "node /usr/local/bin/gemini",
                 cwd: procCwd,
-                tty: 'ttys001',
+                tty: "ttys001",
                 startTime: new Date()
             };
             mockedListAgentProcesses.mockReturnValue([
@@ -409,55 +412,56 @@ describe('GeminiCliAdapter', ()=>{
             expect(agents[0].sessionId).toBe(`pid-${proc.pid}`);
         });
     });
-    describe('detectAgents — registry cache short-circuit', ()=>{
+    describe("detectAgents — registry cache short-circuit", ()=>{
         let regPath;
         let registry;
         let cachedAdapter;
         let sessionFilePath;
         function registerEntry(over = {}) {
             registry.register({
-                name: 'gemini-100',
-                type: 'gemini_cli',
+                name: "gemini-100",
+                type: "gemini_cli",
                 pid: 100,
-                tmuxSession: '',
-                cwd: '/repo-a',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 's-cached',
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/repo-a",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "s-cached",
                 sessionFilePath,
                 ...over
             });
         }
         beforeEach(()=>{
-            regPath = path.join(tmpHome, 'agents.json');
+            regPath = path.join(tmpHome, "agents.json");
             registry = new AgentRegistry(regPath);
             cachedAdapter = new GeminiCliAdapter(registry);
             const now = new Date().toISOString();
-            sessionFilePath = path.join(tmpHome, 'gemini-session.json');
+            sessionFilePath = path.join(tmpHome, "gemini-session.json");
             fs.writeFileSync(sessionFilePath, JSON.stringify({
-                sessionId: 's-cached',
-                projectHash: 'h',
+                sessionId: "s-cached",
+                projectHash: "h",
                 startTime: now,
                 lastUpdated: now,
                 directories: [
-                    '/repo-a'
+                    "/repo-a"
                 ],
                 messages: [
                     {
-                        id: 'm1',
+                        id: "m1",
                         timestamp: now,
-                        type: 'user',
-                        content: 'Hello from gemini cache'
+                        type: "user",
+                        content: "Hello from gemini cache"
                     }
                 ]
             }));
         });
-        it('short-circuits matching when registry has a valid entry', async ()=>{
+        it("short-circuits matching when registry has a valid entry", async ()=>{
             registerEntry();
             const proc = {
                 pid: 100,
-                command: 'node /path/to/gemini --help',
-                cwd: '/repo-a',
-                tty: 'ttys001',
+                command: "node /path/to/gemini --help",
+                cwd: "/repo-a",
+                tty: "ttys001",
                 startTime: new Date()
             };
             mockedListAgentProcesses.mockReturnValue([
@@ -466,101 +470,103 @@ describe('GeminiCliAdapter', ()=>{
             const agents = await cachedAdapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                type: 'gemini_cli',
+                type: "gemini_cli",
                 pid: 100,
-                sessionId: 's-cached',
-                summary: 'Hello from gemini cache'
+                sessionId: "s-cached",
+                summary: "Hello from gemini cache"
             });
             expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
         });
-        it('falls through when no registry entry exists for the pid', async ()=>{
+        it("falls through when no registry entry exists for the pid", async ()=>{
             const proc = {
                 pid: 100,
-                command: 'node /path/to/gemini --help',
-                cwd: '/repo-a',
-                tty: 'ttys001',
+                command: "node /path/to/gemini --help",
+                cwd: "/repo-a",
+                tty: "ttys001",
                 startTime: new Date()
             };
             mockedListAgentProcesses.mockReturnValue([
                 proc
             ]);
             const agents = await cachedAdapter.detectAgents();
-            expect(agents[0].sessionId).toBe('pid-100');
+            expect(agents[0].sessionId).toBe("pid-100");
         });
-        it('falls through when registry entry type does not match', async ()=>{
+        it("falls through when registry entry type does not match", async ()=>{
             registerEntry({
-                type: 'claude'
+                type: "claude"
             });
             const proc = {
                 pid: 100,
-                command: 'node /path/to/gemini --help',
-                cwd: '/repo-a',
-                tty: 'ttys001',
+                command: "node /path/to/gemini --help",
+                cwd: "/repo-a",
+                tty: "ttys001",
                 startTime: new Date()
             };
             mockedListAgentProcesses.mockReturnValue([
                 proc
             ]);
             const agents = await cachedAdapter.detectAgents();
-            expect(agents[0].sessionId).toBe('pid-100');
+            expect(agents[0].sessionId).toBe("pid-100");
         });
-        it('falls through when the cached session file no longer exists', async ()=>{
+        it("falls through when the cached session file no longer exists", async ()=>{
             registerEntry({
-                sessionFilePath: path.join(tmpHome, 'deleted.json')
+                sessionFilePath: path.join(tmpHome, "deleted.json")
             });
             const proc = {
                 pid: 100,
-                command: 'node /path/to/gemini --help',
-                cwd: '/repo-a',
-                tty: 'ttys001',
+                command: "node /path/to/gemini --help",
+                cwd: "/repo-a",
+                tty: "ttys001",
                 startTime: new Date()
             };
             mockedListAgentProcesses.mockReturnValue([
                 proc
             ]);
             const agents = await cachedAdapter.detectAgents();
-            expect(agents[0].sessionId).toBe('pid-100');
+            expect(agents[0].sessionId).toBe("pid-100");
         });
-        it('carries the managed wrapper name to the detected child process', async ()=>{
+        it("carries the managed wrapper name to the detected child process", async ()=>{
             const wrapperProc = {
                 pid: 20339,
                 ppid: 17570,
-                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
-                cwd: '/repo-a',
-                tty: 'ttys002',
-                startTime: new Date('2026-06-13T19:00:53Z')
+                command: "/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini",
+                cwd: "/repo-a",
+                tty: "ttys002",
+                startTime: new Date("2026-06-13T19:00:53Z")
             };
             const childProc = {
                 pid: 21038,
                 ppid: 20339,
-                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
-                cwd: '/repo-a',
-                tty: 'ttys002',
-                startTime: new Date('2026-06-13T19:00:57Z')
+                command: "/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini",
+                cwd: "/repo-a",
+                tty: "ttys002",
+                startTime: new Date("2026-06-13T19:00:57Z")
             };
             const now = new Date().toISOString();
-            sessionFilePath = writeSession(tmpHome, 'cli-2', 'session-2026-06-13T19-00-s-cached', {
-                sessionId: 's-cached',
-                projectHash: hashProjectRoot('/repo-a'),
+            sessionFilePath = writeSession(tmpHome, "cli-2", "session-2026-06-13T19-00-s-cached", {
+                sessionId: "s-cached",
+                projectHash: hashProjectRoot("/repo-a"),
                 startTime: now,
                 lastUpdated: now,
                 directories: [
-                    '/repo-a'
+                    "/repo-a"
                 ],
                 messages: [
                     {
-                        id: 'm1',
+                        id: "m1",
                         timestamp: now,
-                        type: 'user',
-                        content: 'Hello from child process'
+                        type: "user",
+                        content: "Hello from child process"
                     }
                 ]
             });
             registerEntry({
-                name: 'cli-mqcq0mg5',
+                name: "cli-mqcq0mg5",
                 pid: wrapperProc.pid,
-                tmuxSession: 'cli-mqcq0mg5',
-                sessionId: 's-cached',
+                runtimeRef: {
+                    session: "cli-mqcq0mg5"
+                },
+                sessionId: "s-cached",
                 sessionFilePath
             });
             mockedListAgentProcesses.mockReturnValue([
@@ -571,11 +577,11 @@ describe('GeminiCliAdapter', ()=>{
                 {
                     process: childProc,
                     session: {
-                        sessionId: 's-cached',
+                        sessionId: "s-cached",
                         filePath: sessionFilePath,
                         projectDir: path.dirname(sessionFilePath),
                         birthtimeMs: Date.now(),
-                        resolvedCwd: '/repo-a'
+                        resolvedCwd: "/repo-a"
                     },
                     deltaMs: 0
                 }
@@ -583,19 +589,19 @@ describe('GeminiCliAdapter', ()=>{
             const agents = await cachedAdapter.detectAgents();
             expect(agents).toHaveLength(1);
             expect(agents[0]).toMatchObject({
-                name: 'cli-mqcq0mg5',
+                name: "cli-mqcq0mg5",
                 pid: childProc.pid,
-                sessionId: 's-cached'
+                sessionId: "s-cached"
             });
         });
     });
-    describe('discoverSessions', ()=>{
-        it('should return empty when ~/.gemini/tmp does not exist', ()=>{
+    describe("discoverSessions", ()=>{
+        it("should return empty when ~/.gemini/tmp does not exist", ()=>{
             const proc = {
                 pid: 1,
-                command: 'gemini',
-                cwd: '/repo',
-                tty: 'ttys001',
+                command: "gemini",
+                cwd: "/repo",
+                tty: "ttys001",
                 startTime: new Date()
             };
             // tmp dir absent by default
@@ -605,20 +611,20 @@ describe('GeminiCliAdapter', ()=>{
             expect(result.sessions).toEqual([]);
             expect(result.contentCache.size).toBe(0);
         });
-        it('should skip processes with empty cwd when building the hash map', ()=>{
+        it("should skip processes with empty cwd when building the hash map", ()=>{
             const proc = {
                 pid: 1,
-                command: 'gemini',
-                cwd: '',
-                tty: 'ttys001',
+                command: "gemini",
+                cwd: "",
+                tty: "ttys001",
                 startTime: new Date()
             };
-            writeSession(tmpHome, 'abc', 'session-x', {
-                sessionId: 's1',
-                projectHash: hashProjectRoot('/some/where'),
+            writeSession(tmpHome, "abc", "session-x", {
+                sessionId: "s1",
+                projectHash: hashProjectRoot("/some/where"),
                 startTime: new Date().toISOString(),
                 lastUpdated: new Date().toISOString(),
-                kind: 'main',
+                kind: "main",
                 messages: []
             });
             const result = adapter.discoverSessions([
@@ -626,20 +632,20 @@ describe('GeminiCliAdapter', ()=>{
             ]);
             expect(result.sessions).toEqual([]);
         });
-        it('should ignore sessions whose projectHash does not match any process cwd', ()=>{
+        it("should ignore sessions whose projectHash does not match any process cwd", ()=>{
             const proc = {
                 pid: 1,
-                command: 'gemini',
-                cwd: '/repo/a',
-                tty: 'ttys001',
+                command: "gemini",
+                cwd: "/repo/a",
+                tty: "ttys001",
                 startTime: new Date()
             };
-            writeSession(tmpHome, 'other', 'session-other', {
-                sessionId: 's-other',
-                projectHash: hashProjectRoot('/repo/different'),
+            writeSession(tmpHome, "other", "session-other", {
+                sessionId: "s-other",
+                projectHash: hashProjectRoot("/repo/different"),
                 startTime: new Date().toISOString(),
                 lastUpdated: new Date().toISOString(),
-                kind: 'main',
+                kind: "main",
                 messages: []
             });
             const result = adapter.discoverSessions([
@@ -647,52 +653,52 @@ describe('GeminiCliAdapter', ()=>{
             ]);
             expect(result.sessions).toEqual([]);
         });
-        it('should skip malformed JSON files and still return valid ones', ()=>{
-            const cwd = '/repo/valid';
+        it("should skip malformed JSON files and still return valid ones", ()=>{
+            const cwd = "/repo/valid";
             const proc = {
                 pid: 1,
-                command: 'gemini',
+                command: "gemini",
                 cwd,
-                tty: 'ttys001',
+                tty: "ttys001",
                 startTime: new Date()
             };
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'abc', 'chats');
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", "abc", "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            fs.writeFileSync(path.join(chatsDir, 'session-bad.json'), '{ not valid');
-            writeSession(tmpHome, 'abc', 'session-good', {
-                sessionId: 's-good',
+            fs.writeFileSync(path.join(chatsDir, "session-bad.json"), "{ not valid");
+            writeSession(tmpHome, "abc", "session-good", {
+                sessionId: "s-good",
                 projectHash: hashProjectRoot(cwd),
                 startTime: new Date().toISOString(),
                 lastUpdated: new Date().toISOString(),
-                kind: 'main',
+                kind: "main",
                 messages: []
             });
             const result = adapter.discoverSessions([
                 proc
             ]);
             expect(result.sessions).toHaveLength(1);
-            expect(result.sessions[0].sessionId).toBe('s-good');
+            expect(result.sessions[0].sessionId).toBe("s-good");
         });
-        it('should match sessions whose projectHash is a parent of the process cwd (git root case)', ()=>{
-            const gitRoot = '/repo/monorepo';
-            const procCwd = '/repo/monorepo/packages/inner';
+        it("should match sessions whose projectHash is a parent of the process cwd (git root case)", ()=>{
+            const gitRoot = "/repo/monorepo";
+            const procCwd = "/repo/monorepo/packages/inner";
             const proc = {
                 pid: 1,
-                command: 'gemini',
+                command: "gemini",
                 cwd: procCwd,
-                tty: 'ttys001',
+                tty: "ttys001",
                 startTime: new Date()
             };
-            writeSession(tmpHome, 'abc', 'session-rootmatch', {
-                sessionId: 's-root',
+            writeSession(tmpHome, "abc", "session-rootmatch", {
+                sessionId: "s-root",
                 // Gemini CLI stores the hash of the walked-up project root,
                 // not the process CWD.
                 projectHash: hashProjectRoot(gitRoot),
                 startTime: new Date().toISOString(),
                 lastUpdated: new Date().toISOString(),
-                kind: 'main',
+                kind: "main",
                 messages: []
             });
             const result = adapter.discoverSessions([
@@ -702,20 +708,20 @@ describe('GeminiCliAdapter', ()=>{
             expect(result.sessions[0].resolvedCwd).toBe(procCwd);
         });
         it('should skip files that do not start with "session-"', ()=>{
-            const cwd = '/repo/keep';
+            const cwd = "/repo/keep";
             const proc = {
                 pid: 1,
-                command: 'gemini',
+                command: "gemini",
                 cwd,
-                tty: 'ttys001',
+                tty: "ttys001",
                 startTime: new Date()
             };
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'abc', 'chats');
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", "abc", "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            fs.writeFileSync(path.join(chatsDir, 'notsession.json'), JSON.stringify({
-                sessionId: 'skip',
+            fs.writeFileSync(path.join(chatsDir, "notsession.json"), JSON.stringify({
+                sessionId: "skip",
                 projectHash: hashProjectRoot(cwd),
                 messages: []
             }));
@@ -725,183 +731,183 @@ describe('GeminiCliAdapter', ()=>{
             expect(result.sessions).toEqual([]);
         });
     });
-    describe('helper methods', ()=>{
-        describe('determineStatus', ()=>{
+    describe("helper methods", ()=>{
+        describe("determineStatus", ()=>{
             it('should return "waiting" when the last message is from gemini', ()=>{
                 const session = {
-                    sessionId: 's',
-                    projectPath: '',
-                    summary: '',
+                    sessionId: "s",
+                    projectPath: "",
+                    summary: "",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastMessageType: 'gemini'
+                    lastMessageType: "gemini"
                 };
                 expect(adapter.determineStatus(session)).toBe(AgentStatus.WAITING);
             });
             it('should return "waiting" when the last message is from assistant', ()=>{
                 const session = {
-                    sessionId: 's',
-                    projectPath: '',
-                    summary: '',
+                    sessionId: "s",
+                    projectPath: "",
+                    summary: "",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastMessageType: 'assistant'
+                    lastMessageType: "assistant"
                 };
                 expect(adapter.determineStatus(session)).toBe(AgentStatus.WAITING);
             });
             it('should return "running" when the last message is from the user', ()=>{
                 const session = {
-                    sessionId: 's',
-                    projectPath: '',
-                    summary: '',
+                    sessionId: "s",
+                    projectPath: "",
+                    summary: "",
                     sessionStart: new Date(),
                     lastActive: new Date(),
-                    lastMessageType: 'user'
+                    lastMessageType: "user"
                 };
                 expect(adapter.determineStatus(session)).toBe(AgentStatus.RUNNING);
             });
             it('should return "idle" when last activity is older than the threshold', ()=>{
                 const session = {
-                    sessionId: 's',
-                    projectPath: '',
-                    summary: '',
+                    sessionId: "s",
+                    projectPath: "",
+                    summary: "",
                     sessionStart: new Date(),
                     lastActive: new Date(Date.now() - 10 * 60 * 1000),
-                    lastMessageType: 'gemini'
+                    lastMessageType: "gemini"
                 };
                 expect(adapter.determineStatus(session)).toBe(AgentStatus.IDLE);
             });
         });
-        describe('parseSession', ()=>{
-            it('should parse a valid session file', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-a', {
-                    sessionId: 's1',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:05:00Z',
-                    kind: 'main',
+        describe("parseSession", ()=>{
+            it("should parse a valid session file", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-a", {
+                    sessionId: "s1",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:05:00Z",
+                    kind: "main",
                     directories: [
-                        '/repo'
+                        "/repo"
                     ],
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
-                            content: 'hello'
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
+                            content: "hello"
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
                 expect(result).toMatchObject({
-                    sessionId: 's1',
-                    projectPath: '/repo',
-                    summary: 'hello'
+                    sessionId: "s1",
+                    projectPath: "/repo",
+                    summary: "hello"
                 });
             });
-            it('should parse from cached content without reading disk', ()=>{
+            it("should parse from cached content without reading disk", ()=>{
                 const content = JSON.stringify({
-                    sessionId: 's2',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+                    sessionId: "s2",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: []
                 });
-                const result = adapter.parseSession(content, '/does/not/exist.json');
-                expect(result?.sessionId).toBe('s2');
+                const result = adapter.parseSession(content, "/does/not/exist.json");
+                expect(result?.sessionId).toBe("s2");
             });
-            it('should return null for a missing file with no cached content', ()=>{
-                expect(adapter.parseSession(undefined, '/missing.json')).toBeNull();
+            it("should return null for a missing file with no cached content", ()=>{
+                expect(adapter.parseSession(undefined, "/missing.json")).toBeNull();
             });
-            it('should return null when the file is not valid JSON', ()=>{
-                const filePath = path.join(tmpHome, 'broken.json');
-                fs.writeFileSync(filePath, 'not json');
+            it("should return null when the file is not valid JSON", ()=>{
+                const filePath = path.join(tmpHome, "broken.json");
+                fs.writeFileSync(filePath, "not json");
                 expect(adapter.parseSession(undefined, filePath)).toBeNull();
             });
-            it('should return null when sessionId is missing', ()=>{
-                const filePath = path.join(tmpHome, 'no-id.json');
+            it("should return null when sessionId is missing", ()=>{
+                const filePath = path.join(tmpHome, "no-id.json");
                 fs.writeFileSync(filePath, JSON.stringify({
                     messages: []
                 }));
                 expect(adapter.parseSession(undefined, filePath)).toBeNull();
             });
-            it('should default the summary when no user message has content', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-empty', {
-                    sessionId: 's3',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+            it("should default the summary when no user message has content", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-empty", {
+                    sessionId: "s3",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'gemini',
-                            content: 'only assistant'
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "gemini",
+                            content: "only assistant"
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
-                expect(result?.summary).toBe('Gemini CLI session active');
+                expect(result?.summary).toBe("Gemini CLI session active");
             });
-            it('should truncate long summaries to 120 characters', ()=>{
-                const longContent = 'x'.repeat(200);
-                const filePath = writeSession(tmpHome, 'p', 'session-long', {
-                    sessionId: 's4',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+            it("should truncate long summaries to 120 characters", ()=>{
+                const longContent = "x".repeat(200);
+                const filePath = writeSession(tmpHome, "p", "session-long", {
+                    sessionId: "s4",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
                             content: longContent
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
                 expect(result?.summary.length).toBe(120);
-                expect(result?.summary.endsWith('...')).toBe(true);
+                expect(result?.summary.endsWith("...")).toBe(true);
             });
-            it('should extract summary when user content is an array of parts (real Gemini shape)', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-parts', {
-                    sessionId: 's-parts',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+            it("should extract summary when user content is an array of parts (real Gemini shape)", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-parts", {
+                    sessionId: "s-parts",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
                             content: [
                                 {
-                                    text: 'hello from part'
+                                    text: "hello from part"
                                 },
                                 {
-                                    text: ' continued'
+                                    text: " continued"
                                 }
                             ]
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
-                expect(result?.summary).toBe('hello from part continued');
+                expect(result?.summary).toBe("hello from part continued");
             });
-            it('should not throw when user content is an array and there is no displayContent', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-parts-only', {
-                    sessionId: 's-parts-only',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+            it("should not throw when user content is an array and there is no displayContent", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-parts-only", {
+                    sessionId: "s-parts-only",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
                             content: [
                                 {
-                                    text: 'only via parts'
+                                    text: "only via parts"
                                 }
                             ]
                         }
@@ -909,115 +915,115 @@ describe('GeminiCliAdapter', ()=>{
                 });
                 expect(()=>adapter.parseSession(undefined, filePath)).not.toThrow();
             });
-            it('should drop non-text parts (data/file) when resolving user content', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-mixed-parts', {
-                    sessionId: 's-mixed',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:00:00Z',
+            it("should drop non-text parts (data/file) when resolving user content", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-mixed-parts", {
+                    sessionId: "s-mixed",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:00:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
                             content: [
                                 {
-                                    text: 'readable text'
+                                    text: "readable text"
                                 },
                                 {
                                     inlineData: {
-                                        mimeType: 'image/png',
-                                        data: 'base64...'
+                                        mimeType: "image/png",
+                                        data: "base64..."
                                     }
                                 },
                                 {
-                                    text: ' + more'
+                                    text: " + more"
                                 }
                             ]
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
-                expect(result?.summary).toBe('readable text + more');
+                expect(result?.summary).toBe("readable text + more");
             });
-            it('should prefer lastUpdated over entry timestamp for lastActive', ()=>{
-                const filePath = writeSession(tmpHome, 'p', 'session-last', {
-                    sessionId: 's5',
-                    projectHash: 'h',
-                    startTime: '2026-04-18T00:00:00Z',
-                    lastUpdated: '2026-04-18T00:10:00Z',
+            it("should prefer lastUpdated over entry timestamp for lastActive", ()=>{
+                const filePath = writeSession(tmpHome, "p", "session-last", {
+                    sessionId: "s5",
+                    projectHash: "h",
+                    startTime: "2026-04-18T00:00:00Z",
+                    lastUpdated: "2026-04-18T00:10:00Z",
                     messages: [
                         {
-                            id: 'm1',
-                            timestamp: '2026-04-18T00:00:01Z',
-                            type: 'user',
-                            content: 'hi'
+                            id: "m1",
+                            timestamp: "2026-04-18T00:00:01Z",
+                            type: "user",
+                            content: "hi"
                         }
                     ]
                 });
                 const result = adapter.parseSession(undefined, filePath);
-                expect(result?.lastActive.toISOString()).toBe('2026-04-18T00:10:00.000Z');
+                expect(result?.lastActive.toISOString()).toBe("2026-04-18T00:10:00.000Z");
             });
         });
     });
-    describe('getConversation', ()=>{
-        it('should return messages from a valid Gemini session file', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-2026-04-18T00-00-id.json');
+    describe("getConversation", ()=>{
+        it("should return messages from a valid Gemini session file", ()=>{
+            const sessionPath = path.join(tmpHome, "session-2026-04-18T00-00-id.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
-                projectHash: 'hash',
-                startTime: '2026-04-18T00:00:00Z',
-                lastUpdated: '2026-04-18T00:00:00Z',
-                kind: 'main',
+                sessionId: "abc",
+                projectHash: "hash",
+                startTime: "2026-04-18T00:00:00Z",
+                lastUpdated: "2026-04-18T00:00:00Z",
+                kind: "main",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'user',
-                        content: 'hi'
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "user",
+                        content: "hi"
                     },
                     {
-                        id: 'm2',
-                        timestamp: '2026-04-18T00:00:02Z',
-                        type: 'gemini',
-                        content: 'hello'
+                        id: "m2",
+                        timestamp: "2026-04-18T00:00:02Z",
+                        type: "gemini",
+                        content: "hello"
                     },
                     {
-                        id: 'm3',
-                        timestamp: '2026-04-18T00:00:03Z',
-                        type: 'tool',
-                        content: 'unused'
+                        id: "m3",
+                        timestamp: "2026-04-18T00:00:03Z",
+                        type: "tool",
+                        content: "unused"
                     }
                 ]
             }));
             const messages = adapter.getConversation(sessionPath);
             expect(messages).toEqual([
                 {
-                    role: 'user',
-                    content: 'hi',
-                    timestamp: '2026-04-18T00:00:01Z'
+                    role: "user",
+                    content: "hi",
+                    timestamp: "2026-04-18T00:00:01Z"
                 },
                 {
-                    role: 'assistant',
-                    content: 'hello',
-                    timestamp: '2026-04-18T00:00:02Z'
+                    role: "assistant",
+                    content: "hello",
+                    timestamp: "2026-04-18T00:00:02Z"
                 }
             ]);
         });
-        it('should include tool entries when verbose is true', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-verbose.json');
+        it("should include tool entries when verbose is true", ()=>{
+            const sessionPath = path.join(tmpHome, "session-verbose.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
-                projectHash: 'hash',
-                startTime: '2026-04-18T00:00:00Z',
-                lastUpdated: '2026-04-18T00:00:00Z',
-                kind: 'main',
+                sessionId: "abc",
+                projectHash: "hash",
+                startTime: "2026-04-18T00:00:00Z",
+                lastUpdated: "2026-04-18T00:00:00Z",
+                kind: "main",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'tool',
-                        content: 'tool call'
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "tool",
+                        content: "tool call"
                     }
                 ]
             }));
@@ -1026,125 +1032,125 @@ describe('GeminiCliAdapter', ()=>{
             });
             expect(messages).toEqual([
                 {
-                    role: 'system',
-                    content: 'tool call',
-                    timestamp: '2026-04-18T00:00:01Z'
+                    role: "system",
+                    content: "tool call",
+                    timestamp: "2026-04-18T00:00:01Z"
                 }
             ]);
         });
-        it('should return empty array for missing or malformed files', ()=>{
-            expect(adapter.getConversation('/nonexistent/file.json')).toEqual([]);
-            const brokenPath = path.join(tmpHome, 'broken.json');
-            fs.writeFileSync(brokenPath, '{ not valid json');
+        it("should return empty array for missing or malformed files", ()=>{
+            expect(adapter.getConversation("/nonexistent/file.json")).toEqual([]);
+            const brokenPath = path.join(tmpHome, "broken.json");
+            fs.writeFileSync(brokenPath, "{ not valid json");
             expect(adapter.getConversation(brokenPath)).toEqual([]);
         });
-        it('should prefer displayContent over content when both are present', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-display.json');
+        it("should prefer displayContent over content when both are present", ()=>{
+            const sessionPath = path.join(tmpHome, "session-display.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
+                sessionId: "abc",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'user',
-                        content: 'raw',
-                        displayContent: 'rendered'
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "user",
+                        content: "raw",
+                        displayContent: "rendered"
                     }
                 ]
             }));
             const messages = adapter.getConversation(sessionPath);
-            expect(messages[0].content).toBe('rendered');
+            expect(messages[0].content).toBe("rendered");
         });
-        it('should skip entries with empty content', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-empty.json');
+        it("should skip entries with empty content", ()=>{
+            const sessionPath = path.join(tmpHome, "session-empty.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
+                sessionId: "abc",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'user',
-                        content: ''
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "user",
+                        content: ""
                     },
                     {
-                        id: 'm2',
-                        timestamp: '2026-04-18T00:00:02Z',
-                        type: 'user',
-                        content: 'real'
+                        id: "m2",
+                        timestamp: "2026-04-18T00:00:02Z",
+                        type: "user",
+                        content: "real"
                     }
                 ]
             }));
             const messages = adapter.getConversation(sessionPath);
             expect(messages).toHaveLength(1);
-            expect(messages[0].content).toBe('real');
+            expect(messages[0].content).toBe("real");
         });
-        it('should skip entries without a type', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-no-type.json');
+        it("should skip entries without a type", ()=>{
+            const sessionPath = path.join(tmpHome, "session-no-type.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
+                sessionId: "abc",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        content: 'typeless'
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        content: "typeless"
                     }
                 ]
             }));
             expect(adapter.getConversation(sessionPath)).toEqual([]);
         });
-        it('should resolve user messages whose content is an array of text parts', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-user-parts.json');
+        it("should resolve user messages whose content is an array of text parts", ()=>{
+            const sessionPath = path.join(tmpHome, "session-user-parts.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
+                sessionId: "abc",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'user',
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "user",
                         content: [
                             {
-                                text: 'hello'
+                                text: "hello"
                             },
                             {
-                                text: ' world'
+                                text: " world"
                             }
                         ]
                     },
                     {
-                        id: 'm2',
-                        timestamp: '2026-04-18T00:00:02Z',
-                        type: 'gemini',
-                        content: 'hi there'
+                        id: "m2",
+                        timestamp: "2026-04-18T00:00:02Z",
+                        type: "gemini",
+                        content: "hi there"
                     }
                 ]
             }));
             const messages = adapter.getConversation(sessionPath);
             expect(messages).toEqual([
                 {
-                    role: 'user',
-                    content: 'hello world',
-                    timestamp: '2026-04-18T00:00:01Z'
+                    role: "user",
+                    content: "hello world",
+                    timestamp: "2026-04-18T00:00:01Z"
                 },
                 {
-                    role: 'assistant',
-                    content: 'hi there',
-                    timestamp: '2026-04-18T00:00:02Z'
+                    role: "assistant",
+                    content: "hi there",
+                    timestamp: "2026-04-18T00:00:02Z"
                 }
             ]);
         });
-        it('should not throw when content is an array but no part carries text', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-no-text-parts.json');
+        it("should not throw when content is an array but no part carries text", ()=>{
+            const sessionPath = path.join(tmpHome, "session-no-text-parts.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
+                sessionId: "abc",
                 messages: [
                     {
-                        id: 'm1',
-                        timestamp: '2026-04-18T00:00:01Z',
-                        type: 'user',
+                        id: "m1",
+                        timestamp: "2026-04-18T00:00:01Z",
+                        type: "user",
                         content: [
                             {
                                 inlineData: {
-                                    mimeType: 'image/png'
+                                    mimeType: "image/png"
                                 }
                             }
                         ]
@@ -1154,57 +1160,57 @@ describe('GeminiCliAdapter', ()=>{
             expect(()=>adapter.getConversation(sessionPath)).not.toThrow();
             expect(adapter.getConversation(sessionPath)).toEqual([]);
         });
-        it('should return empty array when messages is not an array', ()=>{
-            const sessionPath = path.join(tmpHome, 'session-bad-messages.json');
+        it("should return empty array when messages is not an array", ()=>{
+            const sessionPath = path.join(tmpHome, "session-bad-messages.json");
             fs.writeFileSync(sessionPath, JSON.stringify({
-                sessionId: 'abc',
-                messages: 'not-an-array'
+                sessionId: "abc",
+                messages: "not-an-array"
             }));
             expect(adapter.getConversation(sessionPath)).toEqual([]);
         });
     });
-    describe('listSessions', ()=>{
-        it('returns empty when ~/.gemini/tmp does not exist', async ()=>{
+    describe("listSessions", ()=>{
+        it("returns empty when ~/.gemini/tmp does not exist", async ()=>{
             // tmpHome has no .gemini dir by default
             const result = await adapter.listSessions();
             expect(result).toEqual([]);
         });
-        it('walks every shortId/chats dir and returns sessions', async ()=>{
-            writeSession(tmpHome, 'aaa', 'session-1', {
-                sessionId: 's-1',
-                projectHash: hashProjectRoot('/repo-a'),
-                startTime: '2025-01-01T00:00:00Z',
-                lastUpdated: '2025-01-01T00:01:00Z',
+        it("walks every shortId/chats dir and returns sessions", async ()=>{
+            writeSession(tmpHome, "aaa", "session-1", {
+                sessionId: "s-1",
+                projectHash: hashProjectRoot("/repo-a"),
+                startTime: "2025-01-01T00:00:00Z",
+                lastUpdated: "2025-01-01T00:01:00Z",
                 directories: [
-                    '/repo-a'
+                    "/repo-a"
                 ],
                 messages: [
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:00Z',
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:00Z",
                         content: [
                             {
-                                text: 'hello a'
+                                text: "hello a"
                             }
                         ]
                     }
                 ]
             });
-            writeSession(tmpHome, 'bbb', 'session-2', {
-                sessionId: 's-2',
-                projectHash: hashProjectRoot('/repo-b'),
-                startTime: '2025-01-02T00:00:00Z',
-                lastUpdated: '2025-01-02T00:01:00Z',
+            writeSession(tmpHome, "bbb", "session-2", {
+                sessionId: "s-2",
+                projectHash: hashProjectRoot("/repo-b"),
+                startTime: "2025-01-02T00:00:00Z",
+                lastUpdated: "2025-01-02T00:01:00Z",
                 directories: [
-                    '/repo-b'
+                    "/repo-b"
                 ],
                 messages: [
                     {
-                        type: 'user',
-                        timestamp: '2025-01-02T00:00:00Z',
+                        type: "user",
+                        timestamp: "2025-01-02T00:00:00Z",
                         content: [
                             {
-                                text: 'hello b'
+                                text: "hello b"
                             }
                         ]
                     }
@@ -1216,148 +1222,148 @@ describe('GeminiCliAdapter', ()=>{
                     r.sessionId,
                     r
                 ]));
-            expect(byId['s-1']).toMatchObject({
-                type: 'gemini_cli',
-                cwd: '/repo-a',
-                firstUserMessage: 'hello a'
+            expect(byId["s-1"]).toMatchObject({
+                type: "gemini_cli",
+                cwd: "/repo-a",
+                firstUserMessage: "hello a"
             });
-            expect(byId['s-2']).toMatchObject({
-                type: 'gemini_cli',
-                cwd: '/repo-b',
-                firstUserMessage: 'hello b'
+            expect(byId["s-2"]).toMatchObject({
+                type: "gemini_cli",
+                cwd: "/repo-b",
+                firstUserMessage: "hello b"
             });
         });
-        it('applies strict-equality cwd filter against directories[0]', async ()=>{
-            writeSession(tmpHome, 'aaa', 'session-keep', {
-                sessionId: 'keep',
-                projectHash: hashProjectRoot('/repo'),
-                startTime: '2025-01-01T00:00:00Z',
+        it("applies strict-equality cwd filter against directories[0]", async ()=>{
+            writeSession(tmpHome, "aaa", "session-keep", {
+                sessionId: "keep",
+                projectHash: hashProjectRoot("/repo"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/repo'
+                    "/repo"
                 ],
                 messages: [
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:00Z',
-                        content: 'yes'
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:00Z",
+                        content: "yes"
                     }
                 ]
             });
-            writeSession(tmpHome, 'bbb', 'session-drop', {
-                sessionId: 'drop',
-                projectHash: hashProjectRoot('/other'),
-                startTime: '2025-01-01T00:00:00Z',
+            writeSession(tmpHome, "bbb", "session-drop", {
+                sessionId: "drop",
+                projectHash: hashProjectRoot("/other"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/other'
+                    "/other"
                 ],
                 messages: [
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:00Z',
-                        content: 'no'
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:00Z",
+                        content: "no"
                     }
                 ]
             });
             const result = await adapter.listSessions({
-                cwd: '/repo'
+                cwd: "/repo"
             });
             expect(result).toHaveLength(1);
-            expect(result[0].sessionId).toBe('keep');
+            expect(result[0].sessionId).toBe("keep");
         });
-        it('skips malformed JSON files', async ()=>{
-            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'aaa', 'chats');
+        it("skips malformed JSON files", async ()=>{
+            const chatsDir = path.join(tmpHome, ".gemini", "tmp", "aaa", "chats");
             fs.mkdirSync(chatsDir, {
                 recursive: true
             });
-            fs.writeFileSync(path.join(chatsDir, 'session-bad.json'), '{ not json');
-            writeSession(tmpHome, 'aaa', 'session-good', {
-                sessionId: 'good',
-                projectHash: hashProjectRoot('/repo'),
-                startTime: '2025-01-01T00:00:00Z',
+            fs.writeFileSync(path.join(chatsDir, "session-bad.json"), "{ not json");
+            writeSession(tmpHome, "aaa", "session-good", {
+                sessionId: "good",
+                projectHash: hashProjectRoot("/repo"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/repo'
+                    "/repo"
                 ],
                 messages: [
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:00Z',
-                        content: 'ok'
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:00Z",
+                        content: "ok"
                     }
                 ]
             });
             const result = await adapter.listSessions();
             expect(result).toHaveLength(1);
-            expect(result[0].sessionId).toBe('good');
+            expect(result[0].sessionId).toBe("good");
         });
-        it('skips files missing sessionId', async ()=>{
-            writeSession(tmpHome, 'aaa', 'session-no-id', {
-                projectHash: hashProjectRoot('/repo'),
-                startTime: '2025-01-01T00:00:00Z',
+        it("skips files missing sessionId", async ()=>{
+            writeSession(tmpHome, "aaa", "session-no-id", {
+                projectHash: hashProjectRoot("/repo"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/repo'
+                    "/repo"
                 ],
                 messages: []
             });
             const result = await adapter.listSessions();
             expect(result).toEqual([]);
         });
-        it('captures the first user-typed message as firstUserMessage', async ()=>{
-            writeSession(tmpHome, 'aaa', 'session-x', {
-                sessionId: 's',
-                projectHash: hashProjectRoot('/repo'),
-                startTime: '2025-01-01T00:00:00Z',
+        it("captures the first user-typed message as firstUserMessage", async ()=>{
+            writeSession(tmpHome, "aaa", "session-x", {
+                sessionId: "s",
+                projectHash: hashProjectRoot("/repo"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/repo'
+                    "/repo"
                 ],
                 messages: [
                     {
-                        type: 'gemini',
-                        timestamp: '2025-01-01T00:00:00Z',
-                        content: 'preamble'
+                        type: "gemini",
+                        timestamp: "2025-01-01T00:00:00Z",
+                        content: "preamble"
                     },
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:01Z',
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:01Z",
                         content: [
                             {
-                                text: 'first user'
+                                text: "first user"
                             }
                         ]
                     },
                     {
-                        type: 'user',
-                        timestamp: '2025-01-01T00:00:02Z',
-                        content: 'second user'
+                        type: "user",
+                        timestamp: "2025-01-01T00:00:02Z",
+                        content: "second user"
                     }
                 ]
             });
             const result = await adapter.listSessions({
-                cwd: '/repo'
+                cwd: "/repo"
             });
             expect(result).toHaveLength(1);
-            expect(result[0].firstUserMessage).toBe('first user');
+            expect(result[0].firstUserMessage).toBe("first user");
         });
-        it('returns empty firstUserMessage when no user message exists', async ()=>{
-            writeSession(tmpHome, 'aaa', 'session-x', {
-                sessionId: 's',
-                projectHash: hashProjectRoot('/repo'),
-                startTime: '2025-01-01T00:00:00Z',
+        it("returns empty firstUserMessage when no user message exists", async ()=>{
+            writeSession(tmpHome, "aaa", "session-x", {
+                sessionId: "s",
+                projectHash: hashProjectRoot("/repo"),
+                startTime: "2025-01-01T00:00:00Z",
                 directories: [
-                    '/repo'
+                    "/repo"
                 ],
                 messages: [
                     {
-                        type: 'gemini',
-                        timestamp: '2025-01-01T00:00:00Z',
-                        content: 'agent only'
+                        type: "gemini",
+                        timestamp: "2025-01-01T00:00:00Z",
+                        content: "agent only"
                     }
                 ]
             });
             const result = await adapter.listSessions({
-                cwd: '/repo'
+                cwd: "/repo"
             });
             expect(result).toHaveLength(1);
-            expect(result[0].firstUserMessage).toBe('');
+            expect(result[0].firstUserMessage).toBe("");
         });
     });
 });
@@ -1365,7 +1371,7 @@ describe('GeminiCliAdapter', ()=>{
  * Write a Gemini session JSON to the temporary home under the expected
  * ~/.gemini/tmp/<shortId>/chats/<fileName>.json layout. Returns the full path.
  */ function writeSession(home, shortId, fileName, body) {
-    const chatsDir = path.join(home, '.gemini', 'tmp', shortId, 'chats');
+    const chatsDir = path.join(home, ".gemini", "tmp", shortId, "chats");
     fs.mkdirSync(chatsDir, {
         recursive: true
     });
@@ -1378,7 +1384,7 @@ describe('GeminiCliAdapter', ()=>{
  * sha256(projectRoot) as hex.
  */ function hashProjectRoot(projectRoot) {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    return crypto.createHash('sha256').update(projectRoot).digest('hex');
+    return crypto.createHash("sha256").update(projectRoot).digest("hex");
 }
 
 //# sourceMappingURL=GeminiCliAdapter.test.js.map