@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/dist/__tests__/AgentManager.test.js

@@ -1,11 +1,11 @@
 /**
  * Tests for AgentManager
- */ import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { AgentManager } from '../AgentManager.js';
-import { AgentStatus } from '../adapters/AgentAdapter.js';
-import { AgentRegistry } from '../utils/AgentRegistry.js';
+ */ import fs from "fs";
+import os from "os";
+import path from "path";
+import { AgentManager } from "../AgentManager.js";
+import { AgentStatus } from "../adapters/AgentAdapter.js";
+import { AgentRegistry } from "../utils/AgentRegistry.js";
 // Mock adapter for testing
 let MockAdapter = class MockAdapter {
     type;
@@ -56,23 +56,23 @@ let MockAdapter = class MockAdapter {
 // Helper to create mock agent
 function createMockAgent(overrides = {}) {
     return {
-        name: 'test-agent',
-        type: 'claude',
+        name: "test-agent",
+        type: "claude",
         status: AgentStatus.RUNNING,
-        summary: 'Test summary',
+        summary: "Test summary",
         pid: 12345,
-        projectPath: '/test/path',
-        sessionId: 'test-session-id',
+        projectPath: "/test/path",
+        sessionId: "test-session-id",
         lastActive: new Date(),
         ...overrides
     };
 }
-describe('AgentManager', ()=>{
+describe("AgentManager", ()=>{
     let manager;
     let tmpDir;
     beforeEach(()=>{
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-manager-'));
-        manager = new AgentManager(new AgentRegistry(path.join(tmpDir, 'agents.json')));
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-manager-"));
+        manager = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")));
     });
     afterEach(()=>{
         fs.rmSync(tmpDir, {
@@ -80,51 +80,51 @@ describe('AgentManager', ()=>{
             force: true
         });
     });
-    describe('registerAdapter', ()=>{
-        it('should register a new adapter', ()=>{
-            const adapter = new MockAdapter('claude');
+    describe("registerAdapter", ()=>{
+        it("should register a new adapter", ()=>{
+            const adapter = new MockAdapter("claude");
             manager.registerAdapter(adapter);
-            expect(manager.hasAdapter('claude')).toBe(true);
+            expect(manager.hasAdapter("claude")).toBe(true);
             expect(manager.getAdapterCount()).toBe(1);
         });
-        it('should throw error when registering duplicate adapter type', ()=>{
-            const adapter1 = new MockAdapter('claude');
-            const adapter2 = new MockAdapter('claude');
+        it("should throw error when registering duplicate adapter type", ()=>{
+            const adapter1 = new MockAdapter("claude");
+            const adapter2 = new MockAdapter("claude");
             manager.registerAdapter(adapter1);
             expect(()=>manager.registerAdapter(adapter2)).toThrow('Adapter for type "claude" is already registered');
         });
-        it('should allow registering multiple different adapter types', ()=>{
-            const adapter1 = new MockAdapter('claude');
-            const adapter2 = new MockAdapter('gemini_cli');
+        it("should allow registering multiple different adapter types", ()=>{
+            const adapter1 = new MockAdapter("claude");
+            const adapter2 = new MockAdapter("gemini_cli");
             manager.registerAdapter(adapter1);
             manager.registerAdapter(adapter2);
             expect(manager.getAdapterCount()).toBe(2);
-            expect(manager.hasAdapter('claude')).toBe(true);
-            expect(manager.hasAdapter('gemini_cli')).toBe(true);
+            expect(manager.hasAdapter("claude")).toBe(true);
+            expect(manager.hasAdapter("gemini_cli")).toBe(true);
         });
     });
-    describe('unregisterAdapter', ()=>{
-        it('should unregister an existing adapter', ()=>{
-            const adapter = new MockAdapter('claude');
+    describe("unregisterAdapter", ()=>{
+        it("should unregister an existing adapter", ()=>{
+            const adapter = new MockAdapter("claude");
             manager.registerAdapter(adapter);
-            const removed = manager.unregisterAdapter('claude');
+            const removed = manager.unregisterAdapter("claude");
             expect(removed).toBe(true);
-            expect(manager.hasAdapter('claude')).toBe(false);
+            expect(manager.hasAdapter("claude")).toBe(false);
             expect(manager.getAdapterCount()).toBe(0);
         });
-        it('should return false when unregistering non-existent adapter', ()=>{
-            const removed = manager.unregisterAdapter('NonExistent');
+        it("should return false when unregistering non-existent adapter", ()=>{
+            const removed = manager.unregisterAdapter("NonExistent");
             expect(removed).toBe(false);
         });
     });
-    describe('getAdapters', ()=>{
-        it('should return empty array when no adapters registered', ()=>{
+    describe("getAdapters", ()=>{
+        it("should return empty array when no adapters registered", ()=>{
             const adapters = manager.getAdapters();
             expect(adapters).toEqual([]);
         });
-        it('should return all registered adapters', ()=>{
-            const adapter1 = new MockAdapter('claude');
-            const adapter2 = new MockAdapter('gemini_cli');
+        it("should return all registered adapters", ()=>{
+            const adapter1 = new MockAdapter("claude");
+            const adapter2 = new MockAdapter("gemini_cli");
             manager.registerAdapter(adapter1);
             manager.registerAdapter(adapter2);
             const adapters = manager.getAdapters();
@@ -133,20 +133,20 @@ describe('AgentManager', ()=>{
             expect(adapters).toContain(adapter2);
         });
     });
-    describe('listAgents', ()=>{
-        it('shares one process capture while giving each adapter only its declared executables', async ()=>{
+    describe("listAgents", ()=>{
+        it("shares one process capture while giving each adapter only its declared executables", async ()=>{
             const processes = [
                 {
                     pid: 101,
-                    command: 'claude',
-                    cwd: '/claude',
-                    tty: 's001'
+                    command: "claude",
+                    cwd: "/claude",
+                    tty: "s001"
                 },
                 {
                     pid: 202,
-                    command: 'node /bin/pi',
-                    cwd: '/pi',
-                    tty: 's002'
+                    command: "node /bin/pi",
+                    cwd: "/pi",
+                    tty: "s002"
                 }
             ];
             const captureSnapshot = vi.fn(async ()=>processes);
@@ -158,22 +158,22 @@ describe('AgentManager', ()=>{
                     getConversation: ()=>[],
                     listSessions: async ()=>[]
                 });
-            const claude = createSnapshotAdapter('claude', [
-                'claude'
+            const claude = createSnapshotAdapter("claude", [
+                "claude"
             ]);
-            const pi = createSnapshotAdapter('pi', [
-                'pi',
-                'node'
+            const pi = createSnapshotAdapter("pi", [
+                "pi",
+                "node"
             ]);
-            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, 'snapshot-agents.json')), captureSnapshot);
+            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, "snapshot-agents.json")), captureSnapshot);
             snapshotManager.registerAdapter(claude);
             snapshotManager.registerAdapter(pi);
             await snapshotManager.listAgents();
             expect(captureSnapshot).toHaveBeenCalledTimes(1);
             expect(captureSnapshot).toHaveBeenCalledWith([
-                'claude',
-                'pi',
-                'node'
+                "claude",
+                "pi",
+                "node"
             ]);
             expect(claude.detectAgents).toHaveBeenCalledWith({
                 processes: [
@@ -186,31 +186,31 @@ describe('AgentManager', ()=>{
                 ]
             });
         });
-        it('does not expose foreign command arguments to broad Pi and Gemini matchers', async ()=>{
+        it("does not expose foreign command arguments to broad Pi and Gemini matchers", async ()=>{
             const processes = [
                 {
                     pid: 100,
-                    command: 'node /usr/local/lib/gemini.js',
-                    cwd: '/g',
-                    tty: 's001'
+                    command: "node /usr/local/lib/gemini.js",
+                    cwd: "/g",
+                    tty: "s001"
                 },
                 {
                     pid: 200,
-                    command: 'codex exec --cd /Users/x/repos/gemini',
-                    cwd: '/c',
-                    tty: 's002'
+                    command: "codex exec --cd /Users/x/repos/gemini",
+                    cwd: "/c",
+                    tty: "s002"
                 },
                 {
                     pid: 300,
-                    command: 'node /usr/local/lib/pi.js',
-                    cwd: '/p',
-                    tty: 's003'
+                    command: "node /usr/local/lib/pi.js",
+                    cwd: "/p",
+                    tty: "s003"
                 },
                 {
                     pid: 400,
-                    command: 'claude --resume /Users/x/pi/session.jsonl',
-                    cwd: '/a',
-                    tty: 's004'
+                    command: "claude --resume /Users/x/pi/session.jsonl",
+                    cwd: "/a",
+                    tty: "s004"
                 }
             ];
             const captureSnapshot = vi.fn(async ()=>processes);
@@ -222,20 +222,20 @@ describe('AgentManager', ()=>{
                     getConversation: ()=>[],
                     listSessions: async ()=>[]
                 });
-            const gemini = createSnapshotAdapter('gemini_cli', [
-                'node'
+            const gemini = createSnapshotAdapter("gemini_cli", [
+                "node"
             ]);
-            const codex = createSnapshotAdapter('codex', [
-                'codex'
+            const codex = createSnapshotAdapter("codex", [
+                "codex"
             ]);
-            const pi = createSnapshotAdapter('pi', [
-                'pi',
-                'node'
+            const pi = createSnapshotAdapter("pi", [
+                "pi",
+                "node"
             ]);
-            const claude = createSnapshotAdapter('claude', [
-                'claude'
+            const claude = createSnapshotAdapter("claude", [
+                "claude"
             ]);
-            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, 'filtered-snapshot-agents.json')), captureSnapshot);
+            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, "filtered-snapshot-agents.json")), captureSnapshot);
             snapshotManager.registerAdapter(gemini);
             snapshotManager.registerAdapter(codex);
             snapshotManager.registerAdapter(pi);
@@ -243,10 +243,10 @@ describe('AgentManager', ()=>{
             await snapshotManager.listAgents();
             expect(captureSnapshot).toHaveBeenCalledTimes(1);
             expect(captureSnapshot).toHaveBeenCalledWith([
-                'node',
-                'codex',
-                'pi',
-                'claude'
+                "node",
+                "codex",
+                "pi",
+                "claude"
             ]);
             expect(gemini.detectAgents).toHaveBeenCalledWith({
                 processes: [
@@ -271,107 +271,107 @@ describe('AgentManager', ()=>{
                 ]
             });
         });
-        it('does not pass a snapshot context to legacy adapters', async ()=>{
+        it("does not pass a snapshot context to legacy adapters", async ()=>{
             const captureSnapshot = vi.fn(async ()=>[]);
-            const legacy = new MockAdapter('claude');
-            const detect = vi.spyOn(legacy, 'detectAgents');
-            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, 'legacy-agents.json')), captureSnapshot);
+            const legacy = new MockAdapter("claude");
+            const detect = vi.spyOn(legacy, "detectAgents");
+            const snapshotManager = new AgentManager(new AgentRegistry(path.join(tmpDir, "legacy-agents.json")), captureSnapshot);
             snapshotManager.registerAdapter(legacy);
             await snapshotManager.listAgents();
             expect(captureSnapshot).not.toHaveBeenCalled();
             expect(detect).toHaveBeenCalledWith();
         });
-        it('should return empty array when no adapters registered', async ()=>{
+        it("should return empty array when no adapters registered", async ()=>{
             const agents = await manager.listAgents();
             expect(agents).toEqual([]);
         });
-        it('should return agents from single adapter', async ()=>{
+        it("should return agents from single adapter", async ()=>{
             const mockAgents = [
                 createMockAgent({
-                    name: 'agent1'
+                    name: "agent1"
                 }),
                 createMockAgent({
-                    name: 'agent2'
+                    name: "agent2"
                 })
             ];
-            const adapter = new MockAdapter('claude', mockAgents);
+            const adapter = new MockAdapter("claude", mockAgents);
             manager.registerAdapter(adapter);
             const agents = await manager.listAgents();
             expect(agents).toHaveLength(2);
-            expect(agents[0].name).toBe('agent1');
-            expect(agents[1].name).toBe('agent2');
+            expect(agents[0].name).toBe("agent1");
+            expect(agents[1].name).toBe("agent2");
         });
-        it('should aggregate agents from multiple adapters', async ()=>{
+        it("should aggregate agents from multiple adapters", async ()=>{
             const claudeAgents = [
                 createMockAgent({
-                    name: 'claude-agent',
-                    type: 'claude'
+                    name: "claude-agent",
+                    type: "claude"
                 })
             ];
             const geminiAgents = [
                 createMockAgent({
-                    name: 'gemini-agent',
-                    type: 'gemini_cli'
+                    name: "gemini-agent",
+                    type: "gemini_cli"
                 })
             ];
-            manager.registerAdapter(new MockAdapter('claude', claudeAgents));
-            manager.registerAdapter(new MockAdapter('gemini_cli', geminiAgents));
+            manager.registerAdapter(new MockAdapter("claude", claudeAgents));
+            manager.registerAdapter(new MockAdapter("gemini_cli", geminiAgents));
             const agents = await manager.listAgents();
             expect(agents).toHaveLength(2);
-            expect(agents.find((a)=>a.name === 'claude-agent')).toBeDefined();
-            expect(agents.find((a)=>a.name === 'gemini-agent')).toBeDefined();
+            expect(agents.find((a)=>a.name === "claude-agent")).toBeDefined();
+            expect(agents.find((a)=>a.name === "gemini-agent")).toBeDefined();
         });
-        it('should sort agents by status priority (waiting first)', async ()=>{
+        it("should sort agents by status priority (waiting first)", async ()=>{
             const mockAgents = [
                 createMockAgent({
-                    name: 'idle-agent',
+                    name: "idle-agent",
                     status: AgentStatus.IDLE
                 }),
                 createMockAgent({
-                    name: 'waiting-agent',
+                    name: "waiting-agent",
                     status: AgentStatus.WAITING
                 }),
                 createMockAgent({
-                    name: 'running-agent',
+                    name: "running-agent",
                     status: AgentStatus.RUNNING
                 }),
                 createMockAgent({
-                    name: 'unknown-agent',
+                    name: "unknown-agent",
                     status: AgentStatus.UNKNOWN
                 })
             ];
-            const adapter = new MockAdapter('claude', mockAgents);
+            const adapter = new MockAdapter("claude", mockAgents);
             manager.registerAdapter(adapter);
             const agents = await manager.listAgents();
-            expect(agents[0].name).toBe('waiting-agent');
-            expect(agents[1].name).toBe('running-agent');
-            expect(agents[2].name).toBe('idle-agent');
-            expect(agents[3].name).toBe('unknown-agent');
+            expect(agents[0].name).toBe("waiting-agent");
+            expect(agents[1].name).toBe("running-agent");
+            expect(agents[2].name).toBe("idle-agent");
+            expect(agents[3].name).toBe("unknown-agent");
         });
-        it('should handle adapter errors gracefully', async ()=>{
-            const goodAdapter = new MockAdapter('claude', [
+        it("should handle adapter errors gracefully", async ()=>{
+            const goodAdapter = new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'good-agent'
+                    name: "good-agent"
                 })
             ]);
-            const badAdapter = new MockAdapter('gemini_cli', [], true); // Will fail
+            const badAdapter = new MockAdapter("gemini_cli", [], true); // Will fail
             manager.registerAdapter(goodAdapter);
             manager.registerAdapter(badAdapter);
             // Should not throw, should return results from working adapter
             const agents = await manager.listAgents();
             expect(agents).toHaveLength(1);
-            expect(agents[0].name).toBe('good-agent');
+            expect(agents[0].name).toBe("good-agent");
         });
-        it('should return empty array when all adapters fail', async ()=>{
-            const adapter1 = new MockAdapter('claude', [], true);
-            const adapter2 = new MockAdapter('gemini_cli', [], true);
+        it("should return empty array when all adapters fail", async ()=>{
+            const adapter1 = new MockAdapter("claude", [], true);
+            const adapter2 = new MockAdapter("gemini_cli", [], true);
             manager.registerAdapter(adapter1);
             manager.registerAdapter(adapter2);
             const agents = await manager.listAgents();
             expect(agents).toEqual([]);
         });
     });
-    describe('listAgents — registry persistence', ()=>{
+    describe("listAgents — registry persistence", ()=>{
         let tmpDir;
         let regPath;
         let registry;
@@ -379,9 +379,9 @@ describe('AgentManager', ()=>{
         let nowMs;
         let databaseOperations;
         beforeEach(()=>{
-            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-manager-'));
-            regPath = path.join(tmpDir, 'agents.json');
-            nowMs = Date.parse('2026-08-14T10:00:00.000Z');
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-manager-"));
+            regPath = path.join(tmpDir, "agents.json");
+            nowMs = Date.parse("2026-08-14T10:00:00.000Z");
             databaseOperations = [];
             registry = new AgentRegistry(regPath, {
                 now: ()=>new Date(nowMs),
@@ -398,149 +398,375 @@ describe('AgentManager', ()=>{
                 force: true
             });
         });
-        it('persists every detected agent to the registry', async ()=>{
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+        function useHerdrPanes(panes) {
+            const fetchHerdrPanes = vi.fn().mockResolvedValue(panes);
+            scopedManager = new AgentManager(registry, undefined, {
+                runtimeProvider: "herdr",
+                fetchHerdrAgentPanes: fetchHerdrPanes
+            });
+            return fetchHerdrPanes;
+        }
+        it("persists every detected agent to the registry", async ()=>{
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'a',
+                    name: "a",
                     pid: process.pid,
-                    sessionId: 'sid-a',
-                    sessionFilePath: '/path/a.jsonl',
-                    projectPath: '/cwd/a'
+                    sessionId: "sid-a",
+                    sessionFilePath: "/path/a.jsonl",
+                    projectPath: "/cwd/a"
                 })
             ]));
             await scopedManager.listAgents();
             const entries = registry.list();
             expect(entries).toHaveLength(1);
             expect(entries[0]).toMatchObject({
-                name: 'a',
-                type: 'claude',
+                name: "a",
+                type: "claude",
                 pid: process.pid,
-                cwd: '/cwd/a',
-                sessionId: 'sid-a',
-                sessionFilePath: '/path/a.jsonl',
-                tmuxSession: ''
+                cwd: "/cwd/a",
+                sessionId: "sid-a",
+                sessionFilePath: "/path/a.jsonl",
+                runtime: "tmux",
+                runtimeRef: null
             });
             expect(entries[0].startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
         });
-        it('prunes entries for dead pids', async ()=>{
+        it("persists a Herdr runtime ref for manually discovered agents matched by session id", async ()=>{
+            useHerdrPanes([
+                {
+                    agent: "codex",
+                    agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w31:p1",
+                    workspaceId: "w31",
+                    tabId: "w31:t1"
+                }
+            ]);
+            scopedManager.registerAdapter(new MockAdapter("codex", [
+                createMockAgent({
+                    name: "ai-devkit-44290",
+                    type: "codex",
+                    pid: process.pid,
+                    sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+                    sessionFilePath: "/path/codex.jsonl",
+                    projectPath: "/cwd/ai-devkit"
+                })
+            ]));
+            await scopedManager.listAgents();
+            expect(registry.list()[0]).toMatchObject({
+                name: "ai-devkit-44290",
+                type: "codex",
+                pid: process.pid,
+                runtime: "herdr",
+                runtimeRef: {
+                    session: "default",
+                    paneId: "w31:p1",
+                    workspaceId: "w31",
+                    tabId: "w31:t1",
+                    agentName: "ai-devkit-44290"
+                }
+            });
+        });
+        it("upgrades an existing tmux fallback row when Herdr later matches by session id", async ()=>{
+            useHerdrPanes([
+                {
+                    agent: "codex",
+                    agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w31:p1"
+                }
+            ]);
             registry.register({
-                name: 'dead',
-                type: 'claude',
+                name: "ai-devkit-44290",
+                type: "codex",
+                pid: process.pid,
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/cwd/ai-devkit",
+                startedAt: "2026-09-14T00:00:00.000Z",
+                sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+                sessionFilePath: "/path/codex.jsonl"
+            });
+            scopedManager.registerAdapter(new MockAdapter("codex", [
+                createMockAgent({
+                    name: "ai-devkit-44290",
+                    type: "codex",
+                    pid: process.pid,
+                    sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+                    sessionFilePath: "/path/codex.jsonl",
+                    projectPath: "/cwd/ai-devkit"
+                })
+            ]));
+            await scopedManager.listAgents();
+            expect(registry.lookup("ai-devkit-44290")).toMatchObject({
+                runtime: "herdr",
+                runtimeRef: {
+                    session: "default",
+                    paneId: "w31:p1",
+                    agentName: "ai-devkit-44290"
+                }
+            });
+        });
+        it("upgrades an existing tmux fallback row when Herdr matches by foreground pid", async ()=>{
+            useHerdrPanes([
+                {
+                    agent: "codex",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w31:p1",
+                    foregroundPids: [
+                        44290
+                    ]
+                },
+                {
+                    agent: "codex",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w32:p1",
+                    foregroundPids: [
+                        process.pid
+                    ]
+                }
+            ]);
+            registry.register({
+                name: "ai-devkit-64904",
+                type: "codex",
+                pid: process.pid,
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/cwd/ai-devkit",
+                startedAt: "2026-09-14T00:00:00.000Z",
+                sessionId: `pid-${process.pid}`,
+                sessionFilePath: ""
+            });
+            scopedManager.registerAdapter(new MockAdapter("codex", [
+                createMockAgent({
+                    name: "ai-devkit-64904",
+                    type: "codex",
+                    pid: process.pid,
+                    sessionId: `pid-${process.pid}`,
+                    sessionFilePath: undefined,
+                    projectPath: "/cwd/ai-devkit"
+                })
+            ]));
+            await scopedManager.listAgents();
+            expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+                runtime: "herdr",
+                runtimeRef: {
+                    session: "default",
+                    paneId: "w32:p1",
+                    agentName: "ai-devkit-64904"
+                }
+            });
+        });
+        it("fetches Herdr panes automatically when the configured runtime is Herdr", async ()=>{
+            const fetchHerdrPanes = useHerdrPanes([
+                {
+                    agent: "codex",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w32:p1",
+                    foregroundPids: [
+                        process.pid
+                    ]
+                }
+            ]);
+            scopedManager.registerAdapter(new MockAdapter("codex", [
+                createMockAgent({
+                    name: "ai-devkit-64904",
+                    type: "codex",
+                    pid: process.pid,
+                    sessionId: `pid-${process.pid}`,
+                    sessionFilePath: undefined,
+                    projectPath: "/cwd/ai-devkit"
+                })
+            ]));
+            await scopedManager.listAgents();
+            expect(fetchHerdrPanes).toHaveBeenCalledOnce();
+            expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+                runtime: "herdr",
+                runtimeRef: {
+                    session: "default",
+                    paneId: "w32:p1",
+                    agentName: "ai-devkit-64904"
+                }
+            });
+        });
+        it("upgrades an existing tmux row with a malformed runtime ref when Herdr matches", async ()=>{
+            useHerdrPanes([
+                {
+                    agent: "codex",
+                    cwd: "/cwd/ai-devkit",
+                    paneId: "w32:p1",
+                    foregroundPids: [
+                        process.pid
+                    ]
+                }
+            ]);
+            registry.register({
+                name: "ai-devkit-64904",
+                type: "codex",
+                pid: process.pid,
+                runtime: "tmux",
+                runtimeRef: {},
+                cwd: "/cwd/ai-devkit",
+                startedAt: "2026-09-14T00:00:00.000Z",
+                sessionId: `pid-${process.pid}`,
+                sessionFilePath: ""
+            });
+            scopedManager.registerAdapter(new MockAdapter("codex", [
+                createMockAgent({
+                    name: "ai-devkit-64904",
+                    type: "codex",
+                    pid: process.pid,
+                    sessionId: `pid-${process.pid}`,
+                    sessionFilePath: undefined,
+                    projectPath: "/cwd/ai-devkit"
+                })
+            ]));
+            await scopedManager.listAgents();
+            expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+                runtime: "herdr",
+                runtimeRef: {
+                    session: "default",
+                    paneId: "w32:p1",
+                    agentName: "ai-devkit-64904"
+                }
+            });
+        });
+        it("prunes entries for dead pids", async ()=>{
+            registry.register({
+                name: "dead",
+                type: "claude",
                 pid: 999999,
-                tmuxSession: '',
-                cwd: '/cwd/dead',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'sid-dead',
-                sessionFilePath: '/path/dead.jsonl'
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/cwd/dead",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "sid-dead",
+                sessionFilePath: "/path/dead.jsonl"
             });
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'live',
+                    name: "live",
                     pid: process.pid
                 })
             ]));
             await scopedManager.listAgents();
             const entries = registry.list();
             expect(entries.map((e)=>e.name)).toEqual([
-                'live'
+                "live"
             ]);
         });
         it('preserves an existing name (e.g. user-set "merry") across cycles', async ()=>{
             registry.register({
-                name: 'merry',
-                type: 'claude',
+                name: "merry",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: 'merry',
-                cwd: '/cwd/merry',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'sid-merry',
-                sessionFilePath: '/path/merry.jsonl'
+                runtime: "tmux",
+                runtimeRef: {
+                    session: "merry"
+                },
+                cwd: "/cwd/merry",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "sid-merry",
+                sessionFilePath: "/path/merry.jsonl"
             });
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'default-name',
+                    name: "default-name",
                     pid: process.pid
                 })
             ]));
             const agents = await scopedManager.listAgents();
-            expect(agents[0].name).toBe('merry');
-            expect(registry.list()[0].name).toBe('merry');
-            expect(registry.list()[0].tmuxSession).toBe('merry');
-            expect(registry.list()[0].startedAt).toBe('2026-05-30T00:00:00.000Z');
+            expect(agents[0].name).toBe("merry");
+            expect(registry.list()[0].name).toBe("merry");
+            expect(registry.list()[0].runtimeRef).toEqual({
+                session: "merry"
+            });
+            expect(registry.list()[0].startedAt).toBe("2026-05-30T00:00:00.000Z");
         });
-        it('preserves custom name and tmux session across two EPERM refresh cycles', async ()=>{
+        it("preserves custom name and tmux runtime ref across two EPERM refresh cycles", async ()=>{
             registry.register({
-                name: 'merry',
-                type: 'claude',
+                name: "merry",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: 'merry-tmux',
-                cwd: '/cwd/merry',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'sid-merry',
-                sessionFilePath: '/path/merry.jsonl'
+                runtime: "tmux",
+                runtimeRef: {
+                    session: "merry-tmux"
+                },
+                cwd: "/cwd/merry",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "sid-merry",
+                sessionFilePath: "/path/merry.jsonl"
             });
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
                     name: `ai-devkit-${process.pid}`,
                     pid: process.pid
                 })
             ]));
-            vi.spyOn(process, 'kill').mockImplementation(()=>{
-                throw Object.assign(new Error('operation not permitted'), {
-                    code: 'EPERM'
+            vi.spyOn(process, "kill").mockImplementation(()=>{
+                throw Object.assign(new Error("operation not permitted"), {
+                    code: "EPERM"
                 });
             });
             const firstRefresh = await scopedManager.listAgents();
             const secondRefresh = await scopedManager.listAgents();
-            expect(firstRefresh[0].name).toBe('merry');
-            expect(secondRefresh[0].name).toBe('merry');
-            expect(registry.lookup('merry')).toMatchObject({
-                name: 'merry',
-                tmuxSession: 'merry-tmux'
+            expect(firstRefresh[0].name).toBe("merry");
+            expect(secondRefresh[0].name).toBe("merry");
+            expect(registry.lookup("merry")).toMatchObject({
+                name: "merry",
+                runtimeRef: {
+                    session: "merry-tmux"
+                }
             });
         });
-        it('preserves a user-managed name when a fallback row was written later for the same pid', async ()=>{
+        it("preserves a user-managed name when a fallback row was written later for the same pid", async ()=>{
             registry.register({
-                name: 'agent-list-debug',
-                type: 'codex',
+                name: "agent-list-debug",
+                type: "codex",
                 pid: process.pid,
-                tmuxSession: 'agent-list-debug',
-                cwd: '/cwd/debug',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'pid-debug',
-                sessionFilePath: ''
+                runtime: "tmux",
+                runtimeRef: {
+                    session: "agent-list-debug"
+                },
+                cwd: "/cwd/debug",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "pid-debug",
+                sessionFilePath: ""
             });
             registry.register({
                 name: `ai-devkit-${process.pid}`,
-                type: 'codex',
+                type: "codex",
                 pid: process.pid,
-                tmuxSession: '',
-                cwd: '/cwd/debug',
-                startedAt: '2026-05-31T00:00:00.000Z',
-                sessionId: 'pid-debug',
-                sessionFilePath: ''
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/cwd/debug",
+                startedAt: "2026-05-31T00:00:00.000Z",
+                sessionId: "pid-debug",
+                sessionFilePath: ""
             });
-            scopedManager.registerAdapter(new MockAdapter('codex', [
+            scopedManager.registerAdapter(new MockAdapter("codex", [
                 createMockAgent({
                     name: `ai-devkit-${process.pid}`,
-                    type: 'codex',
+                    type: "codex",
                     pid: process.pid
                 })
             ]));
             const agents = await scopedManager.listAgents();
-            expect(agents[0].name).toBe('agent-list-debug');
+            expect(agents[0].name).toBe("agent-list-debug");
             expect(registry.list()).toHaveLength(1);
             expect(registry.list()[0]).toMatchObject({
-                name: 'agent-list-debug',
+                name: "agent-list-debug",
                 pid: process.pid,
-                tmuxSession: 'agent-list-debug'
+                runtimeRef: {
+                    session: "agent-list-debug"
+                }
             });
         });
-        it('writes a fresh startedAt for new entries', async ()=>{
+        it("writes a fresh startedAt for new entries", async ()=>{
             const before = new Date().toISOString();
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'new',
+                    name: "new",
                     pid: process.pid
                 })
             ]));
@@ -548,36 +774,36 @@ describe('AgentManager', ()=>{
             const entry = registry.list()[0];
             expect(entry.startedAt >= before).toBe(true);
         });
-        it('batches the write — a single registerBatch call per listAgents', async ()=>{
-            const spy = vi.spyOn(registry, 'registerBatch');
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+        it("batches the write — a single registerBatch call per listAgents", async ()=>{
+            const spy = vi.spyOn(registry, "registerBatch");
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'a',
+                    name: "a",
                     pid: process.pid
                 })
             ]));
-            scopedManager.registerAdapter(new MockAdapter('codex', [
+            scopedManager.registerAdapter(new MockAdapter("codex", [
                 createMockAgent({
-                    name: 'b',
-                    type: 'codex',
+                    name: "b",
+                    type: "codex",
                     pid: process.pid + 1
                 })
             ]));
             await scopedManager.listAgents();
             expect(spy).toHaveBeenCalledTimes(1);
             expect(spy.mock.calls[0][0].map((e)=>e.name).sort()).toEqual([
-                'a',
-                'b'
+                "a",
+                "b"
             ]);
         });
-        it('performs zero database writes on an unchanged refresh', async ()=>{
-            const adapter = new MockAdapter('claude', [
+        it("performs zero database writes on an unchanged refresh", async ()=>{
+            const adapter = new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'stable',
+                    name: "stable",
                     pid: process.pid,
-                    projectPath: '/cwd/stable',
-                    sessionId: 'stable-session',
-                    sessionFilePath: '/sessions/stable.jsonl'
+                    projectPath: "/cwd/stable",
+                    sessionId: "stable-session",
+                    sessionFilePath: "/sessions/stable.jsonl"
                 })
             ]);
             scopedManager.registerAdapter(adapter);
@@ -587,66 +813,66 @@ describe('AgentManager', ()=>{
             const writes = databaseOperations.filter((sql)=>/^\s*(BEGIN|COMMIT|INSERT|UPDATE|DELETE)/i.test(sql));
             expect(writes).toEqual([]);
         });
-        it('exposes a persisted pin and preserves it across a changed poll refresh', async ()=>{
-            const adapter = new MockAdapter('claude', [
+        it("exposes a persisted pin and preserves it across a changed poll refresh", async ()=>{
+            const adapter = new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'pinned',
+                    name: "pinned",
                     pid: process.pid,
-                    sessionId: 'before'
+                    sessionId: "before"
                 })
             ]);
             scopedManager.registerAdapter(adapter);
             await scopedManager.listAgents();
-            registry.togglePin('claude', process.pid);
+            registry.togglePin("claude", process.pid);
             adapter.setAgents([
                 createMockAgent({
-                    name: 'pinned',
+                    name: "pinned",
                     pid: process.pid,
-                    sessionId: 'after'
+                    sessionId: "after"
                 })
             ]);
             const agents = await scopedManager.listAgents();
             expect(agents[0].pinned).toBe(true);
-            expect(registry.lookup('pinned')).toMatchObject({
-                sessionId: 'after',
+            expect(registry.lookup("pinned")).toMatchObject({
+                sessionId: "after",
                 pinned: true
             });
         });
-        it('uses registry updated_at as lastActive for pinned recency ordering', async ()=>{
-            const adapter = new MockAdapter('claude', [
+        it("uses registry updated_at as lastActive for pinned recency ordering", async ()=>{
+            const adapter = new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'recently-pinned',
+                    name: "recently-pinned",
                     pid: process.pid,
-                    lastActive: new Date('2026-01-01T00:00:00.000Z')
+                    lastActive: new Date("2026-01-01T00:00:00.000Z")
                 })
             ]);
             scopedManager.registerAdapter(adapter);
             await scopedManager.listAgents();
             nowMs += 60_000;
-            scopedManager.togglePin('recently-pinned');
+            scopedManager.togglePin("recently-pinned");
             const agents = await scopedManager.listAgents();
             expect(agents[0].pinned).toBe(true);
-            expect(agents[0].lastActive.toISOString()).toBe('2026-08-14T10:01:00.000Z');
+            expect(agents[0].lastActive.toISOString()).toBe("2026-08-14T10:01:00.000Z");
         });
-        it('preserves adapter lastActive for unpinned agents', async ()=>{
-            scopedManager.registerAdapter(new MockAdapter('claude', [
+        it("preserves adapter lastActive for unpinned agents", async ()=>{
+            scopedManager.registerAdapter(new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'unpinned',
+                    name: "unpinned",
                     pid: process.pid,
-                    lastActive: new Date('2026-01-01T00:00:00.000Z')
+                    lastActive: new Date("2026-01-01T00:00:00.000Z")
                 })
             ]));
             await scopedManager.listAgents();
             const agents = await scopedManager.listAgents();
             expect(agents[0].pinned).toBe(false);
-            expect(agents[0].lastActive.toISOString()).toBe('2026-01-01T00:00:00.000Z');
+            expect(agents[0].lastActive.toISOString()).toBe("2026-01-01T00:00:00.000Z");
         });
-        it('persists changed fields once in one write transaction', async ()=>{
-            const adapter = new MockAdapter('claude', [
+        it("does not persist passive cwd changes when an existing cwd is present", async ()=>{
+            const adapter = new MockAdapter("claude", [
                 createMockAgent({
-                    name: 'changing',
+                    name: "changing",
                     pid: process.pid,
-                    projectPath: '/cwd/before'
+                    projectPath: "/cwd/before"
                 })
             ]);
             scopedManager.registerAdapter(adapter);
@@ -655,350 +881,356 @@ describe('AgentManager', ()=>{
             nowMs += 1_000;
             adapter.setAgents([
                 createMockAgent({
-                    name: 'changing',
+                    name: "changing",
                     pid: process.pid,
-                    projectPath: '/cwd/after'
+                    projectPath: "/cwd/after"
                 })
             ]);
             await scopedManager.listAgents();
             const upserts = databaseOperations.filter((sql)=>/^\s*INSERT INTO agents/i.test(sql));
             const transactions = databaseOperations.filter((sql)=>/^\s*(BEGIN|COMMIT)/i.test(sql));
-            expect(upserts).toHaveLength(1);
-            expect(upserts[0]).toContain("'2026-08-14T10:00:01.000Z'");
-            expect(transactions).toHaveLength(2);
-            expect(registry.lookup('changing')?.cwd).toBe('/cwd/after');
+            expect(upserts).toHaveLength(0);
+            expect(transactions).toHaveLength(0);
+            expect(registry.lookup("changing")?.cwd).toBe("/cwd/before");
         });
-        it('prunes newly dead entries only when the passive cadence is due', async ()=>{
+        it("prunes newly dead entries only when the passive cadence is due", async ()=>{
             registry.register({
-                name: 'cadenced',
-                type: 'claude',
+                name: "cadenced",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: '',
-                cwd: '/cwd/cadenced',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'sid-cadenced',
-                sessionFilePath: ''
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/cwd/cadenced",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "sid-cadenced",
+                sessionFilePath: ""
             });
-            const alive = vi.spyOn(registry, 'isAlive').mockReturnValue(true);
+            const alive = vi.spyOn(registry, "isAlive").mockReturnValue(true);
             await scopedManager.listAgents();
             expect(alive).toHaveBeenCalledTimes(1);
             alive.mockReturnValue(false);
             nowMs += 29_999;
             await scopedManager.listAgents();
             expect(alive).toHaveBeenCalledTimes(1);
-            expect(registry.lookup('cadenced')).not.toBeNull();
+            expect(registry.lookup("cadenced")).not.toBeNull();
             nowMs += 1;
             await scopedManager.listAgents();
             expect(alive).toHaveBeenCalledTimes(2);
-            expect(registry.lookup('cadenced')).toBeNull();
+            expect(registry.lookup("cadenced")).toBeNull();
         });
-        it('does not inherit a name when the same pid is reused by another agent type', async ()=>{
+        it("does not inherit a name when the same pid is reused by another agent type", async ()=>{
             registry.register({
-                name: 'old-claude',
-                type: 'claude',
+                name: "old-claude",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: 'old-claude',
-                cwd: '/cwd/old',
-                startedAt: '2026-05-30T00:00:00.000Z',
-                sessionId: 'old-session',
-                sessionFilePath: ''
+                runtime: "tmux",
+                runtimeRef: {
+                    session: "old-claude"
+                },
+                cwd: "/cwd/old",
+                startedAt: "2026-05-30T00:00:00.000Z",
+                sessionId: "old-session",
+                sessionFilePath: ""
             });
-            scopedManager.registerAdapter(new MockAdapter('codex', [
+            scopedManager.registerAdapter(new MockAdapter("codex", [
                 createMockAgent({
-                    name: 'new-codex',
-                    type: 'codex',
+                    name: "new-codex",
+                    type: "codex",
                     pid: process.pid,
-                    projectPath: '/cwd/new',
-                    sessionId: 'new-session'
+                    projectPath: "/cwd/new",
+                    sessionId: "new-session"
                 })
             ]));
             const agents = await scopedManager.listAgents();
-            expect(agents[0].name).toBe('new-codex');
-            expect(registry.lookup('old-claude')).toBeNull();
-            expect(registry.lookup('new-codex')).toMatchObject({
-                type: 'codex',
+            expect(agents[0].name).toBe("new-codex");
+            expect(registry.lookup("old-claude")).toBeNull();
+            expect(registry.lookup("new-codex")).toMatchObject({
+                type: "codex",
                 pid: process.pid
             });
         });
-        it('skips registerBatch when no agents are detected and prune is not due', async ()=>{
-            const writeSpy = vi.spyOn(registry, 'registerBatch');
-            const pruneSpy = vi.spyOn(registry, 'pruneIfDue');
-            scopedManager.registerAdapter(new MockAdapter('claude', []));
+        it("skips registerBatch when no agents are detected and prune is not due", async ()=>{
+            const writeSpy = vi.spyOn(registry, "registerBatch");
+            const pruneSpy = vi.spyOn(registry, "pruneIfDue");
+            scopedManager.registerAdapter(new MockAdapter("claude", []));
             await scopedManager.listAgents();
             await scopedManager.listAgents();
             expect(writeSpy).not.toHaveBeenCalled();
             expect(pruneSpy).toHaveBeenCalledTimes(2);
         });
     });
-    describe('togglePin', ()=>{
-        it('resolves the agent name to its process identity and toggles the pin', ()=>{
-            const registry = new AgentRegistry(path.join(tmpDir, 'toggle.json'));
+    describe("togglePin", ()=>{
+        it("resolves the agent name to its process identity and toggles the pin", ()=>{
+            const registry = new AgentRegistry(path.join(tmpDir, "toggle.json"));
             const scopedManager = new AgentManager(registry);
             registry.register({
-                name: 'renamed-agent',
-                type: 'claude',
+                name: "renamed-agent",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: '',
-                cwd: '/tmp',
-                startedAt: '2026-08-16T00:00:00.000Z',
-                sessionId: 'session',
-                sessionFilePath: '',
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/tmp",
+                startedAt: "2026-08-16T00:00:00.000Z",
+                sessionId: "session",
+                sessionFilePath: "",
                 pinned: false
             });
-            expect(scopedManager.togglePin('renamed-agent')).toBe(true);
-            expect(registry.lookup('renamed-agent')?.pinned).toBe(true);
+            expect(scopedManager.togglePin("renamed-agent")).toBe(true);
+            expect(registry.lookup("renamed-agent")?.pinned).toBe(true);
         });
-        it('reports when the agent is no longer running', ()=>{
-            expect(()=>manager.togglePin('missing')).toThrow(/no longer running/i);
+        it("reports when the agent is no longer running", ()=>{
+            expect(()=>manager.togglePin("missing")).toThrow(/no longer running/i);
         });
-        it('rejects a dead process and prunes its row', ()=>{
-            const registry = new AgentRegistry(path.join(tmpDir, 'dead-toggle.json'));
+        it("rejects a dead process and prunes its row", ()=>{
+            const registry = new AgentRegistry(path.join(tmpDir, "dead-toggle.json"));
             const scopedManager = new AgentManager(registry);
             registry.register({
-                name: 'dead',
-                type: 'claude',
+                name: "dead",
+                type: "claude",
                 pid: 999999,
-                tmuxSession: '',
-                cwd: '/tmp',
-                startedAt: '2026-08-16T00:00:00.000Z',
-                sessionId: 'session',
-                sessionFilePath: '',
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/tmp",
+                startedAt: "2026-08-16T00:00:00.000Z",
+                sessionId: "session",
+                sessionFilePath: "",
                 pinned: false
             });
-            expect(()=>scopedManager.togglePin('dead')).toThrow(/no longer running/i);
-            expect(registry.lookup('dead')).toBeNull();
+            expect(()=>scopedManager.togglePin("dead")).toThrow(/no longer running/i);
+            expect(registry.lookup("dead")).toBeNull();
         });
-        it('surfaces a clear readonly mutation error', ()=>{
-            const regPath = path.join(tmpDir, 'readonly-toggle.json');
+        it("surfaces a clear readonly mutation error", ()=>{
+            const regPath = path.join(tmpDir, "readonly-toggle.json");
             const writable = new AgentRegistry(regPath);
             writable.register({
-                name: 'readonly-agent',
-                type: 'claude',
+                name: "readonly-agent",
+                type: "claude",
                 pid: process.pid,
-                tmuxSession: '',
-                cwd: '/tmp',
-                startedAt: '2026-08-16T00:00:00.000Z',
-                sessionId: 'session',
-                sessionFilePath: '',
+                runtime: "tmux",
+                runtimeRef: null,
+                cwd: "/tmp",
+                startedAt: "2026-08-16T00:00:00.000Z",
+                sessionId: "session",
+                sessionFilePath: "",
                 pinned: false
             });
             const readonlyManager = new AgentManager(new AgentRegistry(regPath, {
                 readonly: true
             }));
-            expect(()=>readonlyManager.togglePin('readonly-agent')).toThrow('Agent registry is readonly; cannot toggle pin.');
+            expect(()=>readonlyManager.togglePin("readonly-agent")).toThrow("Agent registry is readonly; cannot toggle pin.");
         });
     });
-    describe('clear', ()=>{
-        it('should remove all adapters', ()=>{
-            manager.registerAdapter(new MockAdapter('claude'));
-            manager.registerAdapter(new MockAdapter('gemini_cli'));
+    describe("clear", ()=>{
+        it("should remove all adapters", ()=>{
+            manager.registerAdapter(new MockAdapter("claude"));
+            manager.registerAdapter(new MockAdapter("gemini_cli"));
             manager.clear();
             expect(manager.getAdapterCount()).toBe(0);
             expect(manager.getAdapters()).toEqual([]);
         });
     });
-    describe('listSessions', ()=>{
+    describe("listSessions", ()=>{
         function createMockSession(overrides = {}) {
             return {
-                type: 'claude',
-                sessionId: 'session-1',
-                cwd: '/repo',
-                firstUserMessage: 'hello',
-                lastActive: new Date('2025-01-01T00:00:00Z'),
-                startedAt: new Date('2025-01-01T00:00:00Z'),
-                sessionFilePath: '/tmp/session-1.jsonl',
+                type: "claude",
+                sessionId: "session-1",
+                cwd: "/repo",
+                firstUserMessage: "hello",
+                lastActive: new Date("2025-01-01T00:00:00Z"),
+                startedAt: new Date("2025-01-01T00:00:00Z"),
+                sessionFilePath: "/tmp/session-1.jsonl",
                 ...overrides
             };
         }
-        it('returns empty array when no adapters are registered', async ()=>{
+        it("returns empty array when no adapters are registered", async ()=>{
             const result = await manager.listSessions();
             expect(result).toEqual([]);
         });
-        it('merges sessions from every registered adapter', async ()=>{
+        it("merges sessions from every registered adapter", async ()=>{
             const claudeSession = createMockSession({
-                type: 'claude',
-                sessionId: 'c1'
+                type: "claude",
+                sessionId: "c1"
             });
             const codexSession = createMockSession({
-                type: 'codex',
-                sessionId: 'cx1'
+                type: "codex",
+                sessionId: "cx1"
             });
-            manager.registerAdapter(new MockAdapter('claude', [], false, [
+            manager.registerAdapter(new MockAdapter("claude", [], false, [
                 claudeSession
             ]));
-            manager.registerAdapter(new MockAdapter('codex', [], false, [
+            manager.registerAdapter(new MockAdapter("codex", [], false, [
                 codexSession
             ]));
             const result = await manager.listSessions();
             expect(result).toHaveLength(2);
             expect(result.map((s)=>s.sessionId).sort()).toEqual([
-                'c1',
-                'cx1'
+                "c1",
+                "cx1"
             ]);
         });
-        it('sorts merged sessions by lastActive descending', async ()=>{
+        it("sorts merged sessions by lastActive descending", async ()=>{
             const older = createMockSession({
-                sessionId: 'older',
-                lastActive: new Date('2025-01-01T00:00:00Z')
+                sessionId: "older",
+                lastActive: new Date("2025-01-01T00:00:00Z")
             });
             const newer = createMockSession({
-                type: 'codex',
-                sessionId: 'newer',
-                lastActive: new Date('2025-06-01T00:00:00Z')
+                type: "codex",
+                sessionId: "newer",
+                lastActive: new Date("2025-06-01T00:00:00Z")
             });
-            manager.registerAdapter(new MockAdapter('claude', [], false, [
+            manager.registerAdapter(new MockAdapter("claude", [], false, [
                 older
             ]));
-            manager.registerAdapter(new MockAdapter('codex', [], false, [
+            manager.registerAdapter(new MockAdapter("codex", [], false, [
                 newer
             ]));
             const result = await manager.listSessions();
             expect(result.map((s)=>s.sessionId)).toEqual([
-                'newer',
-                'older'
+                "newer",
+                "older"
             ]);
         });
-        it('skips adapters whose type does not match opts.type', async ()=>{
-            const claudeAdapter = new MockAdapter('claude', [], false, [
+        it("skips adapters whose type does not match opts.type", async ()=>{
+            const claudeAdapter = new MockAdapter("claude", [], false, [
                 createMockSession({
-                    type: 'claude',
-                    sessionId: 'c1'
+                    type: "claude",
+                    sessionId: "c1"
                 })
             ]);
-            const codexAdapter = new MockAdapter('codex', [], false, [
+            const codexAdapter = new MockAdapter("codex", [], false, [
                 createMockSession({
-                    type: 'codex',
-                    sessionId: 'cx1'
+                    type: "codex",
+                    sessionId: "cx1"
                 })
             ]);
             manager.registerAdapter(claudeAdapter);
             manager.registerAdapter(codexAdapter);
             const result = await manager.listSessions({
-                type: 'claude'
+                type: "claude"
             });
             expect(result).toHaveLength(1);
-            expect(result[0].sessionId).toBe('c1');
+            expect(result[0].sessionId).toBe("c1");
             // Codex adapter must not have been called
             expect(codexAdapter.lastListSessionsOpts).toBeUndefined();
             expect(claudeAdapter.lastListSessionsOpts).toEqual({
-                type: 'claude'
+                type: "claude"
             });
         });
-        it('tolerates an adapter that throws and still returns the others', async ()=>{
+        it("tolerates an adapter that throws and still returns the others", async ()=>{
             const goodSession = createMockSession({
-                sessionId: 'good'
+                sessionId: "good"
             });
-            manager.registerAdapter(new MockAdapter('claude', [], false, [
+            manager.registerAdapter(new MockAdapter("claude", [], false, [
                 goodSession
             ]));
-            manager.registerAdapter(new MockAdapter('codex', [], false, [], true));
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(()=>undefined);
+            manager.registerAdapter(new MockAdapter("codex", [], false, [], true));
+            const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>undefined);
             try {
                 const result = await manager.listSessions();
                 expect(result).toHaveLength(1);
-                expect(result[0].sessionId).toBe('good');
+                expect(result[0].sessionId).toBe("good");
                 expect(consoleErrorSpy).toHaveBeenCalled();
             } finally{
                 consoleErrorSpy.mockRestore();
             }
         });
-        it('passes the same opts to every called adapter', async ()=>{
-            const a = new MockAdapter('claude', [], false, []);
-            const b = new MockAdapter('codex', [], false, []);
+        it("passes the same opts to every called adapter", async ()=>{
+            const a = new MockAdapter("claude", [], false, []);
+            const b = new MockAdapter("codex", [], false, []);
             manager.registerAdapter(a);
             manager.registerAdapter(b);
             await manager.listSessions({
-                cwd: '/Users/test/proj'
+                cwd: "/Users/test/proj"
             });
             expect(a.lastListSessionsOpts).toEqual({
-                cwd: '/Users/test/proj'
+                cwd: "/Users/test/proj"
             });
             expect(b.lastListSessionsOpts).toEqual({
-                cwd: '/Users/test/proj'
+                cwd: "/Users/test/proj"
             });
         });
     });
-    describe('resolveAgent', ()=>{
-        it('should return null for empty input or empty agents list', ()=>{
+    describe("resolveAgent", ()=>{
+        it("should return null for empty input or empty agents list", ()=>{
             const agent = createMockAgent({
-                name: 'test-agent'
+                name: "test-agent"
             });
-            expect(manager.resolveAgent('', [
+            expect(manager.resolveAgent("", [
                 agent
             ])).toBeNull();
-            expect(manager.resolveAgent('test', [])).toBeNull();
+            expect(manager.resolveAgent("test", [])).toBeNull();
         });
-        it('should resolve exact match (case-insensitive)', ()=>{
+        it("should resolve exact match (case-insensitive)", ()=>{
             const agent = createMockAgent({
-                name: 'My-Agent'
+                name: "My-Agent"
             });
             const agents = [
                 agent,
                 createMockAgent({
-                    name: 'Other'
+                    name: "Other"
                 })
             ];
             // Exact match
-            expect(manager.resolveAgent('My-Agent', agents)).toBe(agent);
+            expect(manager.resolveAgent("My-Agent", agents)).toBe(agent);
             // Case-insensitive
-            expect(manager.resolveAgent('my-agent', agents)).toBe(agent);
+            expect(manager.resolveAgent("my-agent", agents)).toBe(agent);
         });
-        it('should resolve unique partial match', ()=>{
+        it("should resolve unique partial match", ()=>{
             const agent = createMockAgent({
-                name: 'ai-devkit'
+                name: "ai-devkit"
             });
             const agents = [
                 agent,
                 createMockAgent({
-                    name: 'other-project'
+                    name: "other-project"
                 })
             ];
-            const result = manager.resolveAgent('dev', agents);
+            const result = manager.resolveAgent("dev", agents);
             expect(result).toBe(agent);
         });
-        it('should return array for ambiguous partial match', ()=>{
+        it("should return array for ambiguous partial match", ()=>{
             const agent1 = createMockAgent({
-                name: 'my-website'
+                name: "my-website"
             });
             const agent2 = createMockAgent({
-                name: 'my-app'
+                name: "my-app"
             });
             const agents = [
                 agent1,
                 agent2,
                 createMockAgent({
-                    name: 'other'
+                    name: "other"
                 })
             ];
-            const result = manager.resolveAgent('my', agents);
+            const result = manager.resolveAgent("my", agents);
             expect(Array.isArray(result)).toBe(true);
             const matches = result;
             expect(matches).toHaveLength(2);
             expect(matches).toContain(agent1);
             expect(matches).toContain(agent2);
         });
-        it('should return null for no match', ()=>{
+        it("should return null for no match", ()=>{
             const agents = [
                 createMockAgent({
-                    name: 'ai-devkit'
+                    name: "ai-devkit"
                 })
             ];
-            expect(manager.resolveAgent('xyz', agents)).toBeNull();
+            expect(manager.resolveAgent("xyz", agents)).toBeNull();
         });
-        it('should prefer exact match over partial matches', ()=>{
+        it("should prefer exact match over partial matches", ()=>{
             // Edge case: "test" matches "test" (exact) and "testing" (partial)
             // Should return exact "test"
             const exact = createMockAgent({
-                name: 'test'
+                name: "test"
             });
             const partial = createMockAgent({
-                name: 'testing'
+                name: "testing"
             });
             const agents = [
                 exact,
                 partial
             ];
-            expect(manager.resolveAgent('test', agents)).toBe(exact);
+            expect(manager.resolveAgent("test", agents)).toBe(exact);
         });
     });
 });