@ai-devkit/agent-manager 0.19.0 → 0.20.0

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

@@ -95,6 +95,11 @@ describe('CodexAdapter', () => {
     });
 
     describe('detectAgents', () => {
+        async function useRealSessionMatcher(): Promise<void> {
+            const actualMatching = await vi.importActual<typeof import('../../utils/matching.js')>('../../utils/matching.js');
+            mockedMatchProcessesToSessions.mockImplementation(actualMatching.matchProcessesToSessions);
+        }
+
         it('should return empty list when no codex process is running', async () => {
             mockedListAgentProcesses.mockReturnValue([]);
 
@@ -190,6 +195,163 @@ describe('CodexAdapter', () => {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
+        it('should match when session_meta timestamp and file birthtime both align with process start', async () => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:05.000Z';
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 101,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-aligned.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-aligned', timestamp: sessionTimestamp, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: sessionTimestamp, payload: { type: 'token_count', message: 'Aligned session' } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-aligned',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date(sessionTimestamp).getTime(),
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 101,
+                sessionId: 'sess-aligned',
+                summary: 'Aligned session',
+            });
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should match late-created session files using session_meta timestamp', async () => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:10.000Z';
+            const lateBirthtime = new Date('2026-03-18T15:05:30.000Z').getTime();
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 102,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-late.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-late', timestamp: sessionTimestamp, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: sessionTimestamp, payload: { type: 'token_count', message: 'Late file session' } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-late',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: lateBirthtime,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 102,
+                sessionId: 'sess-late',
+                summary: 'Late file session',
+            });
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(new Date(sessionTimestamp).getTime());
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it.each<[string, string | undefined]>([
+            ['missing', undefined],
+            ['invalid', 'not-a-date'],
+        ])('should fall back to file birthtime when session_meta timestamp is %s', async (_label, metaTimestamp) => {
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const fileBirthtime = new Date('2026-03-18T15:00:20.000Z').getTime();
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 103,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const payload: { id: string; cwd: string; timestamp?: string } = { id: `sess-${_label}`, cwd: '/repo-a' };
+            if (metaTimestamp !== undefined) {
+                payload.timestamp = metaTimestamp;
+            }
+
+            const sessionFile = path.join(dateDir, `sess-${_label}.jsonl`);
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({ type: 'session_meta', payload }),
+                JSON.stringify({ type: 'event', timestamp: '2026-03-18T15:00:30.000Z', payload: { type: 'token_count', message: `${_label} timestamp session` } }),
+            ].join('\n'));
+
+            (adapter as any).codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: `sess-${_label}`,
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: fileBirthtime,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].sessionId).toBe(`sess-${_label}`);
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(fileBirthtime);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
         it('should fall back to process-only for unmatched processes', async () => {
             const processes: ProcessInfo[] = [
                 { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
@@ -602,6 +764,133 @@ describe('CodexAdapter', () => {
             const { sessions } = discoverSessions(processes);
             expect(sessions[0].resolvedCwd).toBe('');
         });
+
+        it('should use session_meta timestamp as the matching birthtime when valid', () => {
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            (adapter as any).codexSessionsDir = sessionsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const sessionFile = path.join(dateDir, 'sess-meta-time.jsonl');
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            fs.writeFileSync(sessionFile,
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-meta-time', timestamp: metaTimestamp, cwd: '/repo-a' } }),
+            );
+
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-meta-time',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date('2026-03-18T15:05:30.000Z').getTime(),
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const { sessions } = discoverSessions([
+                { pid: 1, command: 'codex', cwd: '/repo-a', tty: '', startTime: new Date('2026-03-18T15:00:00Z') },
+            ]);
+
+            expect(sessions[0].resolvedCwd).toBe('/repo-a');
+            expect(sessions[0].birthtimeMs).toBe(new Date(metaTimestamp).getTime());
+        });
+
+        it('should tolerate malformed session_meta and unreadable files', () => {
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            (adapter as any).codexSessionsDir = sessionsDir;
+            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
+
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, { recursive: true });
+
+            const malformedFile = path.join(dateDir, 'malformed.jsonl');
+            const missingFile = path.join(dateDir, 'missing.jsonl');
+            fs.writeFileSync(malformedFile, '{not valid json');
+
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'malformed',
+                    filePath: malformedFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800324000,
+                    resolvedCwd: '',
+                },
+                {
+                    sessionId: 'missing',
+                    filePath: missingFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800325000,
+                    resolvedCwd: '',
+                },
+            ]);
+
+            const result = discoverSessions([
+                { pid: 1, command: 'codex', cwd: '/repo', tty: '', startTime: new Date('2026-03-18T15:00:00Z') },
+            ]);
+
+            expect(result.sessions).toHaveLength(2);
+            expect(result.sessions[0].resolvedCwd).toBe('');
+            expect(result.sessions[1].resolvedCwd).toBe('');
+            expect(result.contentCache.has(malformedFile)).toBe(true);
+            expect(result.contentCache.has(missingFile)).toBe(false);
+        });
+    });
+
+    describe('findSessionFileById', () => {
+        let tmpDir: string;
+        let sessionsDir: string;
+        const sessionId = 'aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee';
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-resume-find-'));
+            sessionsDir = path.join(tmpDir, 'sessions');
+            fs.mkdirSync(path.join(sessionsDir, '2026', '03', '18'), { recursive: true });
+            (adapter as any).codexSessionsDir = sessionsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeResumeSession(timestamp?: string): string {
+            const filePath = path.join(sessionsDir, '2026', '03', '18', `${sessionId}.jsonl`);
+            const payload: { id: string; cwd: string; timestamp?: string } = { id: sessionId, cwd: '/repo-a' };
+            if (timestamp !== undefined) {
+                payload.timestamp = timestamp;
+            }
+            fs.writeFileSync(filePath, JSON.stringify({ type: 'session_meta', payload }));
+            return filePath;
+        }
+
+        it('should return session_meta timestamp as birthtimeMs when valid', () => {
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            writeResumeSession(metaTimestamp);
+            const findSessionFileById = (adapter as any).findSessionFileById.bind(adapter);
+
+            const session = findSessionFileById(sessionId);
+
+            expect(session).toMatchObject({
+                sessionId,
+                resolvedCwd: '/repo-a',
+                birthtimeMs: new Date(metaTimestamp).getTime(),
+            });
+        });
+
+        it.each<[string, string | undefined]>([
+            ['missing', undefined],
+            ['invalid', 'not-a-date'],
+        ])('should fall back to stat birthtimeMs when session_meta timestamp is %s', (_label, metaTimestamp) => {
+            const sessionFile = writeResumeSession(metaTimestamp);
+            const stat = fs.statSync(sessionFile);
+            const findSessionFileById = (adapter as any).findSessionFileById.bind(adapter);
+
+            const session = findSessionFileById(sessionId);
+
+            expect(session).not.toBeNull();
+            expect(session.birthtimeMs).toBe(stat.birthtimeMs);
+        });
     });
 
     describe('helper methods', () => {

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__/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;