@integrity-labs/agt-cli 0.14.15 → 0.15.0

package/dist/lib/manager-worker.js

@@ -19,7 +19,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-LGEQOVFU.js";
+} from "../chunk-WB3T6XIV.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -649,9 +649,43 @@ function parsePsOutput(psOutput) {
   }
   return results;
 }
-function pickKillTargets(processes, agentCodeNames) {
+function parseAllPids(psOutput) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rawLine of psOutput.split("\n")) {
+    const line = rawLine.trimStart();
+    if (!line) continue;
+    const firstSpace = line.search(/\s+/);
+    if (firstSpace < 0) continue;
+    const pid = parseInt(line.slice(0, firstSpace), 10);
+    if (!Number.isFinite(pid)) continue;
+    const afterPid = line.slice(firstSpace).trimStart();
+    const secondSpace = afterPid.search(/\s+/);
+    if (secondSpace < 0) continue;
+    const ppid = parseInt(afterPid.slice(0, secondSpace), 10);
+    if (!Number.isFinite(ppid)) continue;
+    map.set(pid, ppid);
+  }
+  return map;
+}
+function walkPpidChain(startPid, parentMap) {
+  const visited = /* @__PURE__ */ new Set();
+  let cur = startPid;
+  for (let i = 0; i < 64; i++) {
+    if (cur <= 1 || visited.has(cur)) break;
+    visited.add(cur);
+    const parent = parentMap.get(cur);
+    if (parent === void 0) break;
+    cur = parent;
+  }
+  return visited;
+}
+function pickKillTargets(args) {
+  const { processes, agentCodeNames, parentMap, livePidsByAgent } = args;
   const kills = [];
-  const ambiguousGroups = [];
+  const fullParentMap = new Map(parentMap);
+  for (const proc of processes) {
+    if (!fullParentMap.has(proc.pid)) fullParentMap.set(proc.pid, proc.ppid);
+  }
   const groups = /* @__PURE__ */ new Map();
   for (const proc of processes) {
     if (!agentCodeNames.has(proc.codeName)) continue;
@@ -660,25 +694,44 @@ function pickKillTargets(processes, agentCodeNames) {
     if (bucket) bucket.push(proc);
     else groups.set(key, [proc]);
   }
-  for (const [key, bucket] of groups) {
-    const orphans = bucket.filter((p) => p.ppid === 1);
-    const nonOrphans = bucket.filter((p) => p.ppid !== 1);
-    if (orphans.length === 0 && nonOrphans.length <= 1) continue;
-    if (nonOrphans.length > 1) {
-      ambiguousGroups.push(key);
-      continue;
-    }
-    for (const proc of orphans) {
-      kills.push({
-        pid: proc.pid,
-        codeName: proc.codeName,
-        channelType: proc.channelType,
-        etimeSeconds: proc.etimeSeconds,
-        reason: "orphan"
-      });
+  for (const [, bucket] of groups) {
+    if (bucket.length === 0) continue;
+    const codeName = bucket[0].codeName;
+    const liveAnchors = livePidsByAgent.get(codeName);
+    const haveAnchors = !!liveAnchors && liveAnchors.size > 0;
+    for (const proc of bucket) {
+      if (proc.ppid === 1) {
+        if (!haveAnchors && bucket.length === 1) continue;
+        kills.push({
+          pid: proc.pid,
+          codeName: proc.codeName,
+          channelType: proc.channelType,
+          etimeSeconds: proc.etimeSeconds,
+          reason: "orphan"
+        });
+        continue;
+      }
+      if (!haveAnchors) continue;
+      const chain = walkPpidChain(proc.pid, fullParentMap);
+      let isLive = false;
+      for (const anchor of liveAnchors) {
+        if (chain.has(anchor)) {
+          isLive = true;
+          break;
+        }
+      }
+      if (!isLive) {
+        kills.push({
+          pid: proc.pid,
+          codeName: proc.codeName,
+          channelType: proc.channelType,
+          etimeSeconds: proc.etimeSeconds,
+          reason: "not-in-live-chain"
+        });
+      }
     }
   }
-  return { kills, ambiguousGroups };
+  return { kills, ambiguousGroups: [] };
 }
 function defaultKill(pid) {
   try {
@@ -686,6 +739,26 @@ function defaultKill(pid) {
   } catch {
   }
 }
+function resolveLiveAnchorPids(agentCodeNames) {
+  const result = /* @__PURE__ */ new Map();
+  for (const codeName of agentCodeNames) {
+    const pids = /* @__PURE__ */ new Set();
+    try {
+      const out = execFileSync("tmux", ["list-panes", "-t", `agt-${codeName}`, "-F", "#{pane_pid}"], {
+        encoding: "utf-8",
+        timeout: 2e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const line of out.split("\n")) {
+        const pid = parseInt(line.trim(), 10);
+        if (Number.isFinite(pid) && pid > 1) pids.add(pid);
+      }
+    } catch {
+    }
+    result.set(codeName, pids);
+  }
+  return result;
+}
 async function sweepChannelProcesses(opts) {
   const { agentCodeNames, dryRun, log: log2 } = opts;
   const kill = opts.killFn ?? defaultKill;
@@ -701,7 +774,9 @@ async function sweepChannelProcesses(opts) {
     return { kills: [], inspected: 0, scannedAgents: [...agentCodeNames], dryRun };
   }
   const processes = parsePsOutput(psOutput);
-  const { kills, ambiguousGroups } = pickKillTargets(processes, agentCodeNames);
+  const parentMap = parseAllPids(psOutput);
+  const livePidsByAgent = resolveLiveAnchorPids(agentCodeNames);
+  const { kills } = pickKillTargets({ processes, agentCodeNames, parentMap, livePidsByAgent });
   for (const target of kills) {
     const ageMin = Math.round(target.etimeSeconds / 60);
     log2(
@@ -709,11 +784,6 @@ async function sweepChannelProcesses(opts) {
     );
     if (!dryRun) kill(target.pid);
   }
-  for (const group of ambiguousGroups) {
-    log2(
-      `[channel-sweep] ambiguous group ${group} \u2014 >1 non-orphan process, cannot determine which is live. Manual check recommended.`
-    );
-  }
   return {
     kills,
     inspected: processes.length,