ragent-cli 1.11.11 → 1.11.12

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.11.11",
+      version: "1.11.12",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -1991,20 +1991,43 @@ function setBlock(turns, turnId, blockId, block) {
   };
 }
 var MAX_SNAPSHOT_TURNS = 1e3;
+var MAX_SNAPSHOT_SIZE_CHARS = 45e4;
 function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
-  if (snapshot.turnOrder.length <= maxTurns) return snapshot;
-  const keptOrder = snapshot.turnOrder.slice(-maxTurns);
-  const keptTurns = {};
-  for (const id of keptOrder) {
-    if (snapshot.turns[id]) {
-      keptTurns[id] = snapshot.turns[id];
+  let currentSnapshot = snapshot;
+  if (currentSnapshot.turnOrder.length > maxTurns) {
+    const keptOrder = currentSnapshot.turnOrder.slice(-maxTurns);
+    const keptTurns = {};
+    for (const id of keptOrder) {
+      if (currentSnapshot.turns[id]) {
+        keptTurns[id] = currentSnapshot.turns[id];
+      }
+    }
+    currentSnapshot = {
+      ...currentSnapshot,
+      turnOrder: keptOrder,
+      turns: keptTurns
+    };
+  }
+  let serialized = JSON.stringify(currentSnapshot);
+  if (serialized.length <= MAX_SNAPSHOT_SIZE_CHARS) {
+    return currentSnapshot;
+  }
+  while (currentSnapshot.turnOrder.length > 1 && serialized.length > MAX_SNAPSHOT_SIZE_CHARS) {
+    const keptOrder = currentSnapshot.turnOrder.slice(1);
+    const keptTurns = {};
+    for (const id of keptOrder) {
+      if (currentSnapshot.turns[id]) {
+        keptTurns[id] = currentSnapshot.turns[id];
+      }
     }
+    currentSnapshot = {
+      ...currentSnapshot,
+      turnOrder: keptOrder,
+      turns: keptTurns
+    };
+    serialized = JSON.stringify(currentSnapshot);
   }
-  return {
-    ...snapshot,
-    turnOrder: keptOrder,
-    turns: keptTurns
-  };
+  return currentSnapshot;
 }
 
 // src/native-stream-manager.ts
@@ -2541,6 +2564,8 @@ function releaseSessionSource(sessionId) {
 
 // src/transcript-watcher.ts
 var log7 = createLogger("transcript-watcher");
+var cachedTicksPerSecond = null;
+var transcriptDiscoveryCache = /* @__PURE__ */ new Map();
 var ClaudeCodeParser = class {
   name = "claude-code";
   /** Maps tool_use id → tool name for matching results back to tools. */
@@ -3054,6 +3079,13 @@ function discoverTranscriptForPid(pid, agentType) {
   }
 }
 function listChildPids(pid) {
+  if (os3.platform() !== "darwin") {
+    try {
+      const content = fs2.readFileSync(`/proc/${pid}/task/${pid}/children`, "utf8");
+      return content.trim().split(/\s+/).map((value) => parseInt(value, 10)).filter((value) => Number.isFinite(value) && value > 0);
+    } catch {
+    }
+  }
   try {
     return (0, import_child_process2.execFileSync)("pgrep", ["-P", String(pid)], {
       encoding: "utf-8",
@@ -3064,6 +3096,16 @@ function listChildPids(pid) {
   }
 }
 function getProcessCommand(pid) {
+  if (os3.platform() !== "darwin") {
+    try {
+      const raw = fs2.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+      const parts = raw.split("\0").filter(Boolean);
+      if (parts.length > 0) {
+        return parts.join(" ");
+      }
+    } catch {
+    }
+  }
   try {
     return (0, import_child_process2.execFileSync)("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf-8",
@@ -3105,10 +3147,13 @@ function getProcessStartEpochMs(pid) {
     const bootLine = procStat.split("\n").find((line) => line.startsWith("btime "));
     const bootSeconds = Number(bootLine?.split(/\s+/)[1]);
     if (!Number.isFinite(bootSeconds) || bootSeconds <= 0) return null;
-    const ticksPerSecond = Number((0, import_child_process2.execFileSync)("getconf", ["CLK_TCK"], {
-      encoding: "utf-8",
-      timeout: 3e3
-    }).trim());
+    if (cachedTicksPerSecond === null) {
+      cachedTicksPerSecond = Number((0, import_child_process2.execFileSync)("getconf", ["CLK_TCK"], {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim());
+    }
+    const ticksPerSecond = cachedTicksPerSecond;
     if (!Number.isFinite(ticksPerSecond) || ticksPerSecond <= 0) return null;
     return (bootSeconds + startTicks / ticksPerSecond) * 1e3;
   } catch {
@@ -3254,29 +3299,66 @@ function discoverAntigravityTranscriptFromHome(pid, minMtimeMs) {
   const brainDir = path2.join(userHome, ".gemini", "antigravity-cli", "brain");
   if (!fs2.existsSync(brainDir)) return null;
   const matches = [];
-  const stack = [brainDir];
-  let visited = 0;
-  while (stack.length > 0 && visited < 3e3) {
-    const current = stack.pop();
-    if (!current) continue;
-    visited++;
-    let entries;
-    try {
-      entries = fs2.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(fullPath);
-      } else if (entry.isFile() && entry.name === "transcript.jsonl") {
-        matches.push(fullPath);
+  try {
+    const folders = fs2.readdirSync(brainDir, { withFileTypes: true });
+    for (const folder of folders) {
+      if (folder.isDirectory()) {
+        const transcriptPath = path2.join(brainDir, folder.name, ".system_generated", "logs", "transcript.jsonl");
+        if (fs2.existsSync(transcriptPath)) {
+          matches.push(transcriptPath);
+        }
       }
     }
+  } catch {
   }
   return getNewestPath(matches, { minMtimeMs });
 }
+function discoverAntigravityViaCwd(paneCwd, pid) {
+  const userHome = resolveUserHome(pid);
+  if (!userHome) return null;
+  const historyFile = path2.join(userHome, ".gemini", "antigravity-cli", "history.jsonl");
+  if (!fs2.existsSync(historyFile)) return null;
+  let targetCwd = paneCwd;
+  try {
+    targetCwd = fs2.realpathSync(paneCwd);
+  } catch {
+  }
+  try {
+    const content = fs2.readFileSync(historyFile, "utf-8");
+    const lines = content.split("\n").filter(Boolean).reverse();
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.workspace) {
+          let entryCwd = entry.workspace;
+          try {
+            entryCwd = fs2.realpathSync(entry.workspace);
+          } catch {
+          }
+          if (entryCwd === targetCwd && entry.conversationId) {
+            const transcriptPath = path2.join(
+              userHome,
+              ".gemini",
+              "antigravity-cli",
+              "brain",
+              entry.conversationId,
+              ".system_generated",
+              "logs",
+              "transcript.jsonl"
+            );
+            if (fs2.existsSync(transcriptPath)) {
+              return transcriptPath;
+            }
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 function discoverViaCwd(paneCwd, pid, minMtimeMs) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
@@ -3296,31 +3378,72 @@ function discoverViaCwd(paneCwd, pid, minMtimeMs) {
     return null;
   }
 }
-function discoverTranscriptFile(sessionId, agentType) {
+function discoverTranscriptFile(sessionId, agentType, forceRefresh = false) {
+  const now2 = Date.now();
+  const cacheKey = `${sessionId}:${agentType || ""}`;
+  if (!forceRefresh) {
+    const cached = transcriptDiscoveryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now2) {
+      return cached.value;
+    }
+  }
+  const result = discoverTranscriptFileImpl(sessionId, agentType);
+  const isProcessSession = sessionId.startsWith("process:");
+  const ttl = result ? isProcessSession ? 3600 * 1e3 : 5e3 : 5e3;
+  transcriptDiscoveryCache.set(cacheKey, {
+    value: result,
+    expiresAt: Date.now() + ttl
+  });
+  return result;
+}
+function discoverTranscriptFileImpl(sessionId, agentType) {
   const processPid = parseProcessPid(sessionId);
   if (processPid) {
+    const t0 = performance.now();
     const procResult = discoverViaProc(processPid, agentType);
-    if (procResult) return procResult;
+    if (procResult) {
+      console.log(`[DISCOVER] discoverViaProc found file for PID ${processPid} in ${(performance.now() - t0).toFixed(2)} ms`);
+      return procResult;
+    }
     if (agentType === "Claude Code") {
+      const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
       const cwdResult = discoverViaProcessCwd(processPid, startMs ? startMs - 6e4 : void 0);
+      console.log(`[DISCOVER] Claude Code discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (cwdResult) return cwdResult;
     }
     if (agentType === "Codex CLI") {
+      const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
       const command = getProcessCommand(processPid);
       if (commandMatchesAgent(command, agentType)) {
         const codexResult = discoverCodexTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0);
+        console.log(`[DISCOVER] Codex CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
         if (codexResult) return codexResult;
       }
     }
     if (agentType === "Gemini CLI") {
+      const t1 = performance.now();
       const geminiResult = discoverGeminiTranscriptFromHome(processPid);
+      console.log(`[DISCOVER] Gemini CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (geminiResult) return geminiResult;
     }
     if (agentType === "Antigravity CLI") {
+      const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
+      try {
+        const processCwd = fs2.readlinkSync(`/proc/${processPid}/cwd`);
+        if (processCwd) {
+          const cwdResult = discoverAntigravityViaCwd(processCwd, processPid);
+          if (cwdResult) {
+            console.log(`[DISCOVER] Antigravity CLI discovery (CWD path) for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
+            return cwdResult;
+          }
+        }
+      } catch {
+      }
       const antigravityResult = discoverAntigravityTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0);
+      console.log(`[DISCOVER] Antigravity CLI discovery (home path) for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (antigravityResult) return antigravityResult;
     }
     return null;
@@ -3380,6 +3503,34 @@ function discoverTranscriptFile(sessionId, agentType) {
     if (agentType === "Gemini CLI") {
       return discoverGeminiTranscriptFromHome(panePid ?? void 0);
     }
+    if (agentType === "Antigravity CLI") {
+      const agentInfos = panePid ? findAgentProcessInfos(panePid, agentType) : [];
+      for (const info of agentInfos) {
+        if (info.cwd) {
+          const cwdResult = discoverAntigravityViaCwd(info.cwd, info.pid);
+          if (cwdResult) return cwdResult;
+        }
+      }
+      try {
+        const paneCwd = (0, import_child_process2.execFileSync)(
+          "tmux",
+          ["display-message", "-t", paneTarget, "-p", "#{pane_current_path}"],
+          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+        ).trim();
+        if (paneCwd) {
+          const cwdResult = discoverAntigravityViaCwd(paneCwd, panePid ?? void 0);
+          if (cwdResult) return cwdResult;
+        }
+      } catch {
+      }
+      const newestForAgent = getNewestPath(
+        agentInfos.map((info) => discoverAntigravityTranscriptFromHome(
+          info.pid,
+          info.startEpochMs ? info.startEpochMs - 6e4 : void 0
+        )).filter((value) => Boolean(value))
+      );
+      if (newestForAgent) return newestForAgent;
+    }
     return null;
   }
   return null;
@@ -3695,7 +3846,7 @@ var TranscriptWatcherManager = class {
     const existing = this.active.get(sessionId);
     let replacingExisting = false;
     if (existing) {
-      const newPath = discoverTranscriptFile(sessionId, agentType);
+      const newPath = discoverTranscriptFile(sessionId, agentType, true);
       const agentChanged = existing.agentType !== requestedAgentType;
       const pathChanged = Boolean(newPath && newPath !== existing.filePath);
       const existingPathGone = !fs2.existsSync(existing.filePath);
@@ -3720,7 +3871,7 @@ var TranscriptWatcherManager = class {
       this.cancelEnableRetry(sessionId);
       return { ok: false, reason: "unsupported_agent" };
     }
-    const filePath = discoverTranscriptFile(sessionId, agentType);
+    const filePath = discoverTranscriptFile(sessionId, agentType, isRetry || replacingExisting);
     if (!filePath) {
       log7.info("no transcript file found", { sessionId });
       this.armEnableRetry(sessionId, agentType);
@@ -3846,7 +3997,7 @@ var TranscriptWatcherManager = class {
         this.stopRediscovery(sessionId);
         return;
       }
-      const newPath = discoverTranscriptFile(sessionId, agentType);
+      const newPath = discoverTranscriptFile(sessionId, agentType, true);
       if (!newPath || newPath === session.filePath) return;
       log7.info("transcript file changed", { sessionId, newPath });
       session.watcher.stop();
@@ -9524,6 +9675,39 @@ function resolveRuntimeTranscriptSource(sessionId) {
 // src/sessions.ts
 var isMac = os5.platform() === "darwin";
 var MARKDOWN_AGENT_TYPES = /* @__PURE__ */ new Set(["Claude Code", "Codex CLI", "Gemini CLI", "Antigravity CLI"]);
+var isTmuxAvailable = null;
+var isScreenAvailable = null;
+var isZellijAvailable = null;
+async function checkTmuxAvailable() {
+  if (isTmuxAvailable !== null) return isTmuxAvailable;
+  try {
+    await execAsync("tmux -V");
+    isTmuxAvailable = true;
+  } catch {
+    isTmuxAvailable = false;
+  }
+  return isTmuxAvailable;
+}
+async function checkScreenAvailable() {
+  if (isScreenAvailable !== null) return isScreenAvailable;
+  try {
+    await execAsync("screen -v");
+    isScreenAvailable = true;
+  } catch {
+    isScreenAvailable = false;
+  }
+  return isScreenAvailable;
+}
+async function checkZellijAvailable() {
+  if (isZellijAvailable !== null) return isZellijAvailable;
+  try {
+    await execAsync("zellij --version");
+    isZellijAvailable = true;
+  } catch {
+    isZellijAvailable = false;
+  }
+  return isZellijAvailable;
+}
 function getProcessStartTime(pid) {
   if (isMac) return null;
   try {
@@ -9540,7 +9724,38 @@ function getProcessStartTime(pid) {
 function collectStartTimes(pids) {
   return pids.map((pid) => getProcessStartTime(pid) ?? 0);
 }
-async function detectVscodeEnvironment(pid) {
+async function getProcessTable() {
+  try {
+    const raw = await execAsync("ps axo pid,ppid,tty,stat,comm,args");
+    const rows = [];
+    const lines = raw.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (!trimmed) continue;
+      if (i === 0 && /^\s*PID\b/i.test(lines[i])) continue;
+      const parts = trimmed.split(/\s+/);
+      if (parts.length < 6) continue;
+      const pid = Number(parts[0]);
+      const ppid = Number(parts[1]);
+      const tty = parts[2];
+      const stat = parts[3];
+      const comm = parts[4];
+      const args = parts.slice(5).join(" ");
+      rows.push({
+        pid,
+        ppid: Number.isFinite(ppid) ? ppid : 0,
+        tty,
+        stat,
+        comm,
+        args
+      });
+    }
+    return rows;
+  } catch {
+    return [];
+  }
+}
+async function detectVscodeEnvironment(pid, processByPid) {
   if (!isMac) {
     try {
       const environ = fs4.readFileSync(`/proc/${pid}/environ`, "utf8");
@@ -9550,17 +9765,36 @@ async function detectVscodeEnvironment(pid) {
     } catch {
     }
   }
-  try {
-    const raw = await execAsync(`ps -p ${pid} -o ppid=`);
-    const ppid = Number(raw.trim());
-    if (ppid > 1) {
-      const parentInfo = await execAsync(`ps -p ${ppid} -o comm=`);
-      const parentComm = parentInfo.trim().toLowerCase();
-      if (parentComm === "code" || parentComm === "code-server") {
-        return true;
+  if (!processByPid || processByPid.size === 0) {
+    try {
+      const raw = await execAsync(`ps -p ${pid} -o ppid=`);
+      const ppid = Number(raw.trim());
+      if (ppid > 1) {
+        const parentInfo = await execAsync(`ps -p ${ppid} -o comm=`);
+        const parentComm = parentInfo.trim().toLowerCase();
+        if (parentComm === "code" || parentComm === "code-server") {
+          return true;
+        }
       }
+    } catch {
     }
-  } catch {
+    return false;
+  }
+  let currentPid = pid;
+  const visited = /* @__PURE__ */ new Set();
+  while (currentPid > 1 && !visited.has(currentPid)) {
+    visited.add(currentPid);
+    const proc = processByPid.get(currentPid);
+    if (!proc) break;
+    const parentPid = proc.ppid;
+    if (parentPid <= 1) break;
+    const parentProc = processByPid.get(parentPid);
+    if (!parentProc) break;
+    const parentComm = parentProc.comm.toLowerCase();
+    if (parentComm === "code" || parentComm === "code-server") {
+      return true;
+    }
+    currentPid = parentPid;
   }
   return false;
 }
@@ -9619,12 +9853,14 @@ function classifyFromCommand(command) {
   }
   return { agentType, confidence: 0.7 };
 }
-async function collectTmuxSessions() {
-  try {
-    await execAsync("tmux -V");
-  } catch {
+async function collectTmuxSessions(processByPid) {
+  if (!await checkTmuxAvailable()) {
     return [];
   }
+  if (!processByPid) {
+    const list = await getProcessTable();
+    processByPid = new Map(list.map((p) => [p.pid, p]));
+  }
   try {
     const raw = await execAsync(
       "tmux list-panes -a -F '#{session_name}|#{window_index}|#{pane_index}|#{pane_current_command}|#{session_attached}|#{window_activity}|#{pane_pid}|#{window_layout}|#{pane_current_path}|#{window_name}|#{pane_title}|#{window_flags}|#{session_group}|#{session_grouped}'"
@@ -9658,11 +9894,14 @@ async function collectTmuxSessions() {
       const pid = Number(panePid);
       if (pid > 0) pids.push(pid);
       const classification = classifyAgent(command, { workingDir: paneCurrentPath });
-      const vscodeDetected = pid > 0 ? await detectVscodeEnvironment(pid) : false;
+      const vscodeDetected = pid > 0 ? await detectVscodeEnvironment(pid, processByPid) : false;
+      const dirName = paneCurrentPath ? paneCurrentPath.split("/").filter(Boolean).pop() : "";
+      const baseName = `${sessionName}:${windowIndex}.${paneIndex}`;
+      const finalName = dirName ? `${baseName} (${dirName})` : baseName;
       results.push({
         id,
         type: "tmux",
-        name: `${sessionName}:${windowIndex}.${paneIndex}`,
+        name: finalName,
         status: Number(attachedCount) > 0 ? "active" : "detached",
         command,
         agentType: classification?.agentType,
@@ -9687,10 +9926,8 @@ async function collectTmuxSessions() {
     return [];
   }
 }
-async function collectScreenSessions() {
-  try {
-    await execAsync("screen -v");
-  } catch {
+async function collectScreenSessions(childrenByPpid) {
+  if (!await checkScreenAvailable()) {
     return [];
   }
   try {
@@ -9702,7 +9939,7 @@ async function collectScreenSessions() {
       if (!match) continue;
       const [, screenPid, sessionName, state] = match;
       const pid = Number(screenPid);
-      const childInfo = await getChildAgentInfo(pid);
+      const childInfo = await getChildAgentInfo(pid, childrenByPpid);
       if (!childInfo) continue;
       const id = `screen:${sessionName}:${screenPid}`;
       const allPids = [pid, ...childInfo.childPids];
@@ -9733,10 +9970,8 @@ async function collectScreenSessions() {
     return [];
   }
 }
-async function collectZellijSessions() {
-  try {
-    await execAsync("zellij --version");
-  } catch {
+async function collectZellijSessions(childrenByPpid, processList) {
+  if (!await checkZellijAvailable()) {
     return [];
   }
   try {
@@ -9745,19 +9980,25 @@ async function collectZellijSessions() {
     for (const line of raw.split("\n")) {
       const sessionName = line.trim();
       if (!sessionName) continue;
-      let serverPids;
-      try {
-        const psOut = await execAsync(
-          `ps axo pid,args | grep 'zellij.*--session ${sessionName}' | grep -v grep`
-        );
-        serverPids = psOut.split("\n").map((l) => Number(l.trim().split(/\s+/)[0])).filter((p) => p > 0);
-      } catch {
-        serverPids = [];
+      let serverPids = [];
+      if (processList) {
+        serverPids = processList.filter(
+          (p) => p.args.includes("zellij") && p.args.includes(`--session ${sessionName}`)
+        ).map((p) => p.pid);
+      } else {
+        try {
+          const psOut = await execAsync(
+            `ps axo pid,args | grep 'zellij.*--session ${sessionName}' | grep -v grep`
+          );
+          serverPids = psOut.split("\n").map((l) => Number(l.trim().split(/\s+/)[0])).filter((p) => p > 0);
+        } catch {
+          serverPids = [];
+        }
       }
       const allChildPids = [];
       let foundAgent = null;
       for (const spid of serverPids) {
-        const childInfo = await getChildAgentInfo(spid);
+        const childInfo = await getChildAgentInfo(spid, childrenByPpid);
         if (childInfo) {
           foundAgent = childInfo;
           allChildPids.push(...childInfo.childPids);
@@ -9809,7 +10050,7 @@ async function getProcessWorkingDir(pid) {
       }
       return null;
     }
-    const cwd = await execAsync(`readlink -f /proc/${pid}/cwd`);
+    const cwd = await fs4.promises.readlink(`/proc/${pid}/cwd`);
     return cwd.trim() || null;
   } catch {
     return null;
@@ -9827,35 +10068,20 @@ function transcriptSourceForSession(agentType, sessionId) {
   if (!agentType) return void 0;
   return getTranscriptSourceForAgentType(agentType);
 }
-async function collectBareAgentProcesses(excludePids) {
+async function collectBareAgentProcesses(excludePids, processList, processByPid) {
   try {
-    const raw = await execAsync("ps axo pid,ppid,tty,stat,comm,args");
+    const tStart = performance.now();
+    if (!processList || !processByPid) {
+      const list = await getProcessTable();
+      processList = list;
+      processByPid = new Map(list.map((p) => [p.pid, p]));
+    }
+    const tInit = performance.now();
     const sessions = [];
     const seen = /* @__PURE__ */ new Set();
     const excluded = excludePids ?? /* @__PURE__ */ new Set();
-    const rows = [];
-    const lines = raw.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const trimmed = lines[i].trim();
-      if (!trimmed) continue;
-      if (i === 0 && /^\s*PID\b/i.test(lines[i])) continue;
-      const parts = trimmed.split(/\s+/);
-      if (parts.length < 6) continue;
-      const pid = Number(parts[0]);
-      const ppid = Number(parts[1]);
-      const tty = parts[2];
-      const stat = parts[3];
-      const args = parts.slice(5).join(" ");
-      rows.push({
-        pid,
-        ppid: Number.isFinite(ppid) ? ppid : 0,
-        tty,
-        stat,
-        args
-      });
-    }
-    rows.sort((a, b) => a.pid - b.pid);
-    const parentByPid = new Map(rows.map((row) => [row.pid, row.ppid]));
+    const parentByPid = new Map(processList.map((row) => [row.pid, row.ppid]));
+    const tParentMap = performance.now();
     const hasTrackedAncestor = (pid, tracked) => {
       const visited = /* @__PURE__ */ new Set();
       let current = parentByPid.get(pid) ?? 0;
@@ -9866,24 +10092,60 @@ async function collectBareAgentProcesses(excludePids) {
       }
       return false;
     };
-    for (const row of rows) {
+    const tFilterStart = performance.now();
+    const candidates = processList.filter((row) => {
       const { pid, tty, stat, args } = row;
-      if (!hasControllingTty(tty)) continue;
-      if (stat.startsWith("Z")) continue;
-      if (excluded.has(pid) || hasTrackedAncestor(pid, excluded)) continue;
-      if (seen.has(pid) || hasTrackedAncestor(pid, seen)) continue;
+      if (!hasControllingTty(tty)) return false;
+      if (stat.startsWith("Z")) return false;
+      if (excluded.has(pid) || hasTrackedAncestor(pid, excluded)) return false;
+      const lowerArgs = args.toLowerCase();
+      const hasKeyword = lowerArgs.includes("claude") || lowerArgs.includes("codex") || lowerArgs.includes("aider") || lowerArgs.includes("cursor") || lowerArgs.includes("windsurf") || lowerArgs.includes("gemini") || lowerArgs.includes("agy") || lowerArgs.includes("antigravity") || lowerArgs.includes("amazon") || lowerArgs.includes("copilot");
+      if (!hasKeyword) return false;
+      return true;
+    });
+    const tFilterEnd = performance.now();
+    const tCwdsStart = performance.now();
+    const cwds = await Promise.all(
+      candidates.map(async (row) => {
+        const cwd = await getProcessWorkingDir(row.pid);
+        return { pid: row.pid, cwd };
+      })
+    );
+    const cwdByPid = new Map(cwds.map((c) => [c.pid, c.cwd]));
+    const tCwdsEnd = performance.now();
+    let tLoopAncestor = 0;
+    let tLoopClassify = 0;
+    let tLoopVscode = 0;
+    let tLoopMarkdown = 0;
+    let tLoopStartTimes = 0;
+    const tLoopStart = performance.now();
+    for (const row of candidates) {
+      const { pid, args } = row;
+      const t0 = performance.now();
+      const skip = seen.has(pid) || hasTrackedAncestor(pid, seen);
+      tLoopAncestor += performance.now() - t0;
+      if (skip) continue;
+      const workingDir = cwdByPid.get(pid) || null;
+      const t1 = performance.now();
       let classification = classifyAgent(args);
       if (!classification) {
-        const inferredWorkingDir = await getProcessWorkingDir(pid);
-        classification = classifyAgent(args, { workingDir: inferredWorkingDir ?? void 0 });
+        classification = classifyAgent(args, { workingDir: workingDir ?? void 0 });
       }
+      tLoopClassify += performance.now() - t1;
       if (!classification) continue;
       seen.add(pid);
-      const workingDir = await getProcessWorkingDir(pid);
       const dirName = workingDir ? workingDir.split("/").pop() : null;
       const displayName = dirName && dirName !== "/" && dirName !== "" ? `${classification.agentType} (${dirName})` : `${classification.agentType} (pid ${pid})`;
-      const vscodeDetected = await detectVscodeEnvironment(pid);
+      const t2 = performance.now();
+      const vscodeDetected = await detectVscodeEnvironment(pid, processByPid);
+      tLoopVscode += performance.now() - t2;
       const id = `process:${pid}`;
+      const t3 = performance.now();
+      const mdAvail = markdownAvailableForSession(id, classification.agentType);
+      tLoopMarkdown += performance.now() - t3;
+      const t4 = performance.now();
+      const startTimes = collectStartTimes([pid]);
+      tLoopStartTimes += performance.now() - t4;
       sessions.push({
         id,
         type: "process",
@@ -9892,32 +10154,54 @@ async function collectBareAgentProcesses(excludePids) {
         command: args,
         agentType: classification.agentType,
         agentConfidence: classification.confidence,
-        markdownAvailable: markdownAvailableForSession(id, classification.agentType),
+        markdownAvailable: mdAvail,
         transcriptSource: transcriptSourceForSession(classification.agentType, id),
         workingDir: workingDir || void 0,
         environment: vscodeDetected ? "vscode" : void 0,
         lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(),
         pids: [pid],
-        startTimes: collectStartTimes([pid])
+        startTimes
       });
     }
+    const tLoopEnd = performance.now();
+    console.log(`[PROFILE-BARE] Init took ${(tInit - tStart).toFixed(2)} ms`);
+    console.log(`[PROFILE-BARE] Parent map took ${(tParentMap - tInit).toFixed(2)} ms`);
+    console.log(`[PROFILE-BARE] Filtering took ${(tFilterEnd - tFilterStart).toFixed(2)} ms`);
+    console.log(`[PROFILE-BARE] CWDs took ${(tCwdsEnd - tCwdsStart).toFixed(2)} ms`);
+    console.log(`[PROFILE-BARE] Loop total took ${(tLoopEnd - tLoopStart).toFixed(2)} ms`);
+    console.log(`  [PROFILE-BARE-LOOP] Ancestor checks: ${tLoopAncestor.toFixed(2)} ms`);
+    console.log(`  [PROFILE-BARE-LOOP] Classify: ${tLoopClassify.toFixed(2)} ms`);
+    console.log(`  [PROFILE-BARE-LOOP] VS Code env: ${tLoopVscode.toFixed(2)} ms`);
+    console.log(`  [PROFILE-BARE-LOOP] Markdown check: ${tLoopMarkdown.toFixed(2)} ms`);
+    console.log(`  [PROFILE-BARE-LOOP] Start times: ${tLoopStartTimes.toFixed(2)} ms`);
     return sessions;
-  } catch {
+  } catch (err) {
+    console.error("[PROFILE-BARE] Error:", err);
     return [];
   }
 }
 async function collectSessionInventory(hostId, command) {
+  const processList = await getProcessTable();
+  const processByPid = /* @__PURE__ */ new Map();
+  const childrenByPpid = /* @__PURE__ */ new Map();
+  for (const p of processList) {
+    processByPid.set(p.pid, p);
+    if (!childrenByPpid.has(p.ppid)) {
+      childrenByPpid.set(p.ppid, []);
+    }
+    childrenByPpid.get(p.ppid).push(p);
+  }
   const [tmux, screen, zellij] = await Promise.all([
-    collectTmuxSessions(),
-    collectScreenSessions(),
-    collectZellijSessions()
+    collectTmuxSessions(processByPid),
+    collectScreenSessions(childrenByPpid),
+    collectZellijSessions(childrenByPpid, processList)
   ]);
   const multiplexerPids = /* @__PURE__ */ new Set();
   for (const s of [...screen, ...zellij]) {
     if (s.pids) s.pids.forEach((p) => multiplexerPids.add(p));
   }
   const tmuxChildTasks = tmux.flatMap(
-    (s) => (s.pids ?? []).map(async (pid) => ({ session: s, pid, childInfo: await getChildAgentInfo(pid) }))
+    (s) => (s.pids ?? []).map(async (pid) => ({ session: s, pid, childInfo: await getChildAgentInfo(pid, childrenByPpid) }))
   );
   const tmuxChildResults = await Promise.all(tmuxChildTasks);
   for (const { session: s, pid, childInfo } of tmuxChildResults) {
@@ -9932,7 +10216,7 @@ async function collectSessionInventory(hostId, command) {
     s.markdownAvailable = markdownAvailableForSession(s.id, s.agentType);
     s.transcriptSource = transcriptSourceForSession(s.agentType, s.id);
   }
-  const bare = await collectBareAgentProcesses(multiplexerPids);
+  const bare = await collectBareAgentProcesses(multiplexerPids, processList, processByPid);
   const ptyClassification = classifyAgent(command);
   const ptySession = {
     id: `pty:${hostId}`,
@@ -9985,7 +10269,7 @@ function detectAgentType(command) {
     return "Windsurf";
   }
   if (binary === "gemini" || scriptArg === "gemini") return "Gemini CLI";
-  if (binary === "agy" || binary === "antigravity" || binary === "antigravity-cli") return "Antigravity CLI";
+  if (binary === "agy" || scriptArg === "agy" || binary === "antigravity" || scriptArg === "antigravity" || binary === "antigravity-cli" || scriptArg === "antigravity-cli") return "Antigravity CLI";
   if (binary === "amazon-q" || binary === "amazon_q") return "Amazon Q";
   if (binary === "copilot" || scriptArg === "copilot") return "Copilot CLI";
   return void 0;
@@ -9999,42 +10283,62 @@ function sessionInventoryFingerprint(sessions) {
     return `${s.id}|${s.type}|${s.name}|${s.status}|${s.command || ""}|${s.runningCommand || ""}|${pidStr}|${markdownFlag}|${sourceFlag}`;
   }).join("\n");
 }
-async function getChildAgentInfo(parentPid, visited = /* @__PURE__ */ new Set()) {
+async function getChildAgentInfo(parentPid, childrenByPpid, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(parentPid)) return null;
   visited.add(parentPid);
-  try {
-    const pgrepOut = await execAsync(`pgrep -P ${parentPid}`);
-    const pidList = pgrepOut.split("\n").map((l) => l.trim()).filter(Boolean).map(Number).filter((p) => p > 0);
-    if (pidList.length === 0) return null;
-    const raw = await execAsync(`ps -p ${pidList.join(",")} -o pid,args`);
-    const descendantPids = new Set(pidList);
-    let foundAgent = null;
-    const lines = raw.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const trimmed = lines[i].trim();
-      if (!trimmed) continue;
-      if (i === 0 && /^\s*PID\b/i.test(lines[i])) continue;
-      const spaceIdx = trimmed.indexOf(" ");
-      if (spaceIdx < 0) continue;
-      const pid = Number(trimmed.slice(0, spaceIdx));
-      const args = trimmed.slice(spaceIdx + 1).trim();
-      if (pid <= 0) continue;
-      const agentType = detectAgentType(args);
-      if (agentType && !foundAgent) {
-        foundAgent = { command: args, agentType };
-      }
-      const deeper = await getChildAgentInfo(pid, visited);
-      if (deeper) {
-        deeper.childPids.forEach((childPid) => descendantPids.add(childPid));
-        if (!foundAgent) {
-          foundAgent = { command: deeper.command, agentType: deeper.agentType };
+  if (!childrenByPpid || childrenByPpid.size === 0) {
+    try {
+      const pgrepOut = await execAsync(`pgrep -P ${parentPid}`);
+      const pidList = pgrepOut.split("\n").map((l) => l.trim()).filter(Boolean).map(Number).filter((p) => p > 0);
+      if (pidList.length === 0) return null;
+      const raw = await execAsync(`ps -p ${pidList.join(",")} -o pid,args`);
+      const descendantPids2 = new Set(pidList);
+      let foundAgent2 = null;
+      const lines = raw.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!trimmed) continue;
+        if (i === 0 && /^\s*PID\b/i.test(lines[i])) continue;
+        const spaceIdx = trimmed.indexOf(" ");
+        if (spaceIdx < 0) continue;
+        const pid = Number(trimmed.slice(0, spaceIdx));
+        const args = trimmed.slice(spaceIdx + 1).trim();
+        if (pid <= 0) continue;
+        const agentType = detectAgentType(args);
+        if (agentType && !foundAgent2) {
+          foundAgent2 = { command: args, agentType };
+        }
+        const deeper = await getChildAgentInfo(pid, void 0, visited);
+        if (deeper) {
+          deeper.childPids.forEach((childPid) => descendantPids2.add(childPid));
+          if (!foundAgent2) {
+            foundAgent2 = { command: deeper.command, agentType: deeper.agentType };
+          }
         }
       }
+      return foundAgent2 ? { ...foundAgent2, childPids: [...descendantPids2] } : null;
+    } catch {
+      return null;
+    }
+  }
+  const children = childrenByPpid.get(parentPid) ?? [];
+  if (children.length === 0) return null;
+  const descendantPids = new Set(children.map((c) => c.pid));
+  let foundAgent = null;
+  for (const child of children) {
+    const agentType = detectAgentType(child.args);
+    if (agentType && !foundAgent) {
+      foundAgent = { command: child.args, agentType };
+    }
+    const deeper = await getChildAgentInfo(child.pid, childrenByPpid, visited);
+    if (deeper) {
+      deeper.childPids.forEach((childPid) => descendantPids.add(childPid));
+      if (!foundAgent) {
+        foundAgent = { command: deeper.command, agentType: deeper.agentType };
+      }
     }
-    return foundAgent ? { ...foundAgent, childPids: [...descendantPids] } : null;
-  } catch {
-    return null;
   }
+  return foundAgent ? { ...foundAgent, childPids: [...descendantPids] } : null;
 }
 
 // src/auth.ts
@@ -11667,16 +11971,16 @@ var InventoryManager = class {
     this.options = options;
   }
   /** Announce to the registry group via WebSocket. */
-  async announceToRegistry(ws, registryGroup, type = "heartbeat") {
+  async announceToRegistry(ws, registryGroup, type = "heartbeat", sessions) {
     if (ws.readyState !== import_ws2.default.OPEN || !registryGroup) return;
-    const sessions = await collectSessionInventory(this.options.hostId, this.options.command);
+    const finalSessions = sessions || await collectSessionInventory(this.options.hostId, this.options.command);
     const vitals = this.collectVitals();
     sendToGroup(ws, registryGroup, {
       type,
       hostId: this.options.hostId,
       hostName: this.options.hostName,
       environment: os7.hostname(),
-      sessions,
+      sessions: finalSessions,
       vitals,
       agentVersion: CURRENT_VERSION,
       lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -11693,7 +11997,7 @@ var InventoryManager = class {
     const checkpointDue = Date.now() - this.lastHttpHeartbeatAt > HTTP_HEARTBEAT_MS;
     if (changed || force) {
       if (ws && ws.readyState === import_ws2.default.OPEN) {
-        await this.announceToRegistry(ws, groups.registryGroup, "inventory");
+        await this.announceToRegistry(ws, groups.registryGroup, "inventory", sessions);
       }
       this.lastSentFingerprint = fingerprint;
     }
@@ -11819,10 +12123,36 @@ var ConnectionManager = class {
   resetReconnectDelay() {
     this.reconnectDelay = DEFAULT_RECONNECT_DELAY_MS;
   }
+  /**
+   * Clear all active connection timers to prevent leaks.
+   */
+  clearTimers() {
+    if (this.wsPingTimer) {
+      clearInterval(this.wsPingTimer);
+      this.wsPingTimer = null;
+    }
+    if (this.wsPongTimeout) {
+      clearTimeout(this.wsPongTimeout);
+      this.wsPongTimeout = null;
+    }
+    if (this.wsHeartbeatTimer) {
+      clearInterval(this.wsHeartbeatTimer);
+      this.wsHeartbeatTimer = null;
+    }
+    if (this.inventorySyncTimer) {
+      clearInterval(this.inventorySyncTimer);
+      this.inventorySyncTimer = null;
+    }
+    if (this.inventorySyncKickTimer) {
+      clearTimeout(this.inventorySyncKickTimer);
+      this.inventorySyncKickTimer = null;
+    }
+  }
   /**
    * Start periodic timers (heartbeat, inventory sync, ping/pong).
    */
   startTimers(onWsHeartbeat, onInventorySync) {
+    this.clearTimers();
     this.onInventorySync = onInventorySync;
     this.wsHeartbeatTimer = setInterval(async () => {
       if (!this.isReady()) return;
@@ -11833,7 +12163,19 @@ var ConnectionManager = class {
     }, INVENTORY_SYNC_MS);
     this.wsPingTimer = setInterval(() => {
       if (!this.activeSocket || this.activeSocket.readyState !== import_ws3.default.OPEN) return;
-      this.activeSocket.ping();
+      if (this.wsPongTimeout) {
+        clearTimeout(this.wsPongTimeout);
+        this.wsPongTimeout = null;
+      }
+      try {
+        this.activeSocket.send(JSON.stringify({ type: "ping" }));
+      } catch (err) {
+        log20.error("failed to send JSON ping", { error: err.message });
+      }
+      try {
+        this.activeSocket.ping();
+      } catch {
+      }
       this.wsPongTimeout = setTimeout(() => {
         log20.warn("no pong received within 10s; closing stale connection");
         try {
@@ -11884,26 +12226,7 @@ var ConnectionManager = class {
    */
   cleanup(opts = {}) {
     if (opts.stopStreams) this.sessionStreamer.stopAll();
-    if (this.wsPingTimer) {
-      clearInterval(this.wsPingTimer);
-      this.wsPingTimer = null;
-    }
-    if (this.wsPongTimeout) {
-      clearTimeout(this.wsPongTimeout);
-      this.wsPongTimeout = null;
-    }
-    if (this.wsHeartbeatTimer) {
-      clearInterval(this.wsHeartbeatTimer);
-      this.wsHeartbeatTimer = null;
-    }
-    if (this.inventorySyncTimer) {
-      clearInterval(this.inventorySyncTimer);
-      this.inventorySyncTimer = null;
-    }
-    if (this.inventorySyncKickTimer) {
-      clearTimeout(this.inventorySyncKickTimer);
-      this.inventorySyncKickTimer = null;
-    }
+    this.clearTimers();
     if (this.activeSocket) {
       this.activeSocket.removeAllListeners();
       try {
@@ -12965,7 +13288,6 @@ var ControlDispatcher = class {
   }
   /** Handle input routing to the correct target. */
   handleInput(data, sessionId) {
-    this.connection.requestInventorySync(800);
     if (!sessionId || sessionId.startsWith("pty:")) {
       this.shell.write(data);
     } else if (sessionId.startsWith("tmux:")) {
@@ -13936,7 +14258,6 @@ async function runAgent(rawOptions) {
   const ptySessionId = `pty:${options.hostId}`;
   const sessionStreamer = new SessionStreamer(
     (sessionId, data, viewerId) => {
-      conn.requestInventorySync();
       if (!conn.isReady()) {
         sessionStreamer.bufferOutput(sessionId, data);
         return;
@@ -13968,7 +14289,6 @@ async function runAgent(rawOptions) {
   );
   const conn = new ConnectionManager(sessionStreamer, outputBuffer);
   const sendOutput = (chunk) => {
-    conn.requestInventorySync();
     if (!conn.isReady()) {
       outputBuffer.push(chunk);
       return;
@@ -14220,6 +14540,10 @@ async function runAgent(rawOptions) {
             } catch {
               return;
             }
+            if (msg.type === "pong") {
+              conn.onPong();
+              return;
+            }
             if (msg.type === "message" && msg.group === groups.privateGroup) {
               const payload = msg.data || {};
               if (payload.type === "input") {

package/dist/sbom.json

@@ -1299,8 +1299,8 @@
     {
       "type": "library",
       "name": "ragent-cli",
-      "version": "1.11.11",
-      "bom-ref": "ragent-live|ragent-cli@1.11.11",
+      "version": "1.11.12",
+      "bom-ref": "ragent-live|ragent-cli@1.11.12",
       "author": "Intellimetrics",
       "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
       "licenses": [
@@ -1311,7 +1311,7 @@
           }
         }
       ],
-      "purl": "pkg:npm/ragent-cli@1.11.11",
+      "purl": "pkg:npm/ragent-cli@1.11.12",
       "externalReferences": [
         {
           "url": "https://github.com/chadlindell/ragent-live/issues",
@@ -1436,7 +1436,7 @@
         "ragent-live|@emnapi/wasi-threads@1.2.1",
         "ragent-live|@pkgjs/parseargs@0.11.0",
         "ragent-live|@tybys/wasm-util@0.10.1",
-        "ragent-live|ragent-cli@1.11.11"
+        "ragent-live|ragent-cli@1.11.12"
       ]
     },
     {
@@ -1584,7 +1584,7 @@
       ]
     },
     {
-      "ref": "ragent-live|ragent-cli@1.11.11",
+      "ref": "ragent-live|ragent-cli@1.11.12",
       "dependsOn": [
         "ragent-live|@azure/web-pubsub-client@1.0.4",
         "ragent-live|@openai/codex-sdk@0.130.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragent-cli",
-  "version": "1.11.11",
+  "version": "1.11.12",
   "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
   "main": "dist/index.js",
   "bin": {