tide-commander 1.199.0 → 1.199.2

package/dist/src/packages/server/claude/session-loader.js

@@ -3845,68 +3845,154 @@ function providerDisplayName(provider) {
         return 'Pi';
     return 'Claude';
 }
-function getProviderProcessPids(provider, execSync) {
-    const pattern = PROVIDER_PROCESS_PATTERNS[provider];
+const PROVIDER_PROCESS_REGEXES = Object.keys(PROVIDER_PROCESS_PATTERNS).map((provider) => ({
+    provider,
+    regex: new RegExp(PROVIDER_PROCESS_PATTERNS[provider]),
+}));
+/**
+ * How long a process snapshot is reused by callers that don't ask for a fresh
+ * one. The snapshot is what every per-agent lookup (orphan polling, perf
+ * metrics, PID resolution) needs, and those lookups come in bursts of one per
+ * agent — with hundreds of agents that used to mean hundreds of blocking
+ * `ps aux | grep` + `readlink` spawns back-to-back. One second of staleness is
+ * harmless for all of them (a process that just died fails `process.kill(pid, 0)`
+ * downstream anyway); kill paths pass `fresh: true`.
+ */
+const PROCESS_SNAPSHOT_TTL_MS = 1000;
+let processSnapshotCache = null;
+let processSnapshotInFlight = null;
+function normalizeCwd(cwd) {
+    return cwd.replace(/\/+$/, '');
+}
+function runCommand(file, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        const chunks = [];
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill('SIGKILL');
+            reject(new Error(`${file} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => chunks.push(chunk));
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`${file} exited with code ${code}`));
+                return;
+            }
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        });
+    });
+}
+/** Resolve a process's cwd without blocking: /proc readlink on Linux, lsof on macOS. */
+async function readProcessCwd(pid) {
     try {
-        const psOutput = execSync(`ps aux | grep -E "${pattern}" | grep -v grep | awk '{print $2}'`, {
-            encoding: 'utf-8',
-            timeout: 5000,
-        }).trim();
-        if (!psOutput) {
-            return [];
+        if (process.platform === 'darwin') {
+            const lsofOutput = await runCommand('lsof', ['-a', '-d', 'cwd', '-p', String(pid), '-Fn'], 2000);
+            const line = lsofOutput.split('\n').find((l) => l.startsWith('n'));
+            return line ? line.substring(1).trim() : null;
         }
-        return psOutput.split('\n').filter(p => p.trim());
+        return (await fs.promises.readlink(`/proc/${pid}/cwd`)).trim();
     }
     catch {
-        return [];
+        return null;
     }
 }
-function getProcessCwd(pid, execSync) {
-    try {
-        if (process.platform === 'darwin') {
-            const lsofOutput = execSync(`lsof -a -d cwd -p ${pid} -Fn 2>/dev/null | grep '^n'`, {
-                encoding: 'utf-8',
-                timeout: 2000,
-                shell: '/bin/bash',
-            }).trim();
-            if (!lsofOutput.startsWith('n')) {
-                return null;
+/**
+ * List every running provider CLI process (claude/codex/opencode/grok/pi) with
+ * its cwd, using ONE `ps aux` spawn plus one non-blocking cwd lookup per match.
+ * Matching runs against the full `ps aux` line, exactly like the former
+ * `ps aux | grep -E <pattern>` pipeline, so the provider patterns keep their
+ * meaning. Snapshots are memoized for PROCESS_SNAPSHOT_TTL_MS and concurrent
+ * callers share the in-flight promise; pass `fresh: true` to bypass both.
+ */
+export async function snapshotProviderProcesses(options = {}) {
+    if (process.platform === 'win32') {
+        return [];
+    }
+    const now = Date.now();
+    if (!options.fresh) {
+        if (processSnapshotCache && now - processSnapshotCache.takenAt < PROCESS_SNAPSHOT_TTL_MS) {
+            return processSnapshotCache.processes;
+        }
+        if (processSnapshotInFlight) {
+            return processSnapshotInFlight;
+        }
+    }
+    const work = (async () => {
+        let psOutput;
+        try {
+            psOutput = await runCommand('ps', ['aux'], 5000);
+        }
+        catch (err) {
+            log.error(' Failed to list processes with ps:', err);
+            return [];
+        }
+        const matches = [];
+        for (const line of psOutput.split('\n')) {
+            if (!line)
+                continue;
+            // A line may satisfy more than one provider pattern; keep it under each,
+            // as the former one-grep-per-provider pipeline did.
+            const providers = PROVIDER_PROCESS_REGEXES.filter(({ regex }) => regex.test(line));
+            if (providers.length === 0)
+                continue;
+            // `ps aux` columns: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
+            const pid = Number.parseInt(line.trim().split(/\s+/)[1] ?? '', 10);
+            if (!Number.isFinite(pid) || pid <= 0)
+                continue;
+            for (const { provider } of providers) {
+                matches.push({ pid, provider });
             }
-            return lsofOutput.substring(1);
         }
-        return execSync(`readlink /proc/${pid}/cwd`, {
-            encoding: 'utf-8',
-            timeout: 1000,
-        }).trim();
+        const processes = await Promise.all(matches.map(async ({ pid, provider }) => ({
+            pid,
+            provider,
+            cwd: await readProcessCwd(pid),
+        })));
+        processSnapshotCache = { takenAt: Date.now(), processes };
+        return processes;
+    })();
+    processSnapshotInFlight = work;
+    try {
+        return await work;
     }
-    catch {
-        return null;
+    finally {
+        if (processSnapshotInFlight === work) {
+            processSnapshotInFlight = null;
+        }
     }
 }
+/** First snapshot entry of `provider` whose cwd matches `cwd` (trailing slashes ignored). */
+function findProviderProcessInSnapshot(processes, cwd, provider) {
+    const normalizedCwd = normalizeCwd(cwd);
+    return processes.find((p) => p.provider === provider && p.cwd !== null && normalizeCwd(p.cwd) === normalizedCwd);
+}
 async function isProviderProcessRunningInCwd(cwd, provider) {
     // Only works on Linux/Unix/macOS
     if (process.platform === 'win32') {
         return false;
     }
     try {
-        const { execSync } = await import('child_process');
-        const pids = getProviderProcessPids(provider, execSync);
-        if (pids.length === 0) {
+        const match = findProviderProcessInSnapshot(await snapshotProviderProcesses(), cwd, provider);
+        if (!match) {
             return false;
         }
-        const normalizedCwd = cwd.replace(/\/+$/, '');
-        for (const pid of pids) {
-            const processCwd = getProcessCwd(pid, execSync);
-            if (!processCwd) {
-                continue;
-            }
-            const normalizedProcessCwd = processCwd.replace(/\/+$/, '');
-            if (normalizedProcessCwd === normalizedCwd) {
-                log.log(` Found ${providerDisplayName(provider)} process ${pid} running in ${cwd}`);
-                return true;
-            }
-        }
-        return false;
+        log.log(` Found ${providerDisplayName(provider)} process ${match.pid} running in ${cwd}`);
+        return true;
     }
     catch (err) {
         log.error(` Error checking for ${providerDisplayName(provider)} processes:`, err);
@@ -3918,26 +4004,7 @@ async function findProviderProcessPidInCwd(cwd, provider) {
         return undefined;
     }
     try {
-        const { execSync } = await import('child_process');
-        const pids = getProviderProcessPids(provider, execSync);
-        if (pids.length === 0) {
-            return undefined;
-        }
-        const normalizedCwd = cwd.replace(/\/+$/, '');
-        for (const pid of pids) {
-            const processCwd = getProcessCwd(pid, execSync);
-            if (!processCwd) {
-                continue;
-            }
-            const normalizedProcessCwd = processCwd.replace(/\/+$/, '');
-            if (normalizedProcessCwd === normalizedCwd) {
-                const numericPid = Number.parseInt(pid, 10);
-                if (Number.isFinite(numericPid) && numericPid > 0) {
-                    return numericPid;
-                }
-            }
-        }
-        return undefined;
+        return findProviderProcessInSnapshot(await snapshotProviderProcesses(), cwd, provider)?.pid;
     }
     catch (err) {
         log.error(` Error finding ${providerDisplayName(provider)} PID in ${cwd}:`, err);
@@ -3950,31 +4017,24 @@ async function killProviderProcessInCwd(cwd, provider) {
         return false;
     }
     try {
-        const { execSync } = await import('child_process');
-        const pids = getProviderProcessPids(provider, execSync);
-        if (pids.length === 0) {
-            return false;
-        }
-        const normalizedCwd = cwd.replace(/\/+$/, '');
-        for (const pid of pids) {
-            const processCwd = getProcessCwd(pid, execSync);
-            if (!processCwd) {
-                continue;
-            }
-            const normalizedProcessCwd = processCwd.replace(/\/+$/, '');
-            if (normalizedProcessCwd !== normalizedCwd) {
+        // Always look at live state here: killing on a stale snapshot could target
+        // a PID that was already reused.
+        const processes = await snapshotProviderProcesses({ fresh: true });
+        const normalizedCwd = normalizeCwd(cwd);
+        const label = providerDisplayName(provider);
+        for (const proc of processes) {
+            if (proc.provider !== provider || proc.cwd === null || normalizeCwd(proc.cwd) !== normalizedCwd) {
                 continue;
             }
-            const label = providerDisplayName(provider);
+            const pid = proc.pid;
             log.log(`🛑 Killing detached ${label} process ${pid} in ${cwd}`);
             try {
-                const numericPid = parseInt(pid, 10);
-                process.kill(numericPid, 'SIGTERM');
+                process.kill(pid, 'SIGTERM');
                 setTimeout(() => {
                     try {
-                        process.kill(numericPid, 0);
+                        process.kill(pid, 0);
                         log.log(`🛑 Force killing ${label} process ${pid}`);
-                        process.kill(numericPid, 'SIGKILL');
+                        process.kill(pid, 'SIGKILL');
                     }
                     catch {
                         // Process already dead, good

package/dist/src/packages/server/data/index.js

@@ -542,17 +542,50 @@ export function saveCustomAgentClasses(classes) {
         log.error(' Failed to save custom agent classes:', err);
     }
 }
+/**
+ * Parsed running-processes file, keyed on the file's (mtime, size) so repeat
+ * callers (per-agent PID lookups, the periodic per-provider persist) don't
+ * re-parse a ~150 KB JSON (it embeds `lastRequest` per process) on every call.
+ * The file is only rewritten by saveRunningProcesses/clearRunningProcesses, so
+ * a stat() is enough to detect staleness.
+ */
+let runningProcessesCache = null;
+let runningProcessesLoggedOnce = false;
 /**
  * Load running processes info from disk
  * Used on startup to detect orphaned processes from previous commander instance
  */
 export function loadRunningProcesses() {
     ensureDataDir();
+    let stat = null;
+    try {
+        stat = fs.statSync(RUNNING_PROCESSES_FILE);
+    }
+    catch {
+        stat = null;
+    }
+    if (stat && runningProcessesCache && runningProcessesCache.mtimeMs === stat.mtimeMs && runningProcessesCache.size === stat.size) {
+        return [...runningProcessesCache.processes];
+    }
     const data = safeReadJsonSync(RUNNING_PROCESSES_FILE, 'Running processes');
     if (data?.processes) {
-        log.log(` Loaded ${data.processes.length} running process records (from commander PID ${data.commanderPid})`);
-        return data.processes;
+        // The first load is a meaningful startup message; every later reload is
+        // just the periodic persist refreshing the file (was ~180 lines per
+        // /api/perf poll before the callers were batched — see runtime-service).
+        const message = ` Loaded ${data.processes.length} running process records (from commander PID ${data.commanderPid})`;
+        if (!runningProcessesLoggedOnce) {
+            runningProcessesLoggedOnce = true;
+            log.log(message);
+        }
+        else {
+            log.debug(message);
+        }
+        if (stat) {
+            runningProcessesCache = { mtimeMs: stat.mtimeMs, size: stat.size, processes: data.processes };
+        }
+        return [...data.processes];
     }
+    runningProcessesCache = null;
     return [];
 }
 /**

package/dist/src/packages/server/routes/perf.js

@@ -5,7 +5,8 @@
 import { Router } from 'express';
 import * as agentService from '../services/agent-service.js';
 import * as runtimeService from '../services/runtime-service.js';
-import { execSync } from 'child_process';
+import { execFile } from 'child_process';
+import * as fs from 'fs';
 import os from 'os';
 const router = Router();
 // Server start time for uptime calculation
@@ -34,27 +35,37 @@ export function recordRequestTiming(method, path, duration) {
         recentRequests.shift();
     }
 }
-function getProcessMemoryMB(pid) {
+/**
+ * Resident memory of a PID in MB. Reads /proc directly on Linux (no subprocess);
+ * falls back to an async `ps` elsewhere. Never blocks the event loop — this runs
+ * once per agent process on every perf poll.
+ */
+async function getProcessMemoryMB(pid) {
     try {
-        const status = execSync(`cat /proc/${pid}/status 2>/dev/null | grep VmRSS`, {
-            encoding: 'utf8',
-            timeout: 500,
-        });
+        const status = await fs.promises.readFile(`/proc/${pid}/status`, 'utf8');
         const match = status.match(/VmRSS:\s+(\d+)\s+kB/);
         if (match) {
             return Math.round(parseInt(match[1], 10) / 1024);
         }
     }
     catch {
-        try {
-            const psOutput = execSync(`ps -o rss= -p ${pid}`, { encoding: 'utf8', timeout: 500 });
-            const kB = parseInt(psOutput.trim(), 10);
-            if (!isNaN(kB))
-                return Math.round(kB / 1024);
-        }
-        catch {
-            // Process may not exist
-        }
+        // Not Linux, or the process is gone — try ps below.
+    }
+    try {
+        const psOutput = await new Promise((resolve, reject) => {
+            execFile('ps', ['-o', 'rss=', '-p', String(pid)], { encoding: 'utf8', timeout: 500 }, (err, stdout) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(stdout);
+            });
+        });
+        const kB = parseInt(psOutput.trim(), 10);
+        if (!isNaN(kB))
+            return Math.round(kB / 1024);
+    }
+    catch {
+        // Process may not exist
     }
     return undefined;
 }
@@ -75,26 +86,25 @@ router.get('/', async (_req, res) => {
         // Per-agent process info with memory
         const agentProcesses = [];
         const rawProcessInfo = [];
-        for (const agent of agents) {
-            try {
-                const info = await runtimeService.getAgentRuntimeProcessInfo(agent.id);
-                rawProcessInfo.push({
-                    id: agent.id,
-                    name: agent.name,
-                    status: agent.status,
-                    source: info.source,
-                    pid: info.pid,
-                });
-            }
-            catch {
-                rawProcessInfo.push({
-                    id: agent.id,
-                    name: agent.name,
-                    status: agent.status,
-                    source: 'none',
-                });
-            }
+        // One batched lookup: a single persisted-file read + a single process
+        // snapshot for all agents (the per-agent form spawned `ps` per agent).
+        let processInfos = [];
+        try {
+            processInfos = await runtimeService.getAgentRuntimeProcessInfoBatch(agents.map((agent) => agent.id));
+        }
+        catch {
+            processInfos = [];
         }
+        agents.forEach((agent, index) => {
+            const info = processInfos[index];
+            rawProcessInfo.push({
+                id: agent.id,
+                name: agent.name,
+                status: agent.status,
+                source: info?.source ?? 'none',
+                pid: info?.pid,
+            });
+        });
         // "discovered" PIDs are inferred by cwd and may map multiple agents to one process.
         // Only show discovered PID/memory when that discovered PID is unique in this snapshot.
         const discoveredPidCounts = new Map();
@@ -104,22 +114,23 @@ router.get('/', async (_req, res) => {
             }
             discoveredPidCounts.set(info.pid, (discoveredPidCounts.get(info.pid) ?? 0) + 1);
         }
-        for (const info of rawProcessInfo) {
+        const memoryReads = rawProcessInfo.map(async (info) => {
             const isReliableSource = info.source === 'active' || info.source === 'persisted';
             const isUniqueDiscoveredPid = info.source === 'discovered' &&
                 info.pid !== undefined &&
                 (discoveredPidCounts.get(info.pid) ?? 0) === 1;
             const shouldShowProcessMetrics = isReliableSource || isUniqueDiscoveredPid;
             const pid = shouldShowProcessMetrics ? info.pid : undefined;
-            const memMB = pid ? getProcessMemoryMB(pid) : undefined;
-            agentProcesses.push({
+            const memMB = pid ? await getProcessMemoryMB(pid) : undefined;
+            return {
                 id: info.id,
                 name: info.name,
                 status: info.status,
                 memoryMB: memMB,
                 pid,
-            });
-        }
+            };
+        });
+        agentProcesses.push(...(await Promise.all(memoryReads)));
         // Request latency stats
         const last30s = recentRequests.filter(r => Date.now() - r.timestamp < 30000);
         const avgLatency = last30s.length > 0

package/dist/src/packages/server/services/git-watch-service.js

@@ -33,6 +33,10 @@ const MAX_WATCHED_PATHS = 200;
 const MAX_STATUS_FILES = 2_000;
 const subscriptions = new Map();
 const cache = new Map();
+// Last over-cap file count warned per dir, so the 10 s poll doesn't repeat the
+// same "has N changed files" warning forever (it used to log ~12 lines/min per
+// big repo); re-warn only when the count changes.
+const overCapWarned = new Map();
 let pollTimer = null;
 let pollInFlight = false;
 async function git(args, cwd) {
@@ -162,7 +166,13 @@ async function computeStatus(dirPath) {
         log.error(`[GitWatch] git status failed for ${dirPath}:`, err);
     }
     if (totalFiles > MAX_STATUS_FILES) {
-        log.warn(`[GitWatch] ${dirPath} has ${totalFiles} changed files — pushing the first ${MAX_STATUS_FILES}`);
+        if (overCapWarned.get(dirPath) !== totalFiles) {
+            overCapWarned.set(dirPath, totalFiles);
+            log.warn(`[GitWatch] ${dirPath} has ${totalFiles} changed files — pushing the first ${MAX_STATUS_FILES}`);
+        }
+    }
+    else {
+        overCapWarned.delete(dirPath);
     }
     let branch = null;
     try {
@@ -255,8 +265,10 @@ async function pollOnce() {
         const union = watchedUnion();
         // Drop cache entries nobody watches anymore.
         for (const key of cache.keys()) {
-            if (!union.has(key))
+            if (!union.has(key)) {
                 cache.delete(key);
+                overCapWarned.delete(key);
+            }
         }
         // Sequential on purpose: keeps the git subprocess load flat no matter how
         // many directories are watched. Local git status is fast (~tens of ms).

package/dist/src/packages/server/services/runtime-service.js

@@ -2,7 +2,7 @@
  * Runtime Service
  * Manages Claude/Codex runtime runners and command execution
  */
-import { isClaudeProcessRunningInCwd, isCodexProcessRunningInCwd, isOpencodeProcessRunningInCwd, isGrokProcessRunningInCwd, isPiProcessRunningInCwd, killClaudeProcessInCwd, killCodexProcessInCwd, killOpencodeProcessInCwd, killGrokProcessInCwd, killPiProcessInCwd, findClaudeProcessPidInCwd, findCodexProcessPidInCwd, findOpencodeProcessPidInCwd, findGrokProcessPidInCwd, findPiProcessPidInCwd, } from '../claude/session-loader.js';
+import { isClaudeProcessRunningInCwd, isCodexProcessRunningInCwd, isOpencodeProcessRunningInCwd, isGrokProcessRunningInCwd, isPiProcessRunningInCwd, killClaudeProcessInCwd, killCodexProcessInCwd, killOpencodeProcessInCwd, killGrokProcessInCwd, killPiProcessInCwd, snapshotProviderProcesses, } from '../claude/session-loader.js';
 import * as agentService from './agent-service.js';
 import { ModelFallbackTracker } from '../../shared/model-fallback.js';
 import { toModelFallbackEvent } from '../claude/types.js';
@@ -97,7 +97,10 @@ function emit(event, ...args) {
     const listenerCount = listeners?.size || 0;
     if (event === 'event') {
         const standardEvent = args[1];
-        log.log(`[EMIT] event: type=${standardEvent?.type} tool=${standardEvent?.toolName || 'n/a'} listeners=${listenerCount}`);
+        // debug-level: fires once per streaming delta (text/thinking) — at log
+        // level it was ~65k lines per afternoon, and every console.log under pm2
+        // is a synchronous pipe write on Linux.
+        log.debug(`[EMIT] event: type=${standardEvent?.type} tool=${standardEvent?.toolName || 'n/a'} listeners=${listenerCount}`);
     }
     if (listeners) {
         listeners.forEach((listener) => listener(...args));
@@ -325,53 +328,96 @@ export function isAgentRunning(agentId) {
  * Prefers in-memory active runner state, then falls back to persisted crash-recovery state.
  */
 export async function getAgentRuntimeProcessInfo(agentId) {
-    // Check all in-memory runners first so provider drift/migration doesn't hide live processes.
+    const [info] = await getAgentRuntimeProcessInfoBatch([agentId]);
+    return info ?? { isRunning: false, source: 'none' };
+}
+/**
+ * Batch variant of getAgentRuntimeProcessInfo: resolves every agent against
+ * ONE read of the persisted crash-recovery file and ONE process snapshot
+ * (a single `ps` + cwd lookups), instead of re-reading the file and spawning
+ * `ps aux | grep` + `readlink` per agent. With hundreds of agents the per-agent
+ * form made a single /api/perf poll take ~30 s of mostly event-loop-blocking
+ * work; this one is a handful of milliseconds after the snapshot.
+ *
+ * Result order matches `agentIds`. Unknown agents resolve to `{ source: 'none' }`.
+ */
+export async function getAgentRuntimeProcessInfoBatch(agentIds) {
+    // 1. In-memory runner state, gathered once across all runners so provider
+    //    drift/migration doesn't hide live processes. First runner wins per agent
+    //    (same as the former sequential scan).
+    const activePids = new Map();
     for (const runner of runners.values()) {
         const runnerWithState = runner;
         if (!runnerWithState.getActiveProcessesState) {
             continue;
         }
-        const state = runnerWithState.getActiveProcessesState().find((proc) => proc.agentId === agentId);
-        if (state?.pid) {
-            return {
-                pid: state.pid,
-                isRunning: true,
-                source: 'active',
-            };
+        for (const state of runnerWithState.getActiveProcessesState()) {
+            if (state.pid && !activePids.has(state.agentId)) {
+                activePids.set(state.agentId, state.pid);
+            }
         }
     }
-    const persistedProcess = loadRunningProcesses().find((proc) => proc.agentId === agentId);
-    if (persistedProcess?.pid && isProcessRunning(persistedProcess.pid)) {
-        return {
-            pid: persistedProcess.pid,
-            isRunning: true,
-            source: 'persisted',
-        };
+    const results = [];
+    const pendingDiscovery = [];
+    // Persisted crash-recovery state: the file is mtime-cached by loadRunningProcesses,
+    // but read it once per batch regardless so all agents see the same view.
+    let persistedByAgent = null;
+    const getPersistedPid = (agentId) => {
+        if (!persistedByAgent) {
+            persistedByAgent = new Map();
+            for (const proc of loadRunningProcesses()) {
+                if (proc.pid && !persistedByAgent.has(proc.agentId)) {
+                    persistedByAgent.set(proc.agentId, proc.pid);
+                }
+            }
+        }
+        return persistedByAgent.get(agentId);
+    };
+    for (const agentId of agentIds) {
+        const activePid = activePids.get(agentId);
+        if (activePid) {
+            results.push({ pid: activePid, isRunning: true, source: 'active' });
+            continue;
+        }
+        const persistedPid = getPersistedPid(agentId);
+        if (persistedPid && isProcessRunning(persistedPid)) {
+            results.push({ pid: persistedPid, isRunning: true, source: 'persisted' });
+            continue;
+        }
+        results.push({ isRunning: false, source: 'none' });
+        const agent = agentService.getAgent(agentId);
+        if (agent?.cwd) {
+            pendingDiscovery.push({ index: results.length - 1, cwd: agent.cwd, provider: agent.provider ?? 'claude' });
+        }
     }
-    const agent = agentService.getAgent(agentId);
-    if (agent?.cwd) {
-        const provider = agent.provider ?? 'claude';
-        const discoveredPid = provider === 'codex'
-            ? await findCodexProcessPidInCwd(agent.cwd)
-            : provider === 'opencode'
-                ? await findOpencodeProcessPidInCwd(agent.cwd)
-                : provider === 'grok'
-                    ? await findGrokProcessPidInCwd(agent.cwd)
-                    : provider === 'pi'
-                        ? await findPiProcessPidInCwd(agent.cwd)
-                        : await findClaudeProcessPidInCwd(agent.cwd);
-        if (discoveredPid && isProcessRunning(discoveredPid)) {
-            return {
-                pid: discoveredPid,
-                isRunning: true,
-                source: 'discovered',
-            };
+    // 2. OS-level discovery by cwd — one snapshot for every agent that needs it.
+    if (pendingDiscovery.length > 0) {
+        let processes = [];
+        try {
+            processes = await snapshotProviderProcesses();
+        }
+        catch (err) {
+            log.error('Failed to snapshot provider processes:', err);
+        }
+        const normalizeCwd = (cwd) => cwd.replace(/\/+$/, '');
+        const byProviderAndCwd = new Map();
+        for (const proc of processes) {
+            if (proc.cwd === null)
+                continue;
+            const key = `${proc.provider}\0${normalizeCwd(proc.cwd)}`;
+            // First match wins, like the former "first pid in ps order" lookup.
+            if (!byProviderAndCwd.has(key)) {
+                byProviderAndCwd.set(key, proc.pid);
+            }
+        }
+        for (const { index, cwd, provider } of pendingDiscovery) {
+            const discoveredPid = byProviderAndCwd.get(`${provider}\0${normalizeCwd(cwd)}`);
+            if (discoveredPid && isProcessRunning(discoveredPid)) {
+                results[index] = { pid: discoveredPid, isRunning: true, source: 'discovered' };
+            }
         }
     }
-    return {
-        isRunning: false,
-        source: 'none',
-    };
+    return results;
 }
 /**
  * Check if there's an orphaned process for this agent