@ai-devkit/agent-manager 0.16.0 → 0.17.0

package/dist/utils/sortAgents.js

@@ -3,7 +3,7 @@ const STATUS_PRIORITY = {
     [AgentStatus.WAITING]: 0,
     [AgentStatus.RUNNING]: 1,
     [AgentStatus.IDLE]: 2,
-    [AgentStatus.UNKNOWN]: 3,
+    [AgentStatus.UNKNOWN]: 3
 };
 function compareByName(a, b) {
     return a.name.localeCompare(b.name);
@@ -11,25 +11,22 @@ function compareByName(a, b) {
 function compareByStatus(a, b) {
     const pa = STATUS_PRIORITY[a.status] ?? 999;
     const pb = STATUS_PRIORITY[b.status] ?? 999;
-    if (pa !== pb)
-        return pa - pb;
+    if (pa !== pb) return pa - pb;
     return compareByName(a, b);
 }
 function compareByPid(a, b) {
-    if (a.pid !== b.pid)
-        return a.pid - b.pid;
+    if (a.pid !== b.pid) return a.pid - b.pid;
     return compareByName(a, b);
 }
 function compareByLastActive(a, b) {
     const ta = a.lastActive instanceof Date ? a.lastActive.getTime() : new Date(a.lastActive).getTime();
     const tb = b.lastActive instanceof Date ? b.lastActive.getTime() : new Date(b.lastActive).getTime();
-    if (tb !== ta)
-        return tb - ta; // most recent first
+    if (tb !== ta) return tb - ta; // most recent first
     return compareByName(a, b);
 }
 export function sortAgents(agents, by) {
     const copy = agents.slice();
-    switch (by) {
+    switch(by){
         case 'name':
             copy.sort(compareByName);
             break;
@@ -45,4 +42,5 @@ export function sortAgents(agents, by) {
     }
     return copy;
 }
+
 //# sourceMappingURL=sortAgents.js.map

package/dist/utils/sortAgents.js.map

@@ -1 +1 @@
-{"version":3,"file":"sortAgents.js","sourceRoot":"","sources":["../../src/utils/sortAgents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,6BAA6B,CAAC;AAI1E,MAAM,eAAe,GAAgC;IACjD,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IACxB,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IACxB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;IACrB,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CAC3B,CAAC;AAEF,SAAS,aAAa,CAAC,CAAY,EAAE,CAAY;IAC7C,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACxC,CAAC;AAED,SAAS,eAAe,CAAC,CAAY,EAAE,CAAY;IAC/C,MAAM,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC;IAC5C,MAAM,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC;IAC5C,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,EAAE,CAAC;IAC9B,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,YAAY,CAAC,CAAY,EAAE,CAAY;IAC5C,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG;QAAE,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC;IAC1C,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,mBAAmB,CAAC,CAAY,EAAE,CAAY;IACnD,MAAM,EAAE,GAAG,CAAC,CAAC,UAAU,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC;IACpG,MAAM,EAAE,GAAG,CAAC,CAAC,UAAU,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC;IACpG,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,oBAAoB;IACnD,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,MAAmB,EAAE,EAAgB;IAC5D,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5B,QAAQ,EAAE,EAAE,CAAC;QACT,KAAK,MAAM;YACP,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACzB,MAAM;QACV,KAAK,QAAQ;YACT,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAC3B,MAAM;QACV,KAAK,KAAK;YACN,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACxB,MAAM;QACV,KAAK,YAAY;YACb,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAC/B,MAAM;IACd,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC"}
+{"version":3,"sources":["../../src/utils/sortAgents.ts"],"sourcesContent":["import { AgentStatus, type AgentInfo } from '../adapters/AgentAdapter.js';\n\nexport type AgentSortKey = 'name' | 'status' | 'pid' | 'lastActive';\n\nconst STATUS_PRIORITY: Record<AgentStatus, number> = {\n    [AgentStatus.WAITING]: 0,\n    [AgentStatus.RUNNING]: 1,\n    [AgentStatus.IDLE]: 2,\n    [AgentStatus.UNKNOWN]: 3,\n};\n\nfunction compareByName(a: AgentInfo, b: AgentInfo): number {\n    return a.name.localeCompare(b.name);\n}\n\nfunction compareByStatus(a: AgentInfo, b: AgentInfo): number {\n    const pa = STATUS_PRIORITY[a.status] ?? 999;\n    const pb = STATUS_PRIORITY[b.status] ?? 999;\n    if (pa !== pb) return pa - pb;\n    return compareByName(a, b);\n}\n\nfunction compareByPid(a: AgentInfo, b: AgentInfo): number {\n    if (a.pid !== b.pid) return a.pid - b.pid;\n    return compareByName(a, b);\n}\n\nfunction compareByLastActive(a: AgentInfo, b: AgentInfo): number {\n    const ta = a.lastActive instanceof Date ? a.lastActive.getTime() : new Date(a.lastActive).getTime();\n    const tb = b.lastActive instanceof Date ? b.lastActive.getTime() : new Date(b.lastActive).getTime();\n    if (tb !== ta) return tb - ta; // most recent first\n    return compareByName(a, b);\n}\n\nexport function sortAgents(agents: AgentInfo[], by: AgentSortKey): AgentInfo[] {\n    const copy = agents.slice();\n    switch (by) {\n        case 'name':\n            copy.sort(compareByName);\n            break;\n        case 'status':\n            copy.sort(compareByStatus);\n            break;\n        case 'pid':\n            copy.sort(compareByPid);\n            break;\n        case 'lastActive':\n            copy.sort(compareByLastActive);\n            break;\n    }\n    return copy;\n}\n"],"names":["AgentStatus","STATUS_PRIORITY","WAITING","RUNNING","IDLE","UNKNOWN","compareByName","a","b","name","localeCompare","compareByStatus","pa","status","pb","compareByPid","pid","compareByLastActive","ta","lastActive","Date","getTime","tb","sortAgents","agents","by","copy","slice","sort"],"mappings":"AAAA,SAASA,WAAW,QAAwB,8BAA8B;AAI1E,MAAMC,kBAA+C;IACjD,CAACD,YAAYE,OAAO,CAAC,EAAE;IACvB,CAACF,YAAYG,OAAO,CAAC,EAAE;IACvB,CAACH,YAAYI,IAAI,CAAC,EAAE;IACpB,CAACJ,YAAYK,OAAO,CAAC,EAAE;AAC3B;AAEA,SAASC,cAAcC,CAAY,EAAEC,CAAY;IAC7C,OAAOD,EAAEE,IAAI,CAACC,aAAa,CAACF,EAAEC,IAAI;AACtC;AAEA,SAASE,gBAAgBJ,CAAY,EAAEC,CAAY;IAC/C,MAAMI,KAAKX,eAAe,CAACM,EAAEM,MAAM,CAAC,IAAI;IACxC,MAAMC,KAAKb,eAAe,CAACO,EAAEK,MAAM,CAAC,IAAI;IACxC,IAAID,OAAOE,IAAI,OAAOF,KAAKE;IAC3B,OAAOR,cAAcC,GAAGC;AAC5B;AAEA,SAASO,aAAaR,CAAY,EAAEC,CAAY;IAC5C,IAAID,EAAES,GAAG,KAAKR,EAAEQ,GAAG,EAAE,OAAOT,EAAES,GAAG,GAAGR,EAAEQ,GAAG;IACzC,OAAOV,cAAcC,GAAGC;AAC5B;AAEA,SAASS,oBAAoBV,CAAY,EAAEC,CAAY;IACnD,MAAMU,KAAKX,EAAEY,UAAU,YAAYC,OAAOb,EAAEY,UAAU,CAACE,OAAO,KAAK,IAAID,KAAKb,EAAEY,UAAU,EAAEE,OAAO;IACjG,MAAMC,KAAKd,EAAEW,UAAU,YAAYC,OAAOZ,EAAEW,UAAU,CAACE,OAAO,KAAK,IAAID,KAAKZ,EAAEW,UAAU,EAAEE,OAAO;IACjG,IAAIC,OAAOJ,IAAI,OAAOI,KAAKJ,IAAI,oBAAoB;IACnD,OAAOZ,cAAcC,GAAGC;AAC5B;AAEA,OAAO,SAASe,WAAWC,MAAmB,EAAEC,EAAgB;IAC5D,MAAMC,OAAOF,OAAOG,KAAK;IACzB,OAAQF;QACJ,KAAK;YACDC,KAAKE,IAAI,CAACtB;YACV;QACJ,KAAK;YACDoB,KAAKE,IAAI,CAACjB;YACV;QACJ,KAAK;YACDe,KAAKE,IAAI,CAACb;YACV;QACJ,KAAK;YACDW,KAAKE,IAAI,CAACX;YACV;IACR;IACA,OAAOS;AACX"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-devkit/agent-manager",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "type": "module",
   "description": "Standalone agent detection and management utilities for AI DevKit",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "dev": "swc src -d dist --strip-leading-paths --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -29,17 +30,20 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "better-sqlite3": "^12.6.2"
+    "better-sqlite3": "^12.6.2",
+    "uuid": "14.0.0"
   },
   "devDependencies": {
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.10.0",
     "@types/better-sqlite3": "^7.6.11",
     "@types/node": "^20.11.5",
-    "@typescript-eslint/eslint-plugin": "^6.19.1",
-    "@typescript-eslint/parser": "^6.19.1",
-    "@vitest/coverage-v8": "^2.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.60.1",
+    "@typescript-eslint/parser": "^8.60.1",
+    "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^8.56.0",
     "typescript": "^5.5.0",
-    "vitest": "^2.1.0"
+    "vitest": "^4.1.8"
   },
   "engines": {
     "node": ">=20.20.0"

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

@@ -758,6 +758,7 @@ describe('ClaudeCodeAdapter', () => {
 
         beforeEach(() => {
             tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-test-'));
+            (adapter as any).projectsDir = path.join(tmpDir, 'projects');
         });
 
         afterEach(() => {
@@ -1073,6 +1074,7 @@ describe('ClaudeCodeAdapter', () => {
 
         beforeEach(() => {
             tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-test-'));
+            (adapter as any).projectsDir = path.join(tmpDir, 'projects');
         });
 
         afterEach(() => {

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

@@ -248,6 +248,100 @@ describe('CodexAdapter', () => {
 
             fs.rmSync(tmpDir, { recursive: true, force: true });
         });
+
+        it('should match resumed sessions by id even when the JSONL predates the process', async () => {
+            const sessionId = '019eabed-4079-7071-9531-b853ddd9914e';
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 88018,
+                    command: `codex resume ${sessionId}`,
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: new Date('2026-06-10T12:00:00.000Z'),
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-resume-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '06', '09');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const recentTs = new Date().toISOString();
+            const sessionFile = path.join(dateDir, `rollout-2026-06-09T12-28-33-${sessionId}.jsonl`);
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload: { id: sessionId, timestamp: recentTs, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: recentTs, payload: { type: 'agent_message', message: 'resumed codex conversation' } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'codex',
+                pid: 88018,
+                sessionId,
+                projectPath: '/repo-a',
+                sessionFilePath: sessionFile,
+            });
+            expect(agents[0].summary).toBe('resumed codex conversation');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should fall back to process-only when a resumed session becomes unreadable after direct matching', async () => {
+            const sessionId = '019eabed-4079-7071-9531-b853ddd9914e';
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 88019,
+                    command: `codex resume ${sessionId}`,
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: new Date('2026-06-10T12:00:00.000Z'),
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-resume-gone-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '06', '09');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, `rollout-2026-06-09T12-28-33-${sessionId}.jsonl`);
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            const findSpy = vi.spyOn(adapter as any, 'findSessionFileById').mockReturnValue({
+                sessionId,
+                filePath: sessionFile,
+                projectDir: dateDir,
+                birthtimeMs: Date.now(),
+                resolvedCwd: '/repo-a',
+            });
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([]);
+
+            try {
+                const agents = await adapter.detectAgents();
+
+                expect(agents).toHaveLength(1);
+                expect(agents[0]).toMatchObject({
+                    type: 'codex',
+                    pid: 88019,
+                    sessionId: 'pid-88019',
+                    projectPath: '/repo-a',
+                });
+                expect(agents[0].sessionFilePath).toBeUndefined();
+            } finally {
+                findSpy.mockRestore();
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
     });
 
     describe('detectAgents — registry cache short-circuit', () => {

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

@@ -0,0 +1,411 @@
+/**
+ * Tests for CopilotAdapter
+ */
+
+import type { MockedFunction } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { CopilotAdapter } from '../../adapters/CopilotAdapter.js';
+import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { generateAgentName } from '../../utils/matching.js';
+
+vi.mock('../../utils/process.js', () => ({
+    listAgentProcesses: vi.fn(),
+    enrichProcesses: vi.fn(),
+}));
+
+vi.mock('../../utils/matching.js', () => ({
+    generateAgentName: vi.fn(),
+}));
+
+const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
+
+describe('CopilotAdapter', () => {
+    let adapter: CopilotAdapter;
+    let tmpDir: string;
+    let sessionStateDir: string;
+
+    beforeEach(() => {
+        adapter = new CopilotAdapter();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'copilot-test-'));
+        sessionStateDir = path.join(tmpDir, 'session-state');
+        fs.mkdirSync(sessionStateDir, { recursive: true });
+        (adapter as any).sessionStateDir = sessionStateDir;
+
+        mockedListAgentProcesses.mockReset();
+        mockedEnrichProcesses.mockReset();
+        mockedGenerateAgentName.mockReset();
+        mockedEnrichProcesses.mockImplementation((procs) => procs);
+        mockedGenerateAgentName.mockImplementation((cwd, pid) => `${path.basename(cwd) || 'unknown'} (${pid})`);
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    function writeSession(
+        sessionId: string,
+        options: {
+            events?: Array<object | string>;
+            workspace?: Record<string, string>;
+            lockPid?: number | string;
+        },
+    ): string {
+        const sessionDir = path.join(sessionStateDir, sessionId);
+        fs.mkdirSync(sessionDir, { recursive: true });
+
+        if (options.events) {
+            const lines = options.events.map((entry) => (
+                typeof entry === 'string' ? entry : JSON.stringify(entry)
+            ));
+            fs.writeFileSync(path.join(sessionDir, 'events.jsonl'), lines.join('\n'));
+        }
+
+        if (options.workspace) {
+            const lines = Object.entries(options.workspace).map(([key, value]) => `${key}: ${value}`);
+            fs.writeFileSync(path.join(sessionDir, 'workspace.yaml'), lines.join('\n'));
+        }
+
+        if (options.lockPid !== undefined) {
+            fs.writeFileSync(path.join(sessionDir, `inuse.${options.lockPid}.lock`), '');
+        }
+
+        return sessionDir;
+    }
+
+    function sessionStart(sessionId: string, cwd: string, startTime = '2026-06-09T09:50:00.000Z'): object {
+        return {
+            type: 'session.start',
+            data: {
+                sessionId,
+                startTime,
+                context: {
+                    cwd,
+                    gitRoot: cwd,
+                    branch: 'main',
+                },
+            },
+            timestamp: startTime,
+        };
+    }
+
+    describe('initialization', () => {
+        it('exposes copilot type', () => {
+            expect(adapter.type).toBe('copilot');
+        });
+    });
+
+    describe('canHandle', () => {
+        it('returns true for copilot commands', () => {
+            expect(adapter.canHandle({ pid: 1, command: 'copilot', cwd: '/repo', tty: 'ttys001' })).toBe(true);
+        });
+
+        it('returns true for full-path Homebrew copilot commands', () => {
+            expect(adapter.canHandle({
+                pid: 2,
+                command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot',
+                cwd: '/repo',
+                tty: 'ttys002',
+            })).toBe(true);
+        });
+
+        it('returns true for copilot.exe commands', () => {
+            expect(adapter.canHandle({ pid: 3, command: '/usr/bin/copilot.exe', cwd: '/repo', tty: 'ttys003' })).toBe(true);
+        });
+
+        it('returns false when copilot appears only in an argument', () => {
+            expect(adapter.canHandle({
+                pid: 4,
+                command: 'node /repo/copilot-plugin/index.js',
+                cwd: '/repo',
+                tty: 'ttys004',
+            })).toBe(false);
+        });
+    });
+
+    describe('detectAgents', () => {
+        it('returns empty list when no copilot process is running', async () => {
+            mockedListAgentProcesses.mockReturnValue([]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toEqual([]);
+            expect(mockedListAgentProcesses).toHaveBeenCalledWith('copilot');
+        });
+
+        it('maps matching inuse lock and events to an active agent', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 14096, command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot', cwd: '/repo', tty: 'ttys001' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            writeSession('sess-a', {
+                lockPid: 14096,
+                events: [
+                    sessionStart('sess-a', '/repo', '2026-06-09T09:50:00.000Z'),
+                    { type: 'user.message', data: { content: 'Build the Copilot adapter' }, timestamp: new Date().toISOString() },
+                    { type: 'assistant.message', data: { content: 'I will inspect the code.' }, timestamp: new Date().toISOString() },
+                ],
+                workspace: {
+                    id: 'sess-a',
+                    cwd: '/fallback',
+                    name: 'Fallback Name',
+                    created_at: '2026-06-09T09:49:00.000Z',
+                    updated_at: '2026-06-09T09:51:00.000Z',
+                },
+            });
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'copilot',
+                status: AgentStatus.WAITING,
+                pid: 14096,
+                projectPath: '/repo',
+                sessionId: 'sess-a',
+                summary: 'Build the Copilot adapter',
+                sessionFilePath: path.join(sessionStateDir, 'sess-a', 'events.jsonl'),
+            });
+        });
+
+        it('ignores invalid and unmatched lock PIDs', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'copilot', cwd: '/repo', tty: 'ttys001' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            writeSession('invalid', {
+                lockPid: 'not-a-pid',
+                events: [sessionStart('invalid', '/invalid')],
+            });
+            writeSession('unmatched', {
+                lockPid: 999999,
+                events: [sessionStart('unmatched', '/unmatched')],
+            });
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 100,
+                sessionId: 'pid-100',
+                summary: 'Copilot process running',
+            });
+        });
+
+        it('falls back to process-only agent when no session lock matches', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 200, command: 'copilot', cwd: '/repo-b', tty: 'ttys002' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'copilot',
+                status: AgentStatus.RUNNING,
+                pid: 200,
+                projectPath: '/repo-b',
+                sessionId: 'pid-200',
+                summary: 'Copilot process running',
+            });
+        });
+
+        it('does not add duplicate process-only agent for wrapper process in the same terminal', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 14095, command: 'copilot', cwd: '/repo', tty: 'ttys001' },
+                { pid: 14096, command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot', cwd: '/repo', tty: 'ttys001' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            writeSession('sess-wrapper', {
+                lockPid: 14096,
+                events: [
+                    sessionStart('sess-wrapper', '/repo', '2026-06-09T09:50:00.000Z'),
+                    { type: 'user.message', data: { content: 'hello' }, timestamp: new Date().toISOString() },
+                ],
+            });
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 14096,
+                sessionId: 'sess-wrapper',
+            });
+        });
+
+        it('uses workspace metadata when events are missing', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 300, command: 'copilot', cwd: '/proc-cwd', tty: 'ttys003' },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            writeSession('workspace-only', {
+                lockPid: 300,
+                workspace: {
+                    id: 'workspace-only',
+                    cwd: '/workspace-cwd',
+                    name: 'Workspace Session',
+                    created_at: '2026-06-09T09:00:00.000Z',
+                    updated_at: '2026-06-09T09:10:00.000Z',
+                },
+            });
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 300,
+                projectPath: '/workspace-cwd',
+                sessionId: 'workspace-only',
+                summary: 'Workspace Session',
+            });
+        });
+    });
+
+    describe('getConversation', () => {
+        it('parses user and assistant message events', () => {
+            const sessionDir = writeSession('conv', {
+                events: [
+                    sessionStart('conv', '/repo'),
+                    { type: 'user.message', data: { content: 'hello' }, timestamp: '2026-06-09T09:50:01.000Z' },
+                    { type: 'assistant.message', data: { content: 'Hi there' }, timestamp: '2026-06-09T09:50:02.000Z' },
+                ],
+            });
+
+            const messages = adapter.getConversation(path.join(sessionDir, 'events.jsonl'));
+
+            expect(messages).toEqual([
+                { role: 'user', content: 'hello', timestamp: '2026-06-09T09:50:01.000Z' },
+                { role: 'assistant', content: 'Hi there', timestamp: '2026-06-09T09:50:02.000Z' },
+            ]);
+        });
+
+        it('includes system/info/warning messages only in verbose mode', () => {
+            const sessionDir = writeSession('verbose', {
+                events: [
+                    { type: 'session.warning', data: { message: 'MCP failed' }, timestamp: '2026-06-09T09:50:01.000Z' },
+                    { type: 'tool.execution_complete', data: { result: { content: 'Tool result' } }, timestamp: '2026-06-09T09:50:02.000Z' },
+                ],
+            });
+            const filePath = path.join(sessionDir, 'events.jsonl');
+
+            expect(adapter.getConversation(filePath)).toEqual([]);
+            expect(adapter.getConversation(filePath, { verbose: true })).toEqual([
+                { role: 'system', content: 'MCP failed', timestamp: '2026-06-09T09:50:01.000Z' },
+                { role: 'system', content: 'Tool result', timestamp: '2026-06-09T09:50:02.000Z' },
+            ]);
+        });
+
+        it('skips malformed JSONL lines and missing text', () => {
+            const sessionDir = writeSession('malformed', {
+                events: [
+                    'not json',
+                    { type: 'user.message', data: { content: 'valid' }, timestamp: '2026-06-09T09:50:01.000Z' },
+                    { type: 'assistant.message', data: {}, timestamp: '2026-06-09T09:50:02.000Z' },
+                ],
+            });
+
+            const messages = adapter.getConversation(path.join(sessionDir, 'events.jsonl'));
+
+            expect(messages).toEqual([
+                { role: 'user', content: 'valid', timestamp: '2026-06-09T09:50:01.000Z' },
+            ]);
+        });
+
+        it('returns empty array for missing file', () => {
+            expect(adapter.getConversation(path.join(tmpDir, 'missing.jsonl'))).toEqual([]);
+        });
+    });
+
+    describe('listSessions', () => {
+        it('returns historical sessions without active locks', async () => {
+            writeSession('history-a', {
+                events: [
+                    sessionStart('history-a', '/repo-a', '2026-06-09T09:00:00.000Z'),
+                    { type: 'user.message', data: { content: 'first user' }, timestamp: '2026-06-09T09:00:01.000Z' },
+                    { type: 'assistant.message', data: { content: 'answer' }, timestamp: '2026-06-09T09:00:02.000Z' },
+                ],
+            });
+            writeSession('history-b', {
+                events: [
+                    sessionStart('history-b', '/repo-b', '2026-06-09T10:00:00.000Z'),
+                    { type: 'user.message', data: { content: 'other user' }, timestamp: '2026-06-09T10:00:01.000Z' },
+                ],
+            });
+
+            const sessions = await adapter.listSessions();
+
+            expect(sessions).toHaveLength(2);
+            const byId = Object.fromEntries(sessions.map((session) => [session.sessionId, session]));
+            expect(byId['history-a']).toMatchObject({
+                type: 'copilot',
+                cwd: '/repo-a',
+                firstUserMessage: 'first user',
+                sessionFilePath: path.join(sessionStateDir, 'history-a', 'events.jsonl'),
+            });
+            expect(byId['history-b']).toMatchObject({
+                type: 'copilot',
+                cwd: '/repo-b',
+                firstUserMessage: 'other user',
+            });
+        });
+
+        it('applies strict cwd filter', async () => {
+            writeSession('keep', { events: [sessionStart('keep', '/repo')] });
+            writeSession('drop', { events: [sessionStart('drop', '/other')] });
+
+            const sessions = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(sessions).toHaveLength(1);
+            expect(sessions[0].sessionId).toBe('keep');
+        });
+
+        it('uses workspace fallback for historical sessions without events', async () => {
+            writeSession('workspace-history', {
+                workspace: {
+                    id: 'workspace-history',
+                    cwd: '/workspace-repo',
+                    name: 'Workspace History',
+                    created_at: '2026-06-09T08:00:00.000Z',
+                    updated_at: '2026-06-09T08:10:00.000Z',
+                },
+            });
+
+            const sessions = await adapter.listSessions();
+
+            expect(sessions).toHaveLength(1);
+            expect(sessions[0]).toMatchObject({
+                type: 'copilot',
+                sessionId: 'workspace-history',
+                cwd: '/workspace-repo',
+                firstUserMessage: '',
+                sessionFilePath: path.join(sessionStateDir, 'workspace-history', 'events.jsonl'),
+            });
+        });
+
+        it('skips session directories without events or workspace metadata', async () => {
+            fs.mkdirSync(path.join(sessionStateDir, 'empty'), { recursive: true });
+
+            const sessions = await adapter.listSessions();
+
+            expect(sessions).toEqual([]);
+        });
+
+        it('returns empty when session-state directory does not exist', async () => {
+            (adapter as any).sessionStateDir = path.join(tmpDir, 'missing');
+
+            await expect(adapter.listSessions()).resolves.toEqual([]);
+        });
+    });
+});