@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/session/active.js

@@ -1,22 +1,4 @@
 import { writerProcessView } from './process-view.js';
-/**
- * Active-session detection across every context an agent can run in:
- *
- *   - `terminal` — agents launched from VS Code / Cursor / Codium via the
- *     agents-cli extension. Published to `~/.agents/.cache/terminals/live-terminals.json`
- *     with PID + session UUID per entry.
- *   - `teams`    — agents spawned by `agents teams add`, tracked in
- *     `~/.agents/teams/agents/<id>/meta.json` with a PID the manager polls.
- *   - `cloud`    — dispatched to Rush / Codex Cloud / Factory, tracked in
- *     the SQLite cache at `~/.agents/cloud/tasks.db`.
- *   - `headless` — bare `claude` / `codex` / `gemini` / `cursor-agent` /
- *     `opencode` processes that don't belong to any of the above. Detected
- *     by `ps` minus the PIDs we've already attributed.
- *
- * `running` vs `idle` is a secondary classification within the alive set:
- * the process is holding its session file, but the file's mtime is older
- * than ACTIVE_MTIME_WINDOW_MS, so it's probably waiting on the user.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -33,12 +15,12 @@ import { loadHookSessionIndex, resolveHookSessionRecord, readStateSessionRecord
 import { buildClaudeLabelMap, getAgentSessionDirs } from './discover.js';
 import { buildRunNameMap } from './run-names.js';
 import { latestSessionFileForCwd, findSessionsByShortIds, findSessionMachinesByIds, getSessionById } from './db.js';
-import { extractSessionTopic, classifyUserPrompt, tidyRequest } from './prompt.js';
-import { readSessionTailWithRaw } from './tail.js';
-import { parseSession } from './parse.js';
+import { extractSessionTopic, classifyUserPrompt, tidyRequest } from '@phnx-labs/sessions-cli/reader';
+import { readSessionTailWithRaw } from '@phnx-labs/sessions-cli/reader';
+import { parseSession } from '@phnx-labs/sessions-cli/reader';
 import { computeTokPerSec } from './throughput.js';
-import { inferSessionState } from './state.js';
-import { isSessionTrackedAgent, SESSION_AGENTS, AG_TMUX_NAME_RE } from './types.js';
+import { inferSessionState } from '@phnx-labs/sessions-cli/reader';
+import { isSessionTrackedAgent, SESSION_AGENTS, AG_TMUX_NAME_RE } from '@phnx-labs/sessions-cli/reader';
 import { AGENTS } from '../agents.js';
 import { confirmedProjectForCwd, listProjectDefsCached } from '../projects.js';
 import { detectProvenance } from './provenance.js';
@@ -47,50 +29,20 @@ import { machineId, normalizeHost } from '../machine-id.js';
 import { presenceFromStore } from './detached.js';
 import { classifyHostLink, hostWindowLost, HOST_HEARTBEAT_STALE_MS } from './host-link.js';
 import { mapBounded } from '../concurrency.js';
-import { linearIssueUrl } from './linear.js';
+import { linearIssueUrl } from '@phnx-labs/sessions-cli/reader';
 import { viewingInLabel } from './viewing-in.js';
 import { claudeProjectDirName } from '../project-key.js';
 const execFileAsync = promisify(execFile);
-/** Prefer live actor attribution; the durable sidecar survives actor-less hook rewrites. */
 export function resolveOwner(pidActor, sessionId) {
     return pidActor ?? (sessionId ? readSessionActorRecord(sessionId)?.actor : undefined) ?? undefined;
 }
-/**
- * Per-PID `lsof` probes run bounded and staggered rather than as one parallel
- * fan-out: a simultaneous system-wide `lsof` burst reads to behavioral EDR
- * (CrowdStrike Falcon) as lateral-movement recon. Results are identical — the
- * cwds are just gathered at a bounded spawn rate instead of a single burst.
- */
 export const LSOF_CONCURRENCY = 4;
 const LSOF_STAGGER_MS = 10;
-/**
- * Hard ceilings on the two syscalls the status path shells out to. Without them
- * a single hung probe (a wedged NFS `lsof`, an EDR that stalls the `ps` snapshot)
- * pins a bounded worker slot forever and silently drops live sessions to a
- * fallback status. On timeout the call rejects, is caught, and the row degrades
- * honestly (unknown / empty table) instead of the sweep hanging.
- */
 const LSOF_TIMEOUT_MS = 5_000;
 const PS_SNAPSHOT_TIMEOUT_MS = 10_000;
-/**
- * Process-local process-table memo (#2047). One `getActiveSessions` scan can
- * call `ps -A` from the terminal path, the headless path, and host ancestry —
- * without this, each is a full process-table snapshot. 5s is well under the
- * ~10–30s menu-bar / `--active` poll so a quiet re-poll usually reuses the
- * snapshot; a brand-new agent pid still appears on the next full refresh.
- */
 export const PROCESS_TABLE_FRESH_MS = 5_000;
-/**
- * How long {@link listUnattributedActive} may reuse its last full `ps`+`lsof`
- * result (#2047). Between full rescans the previous rows are re-emitted after
- * dropping dead PIDs and PIDs that are now attributed. A *shrinking* attributed
- * set forces a rescan so a process that just left teams/terminals can reappear
- * as headless instead of vanishing until the next cold poll.
- */
 export const UNATTRIBUTED_RESCAN_MS = 15_000;
-/** Injectable clock for the active-scan memos (tests only). */
 let activeScanNow = () => Date.now();
-/** Test seam: override the clock used by process-table / unattributed memos. */
 export function setActiveScanClockForTest(fn) {
     activeScanNow = fn ?? (() => Date.now());
 }
@@ -98,7 +50,6 @@ let processTableCache;
 let processTableLiveReads = 0;
 let unattributedCache;
 let unattributedFullRescans = 0;
-/** Test seam: drop the process-table + unattributed memos and their counters. */
 export function clearActiveScanCachesForTest() {
     processTableCache = undefined;
     processTableLiveReads = 0;
@@ -106,18 +57,12 @@ export function clearActiveScanCachesForTest() {
     unattributedFullRescans = 0;
     activeScanNow = () => Date.now();
 }
-/** Test seam: how many times the live `ps` / CIM path actually ran. */
 export function processTableLiveReadCountForTest() {
     return processTableLiveReads;
 }
-/** Test seam: how many full unattributed (ps + lsof) rescans ran. */
 export function unattributedFullRescanCountForTest() {
     return unattributedFullRescans;
 }
-/**
- * True when any pid in `prev` is absent from `next` — the attributed set
- * shrank, so a process may need to reappear as unattributed. Pure for tests.
- */
 export function attributedSetLostPids(prev, next) {
     for (const p of prev) {
         if (!next.has(p))
@@ -125,12 +70,6 @@ export function attributedSetLostPids(prev, next) {
     }
     return false;
 }
-/**
- * Drop rows whose pid is now attributed or no longer alive. Pure over the
- * inputs so the unattributed TTL reuse path is unit-testable without a live
- * process table. `alive` receives the row's `startedAtMs` so callers can apply
- * the same pid-reuse guard {@link isPidAlive} uses elsewhere.
- */
 export function filterCachedUnattributed(sessions, attributed, alive, ppidMap) {
     return sessions.filter((s) => {
         if (s.pid == null)
@@ -140,14 +79,6 @@ export function filterCachedUnattributed(sessions, attributed, alive, ppidMap) {
         return alive(s.pid, s.startedAtMs);
     });
 }
-/**
- * Fold index-only enrichment onto live rows, then RE-DERIVE the recap for every
- * row it touched. The re-derive is load-bearing: `foldRecap` runs inside
- * {@link getActiveSessions}, before any caller reaches the index, so a `label`
- * or `generatedTitle` that only the index knows would otherwise never reach the
- * shown `title` (PHNX-3797). Doing it here rather than at each of the three
- * backfill call sites is what keeps them from drifting apart.
- */
 export function backfillActiveRowsFromMeta(sessions, metaById) {
     const accounts = listNativeAccounts(readMeta());
     for (const s of sessions) {
@@ -190,8 +121,6 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.durationMs = m.durationMs;
         if (s.subAgentCount == null && m.subAgentCount != null)
             s.subAgentCount = m.subAgentCount;
-        // A pane kept open for days has a start time but no activity signal of its
-        // own; the index's last transcript write is what "idle 14d" is read from.
         if (s.lastActivityMs == null && m.lastActivity) {
             const ts = Date.parse(m.lastActivity);
             if (!Number.isNaN(ts))
@@ -200,7 +129,6 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
         applyRecap(s);
     }
 }
-/** Resolve a display name only when the indexed identity names one registered slot. */
 export function sessionAccountLabel(kind, session, accounts = listNativeAccounts(readMeta())) {
     const matches = accounts.filter(account => {
         if (account.agent !== kind)
@@ -208,7 +136,6 @@ export function sessionAccountLabel(kind, session, accounts = listNativeAccounts
         if (session.accountId)
             return account.id === session.accountId;
         if (session.accountKey && !session.accountKey.startsWith('unattributed:')) {
-            // Claude's index groups quota by org; the registry names a login within it.
             const indexed = parseNativeIdentityKey(account.agent, session.accountKey);
             const emailMatches = !!session.account && account.identityLabel?.toLowerCase() === session.account.toLowerCase();
             if (!indexed || (!indexed.account && !emailMatches))
@@ -236,7 +163,6 @@ function loadBackfillMetaFor(sessions) {
         }
     }
     catch {
-        /* enrichment is best-effort — an unavailable DB leaves rows un-backfilled */
     }
     return byId;
 }
@@ -248,6 +174,7 @@ export function isRunningLiveSession(s) {
         return false;
     if (s.context === 'cloud')
         return Boolean(s.cloudProvider) && Boolean(s.cloudTaskId);
+    // Unknown liveness from an older peer is not enough for bare --active.
     return Boolean(s.machine) && typeof s.pid === 'number' && s.pid > 0 && s.pidAlive === true;
 }
 export function activeSessionProjectKey(s) {
@@ -256,16 +183,11 @@ export function activeSessionProjectKey(s) {
     return s.context === 'cloud' ? 'cloud' : 'other';
 }
 export function serializeActiveSessionsForJson(sessions) {
-    // One definition read for the whole batch, not per row (PHNX-3999 F08/F09).
     const defs = listProjectDefsCached();
     return sessions.map((s) => ({
         ...s,
         ticketId: s.ticket?.id ?? null,
         project: activeSessionProjectKey(s),
-        // The project a person is shown this row under, or null for Uncategorized.
-        // `project` above is the always-present join KEY (basename of the cwd, or the
-        // explicit cloud/other bucket) and stays exactly as it was — grouping by it is
-        // what filed unbound directories as projects of their own.
         confirmedProject: confirmedProjectForCwd(s.cwd, defs) ?? null,
         prLink: s.pr?.url ?? null,
         viewingIn: viewingInLabel(s) ?? null,
@@ -291,88 +213,20 @@ export function activeStatusFromCloudStatus(status) {
     }
 }
 const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
-/**
- * A process is classified `running` if its session file was touched in the
- * last 2 minutes. Every Claude/Codex tool-call appends an event, so a
- * healthy session writes several times a minute.
- */
 const ACTIVE_MTIME_WINDOW_MS = 2 * 60_000;
-/**
- * Bound on the tmux `list-panes` call in {@link listTmuxAgentSessions}. A wedged
- * tmux server would otherwise hang the whole `--active` scan (the other sources
- * can't run past it); on timeout the tmux source throws {@link TmuxDiscoveryDegradedError}.
- */
 const TMUX_LIST_PANES_TIMEOUT_MS = 5_000;
-/**
- * Thrown by {@link listTmuxAgentSessions} when the socket exists (a server has
- * run) but tmux could not be asked for its truth — spawn failure, timeout, or a
- * nonzero exit. Distinct from a missing socket, which means no server ever ran
- * and is genuinely empty, not degraded. `getActiveSessions` still swallows this
- * to `[]` so its return type stays a plain session array, but
- * {@link describeActiveDiscoveryHealth} re-probes and surfaces it so the empty
- * case a real fleet sweep found (RUSH-2507) reads differently from a clean one.
- */
 export class TmuxDiscoveryDegradedError extends Error {
     constructor(message) {
         super(message);
         this.name = 'TmuxDiscoveryDegradedError';
     }
 }
-/**
- * A live process can only borrow an indexed session file if that transcript
- * has been touched recently enough to plausibly belong to the process. This is
- * deliberately wider than ACTIVE_MTIME_WINDOW_MS: an inactive-but-live CLI can
- * be idle for longer than 2 minutes, but it must not attach to a weeks-old
- * transcript just because a GUI app service with the same basename is alive.
- */
 const ACTIVE_SESSION_STALE_MS = 24 * 60 * 60_000;
-/**
- * A session whose transcript hasn't been written in this long is ABANDONED /
- * dangling — the framework can no longer treat it as live work, whether its PID
- * is dead (long gone) or still alive but making no progress (a hung agent).
- * Two days: past a normal work gap, well short of a session legitimately kept
- * open across a long weekend. Deliberately far wider than
- * {@link ACTIVE_SESSION_STALE_MS} (which bounds transcript-borrowing, a different
- * concern) — this is the lifecycle threshold, not the freshness window.
- */
 export const ABANDONED_STALE_MS = 2 * 24 * 60 * 60_000;
-/**
- * Field separator for every `tmux list-panes -F` query here.
- *
- * NOT a tab. tmux sanitizes non-printable characters out of format output (3.6a
- * rewrites a literal tab — and any non-ASCII sentinel — to `_`), so a
- * tab-separated format comes back as one unsplittable field.
- * {@link listTmuxAgentSessions} split on `\t`, so on such a tmux every line
- * failed its `sessName` guard and the function returned ZERO rows, silently
- * losing the authoritative tmux source (exact `%pane`, real identities) on every
- * box running a recent tmux.
- *
- * `:` specifically, and not some other printable: tmux itself replaces `:` (and
- * `.`) in a session name with `_`, so the separator provably cannot occur inside
- * the one free-text field that is not last. A path CAN contain `:`, which is why
- * `pane_current_path` is queried last and its tail rejoined rather than
- * destructured. A separator that a session name may contain — `|`, say — would
- * just reintroduce the same class of bug with a lower probability.
- */
 const TMUX_FIELD_SEP = ':';
-/**
- * Process comm names that are NOT derivable from the AGENTS registry's
- * `cliCommand`. `rush` is a {@link SESSION_AGENTS} member with no AGENTS registry
- * row (it is the Rush app, not a managed harness), so its executable name is
- * mapped explicitly here. Everything else flows from the registry below.
- */
 const EXTRA_SESSION_AGENT_COMMS = {
     rush: ['rush'],
 };
-/**
- * Every process executable ("comm") name that identifies a given session-agent
- * kind in the headless `ps`-scan. Driven off the AGENTS registry's `cliCommand`
- * (the real executable name — e.g. `agy` for antigravity, `cursor-agent` for
- * cursor) plus {@link EXTRA_SESSION_AGENT_COMMS} for members with no registry
- * row. Exported so the completeness test can assert every {@link SESSION_AGENTS}
- * member resolves — the fix for the harness-parity gap where bare-headless
- * grok/kimi/antigravity/openclaw/hermes/rush were silently dropped.
- */
 export function sessionAgentComms(id) {
     const comms = new Set();
     const cli = AGENTS[id]?.cliCommand;
@@ -382,12 +236,6 @@ export function sessionAgentComms(id) {
         comms.add(extra);
     return [...comms];
 }
-/**
- * Executables we recognize as agent CLIs when scanning the process table. Built
- * once from {@link sessionAgentComms} across {@link SESSION_AGENTS} — a single
- * derived source, not a second hand-maintained allowlist that drifts from the
- * discovery surface (the harness-parity code-review rule).
- */
 const AGENT_CLI_NAMES = (() => {
     const map = {};
     for (const id of SESSION_AGENTS) {
@@ -396,56 +244,23 @@ const AGENT_CLI_NAMES = (() => {
     }
     return map;
 })();
-/**
- * Resolve an agent kind from a process's reported executable. `comm` may be an
- * absolute path (shim-launched agents), and Windows image names carry an
- * `.exe` suffix (`claude.exe`), so basename + suffix-strip before the lookup.
- */
 export function agentKindFromComm(commRaw) {
-    // A GUI desktop app can bundle a binary with the SAME name as an agent CLI: the
-    // Codex desktop app ships `/Applications/Codex.app/Contents/Resources/codex` (its
-    // `app-server`), whose basename `codex` would otherwise match the codex CLI and
-    // surface the app's background server as a phantom agent session — running at cwd
-    // '/', so it shows up unattributed in the feed. A real agent CLI is never inside a
-    // `.app` bundle, so exclude those. (The Claude desktop app is a separate case,
-    // already excluded by name below: its process is 'Claude', not the CLI's 'claude'.)
     if (commRaw.includes('.app/Contents/'))
         return undefined;
     const base = path.basename(commRaw);
     const stripped = base.replace(/\.exe$/i, '');
-    // Windows image names compare case-insensitively; POSIX comms stay exact —
-    // macOS's Claude desktop app process is named 'Claude' and must NOT match.
     const key = stripped === base ? base : stripped.toLowerCase();
     return AGENT_CLI_NAMES[key];
 }
-/**
- * A tmux agent session name is `ag-<agent>-<shortid>` (see src/lib/exec.ts
- * `runInTmux`), where `<agent>` is the agent kind passed to `agents run` (may
- * contain a hyphen, e.g. `cursor-agent`) and `<shortid>` is the first 8 hex chars
- * of the session UUID. Anchored on the 8-hex suffix so the agent part is split
- * unambiguously. The agent part is NOT cross-checked against AGENT_CLI_NAMES (that
- * map is the narrower ps-scan comm set): the panes live on the agent-only socket,
- * and validating there would silently drop grok/kimi/antigravity — the exact
- * harness-parity gap we are fixing.
- */
 const AG_NAME_RE = AG_TMUX_NAME_RE;
-/** Agent kind from an `ag-<agent>-<shortid>` tmux session name, else undefined. */
 export function agentKindFromName(sessName) {
     const m = AG_NAME_RE.exec(sessName);
     return m ? m[1].toLowerCase() : undefined;
 }
-/** The 8-char session-id prefix from an `ag-<agent>-<shortid>` name, else undefined. */
 export function shortIdFromName(sessName) {
     const m = AG_NAME_RE.exec(sessName);
     return m ? m[2].toLowerCase() : undefined;
 }
-/**
- * Map every `ag-<agent>-<shortid>` tmux session name to its full session UUID in
- * ONE batched DB lookup. The live scan calls this once per poll (not per pane),
- * then resolvePaneIdentity reads the map — the recovery that makes a detached
- * agent findable by `focus <id>` even when its durable identity records are gone.
- * `findSessionsByShortIds` is injected so this stays unit-testable without a DB.
- */
 export function resolveNamesToSessionIds(sessionNames, deps) {
     const shortIdToNames = new Map();
     for (const name of sessionNames) {
@@ -468,26 +283,7 @@ export function resolveNamesToSessionIds(sessionNames, deps) {
     }
     return out;
 }
-/**
- * A process that began more than this long AFTER a session's recorded
- * `startedAtMs` cannot be that session's process — the OS handed its pid to
- * something newer. The window absorbs clock granularity (`ps -o lstart=` reports
- * whole seconds) and the gap between a process spawning and the SessionStart
- * hook recording `startedAtMs`; it is far below the minutes-to-hours it takes the
- * pid space to wrap and actually recycle a pid, so it never false-kills a live
- * session.
- */
 const PID_REUSE_TOLERANCE_MS = 60_000;
-/**
- * Epoch-ms start time of the process at `pid`, or null if unknowable.
- *
- * Distinct from teams/agents.ts's `captureProcessStartTime`, which returns an
- * opaque token only meaningful for equality against a prior capture of the SAME
- * pid. Here we need a value comparable to a session's `startedAtMs`, so we read
- * `ps -o lstart=` — a ctime string on both macOS and Linux — and parse it to
- * epoch ms. Windows and any exec/parse failure return null, so the caller falls
- * back to a bare existence check (never worse than before).
- */
 function processStartMs(pid) {
     if (process.platform === 'win32')
         return null;
@@ -505,16 +301,6 @@ function processStartMs(pid) {
         return null;
     }
 }
-/**
- * True when `pid` names a live process AND — when a session's recorded
- * `startedAtMs` is supplied — that process is plausibly the SAME one, not a later
- * process that recycled the pid. The OS reuses pids, so a bare
- * `process.kill(pid, 0)` existence check reports a dead session as alive (a
- * "zombie") once its pid is handed to an unrelated process. A genuine session
- * process starts at or before its own recorded start, so a process that began
- * meaningfully AFTER `startedAtMs` is a reused pid and the session is dead. When
- * the start time can't be read, we keep the existence answer.
- */
 export function isPidAlive(pid, startedAtMs) {
     if (!pid || pid < 1)
         return false;
@@ -522,23 +308,18 @@ export function isPidAlive(pid, startedAtMs) {
         process.kill(pid, 0);
     }
     catch (err) {
-        // EPERM means the pid exists but is owned by another user — still "alive",
-        // fall through to the identity check. Any other error means no such process.
         if (err?.code !== 'EPERM')
             return false;
     }
     if (startedAtMs && startedAtMs > 0) {
+        // A live recycled PID must not revive an unrelated dead session.
         const procStartMs = processStartMs(pid);
         if (procStartMs !== null && procStartMs > startedAtMs + PID_REUSE_TOLERANCE_MS) {
-            return false; // pid recycled by a newer process — this session is gone
+            return false;
         }
     }
     return true;
 }
-/**
- * Keep dead entries only when their window heartbeat also stopped, proving a crash;
- * a live duplicate always wins.
- */
 function readLiveTerminals() {
     let raw;
     try {
@@ -566,13 +347,9 @@ function readLiveTerminals() {
             if (!e?.sessionId)
                 continue;
             const alive = isPidAlive(e.pid, e.startedAtMs);
-            // Dead pid + a window still republishing = an ordinary close mid-debounce.
-            // Dead pid + a window that stopped republishing = the crash we must report.
             if (!alive && !windowGone)
                 continue;
             const entry = { ...e, windowId, windowHeartbeatMs, pidDead: !alive };
-            // A live entry always wins a dead one for the same session (the agent was
-            // relaunched into a new window while the crashed window's slice lingers).
             const prev = merged.get(e.sessionId);
             if (prev && !prev.pidDead && !alive)
                 continue;
@@ -581,23 +358,9 @@ function readLiveTerminals() {
     }
     return Array.from(merged.values());
 }
-/**
- * Process-local memo for Claude transcript path resolution. Each active-session
- * poll re-walks every Claude version-home `projects/` tree for every live pid
- * (#2047). A resolved path is sticky while the file still exists; a miss or a
- * vanished file re-walks. Cap size so a long-lived process cannot retain every
- * cwd it has ever seen.
- */
 const CLAUDE_SESSION_FILE_CACHE_MAX = 256;
 const claudeSessionFileCache = new Map();
-/**
- * Search every version home because the live ~/.claude symlink moves after upgrades
- * while older running sessions keep writing to their original home.
- */
 function findClaudeSessionFile(cwd, sessionId) {
-    // Only memoize when the exact session UUID is known. Without an id the
-    // resolver picks newest-by-mtime under the project dir; caching that path
-    // would stick to an old transcript after a new session starts in the same cwd.
     if (sessionId) {
         const cacheKey = `${cwd}\0${sessionId}`;
         const hit = claudeSessionFileCache.get(cacheKey);
@@ -606,7 +369,7 @@ function findClaudeSessionFile(cwd, sessionId) {
                 if (fs.existsSync(hit))
                     return hit;
             }
-            catch { /* re-resolve */ }
+            catch { }
             claudeSessionFileCache.delete(cacheKey);
         }
         const resolved = pickClaudeSessionFileAcrossRoots(getAgentSessionDirs('claude', 'projects'), cwd, sessionId);
@@ -619,12 +382,6 @@ function findClaudeSessionFile(cwd, sessionId) {
     }
     return pickClaudeSessionFileAcrossRoots(getAgentSessionDirs('claude', 'projects'), cwd, sessionId);
 }
-/**
- * Resolve a Claude transcript for `cwd` across the given project roots, newest
- * mtime winning when the same id/cwd resolves in more than one version home
- * (the actively-written copy is the newest). Pure over `projectRoots`, so it is
- * testable against temp dirs without touching the real home directory.
- */
 export function pickClaudeSessionFileAcrossRoots(projectRoots, cwd, sessionId) {
     const enc = claudeProjectDirName(cwd);
     let best;
@@ -644,18 +401,6 @@ export function pickClaudeSessionFileAcrossRoots(projectRoots, cwd, sessionId) {
     }
     return best?.path;
 }
-/**
- * Pick a Claude transcript file within a project dir.
- *
- * With a CONCRETE session id: return that id's `<id>.jsonl` or undefined — NEVER a
- * sibling's. Falling back to the newest file here is the bug that made N distinct
- * co-located sessions (e.g. several editor tabs in one cwd, or two worktree siblings)
- * all collapse onto ONE file and render identical preview + topic (they look like
- * duplicate cards). The mtime fallback is only sound when NO id is known.
- *
- * With NO id: return the newest `.jsonl` by mtime (the legitimate single-session
- * heuristic for a directly-launched agent with no registry entry).
- */
 export function pickSessionFile(projectDir, sessionId) {
     if (sessionId) {
         const specific = path.join(projectDir, `${sessionId}.jsonl`);
@@ -676,16 +421,10 @@ export function pickSessionFile(projectDir, sessionId) {
             if (!best || m > best.mtime)
                 best = { path: p, mtime: m };
         }
-        catch { /* file vanished between readdir and stat */ }
+        catch { }
     }
     return best?.path;
 }
-/**
- * One `stat` → the transcript's creation (≈ session start) and last-write (≈ last
- * activity) epochs. Both `undefined` when the file can't be stat'd (vanished /
- * unresolved). `birthtimeMs` can be 0 on filesystems without creation time — coerce
- * that to `undefined` so callers fall through to a real signal instead of epoch 0.
- */
 export function sessionFileTimes(sessionFile) {
     if (!sessionFile)
         return {};
@@ -697,22 +436,6 @@ export function sessionFileTimes(sessionFile) {
         return {};
     }
 }
-/**
- * The lifecycle status computed purely from the two hard signals the framework
- * always has — PID liveness and transcript last-write (mtime) — independent of
- * anything the agent self-reports or what its last transcript turn happened to
- * look like. Returns the definitive lifecycle label when one applies, or
- * `undefined` when the process is live and fresh (so the caller uses the richer
- * activity-derived status instead).
- *
- *   - No write in {@link ABANDONED_STALE_MS} ⇒ `abandoned` (dangling): a
- *     days-stale session is not live work, whether its PID is dead (long gone)
- *     or still alive but stuck. Checked first — it outranks a bare `closed`.
- *   - Otherwise, PID dead ⇒ `closed`: the process has exited. This is the fix
- *     for the old "dead PID reports idle" lie — `idle` reads as "done, waiting
- *     for you", but a dead process is done, period.
- *   - Otherwise (alive + fresh) ⇒ `undefined`: defer to the activity engine.
- */
 export function lifecycleStatus(pidAlive, mtimeMs, nowMs = Date.now()) {
     if (mtimeMs !== undefined && nowMs - mtimeMs >= ABANDONED_STALE_MS)
         return 'abandoned';
@@ -720,49 +443,10 @@ export function lifecycleStatus(pidAlive, mtimeMs, nowMs = Date.now()) {
         return 'closed';
     return undefined;
 }
-/**
- * The ONE place a fallback status is decided when no rich transcript state is
- * available — an opaque kind we cannot parse (openclaw), or a transcript
- * whose parse/tail was empty or unreadable. Honest by construction: computed from
- * PID + mtime, never a fabricated `idle`.
- *
- *   - Dead PID, or a days-stale transcript ⇒ {@link lifecycleStatus} (`closed` /
- *     `abandoned`). A dead process is `closed`, not the old fabricated `idle`
- *     (which the UI reads as "done, waiting for you"); a dead process whose file
- *     also vanished is still `closed` (death is a definitive answer, not `unknown`).
- *   - Live + fresh ⇒ `running`. A live process is, at minimum, running: we may
- *     not see WHAT an opaque harness (or an empty tail) is doing, but the process
- *     being alive is a positive signal — never a blank `unknown` (the old blanket
- *     bug for every non-claude/codex live agent) nor a downgraded `idle`.
- */
 export function resolveFallbackStatus(sessionFile, pidAlive, nowMs = Date.now()) {
     const { mtimeMs } = sessionFileTimes(sessionFile);
     return lifecycleStatus(pidAlive, mtimeMs, nowMs) ?? 'running';
 }
-/**
- * Locate the live transcript for an agent process. Claude files are keyed by cwd
- * (+ optional session uuid), so they resolve straight off disk. Every OTHER
- * tracked harness — Codex (date-partitioned), plus grok / droid / rush / gemini /
- * kimi / hermes / opencode / antigravity / cursor (per-session dirs, SQLite, single-JSON)
- * — is resolved through the session index. When the session id is KNOWN, that id
- * selects the transcript. Only an id-less process falls back to the newest indexed
- * transcript for that cwd, bounded by ACTIVE_SESSION_STALE_MS so a live pid never
- * borrows a weeks-old transcript. This is what lets a live NON-claude/codex agent
- * get a real status instead of falling through to `unknown` (the file feeds
- * {@link computeLiveSignals}). An opaque kind we don't track still yields undefined
- * here and degrades honestly to a live `running`.
- *
- * The id branch exists because the cwd fallback is only safe when there is nothing
- * better: it answers `WHERE agent = ? AND cwd = ? ORDER BY last_activity DESC LIMIT 1`
- * (`latestSessionFileForCwd`), so with two same-harness agents in ONE cwd — routine on
- * this fleet — every one of them resolves to whichever transcript was touched last.
- * That is the same "one stranger's transcript" hazard the id-less tmux pane already
- * refuses to guess at (see `listTmuxAgentSessions`), and since RUSH-2682 it reaches
- * further than a status badge: the live row now backs `sessions preview <id>`, so the
- * guess renders session B's digest under session A's header and caches it against A.
- * An id we cannot resolve yields undefined — the honest "not indexed here" render —
- * rather than a neighbour's transcript (RUSH-2691).
- */
 export function findSessionFileForKind(kind, cwd, sessionId) {
     if (!cwd)
         return undefined;
@@ -774,36 +458,19 @@ export function findSessionFileForKind(kind, cwd, sessionId) {
         return indexedSessionFileForId(kind, sessionId);
     return latestSessionFileForCwd(kind, cwd, { maxAgeMs: ACTIVE_SESSION_STALE_MS });
 }
-/**
- * The indexed transcript for one exact session id, or undefined when the index has
- * not reached it yet. The `agent` guard rejects a row that belongs to a different
- * harness than the live process claims: those cannot be the same conversation, and
- * returning it would reintroduce the misattribution this function exists to avoid.
- */
 function indexedSessionFileForId(kind, sessionId) {
     const row = getSessionById(sessionId);
     if (!row || row.agent !== kind)
         return undefined;
     return row.filePath || undefined;
 }
-/** Recover the session UUID from a transcript filename (Claude `<uuid>.jsonl`, Codex `rollout-…-<uuid>.jsonl`). */
 const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 function sessionIdFromFile(file) {
     if (!file)
         return undefined;
     return path.basename(file).match(UUID_RE)?.[0];
 }
-/** Cap the events fed to state inference for a non-tailable harness — the last
- * turns are all `inferActivity` needs, and a bound keeps a huge transcript cheap. */
 const LIVE_STATE_MAX_EVENTS = 80;
-/**
- * Parse a NON-claude/codex transcript with that harness's own parser and return
- * its last events for state inference. These formats vary too much for the
- * single-file byte-tail fast path (per-session dirs for grok/kimi, SQLite for
- * opencode/antigravity, single-JSON for gemini/hermes), so parse the whole
- * (size-guarded, via safeReadSessionFile) transcript and keep the tail. A parse
- * failure yields no events, degrading honestly to the live fallback.
- */
 function parseTailEventsForKind(agent, sessionFile) {
     let events;
     try {
@@ -814,32 +481,11 @@ function parseTailEventsForKind(agent, sessionFile) {
     }
     return events.length > LIVE_STATE_MAX_EVENTS ? events.slice(-LIVE_STATE_MAX_EVENTS) : events;
 }
-/**
- * Process-local memo of the PARSED TAIL for {@link computeLiveSignals}. The
- * menu-bar / `--active` poll re-reads every live session on a ~30s tick (#2047),
- * and while a transcript's mtime is unchanged its bytes are unchanged — so the
- * parse (the expensive half) is memoized on mtime. The CLASSIFICATION is not:
- * `inferSessionState` is re-run on every call against the current clock and the
- * current `pidAlive`, because a time-based verdict (the 30-minute prose-question
- * decay) must expire on schedule even while the bytes sit still — a memo keyed
- * on mtime froze that verdict for as long as nobody typed (PHNX-3999). Bound the
- * map so a long-lived daemon that sees thousands of sessions cannot retain them
- * forever.
- */
 const LIVE_TAIL_CACHE_MAX = 512;
 const liveTailCache = new Map();
-/** Test seam: drop the in-process parsed-tail memo. */
 export function clearLiveSignalsCacheForTest() {
     liveTailCache.clear();
 }
-/**
- * Parse the transcript tail for one harness. Claude/Codex take the fast bounded
- * byte-tail ({@link readSessionTailWithRaw}) — the hot path, and the only two
- * that also yield throughput (their raw lines carry usage the event model drops).
- * EVERY OTHER tracked harness (grok, droid, rush, gemini, kimi, hermes, opencode,
- * antigravity, cursor) is parsed with its own parser. An opaque/untracked kind
- * yields no events.
- */
 function parseLiveTail(kind, sessionFile, mtimeMs) {
     if (kind === 'claude' || kind === 'codex') {
         const { events, content } = readSessionTailWithRaw(sessionFile, kind);
@@ -850,20 +496,6 @@ function parseLiveTail(kind, sessionFile, mtimeMs) {
         return { mtimeMs, events: parseTailEventsForKind(kind, sessionFile) };
     return { mtimeMs, events: [] };
 }
-/**
- * Derive the inferred state (working / waiting / idle + preview/badges) and, for
- * the two harnesses whose raw lines carry it, the output-token throughput.
- *
- * Every tracked harness runs through the SAME {@link inferSessionState}, so a
- * live non-claude/codex agent gets a real working/waiting/idle instead of the
- * blanket `unknown` it used to fall through to. An opaque/untracked kind or an
- * unreadable/empty transcript yields an empty signal set, and the caller's
- * {@link resolveFallbackStatus} reports the honest live floor (`running`).
- *
- * An unchanged-mtime call reuses the parsed tail (see {@link liveTailCache}) so a
- * 30s active-session poll does not re-tail every quiet transcript — but it always
- * re-classifies against `nowMs`, so an elapsed-time verdict is never frozen.
- */
 export function computeLiveSignals(kind, sessionFile, cwd, pidAlive, nowMs = Date.now()) {
     if (!sessionFile)
         return {};
@@ -871,7 +503,7 @@ export function computeLiveSignals(kind, sessionFile, cwd, pidAlive, nowMs = Dat
     try {
         mtimeMs = fs.statSync(sessionFile).mtimeMs;
     }
-    catch { /* vanished between calls */ }
+    catch { }
     const cacheKey = `${kind}\0${sessionFile}\0${cwd ?? ''}`;
     let tail = liveTailCache.get(cacheKey);
     if (!tail || tail.mtimeMs !== mtimeMs) {
@@ -885,38 +517,27 @@ export function computeLiveSignals(kind, sessionFile, cwd, pidAlive, nowMs = Dat
     const state = inferSessionState(tail.events, { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS, nowMs });
     return { state, tokPerSec: tail.tokPerSec };
 }
-/** Map inferred activity onto the coarse ActiveStatus used by the renderer and counts. */
 function statusFromActivity(activity) {
     return activity === 'working' ? 'running' : activity === 'waiting_input' ? 'input_required' : 'idle';
 }
-/**
- * Fold a computed SessionState onto an active-session row: rich status +
- * preview + PR/worktree/ticket badges. With no state (an opaque/untracked kind,
- * or an unreadable/empty transcript) it degrades to
- * {@link resolveFallbackStatus}, which reports the honest live floor (`running`
- * for an alive process) rather than the old blanket `unknown`.
- */
 function applyState(base, state, fallbackFile, pidAlive) {
     if (!state)
         return { ...base, pidAlive, status: resolveFallbackStatus(fallbackFile, pidAlive) };
-    // Lifecycle (closed/abandoned) is computed from PID + mtime and OVERRIDES the
-    // activity-derived status: a dead or days-stale process is closed/abandoned no
-    // matter what its last parsed transcript turn looked like (a dead session whose
-    // tail ended mid-tool-call must not read as `running`). `base.lastActivityMs` is
-    // the transcript mtime the row already resolved — reuse it, no extra stat.
     const life = lifecycleStatus(pidAlive, base.lastActivityMs ?? sessionFileTimes(fallbackFile).mtimeMs);
     return {
         ...base,
         pidAlive,
         status: life ?? statusFromActivity(state.activity),
         activity: state.activity,
+        model: state.model,
+        failures: state.failures,
+        userTurns: state.userTurns,
         awaitingReason: state.awaitingReason,
         question: state.question,
         lastEventMs: state.lastEventMs,
         plan: state.plan,
         todos: state.todos,
         tail: state.tail,
-        // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
         preview: state.preview ?? base.preview,
         pr: state.pr,
         worktree: state.worktree,
@@ -929,11 +550,6 @@ function applyState(base, state, fallbackFile, pidAlive) {
         rateLimited: state.rateLimited,
     };
 }
-/**
- * Extract the first user message's content from a Claude JSONL file.
- * Reads only the first ~50 lines for speed, since the user message is
- * typically near the top (after system/queue events).
- */
 function extractClaudeUserText(parsed) {
     const msg = parsed.message;
     if (!msg?.content)
@@ -1002,11 +618,6 @@ function quickExtractTopic(sessionFile) {
     }
     return undefined;
 }
-/**
- * One-line summary of a teammate's spawn prompt — the team's task/target. Takes
- * the first non-empty line, strips a leading `MISSION:`/`CONTEXT:`/`TASK:` label,
- * and truncates. Exported for tests.
- */
 export function summarizeMission(prompt) {
     if (!prompt)
         return undefined;
@@ -1018,40 +629,17 @@ export function summarizeMission(prompt) {
         return undefined;
     return cleaned.length > 80 ? `${cleaned.slice(0, 79)}…` : cleaned;
 }
-/**
- * Live teams teammates. Reuses AgentManager which already polls PIDs via
- * `kill -0`. `localOnly` (RUSH-2118) skips the ssh round-trip AgentManager
- * would otherwise issue for every distributed (remote-host) teammate.
- */
 export async function listTeamsActive(opts = {}) {
     const mgr = new AgentManager(undefined, undefined, undefined, undefined, undefined, opts.localOnly ?? false);
     const running = await mgr.listRunning();
     const self = machineId();
     return running.map((a) => {
-        // The teammate's OWN transcript is `remoteSessionId` (captured from its first
-        // stream event). `parentSessionId` is the ORCHESTRATOR that spawned the team
-        // (AGENTS_SESSION_ID at spawn) — a link, not this teammate's id. Keying the
-        // row off the orchestrator conflated the two (a teammate showed the
-        // orchestrator's id/topic and lineage was invisible); resolve the teammate's
-        // own session for the row and expose the orchestrator separately.
         const ownSessionId = a.remoteSessionId ?? undefined;
         const sessionFile = findSessionFileForKind(a.agentType, a.cwd ?? undefined, ownSessionId);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const pidAlive = a.pid ? isPidAlive(a.pid) : true;
         const { state, tokPerSec } = computeLiveSignals(a.agentType, sessionFile, a.cwd ?? undefined, pidAlive);
         const resolvedId = ownSessionId ?? sessionIdFromFile(sessionFile);
-        // A remote teams teammate (`teams add --device <peer>`) EXECUTES on that
-        // peer, not on this orchestrator box — but it gets no host-dispatch index
-        // row, so `foldExecutionMachine` can't reach it and the self-stamp in
-        // `commands/sessions.ts` would claim it, listing a peer's teammate under
-        // `--device <orchestrator>` (SES-GAP-10). Attribute the row to the execution
-        // host and mark the dispatcher, the same shape `run --device` gets: `machine`
-        // survives the cross-machine fan-out because `parseRemoteActive` keeps an
-        // `offloadedFrom` row's own machine, and `offloadedFrom` is COMPARED to this
-        // box by `sessionProcessIsLocal` (never merely tested), so a third box seeing
-        // this row over the fan-out reads it as the peer's, not its own. A local
-        // teammate (no `hostName`, or pinned to this box) is left unattributed for
-        // the self-stamp.
         const execHost = a.hostName ? normalizeHost(a.hostName) : undefined;
         const offloaded = execHost !== undefined && execHost !== self;
         return applyState({
@@ -1073,32 +661,21 @@ export async function listTeamsActive(opts = {}) {
             teamName: a.taskName,
             assignedTask: summarizeMission(a.prompt),
             agentId: a.agentId,
-            // The frozen actor stamped on the teammate record (RUSH-2028) — who ran
-            // this teammate, surfaced as the owner in --active (RUSH-2018); sidecar
-            // fallback for a teammate record predating the actor field.
             owner: resolveOwner(a.actor, resolvedId),
         }, state, sessionFile, pidAlive);
     });
 }
-/** Live editor-terminal agents across every IDE window. */
 export async function listTerminalsActive() {
     const entries = readLiveTerminals();
     if (entries.length === 0)
         return [];
-    // Walk the shell PIDs through the process table once so we can name the host
-    // (code / cursor / codium) per entry rather than a generic 'terminal'.
     const procByPid = new Map();
     for (const r of await readProcessTable())
         procByPid.set(r.pid, r);
     const children = childrenByParent(new Map([...procByPid.values()].map(r => [r.pid, r.ppid])));
-    // Build label map from Claude's sessions/*.json for /rename support
     const labelMap = buildClaudeLabelMap();
-    // Run-name handles (`agents run --name`) keyed by session id, for the same
-    // sessionId → handle resolution as labels.
     const runNameMap = buildRunNameMap();
     return entries.map((t) => {
-        // Keep the shell pid for tab ownership and headless suppression; the live
-        // agent below it owns the session after an exit-and-rerun in the same tab.
         const directEntry = readPidSessionEntry(t.pid, procByPid.get(t.pid)?.startTime);
         const candidate = directEntry?.sessionId ? directEntry
             : (!t.pidDead ? terminalDescendantEntry(t.pid, procByPid, children) : undefined) ?? directEntry;
@@ -1108,9 +685,7 @@ export async function listTerminalsActive() {
         const sessionKind = pidEntry?.agent ?? t.kind;
         const sessionFile = findSessionFileForKind(sessionKind, cwd, resolvedId);
         const label = t.label ?? (resolvedId ? labelMap.get(resolvedId) : undefined) ?? undefined;
-        // Durable run name from `agents run --name`, resolved by the run's session id.
         const name = resolvedId ? runNameMap.get(resolvedId) ?? undefined : undefined;
-        // Extract topic from session file (first meaningful user message)
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const pidAlive = isPidAlive(t.pid, t.startedAtMs);
         const { state, tokPerSec } = computeLiveSignals(sessionKind, sessionFile, cwd, pidAlive);
@@ -1139,7 +714,6 @@ export async function listTerminalsActive() {
         }, state, sessionFile, pidAlive);
     });
 }
-/** Cloud tasks still in a non-terminal state. `tasks.db` may not exist; that's fine. */
 function listCloudActive() {
     let tasks;
     try {
@@ -1159,18 +733,11 @@ function listCloudActive() {
         cloudStatus: t.status,
     }));
 }
-/**
- * Ordered ancestor-process matchers. First match wins (most specific to least),
- * so an IDE renderer is preferred over the terminal-app that launched the IDE,
- * and a terminal-app is preferred over the multiplexer inside it.
- */
 const HOST_MATCHERS = [
-    // IDE renderers (Electron helper processes on macOS, image names on Windows)
     { host: 'code', tokens: ['Code Helper', 'Code - Insiders Helper', 'Code.exe'] },
     { host: 'cursor', tokens: ['Cursor Helper', 'Cursor.exe'] },
     { host: 'codium', tokens: ['VSCodium Helper', 'VSCodium.exe'] },
     { host: 'windsurf', tokens: ['Windsurf Helper', 'Windsurf.exe'] },
-    // Native terminal apps
     { host: 'iterm', tokens: ['iTerm2', 'iTermServer', 'iTerm'] },
     { host: 'terminal', tokens: ['Terminal.app', '/Applications/Utilities/Terminal.app', 'WindowsTerminal.exe'] },
     { host: 'warp', tokens: ['Warp.app', 'stable_'] },
@@ -1179,21 +746,9 @@ const HOST_MATCHERS = [
     { host: 'hyper', tokens: ['Hyper.app', 'Hyper Helper'] },
     { host: 'wezterm', tokens: ['wezterm', 'WezTerm'] },
     { host: 'ghostty', tokens: ['ghostty', 'Ghostty'] },
-    // Multiplexers (fallback — only if no UI found above them)
     { host: 'tmux', tokens: ['tmux'] },
     { host: 'screen', tokens: ['screen'] },
 ];
-/**
- * Snapshot the whole process table in one `ps` call. Includes ppid so we can
- * walk ancestry chains to attribute child processes to their terminal hosts.
- * `comm` may be an absolute path for shim-launched agents, so basename before
- * matching against AGENT_CLI_NAMES.
- *
- * Memoized for {@link PROCESS_TABLE_FRESH_MS} so one active-session scan (and a
- * quiet re-poll within the window) does not re-shell `ps -A` / CIM for every
- * caller — terminal host detection, headless attribution, and `hostFromPid`
- * all share the same snapshot (#2047).
- */
 async function readProcessTable() {
     const now = activeScanNow();
     if (processTableCache && now - processTableCache.at < PROCESS_TABLE_FRESH_MS) {
@@ -1203,7 +758,6 @@ async function readProcessTable() {
     processTableCache = { at: now, rows };
     return rows;
 }
-/** Uncached process-table snapshot (the live `ps` / CIM path). */
 async function readProcessTableLive() {
     processTableLiveReads += 1;
     if (process.platform === 'win32')
@@ -1217,8 +771,6 @@ async function readProcessTableLive() {
     }
     const rows = [];
     for (const line of out.split('\n')) {
-        // pid ppid tty lstart comm — tty is a single token ('ttys003', 's003', or '??'/'?'
-        // for none); comm stays last so it may contain spaces.
         const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(\S+\s+\S+\s+\d+\s+\S+\s+\d+)\s+(.+)$/);
         if (!m)
             continue;
@@ -1233,11 +785,6 @@ async function readProcessTableLive() {
     }
     return rows;
 }
-/**
- * Windows process table in one CIM query (`wmic` is removed on current
- * Windows 11, so PowerShell is the stable interface). Same pid/ppid/comm
- * shape as the POSIX `ps` snapshot; `Name` is the image name (`claude.exe`).
- */
 async function readProcessTableWin32() {
     let out;
     try {
@@ -1251,7 +798,6 @@ async function readProcessTableWin32() {
     }
     return parseWin32ProcessCsv(out);
 }
-/** Parse `ConvertTo-Csv` output of Win32_Process rows. Exported for tests. */
 export function parseWin32ProcessCsv(out) {
     const rows = [];
     for (const line of out.split(/\r?\n/)) {
@@ -1279,8 +825,6 @@ function childrenByParent(ppidMap) {
     return children;
 }
 function terminalDescendantEntry(pid, processes, children) {
-    // Windows only proves pidExists: a recycled PID can be a live shell descendant.
-    // Retain the published identity until that platform can prove process starts.
     if (process.platform === 'win32')
         return undefined;
     let pending = children.get(pid) ?? [];
@@ -1294,16 +838,15 @@ function terminalDescendantEntry(pid, processes, children) {
                 continue;
             seen.add(child);
             const entry = readPidSessionEntry(child, processes.get(child)?.startTime);
-            if (!entry || !isSessionTrackedAgent(entry.agent)) {
+            const agent = entry?.agent || processes.get(child)?.kind;
+            if (!entry || !agent || !isSessionTrackedAgent(agent)) {
                 next.push(...(children.get(child) ?? []));
                 continue;
             }
-            // A recorded agent is a boundary even before its session ID is known:
-            // its tools may launch agents of their own, which never own this tab.
             recordedAgent = true;
             if (entry.sessionId && (!newest || entry.startedAtMs > newest.startedAtMs
                 || (entry.startedAtMs === newest.startedAtMs && entry.pid > newest.pid)))
-                newest = entry;
+                newest = { ...entry, agent };
         }
         if (recordedAgent)
             return newest;
@@ -1311,11 +854,6 @@ function terminalDescendantEntry(pid, processes, children) {
     }
     return undefined;
 }
-/**
- * True when any ancestor in pid's parent chain is a known attributed PID.
- * VS Code / Cursor terminals store the *shell* PID in live-terminals.json,
- * while `ps` reports the *child* claude PID, so a direct set lookup misses.
- */
 function hasAttributedAncestor(pid, ppidMap, attributed) {
     let cur = ppidMap.get(pid);
     const seen = new Set();
@@ -1327,23 +865,10 @@ function hasAttributedAncestor(pid, ppidMap, attributed) {
     }
     return false;
 }
-/**
- * Resolve every candidate PID's cwd, bounded and staggered so the probes no
- * longer fan out as one simultaneous system-wide `lsof` burst (a behavioral-EDR
- * recon trigger). Order matches the input `pids`. The `probe` seam is injectable
- * for testing the bound; production always uses the real `lsof`-backed probe.
- */
 export function resolveCwds(pids, probe = getCwdForPid) {
     return mapBounded(pids, probe, { concurrency: LSOF_CONCURRENCY, staggerMs: LSOF_STAGGER_MS });
 }
-/**
- * Resolve a process's current working directory via `lsof`. The `-a` flag
- * ANDs the filters; without it macOS treats `-p` and `-d` as a union and
- * returns the cwd of every process on the system.
- */
 async function getCwdForPid(pid) {
-    // No lsof on Windows and no cheap foreign-process cwd API; the pid registry
-    // written by `ag run` supplies the cwd for registry-launched agents instead.
     if (process.platform === 'win32')
         return undefined;
     let out;
@@ -1363,12 +888,6 @@ async function getCwdForPid(pid) {
     }
     return undefined;
 }
-/**
- * Walk a pid's ancestor chain and return the most specific host app found.
- * Checks each HOST_MATCHERS entry against every ancestor, returns the first
- * host whose tokens match — so IDEs beat terminal apps, terminals beat
- * multiplexers. Returns undefined if nothing is recognised (true headless).
- */
 function detectHost(pid, procByPid) {
     const chain = [];
     let cur = procByPid.get(pid)?.ppid;
@@ -1387,13 +906,6 @@ function detectHost(pid, procByPid) {
     }
     return undefined;
 }
-/**
- * Resolve the host app for a single pid by walking its process ancestry with the
- * same HOST_MATCHERS logic `detectHost` uses. Reads the whole process table per
- * call, so it's for the low-cardinality renderer path (one tmux client per
- * session), not a hot loop. Returns undefined when nothing above the pid is a
- * recognised UI. Exported for the "viewing in <app>" resolver.
- */
 export async function hostFromPid(pid) {
     if (!pid || pid < 1)
         return undefined;
@@ -1402,20 +914,11 @@ export async function hostFromPid(pid) {
         procByPid.set(r.pid, r);
     return detectHost(pid, procByPid);
 }
-/** IDE / terminal / multiplexer hosts all count as UI-hosted. Absence = truly headless. */
 const UI_HOSTS = new Set([
     'code', 'cursor', 'codium', 'windsurf',
     'iterm', 'terminal', 'warp', 'alacritty', 'kitty', 'hyper', 'wezterm', 'ghostty',
     'tmux', 'screen',
 ]);
-/**
- * Find the launch registry entry recorded by a WRAPPER of this process. The
- * shim delegate records the pid it spawned, but on Windows the `.cmd` shell
- * path makes that a cmd.exe intermediary whose child is the real agent binary
- * — so the agent pid itself has no entry and the wrapper one ancestor up does.
- * The nearest entry wins, and only if its agent matches the candidate's kind:
- * a claude session shelling out to codex must not hand codex its identity.
- */
 export function readAncestorSessionEntry(pid, ppidMap, kind, readEntry = readPidSessionEntry) {
     let cur = ppidMap.get(pid);
     const seen = new Set();
@@ -1428,24 +931,6 @@ export function readAncestorSessionEntry(pid, ppidMap, kind, readEntry = readPid
     }
     return undefined;
 }
-/**
- * Collapse agent processes spawned by another live agent process of the same
- * kind onto their nearest kept ancestor. Claude runs subagents, forks, and
- * even its bundled ripgrep as child `claude` processes — on POSIX those
- * children resolve to the parent's cwd and collapse in dedupeBySession, but
- * where no cwd can be recovered (Windows has no lsof) every fork would print
- * as its own headless row. Two exceptions keep their own row: a candidate with
- * its own registry entry — on its pid OR on a wrapper ancestor strictly below
- * the pid it would fold into (the shim's entry lands on the cmd.exe
- * intermediary on Windows) — a child whose live argv carries `--session-id`
- * (RUSH-2384: empty by-pid must not fold a real session into a parent and
- * drop it from the active set) — and a child of a *different* agent kind
- * (claude shelling out to codex is a real second session, not a fork).
- * Returns the kept roots plus, per root pid, how many descendants folded in.
- *
- * `hasLiveSessionId` defaults to reading `--session-id` from the live process
- * argv; tests inject a pure predicate so they do not need real agent pids.
- */
 export function foldSubordinateAgents(candidates, ppidMap, readEntry, hasLiveSessionId = (pid) => sessionIdFromLivePid(pid) != null) {
     const kindByPid = new Map(candidates.map(c => [c.pid, c.kind]));
     const nearestSameKindAncestor = (pid, kind) => {
@@ -1459,11 +944,6 @@ export function foldSubordinateAgents(candidates, ppidMap, readEntry, hasLiveSes
         }
         return undefined;
     };
-    // Own launch identity: a matching-kind registry entry on the candidate or on
-    // any wrapper between it and the pid it would fold into (exclusive). Entries
-    // above the fold target belong to that ancestor's session, not this one.
-    // A live `--session-id` on argv is also own identity (RUSH-2384) — the
-    // registry is often empty while the process still names its session.
     const hasOwnSession = (c, stopPid) => {
         if (readEntry(c.pid)?.agent === c.kind)
             return true;
@@ -1493,15 +973,12 @@ export function foldSubordinateAgents(candidates, ppidMap, readEntry, hasLiveSes
             kept.push(c);
             continue;
         }
-        // Walk up through folded intermediates to the nearest kept same-kind pid.
         let cur = nearestSameKindAncestor(c.pid, c.kind);
         const seen = new Set();
         while (cur !== undefined && !keptPids.has(cur) && !seen.has(cur)) {
             seen.add(cur);
             cur = nearestSameKindAncestor(cur, c.kind);
         }
-        // A fold target must itself be a kept row (a ppid cycle from pid reuse
-        // can orphan the whole chain) — otherwise keep the row rather than drop it.
         if (cur === undefined || !keptPids.has(cur)) {
             kept.push(c);
             continue;
@@ -1510,18 +987,6 @@ export function foldSubordinateAgents(candidates, ppidMap, readEntry, hasLiveSes
     }
     return { kept, foldedByRoot };
 }
-/**
- * Agent processes not attributed to a team or the runtime registry.
- * Classified by walking the ppid chain: any recognised UI ancestor (IDE
- * helper, terminal-app, or multiplexer) means `terminal`; nothing of the
- * sort means `headless` (daemon, launchd-spawned, orphan).
- *
- * Full `ps`+`lsof` rescans are throttled to {@link UNATTRIBUTED_RESCAN_MS}
- * (#2047). Between rescans the previous rows are re-emitted after dropping
- * dead PIDs and PIDs that are now attributed. A shrinking attributed set
- * forces a rescan so a process that just left teams/terminals can reappear
- * as headless.
- */
 export async function listUnattributedActive(attributed) {
     const now = activeScanNow();
     if (unattributedCache &&
@@ -1533,7 +998,6 @@ export async function listUnattributedActive(attributed) {
     unattributedCache = { at: now, attributed: new Set(attributed), ...result };
     return result.sessions;
 }
-/** Unthrottled headless scan (live process table + cwd probes). */
 async function listUnattributedActiveLive(attributed) {
     unattributedFullRescans += 1;
     const table = await readProcessTable();
@@ -1543,7 +1007,6 @@ async function listUnattributedActiveLive(attributed) {
         procByPid.set(r.pid, r);
         ppidMap.set(r.pid, r.ppid);
     }
-    // Candidate PIDs first — we only shell out to lsof for these, not the whole table.
     const candidates = [];
     for (const { pid, kind } of table) {
         if (!kind)
@@ -1554,45 +1017,17 @@ async function listUnattributedActiveLive(attributed) {
             continue;
         candidates.push({ pid, kind });
     }
-    // Forks/subagents of a live agent process collapse onto their root before
-    // the cwd probes — fewer spawns, and one session stays one row even when
-    // cwd-based dedupe is unavailable (Windows).
     const { kept, foldedByRoot } = foldSubordinateAgents(candidates, ppidMap, readPidSessionEntry);
-    // Bounded + staggered lsof probes: same cwds, but a trickle of spawns instead
-    // of one simultaneous system-wide burst that behavioral EDR flags as recon.
     const cwds = await resolveCwds(kept.map(c => c.pid));
-    // The hook state dir is scanned at most ONCE per active-scan, and the ppid map
-    // is inverted at most once — both built lazily on the first candidate that
-    // lacks an exact launch-time id, so an all-Claude set does neither. The ~3s
-    // poll must not re-read the dir (or re-invert the map) per candidate.
     let hookIndex;
     let children;
-    // Durable `agents run --name` handles keyed by session id — the same source the
-    // terminal path uses to name a row. Headless agents have no live-terminals
-    // label and no /rename, so without this a `--name`d headless run would surface
-    // with only a topic and no tab title. Built once per scan.
     const runNameMap = buildRunNameMap();
     const ensureChildren = () => children ??= childrenByParent(ppidMap);
     const out = [];
     for (let i = 0; i < kept.length; i++) {
         const { pid, kind } = kept[i];
-        // The per-pid registry (written by `ag run` and the shim delegate) gives
-        // the EXACT session id this pid was launched with — so N agents in one cwd
-        // resolve to N distinct sessions instead of all collapsing onto the newest
-        // .jsonl. The shim's entry may sit on a wrapper ancestor (Windows .cmd
-        // path). Absent entirely (direct launch outside agents-cli) → heuristic.
         const entry = readPidSessionEntry(pid) ?? readAncestorSessionEntry(pid, ppidMap, kind);
-        // Exact session id, in priority: (1) the id we recorded at launch (Claude,
-        // known up front via --session-id); (2) the live process's own argv
-        // `--session-id` (RUSH-2384 — by-pid is often empty mid-run while the
-        // process still advertises the id); (3) the agent's OWN SessionStart hook,
-        // authoritative for non-Claude and for agents we didn't launch, joined by
-        // launchId/terminalId/pid and kind-guarded against a stale reused-pid file;
-        // (4) the newest-jsonl heuristic (sessionIdFromFile, below).
         let exactId = entry?.sessionId ?? sessionIdFromLivePid(pid);
-        // The hook record (when we fall to it) also carries the SessionStart `ts` — the
-        // real session-start epoch. Capture it so terminal/headless rows get a
-        // `startedAtMs` instead of rendering "0s ago" (they set none before this).
         let hookRec;
         if (!exactId) {
             hookIndex ??= loadHookSessionIndex();
@@ -1605,11 +1040,6 @@ async function listUnattributedActiveLive(attributed) {
             });
             exactId = hookRec?.session_id;
         }
-        // RUSH-2501: the hook-sessions index (terminals/sessions/) is populated only
-        // by @agents/session-tracker, which is not deployed on most fleet machines.
-        // The DEPLOYED SessionStart hook writes to state/sessions/<pid>.json instead.
-        // Try that path when the index lookup found nothing, so cursor/grok/kimi/droid
-        // agents (which carry no --session-id argv) can be attributed.
         if (!exactId) {
             const stateRec = readStateSessionRecord(pid, entry?.startedAtMs);
             if (stateRec)
@@ -1620,16 +1050,8 @@ async function listUnattributedActiveLive(attributed) {
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
-        // pidAlive is true by construction: this pid was just enumerated from the
-        // live process table, so an opaque (non-parseable) kind resolves to
-        // `running`, not a fake `idle` or blanket `unknown`.
         const { state, tokPerSec } = computeLiveSignals(kind, sessionFile, cwd, true);
         const { birthtimeMs, mtimeMs } = sessionFileTimes(sessionFile);
-        // Durable run name from `agents run --name`, resolved by the run's session id
-        // — the tab-title handle for a run we launched by name. A headless row carries
-        // no /rename label and no live-terminals label, so this handle IS its label
-        // (mirrors listTeamsActive `label: a.name`). Absent a `--name`, label stays
-        // undefined and the display falls back to the topic on its own — no band-aid.
         const resolvedId = exactId ?? sessionIdFromFile(sessionFile);
         const name = resolvedId ? runNameMap.get(resolvedId) ?? undefined : undefined;
         const label = name;
@@ -1647,8 +1069,6 @@ async function listUnattributedActiveLive(attributed) {
             topic,
             tokPerSec,
             sessionFile,
-            // Session start: the hook's authoritative SessionStart `ts`, else the
-            // transcript's creation time. Last activity: the transcript's last write.
             startedAtMs: hookRec?.ts ?? birthtimeMs,
             lastActivityMs: mtimeMs,
             pidCount: 1 + (foldedByRoot.get(pid) ?? 0),
@@ -1657,43 +1077,15 @@ async function listUnattributedActiveLive(attributed) {
             terminalId: entry?.terminalId ?? hookRec?.terminal_id,
         }, state, sessionFile, true));
     }
-    // Housekeeping: drop registry files for pids that have since died.
     prunePidSessionRegistry(isPidAlive);
     return { sessions: out, ppidMap };
 }
-/**
- * Attribute a single tmux pane to the agent actually running in it.
- *
- * The launch registry — written per bare-spawn AND per wrap, each stamped with the
- * `tmuxPane` it targeted (see src/lib/exec.ts) — is the EXACT, per-pane source of
- * truth. So an agent spawned into an EXISTING pane (a split, where `$TMUX` is
- * already set so no new session meta is stamped) is attributed to its OWN launch,
- * not the session's original agent — closing the gap where such an agent was
- * dropped by this source and left to the weaker ps-scan fallback. Session-meta
- * labels remain the fallback for the wrapped origin pane of a session whose
- * registry entry is absent (a failed best-effort write, or a legacy session that
- * predates the registry's `tmuxPane` field) — and ONLY for that origin pane
- * (`meta.pane`), so a split shell pane of a labeled session isn't mis-attributed
- * the wrapped agent. When `meta.pane` is unknown (attach-existing sessions), any
- * labeled pane is accepted and the caller's per-session dedupe keeps one.
- * `source: 'teams'` panes are skipped — teammates are surfaced by listTeamsActive.
- * Pure so it is unit-tested without tmux.
- */
 export function resolvePaneIdentity(pane, sessName, meta, liveEntry, getHookIndex, nameToFullId) {
     if (meta?.source === 'teams')
         return undefined;
-    // The tmux session name encodes the agent kind (100% of ag-* panes) and, for a
-    // spawn whose id was known at creation (Claude), the session-id prefix — already
-    // resolved to a full UUID in the batch map. It is the last-resort id source when
-    // every durable record is missing (the common fleet case: meta/pid-reg/hook all
-    // ~3% populated), and would otherwise leave the pane id-less and mis-collapsed.
     const nameAgent = agentKindFromName(sessName);
     const nameSessionId = nameToFullId.get(sessName);
     if (liveEntry) {
-        // Exact id: the id recorded at launch (Claude), else the agent's own
-        // SessionStart hook joined by launchId/terminalId (non-Claude, or agents we
-        // didn't launch) — kind-guarded against a stale reused-pid file — else the id
-        // carried in the pane's own tmux name.
         const sessionId = liveEntry.sessionId
             ?? resolveHookSessionRecord(getHookIndex(), {
                 pid: liveEntry.pid,
@@ -1704,10 +1096,6 @@ export function resolvePaneIdentity(pane, sessName, meta, liveEntry, getHookInde
             ?? nameSessionId;
         return { agent: liveEntry.agent, harness: liveEntry.harness, sessionId, pid: liveEntry.pid };
     }
-    // No live-registry entry. Session-meta labels are the wrapped-origin fallback;
-    // prefer them, then fall back to the name so a pane with neither a registry
-    // entry nor meta labels still resolves (agent from the name, id from the batch
-    // map when present) instead of being dropped and mis-attributed by the ps-scan.
     const agent = meta?.labels?.agent;
     const sessionId = meta?.labels?.sessionId;
     if (agent && sessionId && (meta?.pane == null || meta.pane === pane))
@@ -1716,25 +1104,11 @@ export function resolvePaneIdentity(pane, sessName, meta, liveEntry, getHookInde
         return { agent: nameAgent, sessionId: nameSessionId };
     return undefined;
 }
-/**
- * Agents hosted in the shared-socket tmux server — the authoritative source for
- * tmux-hosted interactive spawns (see src/lib/exec.ts `runInTmux`). Enumerates
- * every pane on the shared socket and attributes each to the agent running in it
- * via {@link resolvePaneIdentity}: the per-pane launch registry (exact) first, the
- * session-meta labels as fallback. Because tmux (not a per-window
- * `live-terminals.json`) is the source of truth, a tmux-hosted agent is captured
- * with its exact `%pane` even when the extension registry is stale — INCLUDING an
- * agent bare-spawned into a split of an existing session, which older logic dropped
- * (it kept only the first pane per session meta). `source: 'teams'` is skipped.
- */
 export async function listTmuxAgentSessions() {
     const { getDefaultSocketPath } = await import('../tmux/paths.js');
     const { readSessionMeta } = await import('../tmux/session.js');
     const { runTmux } = await import('../tmux/binary.js');
     const socket = getDefaultSocketPath();
-    // No server has ever run on this socket — genuinely nothing to report, not
-    // a degraded read. Distinct from the throws below, which mean tmux truth
-    // exists but could not be read (RUSH-2507).
     if (!fs.existsSync(socket))
         return [];
     let res;
@@ -1743,11 +1117,6 @@ export async function listTmuxAgentSessions() {
             socket,
             args: ['list-panes', '-a', '-F', ['#{pane_id}', '#{session_name}', '#{pane_pid}', '#{pane_dead}', '#{pane_current_path}'].join(TMUX_FIELD_SEP)],
             throwOnError: false,
-            // A wedged tmux server must not hang the whole active-session scan. The
-            // catch below turns a timeout into a DEGRADED-tmux-source signal (the
-            // other sources still report) rather than a frozen `agents sessions
-            // --active` — and, crucially, no longer collapses into the same silent
-            // `[]` a genuinely-idle socket returns (RUSH-2507).
             timeoutMs: TMUX_LIST_PANES_TIMEOUT_MS,
         });
     }
@@ -1757,9 +1126,6 @@ export async function listTmuxAgentSessions() {
     if (res.code !== 0) {
         throw new TmuxDiscoveryDegradedError(`tmux list-panes on ${socket} exited ${res.code}: ${res.stderr.trim() || res.stdout.trim()}`);
     }
-    // Index live launches by the pane they target, so a pane we did NOT wrap (a
-    // split) resolves to its own agent. Newest launch wins a pane (pid reuse), and
-    // only live pids count — a dead agent's stale entry can't light up its old pane.
     const liveByPane = new Map();
     for (const recorded of listPidSessionEntries()) {
         const e = readPidSessionEntry(recorded.pid);
@@ -1769,22 +1135,14 @@ export async function listTmuxAgentSessions() {
         if (!prev || e.startedAtMs > prev.startedAtMs)
             liveByPane.set(e.tmuxPane, e);
     }
-    // Hook index is scanned lazily — only when a live launch lacks a recorded id
-    // (a non-Claude split) and needs the SessionStart-hook join.
     let hookIndex;
     const getHookIndex = () => (hookIndex ??= loadHookSessionIndex());
-    // Resolve every `ag-<agent>-<shortid>` pane name to its full session UUID in one
-    // batched DB round-trip, so resolvePaneIdentity can recover the id straight from
-    // the pane name — the signal present on 100% of ag-* panes when the durable
-    // identity stores are empty.
     const nameToFullId = resolveNamesToSessionIds(res.stdout.split('\n').map((l) => l.split(TMUX_FIELD_SEP)[1]).filter((n) => !!n), { findSessionsByShortIds });
     const out = [];
     const seen = new Set();
     for (const line of res.stdout.split('\n')) {
         if (!line.trim())
             continue;
-        // The path is the LAST field, so rejoin its tail: a directory containing the
-        // separator must not truncate it (the earlier fields cannot contain one).
         const parts = line.split(TMUX_FIELD_SEP);
         const [pane, sessName, pidRaw, paneDeadRaw] = parts;
         const curPath = parts.slice(4).join(TMUX_FIELD_SEP);
@@ -1793,19 +1151,8 @@ export async function listTmuxAgentSessions() {
         const meta = readSessionMeta(sessName);
         const liveEntry = liveByPane.get(pane);
         let id = resolvePaneIdentity(pane, sessName, meta, liveEntry, getHookIndex, nameToFullId);
-        // Only a genuinely foreign pane — no live entry, no meta labels, and not one
-        // of our `ag-*` names — is dropped now; every agent pane survives to be either
-        // id-resolved or emitted as its own distinct id-less row.
         if (!id)
             continue;
-        // RUSH-2007 Layer A: a non-Claude tmux session whose id resolved via neither the
-        // launch registry (no id minted at spawn) nor the session-tracker index (not
-        // deployed on the fleet — its dir is empty) — backfill it from the DEPLOYED
-        // hook's own per-pid record at state/sessions/<pid>.json. Targeted single-file
-        // reads on the pane leaf pid, then the registry launch pid; freshness-guarded by
-        // the launch's known start so a reused-pid graveyard file can't cross sessions.
-        // Without this the session surfaces id-less (keyed on the bare pane) and is
-        // invisible to `agents sessions focus` — the remaining RUSH-2007 discovery gap.
         if (!id.sessionId) {
             const panePid = parseInt(pidRaw, 10) || undefined;
             const backfilled = (panePid ? readStateSessionRecord(panePid, liveEntry?.startedAtMs)?.session_id : undefined)
@@ -1816,34 +1163,18 @@ export async function listTmuxAgentSessions() {
         if (id.sessionId && shortIdFromName(sessName)) {
             writeSessionAliasRecord(id.sessionId, sessName);
         }
-        // Dedupe by resolved session id; an as-yet-unresolved id (a hookless/lagging
-        // split) keys on the unique pane so it still surfaces as its own row.
         const dedupKey = id.sessionId ?? pane;
         if (seen.has(dedupKey))
             continue;
         seen.add(dedupKey);
-        // Prefer the registry pid (the agent), falling back to the pane leaf pid. A
-        // pid we emit here goes into getActiveSessions' attributed set, so the ps-scan
-        // does NOT also surface this agent as a duplicate headless row.
         const pid = id.pid ?? (parseInt(pidRaw, 10) || undefined);
         const cwd = liveEntry?.cwd ?? meta?.cwd ?? (curPath || undefined);
-        // Only resolve a transcript when we KNOW the session id. With no id,
-        // findSessionFileForKind falls back to the newest .jsonl in the cwd — which
-        // collapses every co-located pane onto one stranger's transcript (the ×N-badge
-        // bug). Refuse to guess: an id-less pane surfaces as its own row instead.
         const sessionFile = id.sessionId ? findSessionFileForKind(id.agent, cwd, id.sessionId) : undefined;
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        // `remain-on-exit` retains the pane after its child exits. pane_dead is the
-        // authoritative signal; a retained pane is diagnostic, not attachable.
         const paneDead = paneDeadRaw === '1';
         const pidAlive = !paneDead && (pid ? isPidAlive(pid, liveEntry?.startedAtMs) : true);
         const { state, tokPerSec } = computeLiveSignals(id.agent, sessionFile, cwd, pidAlive);
         const { birthtimeMs, mtimeMs } = sessionFileTimes(sessionFile);
-        // The mux/reply rails are known exactly here (the pane IS a tmux pane), so we
-        // stamp them off the pane. `transport:'local'` is only a placeholder: the pane
-        // can't reveal how the shell above it was reached. enrichProvenance later reads
-        // the pane process's env and upgrades this to 'ssh' (with the real origin) when
-        // SSH_CONNECTION is present, while preserving this mux/reply.
         const provenance = {
             host: os.hostname(),
             transport: 'local',
@@ -1861,34 +1192,18 @@ export async function listTmuxAgentSessions() {
             topic,
             tokPerSec,
             sessionFile,
-            // Prefer the launch registry's start when known (more accurate than
-            // transcript birth for a resumed/reused file); else transcript times.
             startedAtMs: liveEntry?.startedAtMs ?? birthtimeMs,
             lastActivityMs: mtimeMs,
             provenance,
             owner: resolveOwner(liveEntry?.actor, id.sessionId ?? sessionIdFromFile(sessionFile)),
-            // Factory / --active join key: AGENT_TERMINAL_ID stamped on the launch
-            // registry and preserved by SessionStart. Without this, Grok/Codex tmux
-            // panes never surface terminalId even when by-pid has it (RUSH-2192).
             launchId: liveEntry?.launchId,
             terminalId: liveEntry?.terminalId,
-            // An id-less pane keys its dedupe on the unique pane, so two anonymous
-            // co-located panes stay two rows instead of folding into one.
             paneId: id.sessionId ?? sessionIdFromFile(sessionFile) ? undefined : pane,
-            // The tmux session name is the one selector an id-less row still exposes —
-            // its `<shortid>` suffix is what `sessions inject` matches on (PHNX-3688).
             tmuxName: sessName,
         }, state, sessionFile, pidAlive));
     }
     return out;
 }
-/**
- * Union of all sources. Teams and terminals spawn actual CLI processes that
- * also show up in `ps`, so headless attribution runs last with the already-
- * attributed PIDs removed. The tmux source goes FIRST into the dedupe so a
- * tmux-hosted agent's row (which carries the exact `%pane`) wins over a staler
- * terminal/headless row for the same session id.
- */
 export async function getActiveSessions(opts = {}) {
     if (!writerProcessView()) {
         const { loadLocalActiveSessions } = await import('./session-cache.js');
@@ -1917,29 +1232,12 @@ export async function getActiveSessions(opts = {}) {
     foldPresence(merged);
     await foldTmuxClients(merged);
     foldHostLink(merged);
-    // Runs before the row leaves this box so every consumer — local render, the
-    // `--json` a peer answers a fan-out with, the browser's device filter — sees
-    // the EXECUTION host rather than the dispatcher (RUSH-2479).
     foldExecutionMachine(merged, recordedMachineLookup(merged), machineId());
     annotateOrchestratorLabels(merged);
-    // Last: derive the shown title (recap ladder) from label/tail/topic now that
-    // every row's live tail + label are resolved (RUSH-3011).
     foldRecap(merged);
-    // Project the coarse lifecycle bucket once status is final (foldHostLink above may
-    // have promoted a row to orphaned/crashed) so consumers read `phase` off the row
-    // instead of re-deriving it (PHNX-2484).
     foldPhase(merged);
     return merged;
 }
-/**
- * Cheap post-hoc health probe for the local discovery sources. `getActiveSessions`
- * always swallows a source failure to `[]` so its return type stays a plain
- * session array — this re-probes the same sources and reports which ones threw,
- * so a caller that got an empty list back can tell "genuinely nothing running"
- * apart from "a source errored and got silently folded into empty" (RUSH-2507).
- * Intended for the empty-result branch only, not the hot path — it repeats a
- * `list-panes` call `getActiveSessions` already made.
- */
 export async function describeActiveDiscoveryHealth() {
     const degradedSources = [];
     try {
@@ -1951,14 +1249,6 @@ export async function describeActiveDiscoveryHealth() {
     }
     return { degradedSources };
 }
-/**
- * True when a live agent process on this host carries `--session-id <id>` in
- * its argv. RUSH-2384 last-resort for `agents message`: getActiveSessions can
- * still miss a row (teams status flap, attributed-ancestor skip), but the
- * process table + argv are ground truth for "this session is alive and
- * mailbox-reachable". Only UUID-shaped ids are accepted so a short prefix
- * never false-matches.
- */
 export async function isSessionIdLiveOnProcessTable(sessionId, deps = {}) {
     if (!isSessionIdShape(sessionId))
         return false;
@@ -1972,22 +1262,6 @@ export async function isSessionIdLiveOnProcessTable(sessionId, deps = {}) {
     }
     return false;
 }
-/**
- * Fold tmux's attached-client count onto every tmux-hosted row.
- *
- * Keyed off `provenance.mux` — which {@link enrichProvenance} has already stamped
- * on any row whose process env names a tmux pane — rather than off
- * {@link listTmuxAgentSessions}. That source only emits a row when it can resolve
- * the pane's agent IDENTITY (launch registry or session meta), and on a machine
- * where neither resolves it emits nothing at all while the same sessions still
- * arrive through the terminal/headless sources carrying full tmux provenance.
- * Hanging the client count off the identity-resolving source would have made the
- * whole orphan signal silently dead on exactly those machines.
- *
- * One `list-panes` per distinct socket, and only when some row is tmux-hosted —
- * a fleet with no tmux pays nothing. A query failure leaves the count undefined,
- * which the classifier reads as "cannot tell", never as a false zero.
- */
 export async function foldTmuxClients(rows) {
     const tmuxRows = rows.filter((s) => s.provenance?.mux?.kind === 'tmux' && s.provenance.mux.pane);
     if (tmuxRows.length === 0)
@@ -2009,14 +1283,12 @@ export async function foldTmuxClients(rows) {
                 if (!pane)
                     continue;
                 const n = parseInt(attached ?? '', 10);
-                // A tmux too old to report `session_attached` yields NaN — leave the pane
-                // unmapped so it stays "cannot tell" rather than becoming a false zero.
                 if (Number.isFinite(n))
                     byPane.set(pane, n);
             }
         }
         catch {
-            continue; // best-effort: no count is honest, a guessed count is not
+            continue;
         }
         for (const s of tmuxRows) {
             if (s.provenance.mux.socket !== socket)
@@ -2027,56 +1299,6 @@ export async function foldTmuxClients(rows) {
         }
     }
 }
-/**
- * Fold the host link onto each row and, where it changes the answer, onto the
- * status. Runs AFTER {@link foldPresence}, because a deliberately backgrounded
- * session (`presence` `background`/`parked`) is supposed to have no client and
- * must not be reported as an orphan.
- *
- * Precedence is deliberate, and the two new statuses slot in where they add
- * information rather than destroy it:
- *
- *   - `abandoned` wins outright. A days-stale session is already dangling; that
- *     it also lost its window is not the headline, and it keeps a crashed row
- *     from lingering as an alert forever.
- *   - `crashed` REPLACES `closed`. Both mean the process is gone, but `closed`
- *     reads as a normal exit; `crashed` says the host window went down with it
- *     and never cleaned up.
- *   - `orphaned` replaces `idle` / `input_required` on ANY `no-client`, and
- *     `running` ONLY when the owning WINDOW was lost (`hostWindowLost`). A
- *     session still working with merely zero tmux clients is a normal headless
- *     run — since RUSH-3125 a detached remote pane is the steady state — so
- *     flagging every one would bury the real signal (the false positive reverted
- *     in 6d973b823). But a running agent whose IDE window stopped republishing
- *     its heartbeat outlived an unclean host death and is genuinely stranded, so
- *     it IS promoted. A session sitting idle — or worse, waiting on a question —
- *     with no client attached is the same stranded case: nobody is coming.
- */
-/**
- * Attribute each live row to the machine the session actually EXECUTES on.
- *
- * A host-dispatched run (`agents run --device <peer>`) leaves a live process on
- * the DISPATCHING box — the ssh/TTY shim — carrying the remote run's session id.
- * Nothing about that local process knows the agent is on the peer, so the row
- * was tagged with THIS machine: `--device <dispatcher>` then claimed a session
- * that is not running here, and its preview dead-ended at "full transcript not
- * indexed here" because the transcript lives on the peer (RUSH-2479).
- *
- * The dispatch already recorded the truth. `registerHostSession` /
- * `registerInteractiveHostSession` write the index row with
- * `machine: normalizeHost(task.host)` (`lib/hosts/session-index.ts:55,134`), so
- * this folds that recorded machine back onto the live row. Every consumer then
- * agrees on one owner: the `--device`/`--device` scope, the browser's device
- * filter, `_remote`/preview routing (`liveSessionToMeta`), and the id resolver.
- *
- * Two rows are deliberately left alone:
- *   - one the cross-machine fan-out already attributed to a peer — that is the
- *     peer's own self-report, which outranks this box's index copy;
- *   - one whose indexed machine IS this box — nothing was offloaded.
- *
- * Pure over the array; `machineOf` is injected so the join is unit-tested
- * without a SQLite index.
- */
 export function foldExecutionMachine(rows, machineOf, self) {
     for (const s of rows) {
         if (!s.sessionId)
@@ -2090,72 +1312,26 @@ export function foldExecutionMachine(rows, machineOf, self) {
         s.offloadedFrom = self;
     }
 }
-/**
- * Is the PROCESS behind this row running on this machine?
- *
- * `machine` answers a different question — "where does the agent execute" —
- * which is what a `--device` scope, preview routing, and resume ownership need.
- * For an offloaded run the two answers diverge: {@link foldExecutionMachine}
- * points `machine` at the peer, while the shim process, its tmux pane, and its
- * terminal window are all still HERE. `offloadedFrom` marks exactly that row.
- *
- * Any caller reaching for a LOCAL pid, pane, or window must ask this rather
- * than `machine === self`. A local tmux pane id (`%N`) handed to a peer's tmux
- * server does not fail — pane ids are small per-server integers, so it can
- * resolve against an unrelated pane and attach the user to someone else's
- * session. That is why this predicate exists instead of ten copies of the
- * comparison.
- */
 export function sessionProcessIsLocal(s, self) {
-    // `offloadedFrom` names WHICH box holds the shim, so it must be compared, not
-    // merely tested. These rows travel: `--active --json` spreads them verbatim
-    // and the fan-out preserves their foreign `machine`, so a THIRD box sees
-    // `{machine: B, offloadedFrom: A}` — a shim that is emphatically not its own.
-    // Answering "local" there sends the caller down the local-tmux path with
-    // A's pane id, attaching an unrelated pane on C: the same hazard this
-    // predicate exists to prevent, one machine over.
     if (s.offloadedFrom)
         return s.offloadedFrom === self;
     return !s.machine || s.machine === self;
 }
-/**
- * The machine to reach for this session's PROCESS — its pid, tmux pane, and
- * window — or `undefined` when that process is right here.
- *
- * Not the same as `machine`, which is where the AGENT executes. For an offloaded
- * run the process lives on the dispatcher (`offloadedFrom`) while the agent runs
- * on the peer, so a caller that ssh'd to `machine` would carry the dispatcher's
- * pane id to a box that never had it.
- */
 export function sessionProcessHost(s, self) {
     if (sessionProcessIsLocal(s, self))
         return undefined;
     return s.offloadedFrom ?? s.machine;
 }
-/**
- * The index lookup behind {@link foldExecutionMachine}. One batched query for
- * every live row (`findSessionMachinesByIds`), not a per-row `SELECT *` —
- * `getActiveSessions` is a hot path the daemon, menubar, and watchdog all poll.
- * Best-effort: an unavailable DB yields an empty map, leaving rows attributed
- * to this box rather than failing the whole live view.
- */
 function recordedMachineLookup(rows) {
     const byId = findSessionMachinesByIds(rows.map((s) => s.sessionId).filter((id) => !!id));
     return (id) => byId.get(id);
 }
 export function foldHostLink(rows) {
     for (const s of rows) {
-        // Cloud tasks have no local pid, window, or tmux server; there is no host
-        // link to classify and no honest answer to give.
         if (s.context === 'cloud')
             continue;
-        // A days-stale row is already `abandoned`; whether its window is also gone
-        // adds nothing, and its pid liveness is genuinely unknown from the status
-        // (abandoned outranks closed), so claim no host link rather than guess one.
         if (s.status === 'abandoned')
             continue;
-        // `closed` IS the dead-pid status — `lifecycleStatus` assigns it from
-        // `!pidAlive` and nothing else — so the status is the pid answer here.
         const signals = {
             pidAlive: s.status !== 'closed',
             windowHeartbeatMs: s.windowHeartbeatMs,
@@ -2164,69 +1340,29 @@ export function foldHostLink(rows) {
         };
         const link = classifyHostLink(signals);
         s.hostLink = link;
-        // `foldPresence` gives every terminal row a DERIVED `attached` — "a live
-        // interactive TUI you're watching" — which is exactly the claim a lost host
-        // disproves. A stored record never yields `attached` (it is background or
-        // parked), so clearing only that value drops the derived lie and leaves a
-        // real detach record untouched.
-        // Only a POSITIVE loss signal disproves a derived `attached`. `unknown` means
-        // we never looked — a bare terminal with no IDE window and no tmux has
-        // neither input — so it must not clear presence, or every plain-terminal
-        // session the user is sitting in would lose its `attached` marker.
         if ((link === 'no-client' || link === 'host-gone') && s.presence === 'attached') {
             s.presence = undefined;
         }
         if (link === 'host-gone' && s.status === 'closed')
             s.status = 'crashed';
-        // A clientless running remote pane is normal; only stopped work can be called orphaned.
         else if (link === 'no-client' && (s.status === 'idle' || s.status === 'input_required')) {
             s.status = 'orphaned';
         }
-        // A still-`running` agent is normally a healthy headless run, so 0 tmux
-        // clients (a detached remote pane) MUST NOT flag it — that false positive was
-        // reverted once already (6d973b823). The ONE exception is a lost WINDOW: its
-        // owning IDE window stopped republishing, so it died uncleanly and the agent
-        // outlived it — genuinely stranded (PHNX-3183, `hostWindowLost`, SES-18a).
         else if (s.status === 'running' && hostWindowLost(signals)) {
             s.status = 'orphaned';
         }
     }
 }
-/** One display line, trimmed and capped, or undefined when empty. */
 function recapLine(s, max = 120) {
     const t = s?.replace(/\s+/g, ' ').trim();
     if (!t)
         return undefined;
     return t.length > max ? t.slice(0, max - 1).trimEnd() + '…' : t;
 }
-/**
- * The headline ladder (PHNX-3797): an explicit `/rename` label, then the
- * daemon-generated title, then the classified user prompt.
- *
- * The prompt rung classifies the RAW latest genuine user turn, not the
- * already-collapsed `topic` (PHNX-3939). Classifying `topic` was how a `/model`
- * echo or a skill body became a session's displayed title: `extractSessionTopic`
- * accepted text `cleanFirstUserMessage` rejected, and the recap then dressed up
- * that scaffolding as the user's words. It also never saw the row's attachments,
- * so an image-only turn could not be recognized. A row that has already been
- * merged with a daemon-folded {@link ActiveSession.request} uses it directly.
- *
- * The agent's last transcript line is deliberately NOT a rung. It is still
- * returned as `lastAgentLine` — and still shown, in the separate live
- * preview/activity slot — but a rolling monologue is not what the session IS,
- * and using it as the headline is the defect this ladder fixes. A session the
- * titler has not reached yet falls back to the classified user prompt, never
- * to the agent's last line.
- */
 export function deriveSessionRecap(row) {
     const lastAgentLine = recapLine(row.tail?.length ? row.tail[row.tail.length - 1] : undefined);
     const raw = row.lastUserMessage ?? row.firstUserMessage ?? row.topic ?? '';
-    // No `turns` here on purpose: this tidy sees ONE turn, not the transcript, so
-    // it cannot count them. The daemon fold sets it (see SessionRequest.turns).
     const tidied = row.request ?? tidyRequest(raw, { attachments: row.attachments });
-    // No genuine turn to show (a synthetic-only transcript, or nothing indexed
-    // yet): fall back to the legacy classifier over whatever `topic` holds rather
-    // than showing an empty prompt rung.
     const fallback = tidied ? undefined : classifyUserPrompt(row.topic ?? '', {
         hasImageAttachment: row.attachments?.some((a) => a.mediaType?.startsWith('image/')),
     });
@@ -2258,28 +1394,13 @@ export function deriveSessionRecap(row) {
         ...(tidied ? { request: tidied } : {}),
     };
 }
-/**
- * The row's SECONDARY line (PHNX-3797 owner feedback): the most important recent
- * agent message, ranked so the operator sees a block before generic chatter —
- * a pending question, then a needs-you wait (plan review / permission /
- * input-required), then the current activity (the agent's latest line). Returns
- * `undefined` only when there is nothing recent to show at all.
- *
- * Pure over the fields it reads so the ranking is unit-tested directly; folded
- * onto every row by {@link applyRecap} beside the {@link deriveSessionRecap} title.
- */
 export function deriveImportantMessage(row) {
-    // The agent's latest words — the fallback text for every kind. `lastAgentLine`
-    // is already trimmed/capped; `preview` (a live tool/turn line) is not.
     const recent = recapLine(row.preview) ?? row.lastAgentLine;
-    // A pending question is the single most important thing an agent can be saying.
     if (row.awaitingReason === 'question' || row.question) {
         const text = recapLine(row.question?.text) ?? recent;
         if (text)
             return { text, kind: 'question' };
     }
-    // Blocked on the operator: a plan review, a permission decision, or a bare
-    // input-required wait. The "needs you" case the Fleet has to make loud.
     const needsYou = row.awaitingReason === 'plan_review'
         || row.awaitingReason === 'permission'
         || row.status === 'input_required'
@@ -2292,12 +1413,10 @@ export function deriveImportantMessage(row) {
                 : 'Waiting for you';
         return { text: recent ?? fallback, kind: 'needs_you' };
     }
-    // Nothing blocking — just what the agent is doing now.
     if (recent)
         return { text: recent, kind: 'activity' };
     return undefined;
 }
-/** Write one row's recap fields from its current label/generatedTitle/topic/tail. */
 function applyRecap(s) {
     const recap = deriveSessionRecap(s);
     s.title = recap.title;
@@ -2307,24 +1426,12 @@ function applyRecap(s) {
     s.lastAgentLine = recap.lastAgentLine;
     if (recap.request)
         s.request = recap.request;
-    // The secondary line rides the same fold as the headline (PHNX-3797), so every
-    // consumer that reads `title` off a row reads `importantMessage` beside it.
     s.importantMessage = deriveImportantMessage(s);
 }
-/** Fold the recap ladder onto every row (see {@link deriveSessionRecap}). */
 export function foldRecap(rows) {
     for (const s of rows)
         applyRecap(s);
 }
-/**
- * Project a {@link SessionPhase} from the finalized {@link ActiveStatus} (PHNX-2484).
- * This is the single source of truth the AGI EXT previously mirrored as
- * `mapStatusToPhase` — the ext now reads the `phase` field instead of re-deriving it.
- * `queued` counts as `running` (dispatched, in the pipeline); `abandoned`, `orphaned`,
- * and `crashed` all bucket to `failed` (dangling/dead — needs attention), which is the
- * drift this fixes: those three used to fall through a status-only map to `idle` and
- * silently hide a dead agent.
- */
 export function derivePhase(status) {
     switch (status) {
         case 'running':
@@ -2344,21 +1451,13 @@ export function derivePhase(status) {
             return 'idle';
     }
 }
-/** Fold the coarse lifecycle {@link SessionPhase} onto every row (see {@link derivePhase}). */
 export function foldPhase(rows) {
     for (const s of rows)
         s.phase = derivePhase(s.status);
 }
-/** Reap only stale sessions with proven-dead pids; unknown or live processes remain recoverable. */
 export function isReapableOrphan(row) {
     return row.status === 'abandoned' && row.pidAlive === false;
 }
-/**
- * Resolve each teams row's `orchestratorLabel` from the orchestrator's own row,
- * when that orchestrator session is itself in the active set (it usually is — the
- * agent that ran `agents teams add` is running). Falls back to nothing, so the
- * renderer shows the short id. Pure over the array; exported for tests.
- */
 export function annotateOrchestratorLabels(sessions) {
     const byId = new Map();
     for (const s of sessions)
@@ -2368,17 +1467,11 @@ export function annotateOrchestratorLabels(sessions) {
         if (!s.orchestratorSessionId)
             continue;
         const orch = byId.get(s.orchestratorSessionId);
-        // ladder-exempt: the team orchestrator's LABEL, resolved before any index backfill (no generatedTitle exists yet); not a headline render.
+        // ladder-exempt: pre-index team label, not a headline render.
         if (orch)
             s.orchestratorLabel = orch.label || orch.topic || undefined;
     }
 }
-/**
- * Fold detach/attach presence onto each row from the detach store. A stored
- * record wins (`background`/`parked`); otherwise a live terminal session is
- * `attached`. Ad-hoc headless runs and cloud/team rows stay unmarked — they are
- * not on the foreground/background axis.
- */
 function foldPresence(rows) {
     for (const s of rows) {
         if (!s.sessionId)
@@ -2390,23 +1483,6 @@ function foldPresence(rows) {
             s.presence = 'attached';
     }
 }
-/**
- * Attach provenance (host / local-vs-SSH / tmux pane / reply rail) to every
- * session that has a live pid. Mutates in place. Runs after dedupe so we probe
- * each session once, not once per fork pid. Probes run in parallel — each is a
- * single /proc read (Linux) or `ps` call (macOS); failures leave `provenance`
- * undefined rather than blocking the listing. The probes use the same bounded
- * concurrency as the adjacent per-PID lsof sweep so large session lists cannot
- * spawn one `ps eww` subprocess per row at once on macOS.
- *
- * A row that already carries provenance (the tmux path, which knows its exact
- * mux/reply from the pane) is not skipped — it is probe-and-MERGED. The tmux
- * path can only stamp a `transport:'local'` placeholder because the pane alone
- * doesn't reveal how the shell above it was reached; the process env does. So we
- * still read the env and fill in the real SSH origin/term, while preserving the
- * authoritative mux/reply the pane already gave us. Skipping this (the old
- * behavior) is exactly why ssh-launched tmux sessions rendered as local.
- */
 export async function enrichProvenance(sessions, probe = detectProvenance) {
     await mapBounded(sessions, async (s) => {
         if (!s.pid)
@@ -2418,8 +1494,6 @@ export async function enrichProvenance(sessions, probe = detectProvenance) {
             s.provenance = probed;
             return;
         }
-        // Row already carries exact mux/reply (the tmux path). Fill only what a
-        // pre-set provenance can't know from the pane alone: the real launch origin.
         if (probed.transport === 'ssh' && !s.provenance.ssh) {
             s.provenance.transport = 'ssh';
             s.provenance.ssh = probed.ssh;
@@ -2428,11 +1502,6 @@ export async function enrichProvenance(sessions, probe = detectProvenance) {
             s.provenance.term = probed.term;
     }, { concurrency: LSOF_CONCURRENCY });
 }
-/**
- * Match an SSH client IP to a registered device (pure — testable with a plain
- * registry object). Returns the device name + ssh login user when the IP is a
- * known device address.
- */
 export function matchOriginDevice(clientIp, reg) {
     for (const d of Object.values(reg)) {
         if (d.address?.ip && d.address.ip === clientIp) {
@@ -2441,12 +1510,6 @@ export function matchOriginDevice(clientIp, reg) {
     }
     return undefined;
 }
-/**
- * Resolve the initiating device for every ssh-transport session by matching its
- * `ssh.clientIp` against the device registry. Read-only and best-effort: a
- * registry that can't be loaded, or an IP that matches no device, leaves
- * `origin` undefined (the raw client IP is still on `ssh`). Mutates in place.
- */
 async function resolveOrigins(sessions) {
     const needing = sessions.filter((s) => s.provenance?.ssh && !s.provenance.origin);
     if (needing.length === 0)
@@ -2464,29 +1527,11 @@ async function resolveOrigins(sessions) {
             s.provenance.origin = match;
     }
 }
-/**
- * Identity for a row the scan could not tie to a session: a daemon's worker
- * processes (an OpenClaw gateway spawning `codex`, a supervisor pool) have no
- * session id, no transcript file, and no cloud/run handle — nothing tells two of
- * them apart, because nothing distinguishes them. Same binary + same working
- * directory + same context IS the identity, so N indistinguishable workers
- * collapse to one row carrying `pidCount: N`.
- *
- * Returns undefined with no cwd: without it there is no stable identity, and
- * keying on kind alone would fold unrelated agents onto one row.
- */
 function anonymousWorkerKey(s) {
     if (!s.cwd)
         return undefined;
     return `anon\0${s.kind}\0${s.context}\0${s.cwd}`;
 }
-/**
- * Collapse rows that resolve to the *same* session — a session with many
- * subagent/fork PIDs (all matched to one transcript file) would otherwise print
- * dozens of identical rows. Keyed by session id, falling back to the transcript
- * file, then the cloud/run handle, then {@link anonymousWorkerKey}. The first row
- * wins and carries a `pidCount`.
- */
 export function dedupeBySession(sessions) {
     const out = [];
     const byKey = new Map();
@@ -2498,7 +1543,6 @@ export function dedupeBySession(sessions) {
         }
         const existing = byKey.get(key);
         if (existing) {
-            // Carry pre-folded fork counts (headless rows arrive with pidCount set).
             existing.pidCount = (existing.pidCount ?? 1) + (s.pidCount ?? 1);
         }
         else {