@ai-devkit/agent-manager 0.18.0 → 0.19.1

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

@@ -12,11 +12,16 @@ 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(),
-}));
+import { AgentRegistry } from '../../utils/AgentRegistry.js';
+
+vi.mock('../../utils/process.js', async (importOriginal) => {
+    const actual = await importOriginal() as typeof import('../../utils/process.js');
+    return {
+        ...actual,
+        listAgentProcesses: vi.fn(),
+        enrichProcesses: vi.fn(),
+    };
+});
 
 vi.mock('../../utils/matching.js', () => ({
     generateAgentName: vi.fn(),
@@ -220,6 +225,55 @@ describe('CopilotAdapter', () => {
             });
         });
 
+        it('suppresses wrapper process-only agents before the session lock exists', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 86800, command: 'copilot', cwd: '/repo', tty: 'ttys001', ppid: 84174 },
+                { pid: 86810, command: '/custom/install/copilot', cwd: '/repo', tty: 'ttys001', ppid: 86800 },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 86810,
+                sessionId: 'pid-86810',
+                summary: 'Copilot process running',
+            });
+        });
+
+        it('carries the managed wrapper name to a process-only child before the session lock exists', async () => {
+            const registry = new AgentRegistry(path.join(tmpDir, 'agents.json'));
+            adapter = new CopilotAdapter(registry);
+            (adapter as any).sessionStateDir = sessionStateDir;
+            const processes: ProcessInfo[] = [
+                { pid: 86800, command: 'copilot', cwd: '/repo', tty: 'ttys001', ppid: 84174 },
+                { pid: 86810, command: '/custom/install/copilot', cwd: '/repo', tty: 'ttys001', ppid: 86800 },
+            ];
+            registry.register({
+                name: 'copilot-started',
+                type: 'copilot',
+                pid: 86800,
+                tmuxSession: 'copilot-started',
+                cwd: '/repo',
+                startedAt: '2026-06-13T19:15:16.211Z',
+                sessionId: 'pid-86800',
+                sessionFilePath: '',
+            });
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                name: 'copilot-started',
+                pid: 86810,
+                sessionId: 'pid-86810',
+            });
+        });
+
         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' },
@@ -244,6 +298,44 @@ describe('CopilotAdapter', () => {
             });
         });
 
+        it('carries the managed wrapper name to a lock-backed child process', async () => {
+            const registry = new AgentRegistry(path.join(tmpDir, 'agents.json'));
+            adapter = new CopilotAdapter(registry);
+            (adapter as any).sessionStateDir = sessionStateDir;
+            const processes: ProcessInfo[] = [
+                { pid: 14095, command: 'copilot', cwd: '/repo', tty: 'ttys001', ppid: 84174 },
+                { pid: 14096, command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot', cwd: '/repo', tty: 'ttys001', ppid: 14095 },
+            ];
+            registry.register({
+                name: 'copilot-started',
+                type: 'copilot',
+                pid: 14095,
+                tmuxSession: 'copilot-started',
+                cwd: '/repo',
+                startedAt: '2026-06-13T19:15:16.211Z',
+                sessionId: 'pid-14095',
+                sessionFilePath: '',
+            });
+            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({
+                name: 'copilot-started',
+                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' },

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

@@ -15,10 +15,14 @@ import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
 import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
 import * as crypto from 'crypto';
 
-vi.mock('../../utils/process.js', () => ({
-    listAgentProcesses: vi.fn(),
-    enrichProcesses: vi.fn(),
-}));
+vi.mock('../../utils/process.js', async (importOriginal) => {
+    const actual = await importOriginal() as typeof import('../../utils/process.js');
+    return {
+        ...actual,
+        listAgentProcesses: vi.fn(),
+        enrichProcesses: vi.fn(),
+    };
+});
 
 vi.mock('../../utils/matching.js', () => ({
     matchProcessesToSessions: vi.fn(),
@@ -158,6 +162,77 @@ describe('GeminiCliAdapter', () => {
             });
         });
 
+        it('should suppress Gemini wrapper process-only agents before a session file exists', async () => {
+            const wrapperProc: ProcessInfo = {
+                pid: 20452,
+                ppid: 17530,
+                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
+                cwd: '/repo',
+                tty: 'ttys007',
+                startTime: new Date('2026-06-13T08:25:21Z'),
+            };
+            const childProc: ProcessInfo = {
+                pid: 21373,
+                ppid: 20452,
+                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
+                cwd: '/repo',
+                tty: 'ttys007',
+                startTime: new Date('2026-06-13T08:25:26Z'),
+            };
+            mockedListAgentProcesses.mockReturnValue([wrapperProc, childProc]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 21373,
+                sessionId: 'pid-21373',
+                summary: 'Gemini CLI process running',
+            });
+        });
+
+        it('should carry the managed wrapper name to a process-only child before a session file exists', async () => {
+            const regPath = path.join(tmpHome, 'agents.json');
+            const registry = new AgentRegistry(regPath);
+            const namedAdapter = new GeminiCliAdapter(registry);
+            const wrapperProc: ProcessInfo = {
+                pid: 35792,
+                ppid: 33068,
+                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
+                cwd: '/repo',
+                tty: 'ttys002',
+                startTime: new Date('2026-06-13T19:15:16Z'),
+            };
+            const childProc: ProcessInfo = {
+                pid: 36514,
+                ppid: 35792,
+                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
+                cwd: '/repo',
+                tty: 'ttys002',
+                startTime: new Date('2026-06-13T19:15:18Z'),
+            };
+            registry.register({
+                name: 'cli-mqcqj469',
+                type: 'gemini_cli',
+                pid: wrapperProc.pid,
+                tmuxSession: 'cli-mqcqj469',
+                cwd: wrapperProc.cwd,
+                startedAt: '2026-06-13T19:15:16.211Z',
+                sessionId: `pid-${wrapperProc.pid}`,
+                sessionFilePath: '',
+            });
+            mockedListAgentProcesses.mockReturnValue([wrapperProc, childProc]);
+
+            const agents = await namedAdapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                name: 'cli-mqcqj469',
+                pid: childProc.pid,
+                sessionId: `pid-${childProc.pid}`,
+            });
+        });
+
         it('should map a process to its matching session file via projectHash', async () => {
             const cwd = '/repo/project-a';
             const projectHash = hashProjectRoot(cwd);
@@ -433,6 +508,66 @@ describe('GeminiCliAdapter', () => {
 
             expect(agents[0].sessionId).toBe('pid-100');
         });
+
+        it('carries the managed wrapper name to the detected child process', async () => {
+            const wrapperProc: ProcessInfo = {
+                pid: 20339,
+                ppid: 17570,
+                command: '/opt/homebrew/opt/node/bin/node /opt/homebrew/bin/gemini',
+                cwd: '/repo-a',
+                tty: 'ttys002',
+                startTime: new Date('2026-06-13T19:00:53Z'),
+            };
+            const childProc: ProcessInfo = {
+                pid: 21038,
+                ppid: 20339,
+                command: '/opt/homebrew/Cellar/node/26.0.0/bin/node --max-old-space-size=8192 /opt/homebrew/bin/gemini',
+                cwd: '/repo-a',
+                tty: 'ttys002',
+                startTime: new Date('2026-06-13T19:00:57Z'),
+            };
+            const now = new Date().toISOString();
+            sessionFilePath = writeSession(tmpHome, 'cli-2', 'session-2026-06-13T19-00-s-cached', {
+                sessionId: 's-cached',
+                projectHash: hashProjectRoot('/repo-a'),
+                startTime: now,
+                lastUpdated: now,
+                directories: ['/repo-a'],
+                messages: [
+                    { id: 'm1', timestamp: now, type: 'user', content: 'Hello from child process' },
+                ],
+            });
+            registerEntry({
+                name: 'cli-mqcq0mg5',
+                pid: wrapperProc.pid,
+                tmuxSession: 'cli-mqcq0mg5',
+                sessionId: 's-cached',
+                sessionFilePath,
+            });
+            mockedListAgentProcesses.mockReturnValue([wrapperProc, childProc]);
+            mockedMatchProcessesToSessions.mockReturnValue([
+                {
+                    process: childProc,
+                    session: {
+                        sessionId: 's-cached',
+                        filePath: sessionFilePath,
+                        projectDir: path.dirname(sessionFilePath),
+                        birthtimeMs: Date.now(),
+                        resolvedCwd: '/repo-a',
+                    },
+                    deltaMs: 0,
+                },
+            ]);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                name: 'cli-mqcq0mg5',
+                pid: childProc.pid,
+                sessionId: 's-cached',
+            });
+        });
     });
 
     describe('discoverSessions', () => {

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

@@ -0,0 +1,92 @@
+import { execFile } from 'child_process';
+import type { MockedFunction } from 'vitest';
+
+import { TerminalFocusManager, TerminalType } from '../../terminal/TerminalFocusManager.js';
+import { getProcessTty } from '../../utils/process.js';
+
+vi.mock('child_process', () => ({
+    execFile: vi.fn(),
+}));
+
+vi.mock('../../utils/process.js', async () => {
+    const actual = await vi.importActual<typeof import('../../utils/process.js')>('../../utils/process.js');
+    return {
+        ...actual,
+        getProcessTty: vi.fn(),
+    };
+});
+
+type ExecFileCb = (err: Error | null, result?: { stdout: string; stderr: string }) => void;
+const mockedExecFile = execFile as unknown as MockedFunction<
+    (cmd: string, args: string[], cb: ExecFileCb) => void
+>;
+const mockedGetProcessTty = getProcessTty as MockedFunction<typeof getProcessTty>;
+
+function setExecFileHandler(handler: (cmd: string, args: string[]) => string | Error) {
+    mockedExecFile.mockImplementation((cmd, args, cb) => {
+        const result = handler(cmd, args);
+        if (result instanceof Error) cb(result);
+        else cb(null, { stdout: result, stderr: '' });
+    });
+}
+
+describe('TerminalFocusManager', () => {
+    beforeEach(() => {
+        mockedExecFile.mockReset();
+        mockedGetProcessTty.mockReset();
+        mockedGetProcessTty.mockReturnValue('ttys000');
+    });
+
+    it('finds iTerm2 when the process is listed by full app binary path', async () => {
+        setExecFileHandler((cmd, args) => {
+            if (cmd === 'tmux') return new Error('tmux not running');
+            if (cmd === 'pgrep') return new Error('pgrep did not match GUI app');
+            if (cmd === 'ps' && args.join(' ') === '-Axo comm') {
+                return '/Applications/iTerm.app/Contents/MacOS/iTerm2\n';
+            }
+            if (cmd === 'osascript') return 'found\n';
+            return '';
+        });
+
+        const location = await new TerminalFocusManager().findTerminal(123);
+
+        expect(location).toEqual({
+            type: TerminalType.ITERM2,
+            identifier: '/dev/ttys000',
+            tty: '/dev/ttys000',
+        });
+        expect(mockedExecFile).not.toHaveBeenCalledWith(
+            'pgrep',
+            expect.any(Array),
+            expect.any(Function),
+        );
+    });
+
+    it('finds Terminal.app when the process is listed by app bundle path', async () => {
+        setExecFileHandler((cmd, args) => {
+            if (cmd === 'tmux') return new Error('tmux not running');
+            if (cmd === 'pgrep') return new Error('pgrep did not match GUI app');
+            if (cmd === 'ps' && args.join(' ') === '-Axo comm') {
+                return '/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal\n';
+            }
+            if (cmd === 'osascript') {
+                const script = args[1] ?? '';
+                return script.includes('tell application "Terminal"') ? 'found\n' : '';
+            }
+            return '';
+        });
+
+        const location = await new TerminalFocusManager().findTerminal(123);
+
+        expect(location).toEqual({
+            type: TerminalType.TERMINAL_APP,
+            identifier: '/dev/ttys000',
+            tty: '/dev/ttys000',
+        });
+        expect(mockedExecFile).not.toHaveBeenCalledWith(
+            'pgrep',
+            expect.any(Array),
+            expect.any(Function),
+        );
+    });
+});

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

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { AGENTS } from '../../../src/utils/agents.js';
+
+describe('AGENTS', () => {
+    it('includes Copilot as a startable agent', () => {
+        expect(AGENTS.copilot.command).toBe('copilot');
+        expect(AGENTS.copilot.matches('/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot')).toBe(true);
+        expect(AGENTS.copilot.matches('node /repo/feature-cli-copilot-cli/script.js')).toBe(false);
+    });
+
+    it('includes Pi as a startable agent', () => {
+        expect(AGENTS.pi.command).toBe('pi');
+        expect(AGENTS.pi.matches('pi')).toBe(true);
+        expect(AGENTS.pi.matches('/usr/local/bin/pi --model x')).toBe(true);
+        expect(AGENTS.pi.matches('node /repo/feature-pi-adapter/script.js')).toBe(false);
+    });
+});

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

@@ -10,6 +10,8 @@ import {
     batchGetProcessCwds,
     batchGetProcessStartTimes,
     enrichProcesses,
+    findWrapperProcess,
+    findWrapperProcessPids,
 } from '../../utils/process.js';
 
 vi.mock('child_process', () => ({
@@ -23,26 +25,28 @@ describe('listAgentProcesses', () => {
         mockedExecFileSync.mockReset();
     });
 
-    it('should parse ps aux | grep output and post-filter by executable name', () => {
+    it('should parse ps output and post-filter by executable name', () => {
         mockedExecFileSync.mockReturnValue(
-            'user  78070  1.0  0.5 485636016 245952 s018  S+   11:18PM   1:55.14 claude\n' +
-            'user  55106  0.1  0.4 485620368  72496 s015  S+    9Mar26   8:06.36 claude\n',
+            '78070     1 s018     claude\n' +
+            '55106 55100 s015     claude\n',
         );
 
         const processes = listAgentProcesses('claude');
         expect(processes).toHaveLength(2);
         expect(processes[0].pid).toBe(78070);
+        expect(processes[0].ppid).toBe(1);
         expect(processes[0].command).toBe('claude');
         expect(processes[0].tty).toBe('s018');
         expect(processes[0].cwd).toBe(''); // not populated yet
         expect(processes[1].pid).toBe(55106);
+        expect(processes[1].ppid).toBe(55100);
     });
 
     it('should filter out non-matching executables', () => {
         mockedExecFileSync.mockReturnValue(
-            'user  100  0.0  0.0 0 0 s001  S  1:00PM  0:00 claude\n' +
-            'user  200  0.0  0.0 0 0 s002  S  1:00PM  0:00 claude-helper --pid 100\n' +
-            'user  300  0.0  0.0 0 0 s003  S  1:00PM  0:00 /usr/bin/claude\n',
+            '100 1 s001 claude\n' +
+            '200 1 s002 claude-helper --pid 100\n' +
+            '300 1 s003 /usr/bin/claude\n',
         );
 
         const processes = listAgentProcesses('claude');
@@ -75,7 +79,11 @@ describe('listAgentProcesses', () => {
     it('should accept valid patterns with dashes and underscores', () => {
         mockedExecFileSync.mockReturnValue('');
         listAgentProcesses('claude-code');
-        expect(mockedExecFileSync).toHaveBeenCalled();
+        expect(mockedExecFileSync).toHaveBeenCalledWith(
+            'ps',
+            ['-axo', 'pid=,ppid=,tty=,command='],
+            { encoding: 'utf-8' },
+        );
 
         mockedExecFileSync.mockReset();
         mockedExecFileSync.mockReturnValue('');
@@ -201,3 +209,19 @@ describe('enrichProcesses', () => {
         expect(enriched[0].startTime).toBeUndefined();
     });
 });
+
+describe('wrapper process detection', () => {
+    it('finds the parent wrapper process for a child in the same terminal and cwd', () => {
+        const wrapper = { pid: 100, ppid: 1, command: 'node /bin/gemini', cwd: '/repo', tty: 'ttys001' };
+        const child = { pid: 200, ppid: 100, command: 'node --max-old-space-size=8192 /bin/gemini', cwd: '/repo', tty: 'ttys001' };
+
+        expect(findWrapperProcess([wrapper, child], child)).toBe(wrapper);
+        expect(findWrapperProcessPids([wrapper, child])).toEqual(new Set([100]));
+    });
+
+    it('does not mark a matched child process as its own wrapper', () => {
+        const child = { pid: 200, ppid: 100, command: 'node --max-old-space-size=8192 /bin/gemini', cwd: '/repo', tty: 'ttys001' };
+
+        expect(findWrapperProcessPids([child], [child])).toEqual(new Set());
+    });
+});

package/src/adapters/AgentAdapter.ts

@@ -59,6 +59,9 @@ export interface ProcessInfo {
     /** Process ID */
     pid: number;
 
+    /** Parent process ID, populated by listAgentProcesses when available */
+    ppid?: number;
+
     /** Process command */
     command: string;
 

package/src/adapters/CopilotAdapter.ts

@@ -19,9 +19,10 @@ import type {
     SessionSummary,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { enrichProcesses, listAgentProcesses } from '../utils/process.js';
+import { enrichProcesses, findWrapperProcess, findWrapperProcessPids, listAgentProcesses } from '../utils/process.js';
 import { generateAgentName } from '../utils/matching.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
+import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
 
 interface CopilotEventEntry {
     type?: string;
@@ -107,10 +108,12 @@ export class CopilotAdapter implements AgentAdapter {
     ]);
 
     private sessionStateDir: string;
+    private registry: AgentRegistry;
 
-    constructor() {
+    constructor(registry: AgentRegistry = AgentRegistry.default()) {
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.sessionStateDir = path.join(homeDir, '.copilot', 'session-state');
+        this.registry = registry;
     }
 
     canHandle(processInfo: ProcessInfo): boolean {
@@ -122,6 +125,7 @@ export class CopilotAdapter implements AgentAdapter {
         if (processes.length === 0) return [];
 
         const processByPid = new Map(processes.map((proc) => [proc.pid, proc]));
+        const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
         const matchedPids = new Set<number>();
         const matchedProcesses: ProcessInfo[] = [];
         const agents: AgentInfo[] = [];
@@ -133,29 +137,36 @@ export class CopilotAdapter implements AgentAdapter {
             const session = this.readSessionDir(lock.sessionDir, lock.sessionId);
             if (!session) continue;
 
-            agents.push(this.mapSessionToAgent(session, proc));
+            const agent = this.mapSessionToAgent(session, proc);
+            this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+            agents.push(agent);
             matchedPids.add(proc.pid);
             matchedProcesses.push(proc);
         }
 
+        const wrapperPids = findWrapperProcessPids(processes, matchedProcesses);
         for (const proc of processes) {
-            if (!matchedPids.has(proc.pid) && !this.isDuplicateProcess(proc, matchedProcesses)) {
-                agents.push(this.mapProcessOnlyAgent(proc));
+            if (!matchedPids.has(proc.pid) && !wrapperPids.has(proc.pid)) {
+                const agent = this.mapProcessOnlyAgent(proc);
+                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+                agents.push(agent);
             }
         }
 
         return agents;
     }
 
-    private isDuplicateProcess(proc: ProcessInfo, matchedProcesses: ProcessInfo[]): boolean {
-        return matchedProcesses.some((matched) => {
-            if (proc.pid === matched.pid) return true;
-
-            const sameTty = proc.tty !== '' && proc.tty !== '?' && proc.tty === matched.tty;
-            const sameCwd = proc.cwd !== '' && proc.cwd === matched.cwd;
-
-            return sameTty && (sameCwd || proc.cwd === '' || matched.cwd === '');
-        });
+    private applyWrapperRegistryName(
+        agent: AgentInfo,
+        processInfo: ProcessInfo,
+        processes: ProcessInfo[],
+        registryEntriesByPid: Map<number, RegistryEntry>,
+    ): void {
+        const wrapper = findWrapperProcess(processes, processInfo);
+        const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
+        if (wrapperEntry?.type === this.type) {
+            agent.name = wrapperEntry.name;
+        }
     }
 
     getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {