@ai-devkit/agent-manager 0.26.1 → 0.26.3

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

@@ -10,7 +10,7 @@ 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 { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
 import { generateAgentName } from '../../utils/matching.js';
 import { AgentRegistry } from '../../utils/AgentRegistry.js';
 
@@ -20,6 +20,7 @@ vi.mock('../../utils/process.js', async (importOriginal) => {
         ...actual,
         listAgentProcesses: vi.fn(),
         enrichProcesses: vi.fn(),
+        captureProcessSnapshot: vi.fn(),
     };
 });
 
@@ -29,6 +30,7 @@ vi.mock('../../utils/matching.js', () => ({
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 describe('CopilotAdapter', () => {
@@ -45,8 +47,13 @@ describe('CopilotAdapter', () => {
 
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
+        mockedCaptureProcessSnapshot.mockReset();
         mockedGenerateAgentName.mockReset();
         mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
+            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
+        ));
         mockedGenerateAgentName.mockImplementation((cwd, pid) => `${path.basename(cwd) || 'unknown'} (${pid})`);
     });
 

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

@@ -11,7 +11,7 @@ import { GeminiCliAdapter } from '../../adapters/GeminiCliAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
 import { AgentRegistry, type RegistryEntry } from '../../utils/AgentRegistry.js';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
 import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
 import * as crypto from 'crypto';
 
@@ -21,6 +21,7 @@ vi.mock('../../utils/process.js', async (importOriginal) => {
         ...actual,
         listAgentProcesses: vi.fn(),
         enrichProcesses: vi.fn(),
+        captureProcessSnapshot: vi.fn(),
     };
 });
 
@@ -31,6 +32,7 @@ vi.mock('../../utils/matching.js', () => ({
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
 const mockedMatchProcessesToSessions = matchProcessesToSessions as MockedFunction<typeof matchProcessesToSessions>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
@@ -45,10 +47,15 @@ describe('GeminiCliAdapter', () => {
         adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
+        mockedCaptureProcessSnapshot.mockReset();
         mockedMatchProcessesToSessions.mockReset();
         mockedGenerateAgentName.mockReset();
 
         mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
+            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
+        ));
         mockedMatchProcessesToSessions.mockReturnValue([]);
         mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
             const folder = path.basename(cwd) || 'unknown';
@@ -110,6 +117,15 @@ describe('GeminiCliAdapter', () => {
                 tty: 'ttys006',
             })).toBe(true);
         });
+
+        it('should recognize Windows executable and entrypoint paths', () => {
+            expect(adapter.canHandle({
+                pid: 7,
+                command: 'C:\\tools\\node.exe C:\\lib\\gemini.js',
+                cwd: 'C:\\repo',
+                tty: '',
+            })).toBe(true);
+        });
     });
 
     describe('detectAgents', () => {
@@ -144,7 +160,7 @@ describe('GeminiCliAdapter', () => {
         it('should return process-only agents when no session files exist for the process', async () => {
             const proc: ProcessInfo = {
                 pid: 1234,
-                command: 'gemini',
+                command: 'node /usr/local/bin/gemini',
                 cwd: '/repo',
                 tty: 'ttys001',
                 startTime: new Date('2026-04-18T00:00:00Z'),
@@ -257,7 +273,7 @@ describe('GeminiCliAdapter', () => {
 
             const proc: ProcessInfo = {
                 pid: 42,
-                command: 'gemini',
+                command: 'node /usr/local/bin/gemini',
                 cwd,
                 tty: 'ttys001',
                 startTime: new Date('2026-04-18T00:00:00Z'),
@@ -383,7 +399,7 @@ describe('GeminiCliAdapter', () => {
 
             const proc: ProcessInfo = {
                 pid: 7,
-                command: 'gemini',
+                command: 'node /usr/local/bin/gemini',
                 cwd: procCwd,
                 tty: 'ttys001',
                 startTime: new Date(),

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

@@ -13,7 +13,7 @@ import * as path from 'path';
 import { GrokCliAdapter } from '../../adapters/GrokCliAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
 import { generateAgentName } from '../../utils/matching.js';
 
 vi.mock('../../utils/process.js', async (importOriginal) => {
@@ -22,6 +22,7 @@ vi.mock('../../utils/process.js', async (importOriginal) => {
         ...actual,
         listAgentProcesses: vi.fn(),
         enrichProcesses: vi.fn(),
+        captureProcessSnapshot: vi.fn(),
     };
 });
 
@@ -35,6 +36,7 @@ vi.mock('../../utils/matching.js', async (importOriginal) => {
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 const SESSION_ID = '019f16c3-5d5d-7dc3-85d1-bc629416ca2d';
@@ -64,9 +66,14 @@ describe('GrokCliAdapter', () => {
 
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
+        mockedCaptureProcessSnapshot.mockReset();
         mockedGenerateAgentName.mockReset();
 
         mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
+            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
+        ));
         mockedGenerateAgentName.mockImplementation((c: string, pid: number) => `${path.basename(c) || 'unknown'}-${pid}`);
     });
 

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

@@ -9,14 +9,19 @@ import * as path from 'path';
 import { OpenCodeAdapter } from '../../adapters/OpenCodeAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
 import { generateAgentName } from '../../utils/matching.js';
 import * as os from 'os';
 
-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(),
+        captureProcessSnapshot: vi.fn(),
+    };
+});
 
 vi.mock('../../utils/matching.js', () => ({
     generateAgentName: vi.fn(),
@@ -25,6 +30,7 @@ vi.mock('../../utils/matching.js', () => ({
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 function makeDb(queries: {
@@ -104,9 +110,14 @@ describe('OpenCodeAdapter', () => {
 
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
+        mockedCaptureProcessSnapshot.mockReset();
         mockedGenerateAgentName.mockReset();
 
         mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
+            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
+        ));
         mockedGenerateAgentName.mockImplementation((cwd, pid) => {
             const folder = path.basename(cwd) || 'unknown';
             return `${folder}-${pid}`;

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

@@ -11,13 +11,18 @@ import { PiAdapter } from '../../adapters/PiAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
 import { AgentRegistry } from '../../utils/AgentRegistry.js';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
 import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
 
-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(),
+        captureProcessSnapshot: vi.fn(),
+    };
+});
 
 vi.mock('../../utils/matching.js', () => ({
     matchProcessesToSessions: vi.fn(),
@@ -26,6 +31,7 @@ vi.mock('../../utils/matching.js', () => ({
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
 const mockedMatchProcessesToSessions = matchProcessesToSessions as MockedFunction<typeof matchProcessesToSessions>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
@@ -43,10 +49,15 @@ describe('PiAdapter', () => {
         adapter = new PiAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
         mockedListAgentProcesses.mockReset();
         mockedEnrichProcesses.mockReset();
+        mockedCaptureProcessSnapshot.mockReset();
         mockedMatchProcessesToSessions.mockReset();
         mockedGenerateAgentName.mockReset();
 
         mockedEnrichProcesses.mockImplementation((procs) => procs);
+        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
+            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
+        ));
         mockedMatchProcessesToSessions.mockReturnValue([]);
         mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
             const folder = path.basename(cwd) || 'unknown';
@@ -67,6 +78,18 @@ describe('PiAdapter', () => {
         expect(adapter.canHandle({ pid: 2, command: '/usr/local/bin/PI --model x', cwd: '/repo', tty: 'ttys002' })).toBe(true);
         expect(adapter.canHandle({ pid: 3, command: 'node /opt/pi/bin/pi.js', cwd: '/repo', tty: 'ttys003' })).toBe(true);
         expect(adapter.canHandle({ pid: 4, command: 'node /repo/feature-pi-adapter/script.js', cwd: '/repo', tty: 'ttys004' })).toBe(false);
+        expect(adapter.canHandle({ pid: 5, command: 'C:\\tools\\node.exe C:\\lib\\pi.js', cwd: '/repo', tty: 'ttys005' })).toBe(true);
+    });
+
+    it('rejects foreign executables from a hand-built snapshot context', async () => {
+        const foreign: ProcessInfo = {
+            pid: 6,
+            command: 'claude --resume /Users/x/repos/pi/session.jsonl',
+            cwd: '/repo',
+            tty: 'ttys006',
+        };
+
+        expect(await adapter.detectAgents({ processes: [foreign] })).toEqual([]);
     });
 
     it('maps a running Pi process to the tracker session for its PID', async () => {

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

@@ -33,29 +33,28 @@ describe('AgentRegistry', () => {
     });
 
     describe('register', () => {
-        it('creates the file and parent directory if missing', () => {
+        it('creates the SQLite database and parent directory if missing', () => {
             registry.register(makeEntry());
-            expect(fs.existsSync(regPath)).toBe(true);
-            const parsed = JSON.parse(fs.readFileSync(regPath, 'utf8'));
-            expect(parsed.entries).toHaveLength(1);
-            expect(parsed.entries[0].name).toBe('agent1');
+            expect(fs.existsSync(regPath.replace(/\.json$/, '.db'))).toBe(true);
+            expect(registry.list()[0].name).toBe('agent1');
         });
 
         it('appends a new entry when name is unique', () => {
             registry.register(makeEntry({ name: 'a' }));
-            registry.register(makeEntry({ name: 'b' }));
+            registry.register(makeEntry({ name: 'b', pid: process.ppid }));
             expect(registry.list()).toHaveLength(2);
         });
 
-        it('upserts in place when name already exists', () => {
-            registry.register(makeEntry({ name: 'a', pid: 100 }));
-            registry.register(makeEntry({ name: 'a', pid: 200 }));
+        it('upserts in place when type and pid already exist', () => {
+            registry.register(makeEntry({ name: 'a', pid: process.pid }));
+            registry.register(makeEntry({ name: 'fallback', pid: process.pid, tmuxSession: '' }));
             const all = registry.list();
             expect(all).toHaveLength(1);
-            expect(all[0].pid).toBe(200);
+            expect(all[0].pid).toBe(process.pid);
+            expect(all[0].name).toBe('a');
         });
 
-        it('writes atomically (no leftover .tmp on success)', () => {
+        it('does not write through the legacy fixed .tmp path', () => {
             registry.register(makeEntry());
             expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);
         });
@@ -69,16 +68,18 @@ describe('AgentRegistry', () => {
 
         it('preserves existing tmuxSession when incoming is empty string', () => {
             registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
-            registry.register(makeEntry({ name: 'a', tmuxSession: '', pid: 999 }));
+            registry.register(makeEntry({ name: 'fallback', tmuxSession: '', pid: process.pid }));
             const saved = registry.lookup('a');
             expect(saved?.tmuxSession).toBe('pinned');
-            expect(saved?.pid).toBe(999);
+            expect(saved?.pid).toBe(process.pid);
         });
 
-        it('replaces tmuxSession when incoming is non-empty', () => {
-            registry.register(makeEntry({ name: 'a', tmuxSession: 'old' }));
-            registry.register(makeEntry({ name: 'a', tmuxSession: 'new' }));
-            expect(registry.lookup('a')?.tmuxSession).toBe('new');
+        it('lets a managed start entry replace a generated fallback for the same pid', () => {
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+            registry.register(makeEntry({ name: 'custom-name', tmuxSession: 'custom-name' }));
+            expect(registry.lookup('custom-name')?.tmuxSession).toBe('custom-name');
+            expect(registry.lookup(`ai-devkit-${process.pid}`)).toBeNull();
+            expect(registry.list()).toHaveLength(1);
         });
     });
 
@@ -88,28 +89,35 @@ describe('AgentRegistry', () => {
             expect(fs.existsSync(regPath)).toBe(false);
         });
 
-        it('upserts multiple entries with a single write', () => {
-            const writeSpy = vi.spyOn(fs, 'writeFileSync');
+        it('upserts multiple entries in a single batch', () => {
             registry.registerBatch([
                 makeEntry({ name: 'a' }),
-                makeEntry({ name: 'b' }),
-                makeEntry({ name: 'c' }),
+                makeEntry({ name: 'b', pid: process.pid + 1 }),
+                makeEntry({ name: 'c', pid: process.pid + 2 }),
             ]);
-            expect(writeSpy).toHaveBeenCalledTimes(1);
-            writeSpy.mockRestore();
             expect(registry.list()).toHaveLength(3);
         });
 
         it('applies the tmuxSession merge per entry', () => {
             registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
             registry.registerBatch([
-                makeEntry({ name: 'a', tmuxSession: '', pid: 7 }),
-                makeEntry({ name: 'b', tmuxSession: '' }),
+                makeEntry({ name: 'fallback', tmuxSession: '', pid: process.pid }),
+                makeEntry({ name: 'b', tmuxSession: '', pid: process.pid + 1 }),
             ]);
             expect(registry.lookup('a')?.tmuxSession).toBe('pinned');
-            expect(registry.lookup('a')?.pid).toBe(7);
+            expect(registry.lookup('a')?.pid).toBe(process.pid);
             expect(registry.lookup('b')?.tmuxSession).toBe('');
         });
+
+        it('handles concurrent registry instances without duplicate pid rows', () => {
+            const other = new AgentRegistry(regPath);
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+            other.register(makeEntry({ name: 'custom-name', tmuxSession: 'custom-name' }));
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+
+            expect(registry.list()).toHaveLength(1);
+            expect(registry.lookup('custom-name')?.pid).toBe(process.pid);
+        });
     });
 
     describe('lookup', () => {
@@ -124,20 +132,20 @@ describe('AgentRegistry', () => {
     });
 
     describe('list', () => {
-        it('returns empty array when file does not exist', () => {
+        it('returns empty array when database does not contain entries', () => {
             expect(registry.list()).toEqual([]);
         });
 
-        it('returns empty array when file is malformed', () => {
+        it('ignores existing legacy agents.json entries', () => {
+            const legacyEntry = makeEntry({ name: 'legacy', tmuxSession: 'legacy' });
             fs.mkdirSync(path.dirname(regPath), { recursive: true });
-            fs.writeFileSync(regPath, 'not json', 'utf8');
-            expect(registry.list()).toEqual([]);
-        });
+            fs.writeFileSync(regPath, JSON.stringify({ entries: [legacyEntry] }), 'utf8');
 
-        it('coerces non-array entries to []', () => {
-            fs.mkdirSync(path.dirname(regPath), { recursive: true });
-            fs.writeFileSync(regPath, JSON.stringify({ entries: 'oops' }), 'utf8');
-            expect(registry.list()).toEqual([]);
+            const legacyRegistry = new AgentRegistry(regPath);
+
+            expect(legacyRegistry.lookup('legacy')).toBeNull();
+            expect(legacyRegistry.list()).toEqual([]);
+            expect(fs.existsSync(regPath.replace(/\.json$/, '.db'))).toBe(true);
         });
     });
 
@@ -163,10 +171,10 @@ describe('AgentRegistry', () => {
 
         it('is a no-op when all entries are alive', () => {
             registry.register(makeEntry({ pid: process.pid }));
-            const before = fs.readFileSync(regPath, 'utf8');
+            const before = registry.list();
             registry.prune();
-            const after = fs.readFileSync(regPath, 'utf8');
-            expect(after).toBe(before);
+            const after = registry.list();
+            expect(after).toEqual(before);
         });
 
         it('does nothing when file is missing', () => {
@@ -203,7 +211,7 @@ describe('AgentRegistry', () => {
 
         it('throws RenameConflictError when new name is already in use by a live entry', () => {
             registry.register(makeEntry({ name: 'agent-a', pid: process.pid }));
-            registry.register(makeEntry({ name: 'agent-b', pid: process.pid }));
+            registry.register(makeEntry({ name: 'agent-b', pid: process.ppid }));
             expect(() => registry.rename('agent-a', 'agent-b')).toThrow(RenameConflictError);
         });
 
@@ -214,7 +222,7 @@ describe('AgentRegistry', () => {
             expect(registry.lookup('agent-b')?.pid).toBe(process.pid);
         });
 
-        it('writes atomically (no leftover .tmp on success)', () => {
+        it('does not create the legacy fixed .tmp path on rename', () => {
             registry.register(makeEntry({ name: 'old-name', pid: process.pid }));
             registry.rename('old-name', 'new-name');
             expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);

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

@@ -4,7 +4,7 @@
 
 import type { MockedFunction } from 'vitest';
 
-import { execFileSync } from 'child_process';
+import { execFile, execFileSync } from 'child_process';
 import {
     listAgentProcesses,
     batchGetProcessCwds,
@@ -12,13 +12,84 @@ import {
     enrichProcesses,
     findWrapperProcess,
     findWrapperProcessPids,
+    captureProcessSnapshot,
+    filterByProcessNames,
 } from '../../utils/process.js';
 
 vi.mock('child_process', () => ({
+    execFile: vi.fn(),
     execFileSync: vi.fn(),
 }));
 
 const mockedExecFileSync = execFileSync as MockedFunction<typeof execFileSync>;
+const mockedExecFile = execFile as unknown as MockedFunction<(
+    file: string,
+    args: readonly string[],
+    options: object,
+    callback: (error: Error | null, stdout: string, stderr: string) => void,
+) => void>;
+
+describe('captureProcessSnapshot', () => {
+    beforeEach(() => {
+        mockedExecFile.mockReset();
+        mockedExecFileSync.mockReset();
+    });
+
+    it('captures and enriches relevant processes without synchronous scans', async () => {
+        mockedExecFile.mockImplementation((file, args, _options, callback) => {
+            queueMicrotask(() => {
+                if (file === 'ps' && args.includes('-axo')) {
+                    callback(null,
+                        '100 1 s001 /usr/bin/claude --resume abc\n' +
+                        '200 1 s002 C:\\\\tools\\\\node.exe C:\\\\bin\\\\pi.js\n' +
+                        '300 1 s003 /usr/bin/unrelated\n',
+                        '');
+                    return;
+                }
+                if (file === 'lsof') {
+                    callback(null, 'p100\nn/projects/claude\np200\nn/projects/pi\n', '');
+                    return;
+                }
+                if (file === 'ps' && args.some((arg) => arg.includes('lstart='))) {
+                    callback(null,
+                        '100 Wed Mar 18 23:18:01 2026\n' +
+                        '200 Thu Mar 19 10:00:00 2026\n',
+                        '');
+                    return;
+                }
+                callback(new Error(`unexpected command: ${file} ${args.join(' ')}`), '', '');
+            });
+        });
+
+        const snapshot = await captureProcessSnapshot(['claude', 'node']);
+
+        expect(snapshot.map((process) => process.pid)).toEqual([100, 200]);
+        expect(snapshot.map((process) => process.cwd)).toEqual(['/projects/claude', '/projects/pi']);
+        expect(snapshot.map((process) => process.startTime)).toEqual([
+            expect.any(Date),
+            expect.any(Date),
+        ]);
+        expect(mockedExecFileSync).not.toHaveBeenCalled();
+        expect(mockedExecFile.mock.calls.filter(([, args]) => args.includes('-axo'))).toHaveLength(1);
+        for (const [, , options] of mockedExecFile.mock.calls) {
+            expect(options).toMatchObject({ encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            expect(options).not.toHaveProperty('stdio');
+        }
+    });
+});
+
+describe('filterByProcessNames', () => {
+    it('matches only argv[0] and normalizes Windows paths and executable suffixes', () => {
+        const processes: ProcessInfo[] = [
+            { pid: 1, command: 'C:\\tools\\node.exe C:\\bin\\pi.js', cwd: '', tty: '' },
+            { pid: 2, command: '/usr/local/bin/node /opt/gemini.js', cwd: '', tty: '' },
+            { pid: 3, command: 'codex exec --cd C:\\repos\\node', cwd: '', tty: '' },
+        ];
+
+        expect(filterByProcessNames(processes, ['node'])).toEqual([processes[0], processes[1]]);
+        expect(filterByProcessNames(processes, ['node.exe'])).toEqual([processes[0], processes[1]]);
+    });
+});
 
 describe('listAgentProcesses', () => {
     beforeEach(() => {

package/src/adapters/AgentAdapter.ts

@@ -59,7 +59,7 @@ export interface ProcessInfo {
     /** Process ID */
     pid: number;
 
-    /** Parent process ID, populated by listAgentProcesses when available */
+    /** Parent process ID, populated by process discovery when available */
     ppid?: number;
 
     /** Process command */
@@ -71,7 +71,7 @@ export interface ProcessInfo {
     /** Terminal TTY (e.g., "ttys030") */
     tty: string;
 
-    /** Process start time, populated by enrichProcesses */
+    /** Process start time, populated by process enrichment */
     startTime?: Date;
 }
 
@@ -148,6 +148,11 @@ export interface ListSessionsOptions {
     type?: AgentType;
 }
 
+export interface AgentDetectionContext {
+    /** One enriched process snapshot shared across this manager refresh. */
+    readonly processes: readonly ProcessInfo[];
+}
+
 /**
  * Agent Adapter Interface
  *
@@ -157,11 +162,14 @@ export interface AgentAdapter {
     /** Type of agent this adapter handles */
     readonly type: AgentType;
 
+    /** Executable basenames required for shared process discovery. */
+    readonly processNames?: readonly string[];
+
     /**
      * Detect running agents of this type
      * @returns List of detected agents
      */
-    detectAgents(): Promise<AgentInfo[]>;
+    detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]>;
 
     /**
      * Check if this adapter can handle the given process

package/src/adapters/ClaudeCodeAdapter.ts

@@ -7,9 +7,10 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';
 import { batchGetSessionFileBirthtimes, isDirectory, listJsonl, safeReaddir, safeStat } from '../utils/session.js';
 import type { SessionFile } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
@@ -60,14 +61,15 @@ const PID_FILE_STALENESS_MS = 60000;
  * Claude Code Adapter
  *
  * Detects Claude Code agents by:
- * 1. Finding running claude processes via shared listAgentProcesses()
- * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 1. Filtering Claude processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
  * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json
  * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file
  * 5. Extracting summary from last user message in session JSONL
  */
 export class ClaudeCodeAdapter implements AgentAdapter {
     readonly type = 'claude' as const;
+    readonly processNames = ['claude'] as const;
 
     private projectsDir: string;
     private sessionsDir: string;
@@ -85,13 +87,14 @@ export class ClaudeCodeAdapter implements AgentAdapter {
     }
 
     private isClaudeExecutable(command: string): boolean {
-        const executable = command.trim().split(/\s+/)[0] || '';
-        const base = path.basename(executable).toLowerCase();
+        const base = executableBasename(command);
         return base === 'claude' || base === 'claude.exe';
     }
 
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(listAgentProcesses('claude'));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) {
             return [];
         }