@ai-devkit/agent-manager 0.19.0 → 0.20.0

package/src/adapters/CodexAdapter.ts

@@ -215,13 +215,14 @@ export class CodexAdapter implements AgentAdapter {
 
                 const stat = safeStat(filePath);
                 if (!stat) continue;
+                const metaTimestampMs = this.parseMetaTimestampMs(parsed.payload?.timestamp);
 
                 return {
                     sessionId,
                     filePath,
                     projectDir: path.dirname(filePath),
-                    birthtimeMs: stat.birthtimeMs,
-                    resolvedCwd: parsed.payload.cwd || '',
+                    birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,
+                    resolvedCwd: parsed.payload?.cwd || '',
                 };
             } catch {
                 continue;
@@ -290,6 +291,10 @@ export class CodexAdapter implements AgentAdapter {
                     const parsed = JSON.parse(firstLine);
                     if (parsed.type === 'session_meta') {
                         file.resolvedCwd = parsed.payload?.cwd || '';
+                        const metaTimestampMs = this.parseMetaTimestampMs(parsed.payload?.timestamp);
+                        if (metaTimestampMs !== null) {
+                            file.birthtimeMs = metaTimestampMs;
+                        }
                     }
                 }
             } catch {
@@ -468,6 +473,16 @@ export class CodexAdapter implements AgentAdapter {
         return Number.isNaN(timestamp.getTime()) ? null : timestamp;
     }
 
+    private parseMetaTimestampMs(value?: string): number | null {
+        if (typeof value !== 'string') return null;
+
+        const timestamp = this.parseTimestamp(value);
+        if (!timestamp) return null;
+
+        const timestampMs = timestamp.getTime();
+        return Number.isFinite(timestampMs) ? timestampMs : null;
+    }
+
     private determineStatus(session: CodexSession): AgentStatus {
         const diffMs = Date.now() - session.lastActive.getTime();
         const diffMinutes = diffMs / 60000;

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[] {

package/src/adapters/GeminiCliAdapter.ts

@@ -22,11 +22,11 @@ import type {
     ListSessionsOptions,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { listAgentProcesses, enrichProcesses, findWrapperProcess, findWrapperProcessPids } from '../utils/process.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import type { SessionFile } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
-import { AgentRegistry } from '../utils/AgentRegistry.js';
+import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
 
 /**
  * A single Gemini CLI message content part. Mirrors the `{text?: string}`
@@ -117,40 +117,70 @@ export class GeminiCliAdapter implements AgentAdapter {
         const processes = nodeProcesses.filter((proc) => this.isGeminiExecutable(proc.command));
         if (processes.length === 0) return [];
 
-        const { cachedAgents, remaining } = this.tryRegistryCache(processes);
+        const wrapperPids = findWrapperProcessPids(processes);
+        const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
         if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
 
-        const { sessions, contentCache } = this.discoverSessions(remaining);
+        const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
+        const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+
+        const { sessions, contentCache } = this.discoverSessions(candidateProcesses);
         if (sessions.length === 0) {
+            const processOnlyAgents = candidateProcesses.map((proc) => {
+                const agent = this.mapProcessOnlyAgent(proc);
+                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+                return agent;
+            });
+
             return this.deduplicateSessionAgents([
                 ...cachedAgents,
-                ...remaining.map((p) => this.mapProcessOnlyAgent(p)),
+                ...processOnlyAgents,
             ]);
         }
 
-        const matches = matchProcessesToSessions(remaining, sessions);
+        const matches = matchProcessesToSessions(candidateProcesses, sessions);
         const matchedPids = new Set(matches.map((m) => m.process.pid));
+        const matchedProcesses: ProcessInfo[] = [];
         const agents: AgentInfo[] = [];
 
         for (const match of matches) {
             const cachedContent = contentCache.get(match.session.filePath);
             const sessionData = this.parseSession(cachedContent, match.session.filePath);
             if (sessionData) {
-                agents.push(this.mapSessionToAgent(sessionData, match.process, match.session.filePath));
+                const agent = this.mapSessionToAgent(sessionData, match.process, match.session.filePath);
+                this.applyWrapperRegistryName(agent, match.process, processes, registryEntriesByPid);
+                agents.push(agent);
+                matchedProcesses.push(match.process);
             } else {
                 matchedPids.delete(match.process.pid);
             }
         }
 
-        for (const proc of remaining) {
-            if (!matchedPids.has(proc.pid)) {
-                agents.push(this.mapProcessOnlyAgent(proc));
+        const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
+        for (const proc of candidateProcesses) {
+            if (!matchedPids.has(proc.pid) && !matchedWrapperPids.has(proc.pid)) {
+                const agent = this.mapProcessOnlyAgent(proc);
+                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+                agents.push(agent);
             }
         }
 
         return this.deduplicateSessionAgents([...cachedAgents, ...agents]);
     }
 
+    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;
+        }
+    }
+
     private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
         const bySession = new Map<string, AgentInfo>();
         const result: AgentInfo[] = [];
@@ -187,7 +217,7 @@ export class GeminiCliAdapter implements AgentAdapter {
         return null;
     }
 
-    private tryRegistryCache(processes: ProcessInfo[]): {
+    private tryRegistryCache(processes: ProcessInfo[], wrapperPids: Set<number>): {
         cachedAgents: AgentInfo[];
         remaining: ProcessInfo[];
     } {
@@ -198,6 +228,7 @@ export class GeminiCliAdapter implements AgentAdapter {
         for (const proc of processes) {
             const entry = byPid.get(proc.pid);
             if (
+                wrapperPids.has(proc.pid) ||
                 !entry ||
                 entry.type !== this.type ||
                 !entry.sessionFilePath ||

package/src/utils/process.ts

@@ -12,10 +12,10 @@ import type { ProcessInfo } from '../adapters/AgentAdapter.js';
 /**
  * List running processes matching an agent executable name.
  *
- * Uses `ps aux` then filters in JS for exact executable basename match.
+ * Uses `ps -axo` then filters in JS for exact executable basename match.
  * This avoids shell pipelines and string interpolation.
  *
- * Returned ProcessInfo has pid, command, tty populated.
+ * Returned ProcessInfo has pid, ppid, command, tty populated.
  * cwd and startTime are NOT populated — call enrichProcesses() to fill them.
  */
 export function listAgentProcesses(namePattern: string): ProcessInfo[] {
@@ -25,7 +25,7 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
     }
 
     try {
-        const output = execFileSync('ps', ['aux'], { encoding: 'utf-8' });
+        const output = execFileSync('ps', ['-axo', 'pid=,ppid=,tty=,command='], { encoding: 'utf-8' });
 
         const lowerPattern = namePattern.toLowerCase();
         const processes: ProcessInfo[] = [];
@@ -33,14 +33,15 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
         for (const line of output.trim().split('\n')) {
             if (!line.trim()) continue;
 
-            const parts = line.trim().split(/\s+/);
-            if (parts.length < 11) continue;
+            const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+            if (!match) continue;
 
-            const pid = parseInt(parts[1], 10);
-            if (Number.isNaN(pid)) continue;
+            const pid = parseInt(match[1], 10);
+            const ppid = parseInt(match[2], 10);
+            if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
 
-            const tty = parts[6];
-            const command = parts.slice(10).join(' ');
+            const tty = match[3];
+            const command = match[4];
 
             // Check that the executable basename matches exactly
             const executable = command.trim().split(/\s+/)[0] || '';
@@ -53,6 +54,7 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
 
             processes.push({
                 pid,
+                ppid,
                 command,
                 cwd: '',
                 tty: ttyShort,
@@ -177,6 +179,59 @@ export function enrichProcesses(processes: ProcessInfo[]): ProcessInfo[] {
     return processes;
 }
 
+function isSameTerminalProcess(proc: ProcessInfo, matched: ProcessInfo): boolean {
+    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 === '');
+}
+
+function matchesProcessIdentity(proc: ProcessInfo, matched: ProcessInfo): boolean {
+    return proc.pid === matched.pid || isSameTerminalProcess(proc, matched);
+}
+
+export function findWrapperProcess(
+    processes: ProcessInfo[],
+    child: ProcessInfo,
+): ProcessInfo | undefined {
+    return processes.find((proc) => (
+        proc.pid !== child.pid &&
+        child.ppid === proc.pid &&
+        matchesProcessIdentity(proc, child)
+    ));
+}
+
+/**
+ * Find parent wrapper processes that should not be reported as separate agents.
+ *
+ * A process is considered a wrapper when it is the parent of another candidate
+ * agent process in the same terminal/worktree, or when it points at the same
+ * terminal/worktree as an already session-matched process.
+ */
+export function findWrapperProcessPids(
+    processes: ProcessInfo[],
+    matchedProcesses: ProcessInfo[] = [],
+): Set<number> {
+    const wrappers = new Set<number>();
+
+    for (const child of processes) {
+        const wrapper = findWrapperProcess(processes, child);
+        if (wrapper) {
+            wrappers.add(wrapper.pid);
+        }
+    }
+
+    for (const proc of processes) {
+        if (matchedProcesses.some((matched) => (
+            proc.pid !== matched.pid && isSameTerminalProcess(proc, matched)
+        ))) {
+            wrappers.add(proc.pid);
+        }
+    }
+
+    return wrappers;
+}
+
 /**
  * Get the TTY device for a specific process
  */