@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/commands/sessions.js

@@ -1,12 +1,3 @@
-/**
- * Session discovery, search, and rendering commands.
- *
- * Implements `agents sessions` -- the unified interface for finding, browsing,
- * and reading agent conversation transcripts across Claude, Codex, Gemini,
- * and OpenCode. Supports interactive picker mode, text/path search, markdown
- * and JSON rendering, role/turn filtering, artifact inspection, and session
- * resume via agent-native CLI flags.
- */
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
@@ -19,33 +10,31 @@ import { resolveProjectKey } from '../lib/project-key.js';
 import { listProjectDefs, resolveProjectNameForCwd } from '../lib/projects.js';
 import ora from 'ora';
 import { interruptibleSpinner } from '../lib/spinner.js';
-import { SESSION_AGENTS, isAgentTmuxAlias, sessionDisplayAgent } from '../lib/session/types.js';
-import { discoverArtifacts, readArtifact, resolveArtifact } from '../lib/session/artifacts.js';
+import { SESSION_AGENTS, isAgentTmuxAlias, sessionDisplayAgent } from '@phnx-labs/sessions-cli/reader';
+import { discoverArtifacts, readArtifact, resolveArtifact } from '@phnx-labs/sessions-cli/reader';
 import { looksLikePath, toComparablePath, homeDir, needsWindowsShell, composeWin32CommandLine } from '../lib/platform/index.js';
-import { getActiveSessions, describeActiveDiscoveryHealth, sessionProcessIsLocal, backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson, shortIdFromName } from '../lib/session/active.js';
+import { getActiveSessions, serializeSessionsJson, shortIdFromName } from '../lib/session/active.js';
 export { activeSessionProjectKey, backfillActiveRowsFromIndex, backfillActiveRowsFromMeta, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../lib/session/active.js';
-import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
-import { mapPanesToTargets, listClients } from '../lib/tmux/session.js';
-import { resolveViewingIn, viewingInLabel } from '../lib/session/viewing-in.js';
-import { machineId, normalizeHost } from '../lib/session/sync/config.js';
-import { gatherRemoteActive, NO_FANOUT_ENV } from '../lib/session/remote-active.js';
-import { loadFleetActiveSessions, loadLocalActiveSessions, readActiveSessionsCache, } from '../lib/session/session-cache.js';
+import { viewingInLabel } from '../lib/session/viewing-in.js';
+import { machineId } from '../lib/session/sync/config.js';
+import { NO_FANOUT_ENV } from '../lib/session/remote-active.js';
+import { loadLocalActiveSessions, readActiveSessionsCache, } from '../lib/session/session-cache.js';
 import { gatherRemoteList, gatherRemoteToolProgramCounts, gatherRemoteToolSearch, runOnPeer } from '../lib/session/remote-list.js';
 import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/session/width.js';
-import { inferSessionState } from '../lib/session/state.js';
+import { inferSessionState } from '@phnx-labs/sessions-cli/reader';
 import { discoverSessions, queryIndexedSessions, countSessionsInScope, resolveSessionById, isCompleteSessionId, looksLikeSessionId, searchContentIndex, getSessionRoots, scopeToManaged } from '../lib/session/discover.js';
 import { findSessionsById, querySessions, readSessionContent, readArchivedSessionPreview, readSessionTimelineAny } from '../lib/session/db.js';
-import { foldTimeline, emptyTimelineState, projectTimeline, projectSessionFiles } from '../lib/session/timeline.js';
-import { readSessionTail } from '../lib/session/tail.js';
+import { foldTimeline, emptyTimelineState, projectTimeline, projectSessionFiles } from '@phnx-labs/sessions-cli/reader';
+import { readSessionTail } from '@phnx-labs/sessions-cli/reader';
 import { liveSessionMetas, fleetExecutionMachineById, reconcileLiveMetaMachine } from '../lib/session/live-metadata.js';
 import { sessionHeadline } from '../lib/session/title.js';
-import { filterTeamSessions, shouldShowTeamSessions, safeTeamText, groupSessionsByTeam, NO_TEAM_GROUP_KEY, } from '../lib/session/team-filter.js';
-import { parseSession } from '../lib/session/parse.js';
+import { filterTeamSessions, shouldShowTeamSessions, safeTeamText, groupSessionsByTeam, NO_TEAM_GROUP_KEY, } from '@phnx-labs/sessions-cli/reader';
+import { parseSession } from '@phnx-labs/sessions-cli/reader';
 import { runRemoteSessions, buildForwardedArgs, ensureWholeIndex } from '../lib/session/remote.js';
-import { formatRelativeTime, formatCompactAge, sessionAgeParts } from '../lib/session/relative-time.js';
-import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList, linkPath, linkUrl, shortenModel, formatTokenCount } from '../lib/session/render.js';
-import { linearIssueUrl } from '../lib/session/linear.js';
+import { formatRelativeTime, sessionAgeParts } from '../lib/session/relative-time.js';
+import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList, linkPath, linkUrl, shortenModel, formatTokenCount } from '@phnx-labs/sessions-cli/reader';
+import { linearIssueUrl } from '@phnx-labs/sessions-cli/reader';
 import { sessionOwnerDevice, RESUME_PINNED_ENV } from '../lib/session/resume-owner.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { AGENTS, colorAgent, resolveAgentName } from '../lib/agents.js';
@@ -59,8 +48,9 @@ import { listInstalledVersions, resolveVersionAliasLoose } from '../lib/installa
 import { getAgentsInvocation } from '../lib/daemon/daemon.js';
 import { sessionAgentSupportsResume, sessionRecoveryRunArgs } from '../lib/session/recovery.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { sessionPicker, buildPreview, loadSessionPreviewDigest, transcriptOnPeerOf, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
+import { sessionPicker, buildPreview, loadSessionPreviewDigest, transcriptOnPeerOf, formatTodoCompact, } from './sessions-picker.js';
 import { setHelpSections } from '../lib/help.js';
+import { cleanPreview, gatherActiveSessions, indexActiveBySessionId, isAwaitingUser, liveGlyphAndPreview, liveStatusWord, remoteHostsToDial, requestedLiveStatuses, resolveRoutineName, runLiveRoster, shouldIncludeLocal, signalBadges, statusColor, } from './ps-roster.js';
 import { registerSessionsTailCommand } from './sessions-tail.js';
 import { registerSessionsResumeCommand } from './sessions-resume.js';
 import { registerSessionsForkCommand } from './fork.js';
@@ -90,17 +80,7 @@ const SESSION_AGENT_FILTER_HELP = `Filter by agent, e.g. claude, codex, claude@2
 function collectQueryClause(value, previous) {
     return [...previous, value];
 }
-/**
- * The prioritized harnesses that get a boolean shorthand flag (e.g. `--claude`
- * === `--agent claude`). The rest stay reachable via `--agent <name>`, which
- * also carries version pins like `codex@0.116.0`.
- */
 const AGENT_SHORTHANDS = ['claude', 'codex', 'kimi', 'antigravity', 'grok', 'opencode'];
-/**
- * Resolve a per-agent shorthand (`--claude`, `--kimi`, …) into `options.agent`.
- * An explicit `--agent` wins; if two shorthands are passed we take the first and
- * ignore the rest (commander gives no ordering, so this is a best-effort alias).
- */
 function applyAgentShorthands(options) {
     if (options.agent)
         return;
@@ -108,10 +88,6 @@ function applyAgentShorthands(options) {
     if (hit)
         options.agent = hit;
 }
-/**
- * Treat a positional `agent@version` as a structured filter only when it names
- * a real installed version. Everything else remains ordinary free-text search.
- */
 export function parseInstalledAgentVersionQuery(query, installedVersions = (agent) => (agent in AGENTS ? listInstalledVersions(agent) : [])) {
     const trimmed = query?.trim();
     if (!trimmed)
@@ -149,7 +125,6 @@ function applyVersionFilters(query, options) {
 const CLAUDE_RESUME_MATCH_WINDOW_MS = 10 * 60_000;
 const LOAD_VERBS = ['Loading', 'Scanning', 'Gathering', 'Indexing', 'Reading'];
 const FIND_VERBS = ['Finding', 'Searching', 'Locating', 'Matching'];
-/** Build a spinner-backed progress tracker that cycles through verbs while scanning sessions. */
 function createScanProgressTracker(verbs, suffix, spinner) {
     const counts = new Map();
     let verbIndex = 0;
@@ -186,24 +161,11 @@ function createScanProgressTracker(verbs, suffix, spinner) {
     };
 }
 const PICKER_RECENT_COUNT = 15;
-/**
- * The `--limit` default, shared with its `.option()` registration. Commander fills
- * the default in, so `options.limit` is never falsy — code that wants to know
- * whether the USER set a limit has to compare against this rather than test
- * truthiness.
- */
 const DEFAULT_LIMIT = '50';
-/** Pool size for `--in-team`: one team's rows can sit anywhere in the history. */
 const WHOLE_TEAM_POOL_LIMIT = 5000;
-// The grouped default view ("overview"): fetch a generous recency-ordered pool
-// for accurate per-project totals, show each project's most-recent rows grouped
-// by project, newest-active project first.
-const OVERVIEW_ROWS_PER_PROJECT = 5; // recent rows shown per project before "· N more"
-const OVERVIEW_POOL_LIMIT = 1000; // fetch cap — accurate per-project totals up to this
-const OVERVIEW_MAX_PROJECTS = 12; // project groups shown before "+N more projects"
-/**
- * Resolve a path-like query to an absolute directory path.
- */
+const OVERVIEW_ROWS_PER_PROJECT = 5;
+const OVERVIEW_POOL_LIMIT = 1000;
+const OVERVIEW_MAX_PROJECTS = 12;
 function resolvePathFilter(query) {
     const expanded = query.startsWith('~')
         ? path.join(os.homedir(), query.slice(1))
@@ -251,28 +213,6 @@ async function renderArtifactsForSession(session, listAll, name) {
     }
     console.log(chalk.gray(`\n${artifacts.length} artifact${artifacts.length !== 1 ? 's' : ''}.`));
 }
-function statusColor(status) {
-    switch (status) {
-        case 'running': return chalk.green;
-        case 'idle': return chalk.gray;
-        case 'queued': return chalk.blue;
-        case 'input_required': return chalk.yellow;
-        // Dead process: dimmed so it recedes from the live rows without being mistaken
-        // for the gray `idle` (which reads as "done, waiting for you" — a live state).
-        case 'closed': return chalk.dim;
-        // Days-stale / dangling: red so a session nobody is driving stands out.
-        case 'abandoned': return chalk.red;
-        // The host window died and took the agent with it — an unclean exit, not the
-        // dimmed `closed` of a normal one. Red-bright so a crash reads as an event.
-        case 'crashed': return chalk.redBright;
-        // Alive with nobody attached. Yellow, like `input_required`: both mean the
-        // session is stuck waiting on a human, and this one has no human to wait for.
-        case 'orphaned': return chalk.yellow;
-        // Alive but un-introspectable (a harness whose transcript we can't parse).
-        // Magenta so it never reads as the gray "idle" it used to be faked as.
-        case 'unknown': return chalk.magenta;
-    }
-}
 function contextColor(context) {
     switch (context) {
         case 'terminal': return chalk.magenta;
@@ -285,9 +225,6 @@ function shortCwd(cwd) {
     if (!cwd)
         return '-';
     const home = homeDir();
-    // Compare in normalized form so the `~` shorthand also lands on Windows
-    // (case-insensitive, backslash paths); on POSIX this is byte-identical to the
-    // previous `cwd.startsWith(home)`. The displayed tail keeps original casing.
     return toComparablePath(cwd).startsWith(toComparablePath(home))
         ? '~' + cwd.slice(home.length)
         : cwd;
@@ -297,276 +234,13 @@ function formatStartedAt(startedAtMs) {
         return '-';
     return formatRelativeTime(new Date(startedAtMs).toISOString());
 }
-/**
- * Strip terminal/harness noise from a preview so the column stays a single line
- * of plain prose: OSC title escapes, CSI/SGR ANSI, and the harness wrapper tags
- * (`<local-command-stdout>`, `<task-notification>`, `<command-*>`) that leak from
- * a captured transcript tail. Collapses runs of whitespace.
- */
-export function cleanPreview(text) {
-    // eslint-disable-next-line no-control-regex
-    return text
-        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '') // OSC (title) sequences
-        .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '') // CSI / SGR ANSI
-        .replace(/<\/?(?:local-command-stdout|command-name|command-message|command-args|task-notification|system-reminder)>/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-/**
- * Build the live description for an active session: checklist progress (when
- * present) plus the state engine's preview (the latest turn), a user label, or
- * the first-prompt topic. Used by both the flat listing's `doing` cell and as
- * the snippet half of the --active row (identity is layered on in printActiveRow).
- *
- * Covers every ActiveSession context: terminal (interactive), headless, teams,
- * cloud, and sub-agent rows that share the same ActiveSession.todos field.
- */
-export function buildSessionDescription(s) {
-    const todo = formatTodoCompact(s.todos);
-    if (s.context === 'cloud') {
-        const base = s.preview || `${s.cloudProvider ?? ''}${s.cloudTaskId ? ` · ${s.cloudTaskId.slice(0, 12)}` : ''}`;
-        return cleanPreview([todo, base].filter(Boolean).join(' · '));
-    }
-    if (s.context === 'teams') {
-        // A teams row identifies its TEAM, then the teammate within it, then who
-        // spun it up, then what it's working on — so several teams from one
-        // orchestrator stay distinct and each shows its target, not just its slug.
-        const parts = [s.teamName];
-        // Teammate name (distinct from the team slug) — which member this row is.
-        if (s.label && s.label !== s.teamName)
-            parts.push(s.label);
-        // Lineage: which orchestrator spun up this team. Prefer the resolved label,
-        // else the short session id, so "by whom" is answerable at a glance.
-        const orch = s.orchestratorLabel || (s.orchestratorSessionId ? s.orchestratorSessionId.slice(0, 8) : '');
-        if (orch)
-            parts.push(`by ${orch}`);
-        if (todo)
-            parts.push(todo);
-        // Target: the live latest turn if working, else the assigned mission (the
-        // team's task/target, shown even before the teammate has a transcript), else
-        // the transcript topic.
-        const target = s.preview || s.assignedTask || s.topic;
-        if (target)
-            parts.push(target);
-        return cleanPreview(parts.filter(Boolean).join(' · '));
-    }
-    // Terminal, headless, or sub-agent: todos + live preview, then label, then topic.
-    // ladder-exempt: the compact --active preview BASE (a live snippet), not the row's headline title.
-    const base = s.preview || s.label || s.topic || '';
-    return cleanPreview([todo, base].filter(Boolean).join(' · '));
-}
-/**
- * Identity + checklist + live snippet for an --active / cross-machine row.
- * Surfaces agent-adjacent identity the flat table already has (label, project)
- * with a clickable project when a GitHub URL is resolvable, then the checklist
- * tally and the latest-turn snippet.
- *
- * Free-text fields are cleaned individually; OSC 8 hyperlinks are applied
- * *after* cleaning so `cleanPreview` does not strip the clickable targets
- * (RUSH-2045 review). Ticket is clickable via {@link signalBadges}, not here,
- * so the id is not printed twice.
- */
-export function formatActiveRowDescription(s) {
-    const parts = [];
-    const pushText = (t) => {
-        const c = t ? cleanPreview(t) : '';
-        if (c)
-            parts.push(c);
-    };
-    if (s.context === 'teams' && s.teamName)
-        pushText(s.teamName);
-    if (s.label)
-        pushText(s.label);
-    // Project = basename(cwd), same derivation as serializeActiveSessionsForJson.
-    const project = s.cwd ? path.basename(s.cwd) : '';
-    if (project && project !== s.label && project !== s.teamName) {
-        const label = cleanPreview(project);
-        const repoUrl = githubRepoUrlFromCwd(s.cwd);
-        parts.push(repoUrl ? linkUrl(repoUrl, label) : label);
-    }
-    const todo = formatTodoCompact(s.todos);
-    if (todo)
-        parts.push(todo);
-    // Latest-turn snippet — avoid repeating label/topic when already used as identity.
-    // A cloud row with no preview yet says nothing here; its provider + task id
-    // ride the locator badge instead (RUSH-2336), not duplicated on this line.
-    if (s.preview) {
-        pushText(s.preview);
-    }
-    else if (!s.label && s.topic) {
-        pushText(s.topic);
-    }
-    return parts.filter(Boolean).join(' · ');
-}
-/** Short human word for a session's activity (falls back to the coarse status). */
-function activityLabel(s) {
-    // Lifecycle status wins over any residual parsed activity — a dead/dangling
-    // session must read `closed`/`abandoned`, not the `idle` its stale tail infers.
-    // `crashed`/`orphaned` are the same kind of claim about the session as a whole,
-    // and both outrank the `idle` its last parsed turn would otherwise show.
-    if (s.status === 'closed' || s.status === 'abandoned')
-        return s.status;
-    if (s.status === 'crashed')
-        return 'crashed';
-    if (s.status === 'orphaned')
-        return 'orphan';
-    if (s.activity === 'waiting_input')
-        return 'waiting';
-    if (s.activity === 'working')
-        return 'working';
-    if (s.activity === 'idle')
-        return 'idle';
-    return s.status === 'input_required' ? 'waiting' : s.status;
-}
-/**
- * Index live sessions by their full session UUID so a historical `SessionMeta`
- * row (`meta.id`) can be matched to the session that is still running now.
- * Rows without a sessionId (some cloud/headless probes) are skipped — they
- * can't be correlated back to a transcript on disk.
- */
-export function indexActiveBySessionId(active) {
-    const byId = new Map();
-    for (const a of active) {
-        if (a.sessionId)
-            byId.set(a.sessionId, a);
-    }
-    return byId;
-}
-/**
- * The live decoration for a listing row: a status glyph and the latest-turn
- * preview, when the session is still running. `●` running / `◐` waiting on the
- * user / `○` idle, colored by the same `statusColor` the --active view uses.
- * Returns empty strings when there is no live match, so callers render the
- * plain historical row unchanged.
- */
-export function liveGlyphAndPreview(a) {
-    if (!a)
-        return { glyph: '', preview: '' };
-    // `◌` (dotted) = alive but un-introspectable — visually distinct from `○` idle
-    // so an opaque harness is never mistaken for a finished one. `⊘` = abandoned /
-    // dangling; `×` = closed (dead pid) — both distinct from the `○` idle a live,
-    // stopped session shows, so a gone session never masquerades as a resting one.
-    // `✗` = crashed (died WITH its host window, uncleanly) — deliberately louder
-    // than the `×` of a clean close. `◍` = orphaned (alive, nothing attached): a
-    // filled ring, so it reads as "still burning" unlike the hollow `○` idle.
-    if (a.status === 'abandoned')
-        return { glyph: statusColor(a.status)('⊘'), preview: buildSessionDescription(a) };
-    if (a.status === 'closed')
-        return { glyph: statusColor(a.status)('×'), preview: buildSessionDescription(a) };
-    if (a.status === 'crashed')
-        return { glyph: statusColor(a.status)('✗'), preview: buildSessionDescription(a) };
-    if (a.status === 'orphaned')
-        return { glyph: statusColor(a.status)('◍'), preview: buildSessionDescription(a) };
-    const waiting = a.status === 'input_required' || a.activity === 'waiting_input';
-    const running = a.status === 'running' || a.activity === 'working';
-    const unknown = a.status === 'unknown';
-    const shape = waiting ? '◐'
-        : running ? '●'
-            : unknown ? '◌'
-                : '○';
-    return { glyph: statusColor(a.status)(shape), preview: buildSessionDescription(a) };
-}
-/**
- * The one-word live status for a listing row — `working` / `waiting` / `idle`,
- * the same three states the `--active` column shows, so the default list is no
- * longer just a glyph. `waiting` is the actionable "needs you" case (a question /
- * permission / plan-review), kept distinct from `idle` (stopped) and `working`.
- * Empty for a not-live row, and for the rare no-signal `unknown`. Pure +
- * exported for the row tests.
- */
-export function liveStatusWord(a) {
-    if (!a)
-        return '';
-    // Lifecycle status is definitive — surface it ahead of any parsed activity.
-    if (a.status === 'closed' || a.status === 'abandoned')
-        return a.status;
-    // Same rank: a lost host is a fact about the session, not about its last turn.
-    if (a.status === 'crashed')
-        return 'crashed';
-    if (a.status === 'orphaned')
-        return 'orphan';
-    if (a.status === 'input_required' || a.activity === 'waiting_input')
-        return 'waiting';
-    if (a.status === 'running' || a.activity === 'working')
-        return 'working';
-    if (a.status === 'idle' || a.activity === 'idle')
-        return 'idle';
-    if (a.status === 'queued')
-        return 'queued';
-    return '';
-}
-/**
- * True when a session is blocked on a human — the `--waiting` contract.
- *
- * NOT `status === 'input_required'`. `foldHostLink` rewrites that status to
- * `orphaned` when nothing is attached, and a session waiting on a question with
- * NOBODY watching is the most acute case `--waiting` exists to surface, not one
- * it should drop. The underlying `activity` is never rewritten, so it is the
- * honest signal here.
- *
- * But `activity` is never rewritten for a DEAD session either: one that died
- * mid-question keeps `waiting_input` forever, and answering it is not a thing a
- * human can do — it needs a relaunch. `--waiting` is a scriptable gate ("does
- * anything need me?"), so a corpse must not trip it.
- *
- * `closed` and `crashed` are unconditionally dead, so they are excluded outright.
- * `abandoned` is NOT: it fires on transcript staleness before the liveness check,
- * so it also covers the live-but-forgotten case — an interactive session that
- * asked a question and sat untouched over a long weekend is still answerable, and
- * is exactly what this gate exists for. It is excluded only when we positively
- * know its process is gone; unknown liveness (an older peer, a row with no pid)
- * stays excluded rather than inventing a human who can answer.
- */
-export function isAwaitingUser(s) {
-    if (s.status === 'crashed' || s.status === 'closed')
-        return false;
-    if (s.status === 'abandoned' && s.pidAlive !== true)
-        return false;
-    return s.status === 'input_required' || s.activity === 'waiting_input';
-}
-/**
- * Whether a row belongs in an unqualified `--active` view (RUSH-2336) — the
- * ONE canonical selector every bare-active surface shares: the CLI's grouped
- * table and `--json` (`renderActiveSessions`), the interactive browser's
- * `--active` filter ({@link applyFilters} in `sessions-browser.ts`), `focus`'s
- * attach gate (`isAttachableLiveSession`), and the menubar snapshot
- * ({@link computeMenubarSnapshot}).
- *
- * The live registry deliberately retains terminally-dead AND not-yet-started
- * rows long enough for `--closed` / `--crashed` / `--queued` and recovery to
- * find them. Presence in that registry therefore is not, by itself, evidence
- * that a session is CURRENTLY active. Explicit lifecycle filters bypass this
- * predicate and select those retained rows through {@link matchesLiveStatus}
- * instead — this function only decides the unqualified default.
- *
- *   - `queued` / `closed` / `crashed` are never active here: queued hasn't
- *     started yet, closed/crashed are unconditionally dead. All three stay
- *     reachable through their explicit filter.
- *   - A cloud row carries no local pid at all — it is active on the
- *     provider's own word (`cloudProvider` + `cloudTaskId`), never a
- *     fabricated pid.
- *   - Every other row is a real OS process (terminal/tmux/headless/team). It
- *     is active only when the row names the machine it runs on, carries a
- *     positive pid, AND has POSITIVELY verified that pid is alive
- *     (`pidAlive === true` — not merely "not known dead"). A live orphaned
- *     row, or a live-but-stuck abandoned row, still qualifies this way since
- *     both carry a genuinely alive pid; unknown liveness (an older peer's
- *     row, or a pid that could never be resolved) does not.
- */
-/** Width of the live status column — `crashed` is the longest word it renders. */
 const LIVE_STATUS_W = 8;
-/** The colored, space-padded status cell for a listing row (empty when not live). */
 function liveStatusCell(live) {
     const word = liveStatusWord(live);
     if (!word || !live)
         return { cell: '', width: 0 };
     return { cell: statusColor(live.status)(padToWidth(word, LIVE_STATUS_W)), width: LIVE_STATUS_W };
 }
-/**
- * The tracker/PR ref for a session's dedicated column: the ticket id when known,
- * else `PR#<n>`, else empty. Pulled out of the trailing badge blob so refs align
- * into a scannable column instead of jamming against a truncated topic.
- */
 export function ticketLabel(s) {
     return s.ticketId ?? (s.prNumber ? `PR#${s.prNumber}` : '');
 }
@@ -585,7 +259,6 @@ export function linkCwdCell(s, label) {
 function modelLabel(model) {
     return model ? shortenModel(model) : '-';
 }
-/** Canonical JSON row consumed by resume pickers and other session UIs. */
 export function serializeSessionPickerRows(sessions, liveSessions, self = machineId()) {
     const liveById = new Map(liveSessions.filter((row) => row.sessionId).map((row) => [row.sessionId, row]));
     return sessions.map((session) => {
@@ -608,389 +281,6 @@ export function serializeSessionPickerRows(sessions, liveSessions, self = machin
         };
     });
 }
-/**
- * Compact, colour-coded badges for the durable/awaiting signals. Text-only (no
- * emoji, per repo convention): `plan` / `ask` / `perm` for why it's waiting,
- * `PR#N`, `wt:slug`, `TICKET-123`.
- */
-function signalBadges(s) {
-    const parts = [];
-    if (s.awaitingReason === 'plan_review')
-        parts.push(chalk.yellow('plan'));
-    else if (s.awaitingReason === 'question')
-        parts.push(chalk.yellow('ask'));
-    else if (s.awaitingReason === 'permission')
-        parts.push(chalk.yellow('perm'));
-    if (s.ticket) {
-        // Clickable when Linear workspace is resolvable (same helper as the picker header).
-        const url = linearIssueUrl(s.ticket.id);
-        parts.push(chalk.cyan(url ? linkUrl(url, s.ticket.id) : s.ticket.id));
-    }
-    if (s.pr) {
-        const label = `PR#${s.pr.number ?? '?'}`;
-        parts.push(chalk.blue(s.pr.url ? linkUrl(s.pr.url, label) : label));
-    }
-    if (s.worktree)
-        parts.push(chalk.magenta(`wt:${s.worktree.slug}`));
-    return parts.join(' ');
-}
-/**
- * Compact locator badge: how to JUMP to the session, not what it's doing.
- * `ssh` flags a remote host. For tmux, prefer the resolved `session:window.pane`
- * (a real `tmux attach -t <session:window>` target) over the raw `%pane` id. For
- * a local Ghostty session we know the tab, show `tab N`. Local, unlocatable
- * sessions add nothing (the common case).
- *
- * RUSH-2336: every row also carries its raw process/provider handle — a
- * `machine:pid` for a real OS process (terminal/tmux/headless/team), or
- * `provider · taskId` for a cloud row with no local pid — so the human view
- * exposes the same locator `--json` now guarantees on every active row.
- */
-function locatorBadge(s) {
-    const p = s.provenance;
-    const parts = [];
-    // An ssh-launched session shows where it was launched FROM when the client IP
-    // resolves to a registered device (`ssh←zion`); bare `ssh` when it doesn't.
-    if (p?.transport === 'ssh')
-        parts.push(chalk.red(p.origin ? `ssh←${p.origin.device}` : 'ssh'));
-    if (p?.mux?.kind === 'tmux' && (s.tmuxTarget || p.mux.pane)) {
-        parts.push(chalk.green(s.tmuxTarget ?? p.mux.pane));
-        // For a tmux-hosted session, say which app+tab is looking at it right now
-        // (or that it's running detached). Only meaningful for tmux (the pane is the
-        // durable handle; the viewer is transient).
-        const label = viewingInLabel(s);
-        if (label)
-            parts.push(chalk.gray(label === 'detached' ? label : `viewing in ${label}`));
-    }
-    else if (p?.mux?.kind === 'screen') {
-        parts.push(chalk.green('screen'));
-    }
-    if (s.ghosttyTab != null)
-        parts.push(chalk.green(`tab ${s.ghosttyTab}`));
-    if (s.context === 'cloud') {
-        const bits = [s.cloudProvider, s.cloudTaskId ? s.cloudTaskId.slice(0, 12) : undefined].filter(Boolean);
-        if (bits.length)
-            parts.push(chalk.dim(bits.join(' · ')));
-    }
-    else if (typeof s.pid === 'number' && s.pid > 0) {
-        parts.push(chalk.dim(`${s.machine ? `${s.machine}:` : ''}pid ${s.pid}`));
-    }
-    return parts.join(' ');
-}
-/**
- * The `created X · idle Y` time cell for a live row (RUSH-2205). `created` is the
- * age of the session start ({@link ActiveSession.startedAtMs}); `idle` is the age
- * of the last transcript write ({@link ActiveSession.lastActivityMs}) — i.e. how
- * long it has been quiet. Compact ("6d", "3h", "now") so the row stays width-safe;
- * either half is omitted when its epoch is unknown.
- */
-function activeTimeCell(s) {
-    const parts = [];
-    if (s.startedAtMs)
-        parts.push(`created ${formatCompactAge(new Date(s.startedAtMs).toISOString())}`);
-    if (s.lastActivityMs)
-        parts.push(`idle ${formatCompactAge(new Date(s.lastActivityMs).toISOString())}`);
-    return parts.join(' · ');
-}
-/** Column widths for line 1 of an active row (id · agent · version · status · owner). */
-const ROW_ID_W = 9;
-const ROW_AGENT_W = 8;
-const ROW_VERSION_W = 8;
-const ROW_STATUS_W = 9;
-const ROW_OWNER_W = 9;
-/**
- * Fit pre-styled content (which may carry SGR colour AND OSC-8 hyperlinks — the
- * clickable ticket/PR/project badges) into `room` display cells. Returns it raw
- * when it already fits, preserving colour and clickable links; otherwise falls
- * back to a width-safe truncation. `truncateToWidth` strips OSC-8 before cutting
- * (see width.ts), so a too-narrow cell drops the hyperlink cleanly rather than
- * slicing a hyperlink escape in half and corrupting the terminal (RUSH-2205
- * review). Never run pre-linked content through `truncateToWidth` directly — that
- * strips its links even when it fits; go through this helper.
- */
-function fitCell(content, room) {
-    if (room <= 0)
-        return '';
-    return stringWidth(content) <= room ? content : truncateToWidth(content, room);
-}
-/**
- * Build the (one or two) rendered lines for a single active-session row.
- * Indent is the leading whitespace (2 spaces for flat groups, 4 inside a window
- * sub-group). Sized to `termW` so no line ever wraps under tmux/SSH (RUSH-2205):
- *
- *   line 1: id · agent version · status · owner · created X · idle Y · ticket/PR
- *   line 2: └ label/topic (+ checklist) · jump locator (ssh/tmux/detached)
- *
- * The label/topic gets its own line so it is no longer buried in a truncated grey
- * snippet, and the actionable ticket/PR badges ride line 1. Version and the
- * ticket/PR/label are backfilled onto the {@link ActiveSession} from the indexed
- * SessionMeta before this renders (a live process reports none of them). Pure +
- * exported so the row layout is unit-tested for content and width without a
- * captured stdout.
- */
-export function renderActiveRowLines(s, indent, termW) {
-    const idCol = chalk.dim(padToWidth((s.sessionId?.slice(0, 8)) ?? '-', ROW_ID_W));
-    const shownKind = sessionDisplayAgent({ agent: s.kind, harness: s.harness });
-    const kindCol = colorAgent(shownKind)(padToWidth(truncateToWidth(shownKind, ROW_AGENT_W), ROW_AGENT_W + 1));
-    const versionCol = chalk.gray(padToWidth(truncateToWidth(s.version ?? '', ROW_VERSION_W), ROW_VERSION_W + 1));
-    const statusCol = statusColor(s.status)(padToWidth(truncateToWidth(activityLabel(s), ROW_STATUS_W - 1), ROW_STATUS_W));
-    const ownerCol = chalk.cyan(padToWidth(truncateToWidth(ownerLabel(s), ROW_OWNER_W - 1), ROW_OWNER_W));
-    const fixedCols = idCol + kindCol + versionCol + statusCol + ownerCol;
-    const fixedW = stringWidth(indent) + ROW_ID_W + (ROW_AGENT_W + 1) + (ROW_VERSION_W + 1) + ROW_STATUS_W + ROW_OWNER_W;
-    const remaining = Math.max(0, termW - fixedW - 1);
-    // Line 1 right side: created/idle time + actionable badges (fork count,
-    // plan/ask/perm, ticket, PR, worktree). Badges are the jump-to-work signal, so
-    // they win the width fight — fitCell keeps them raw+clickable when they fit and
-    // drops the link cleanly when narrow; the time cell takes whatever is left.
-    const fork = s.pidCount && s.pidCount > 1 ? chalk.dim(`×${s.pidCount} `) : '';
-    const badgesCell = fitCell(fork + signalBadges(s), remaining);
-    const badgesW = stringWidth(badgesCell);
-    const timeRoom = Math.max(0, remaining - (badgesW ? badgesW + 2 : 0));
-    const timeCell = chalk.gray(truncateToWidth(activeTimeCell(s), timeRoom));
-    let right = timeCell;
-    if (badgesCell)
-        right += (stringWidth(timeCell) ? '  ' : '') + badgesCell;
-    // right's visible width is <= remaining by construction, so the assembled line
-    // is <= termW-1 whenever the fixed columns fit; the clamp only bites a terminal
-    // narrower than the fixed columns (where right is empty — no link to corrupt).
-    let line1 = indent + fixedCols + right;
-    if (stringWidth(line1) > termW)
-        line1 = truncateToWidth(line1, termW);
-    const lines = [line1];
-    // Line 2: label/topic + checklist (the identity, no longer buried) then the
-    // jump locator. Skipped entirely when there is nothing to say. desc may carry a
-    // clickable project link, so it also goes through fitCell.
-    const contIndent = indent + ' '.repeat(ROW_ID_W);
-    const desc = formatActiveRowDescription(s);
-    const loc = locatorBadge(s);
-    if (desc || loc) {
-        const room2 = Math.max(0, termW - stringWidth(contIndent) - 2);
-        const locCell = fitCell(loc, room2);
-        const locW = stringWidth(locCell);
-        const descRoom = Math.max(0, room2 - (locW ? locW + 2 : 0));
-        const descCell = chalk.white(fitCell(desc || '-', descRoom));
-        let line2 = contIndent + chalk.dim('└ ') + descCell;
-        if (locCell)
-            line2 += '  ' + locCell;
-        if (stringWidth(line2) > termW)
-            line2 = truncateToWidth(line2, termW);
-        lines.push(line2);
-    }
-    // Secondary line (PHNX-3797 owner feedback): surface the most important recent
-    // agent message when it is a pending QUESTION or a NEEDS-YOU block — the urgency
-    // a rolling activity preview buries. Plain `activity` is already the preview on
-    // line 2, so it earns no extra line here; the full ranked message still rides
-    // the JSON/mirror feed for AGI EXT via `s.importantMessage`.
-    const important = s.importantMessage;
-    if (important && (important.kind === 'question' || important.kind === 'needs_you')) {
-        const glyph = important.kind === 'question' ? '? ' : '! ';
-        const room3 = Math.max(0, termW - stringWidth(contIndent) - 2 - glyph.length);
-        const msgCell = fitCell(cleanPreview(important.text), room3);
-        if (msgCell) {
-            let line3 = contIndent + chalk.dim(glyph + msgCell);
-            if (stringWidth(line3) > termW)
-                line3 = truncateToWidth(line3, termW);
-            lines.push(line3);
-        }
-    }
-    return lines;
-}
-/** Render a single agent-session row inside an already-printed group header. */
-function printActiveRow(s, indent) {
-    for (const line of renderActiveRowLines(s, indent, terminalWidth()))
-        console.log(line);
-}
-/**
- * Compact owner display for the `--active` owner column: the local-part of a
- * resolved actor email/login (`muqsit@getrush.ai` -> `muqsit`), the id as-is
- * when it has no `@`, and `-` when the actor is unresolved (`UNRESOLVED@<host>`)
- * or absent (a launch predating actor stamping). Honest by design — an
- * unresolved local run shows no owner rather than inventing one.
- */
-export function ownerLabel(s) {
-    const owner = s.owner;
-    if (!owner || owner.startsWith('UNRESOLVED@'))
-        return '-';
-    const at = owner.indexOf('@');
-    return at > 0 ? owner.slice(0, at) : owner;
-}
-/**
- * Short label for an IDE window. The slice key in live-terminals.json is
- * `${vscode.env.sessionId}-${ext-host pid}`; the trailing pid is the cheap
- * stable disambiguator. We surface it as `ext-pid` so two windows on the
- * same repo are visibly different.
- */
-function shortWindowLabel(windowId) {
-    const m = windowId.match(/-(\d+)$/);
-    return m ? `ext-pid ${m[1]}` : `win ${windowId.slice(0, 8)}`;
-}
-/**
- * Group sessions by workspace, then split each workspace into IDE-window
- * sub-groups + a flat bucket. Pure function — no I/O — so the renderer's
- * grouping rules can be tested without mocking the session scanner.
- *
- * Sort order:
- *   - workspaces: by session count descending, then key ascending
- *   - windows within a workspace: by oldest startedAtMs ascending
- *   - sessions within a window/flat bucket: input order preserved
- */
-export function groupActiveSessions(sessions) {
-    const byWorkspace = new Map();
-    for (const s of sessions) {
-        const key = s.cwd ?? (s.context === 'cloud' ? '__cloud__' : '__unknown__');
-        const list = byWorkspace.get(key) || [];
-        list.push(s);
-        byWorkspace.set(key, list);
-    }
-    const sortedKeys = Array.from(byWorkspace.keys()).sort((a, b) => {
-        const aCount = byWorkspace.get(a).length;
-        const bCount = byWorkspace.get(b).length;
-        if (aCount !== bCount)
-            return bCount - aCount;
-        return a.localeCompare(b);
-    });
-    const workspaces = sortedKeys.map((key) => {
-        const group = byWorkspace.get(key);
-        const windowedSessions = [];
-        const flat = [];
-        for (const s of group) {
-            if (s.context === 'terminal' && s.windowId)
-                windowedSessions.push(s);
-            else
-                flat.push(s);
-        }
-        const byWindow = new Map();
-        for (const s of windowedSessions) {
-            const list = byWindow.get(s.windowId) || [];
-            list.push(s);
-            byWindow.set(s.windowId, list);
-        }
-        const windowKeys = Array.from(byWindow.keys()).sort((a, b) => {
-            const aStart = Math.min(...byWindow.get(a).map(s => s.startedAtMs ?? Infinity));
-            const bStart = Math.min(...byWindow.get(b).map(s => s.startedAtMs ?? Infinity));
-            return aStart - bStart;
-        });
-        return {
-            key,
-            total: group.length,
-            windows: windowKeys.map((wid) => ({ windowId: wid, sessions: byWindow.get(wid) })),
-            flat,
-        };
-    });
-    return { workspaces };
-}
-/**
- * The machine a session belongs to: an explicit tag (set when merging
- * cross-machine results) wins; else the process's provenance host (normalized
- * to the same id form); else the local machine. Never keys off `ActiveSession.host`
- * — that is the terminal *app* (code/tmux), not the computer.
- */
-/** Synthetic top-level group key for provider-sandboxed cloud tasks. */
-const CLOUD_MACHINE_KEY = 'cloud';
-function machineKeyFor(s, localMachine) {
-    // Cloud tasks run in a provider sandbox, not on the machine they're attributed
-    // to for reply routing (s.machine = the querier). Surface them as their own
-    // top-level "cloud" group instead of nested under the local device.
-    if (s.context === 'cloud')
-        return CLOUD_MACHINE_KEY;
-    if (s.machine)
-        return s.machine;
-    if (s.provenance?.host)
-        return normalizeHost(s.provenance.host);
-    return localMachine;
-}
-/**
- * Group active sessions by machine, then delegate each machine's sessions to the
- * existing workspace/window grouping. Local machine is pinned first and flagged;
- * the rest sort by session count descending, then name. Pure — `localMachine` is
- * injected so the function stays testable without reading os.hostname().
- */
-export function groupSessionsByMachine(sessions, localMachine) {
-    const byMachine = new Map();
-    for (const s of sessions) {
-        const key = machineKeyFor(s, localMachine);
-        (byMachine.get(key) ?? byMachine.set(key, []).get(key)).push(s);
-    }
-    const keys = Array.from(byMachine.keys()).sort((a, b) => {
-        if (a === localMachine)
-            return -1;
-        if (b === localMachine)
-            return 1;
-        // The synthetic "cloud" category sorts after all real machines.
-        if (a === CLOUD_MACHINE_KEY)
-            return 1;
-        if (b === CLOUD_MACHINE_KEY)
-            return -1;
-        const ac = byMachine.get(a).length, bc = byMachine.get(b).length;
-        if (ac !== bc)
-            return bc - ac;
-        return a.localeCompare(b);
-    });
-    const machines = keys.map((machine) => ({
-        machine,
-        isLocal: machine === localMachine,
-        total: byMachine.get(machine).length,
-        layout: groupActiveSessions(byMachine.get(machine)),
-    }));
-    return { machines };
-}
-/**
- * Collapse duplicate sessions after a cross-machine merge. Two rows collapse
- * only when they share both machine and session UUID (the same host listed
- * twice, or a local/remote overlap); rows without a sessionId can't be
- * correlated, so they're all kept.
- */
-export function dedupeByMachineSession(sessions) {
-    const seen = new Map();
-    const out = [];
-    for (const s of sessions) {
-        if (!s.sessionId) {
-            out.push(s);
-            continue;
-        }
-        const key = `${s.machine ?? ''}:${s.sessionId}`;
-        const at = seen.get(key);
-        if (at === undefined) {
-            seen.set(key, out.length);
-            out.push(s);
-            continue;
-        }
-        // Both rows now describe the same session on the same machine, so the tie is
-        // between the EXECUTING box's own row and the dispatcher's shim row for a
-        // host-dispatched run (they only started colliding once foldExecutionMachine
-        // attributed both to the executing host — RUSH-2479). The shim carries no
-        // transcript and a `[host/<peer>]` placeholder label, so keeping it first
-        // would strip a real preview off the merged fleet view. Prefer the row that
-        // is not an offload shim; otherwise the first one still wins.
-        if (out[at].offloadedFrom && !s.offloadedFrom)
-            out[at] = s;
-    }
-    return out;
-}
-/**
- * Narrow a gathered live set to the machines an explicit `--device`
- * scope named. The gather picks which boxes to ASK; this asserts what the answer
- * may contain, and the two are not the same question: a host-dispatched run is
- * reported by the box that dispatched it while executing somewhere else, so
- * `--device <dispatcher>` used to list sessions that were not running there at
- * all (RUSH-2479). No scope → unchanged. Pure; exported for unit testing.
- */
-export function filterActiveSessionsByHostScope(sessions, hosts, self) {
-    if (!hosts || hosts.length === 0)
-        return sessions;
-    const wanted = new Set(hosts.map(hostToken));
-    return sessions.filter((s) => wanted.has(s.machine ?? self));
-}
-/**
- * Order a merged listing so the local machine's sessions come first, then each
- * remote machine as a contiguous block (more sessions first, then name), with
- * every machine keeping its incoming order (timestamp) within the block. Also
- * dedupes: a session present both locally (a synced mirror copy) and via live
- * fan-out collapses to one, keyed by machine + session id. Rows are keyed by
- * `machine` (discover tags local rows with the local id; fan-out tags remote
- * rows with the peer id) falling back to `localMachine` when untagged. Pure —
- * `localMachine` is injected so the ordering is testable without os.hostname().
- */
 export function mergeLocalFirst(sessions, localMachine) {
     const byMachine = new Map();
     const seen = new Set();
@@ -1016,17 +306,7 @@ export function mergeLocalFirst(sessions, localMachine) {
     });
     return keys.flatMap((k) => byMachine.get(k));
 }
-/**
- * Serialize a `SessionMeta[]` to the clean JSON shape the `--json` listing
- * emits: strip the internal-only scoring/provenance fields (`_matchedTerms`,
- * `_bm25Score`, `_remote`) that are search/fan-out bookkeeping, never part of
- * the public record, then pretty-print as a 2-space array with a trailing
- * newline. The single seam shared by the local `--json` path and the
- * `--json --host` remote fan-out so both emit byte-identical row shapes.
- */
-/** The intentionally small metadata contract emitted by `sessions --resolve`.
- * It includes only launch identity needed to route/resume. Transcript paths,
- * extracted plans, costs, and content stay on the machine that owns them. */
+// Peer resolution exposes launch identity only; paths, plans, costs, and content stay local.
 export function serializeResolvedSessionsJson(sessions) {
     const safe = sessions.map((session) => ({
         id: session.id,
@@ -1045,30 +325,13 @@ export function serializeResolvedSessionsJson(sessions) {
     }));
     return JSON.stringify(safe, null, 2) + '\n';
 }
-/**
- * `agents sessions --json --host <h>` — fan the RECENT (non-active) listing out
- * to the named host(s) and emit ONE clean merged `SessionMeta[]` JSON array,
- * the same shape the local `--json` path emits. Reuses `gatherRemoteList` (the
- * exact SSH fan-out the interactive cross-machine listing already uses) and
- * serializes the merged, machine-tagged rows — instead of `runRemoteSessions`,
- * which streams each remote's raw stdout under a per-host banner and so can
- * never be JSON.parsed. A dead host contributes `[]` (with a stderr note from
- * the fan-out), so stdout is always a valid array and the exit stays 0.
- */
 async function runRemoteSessionsJson(hosts) {
-    // Forward the caller's own filters (query, --limit, --since, …) minus --host,
-    // and guarantee --json so each peer answers with a parseable array. Force
-    // whole-index scope: an explicit --host means "that box's index", not the
-    // slice that happens to sit under the peer's SSH-login home dir.
     const forwarded = ensureWholeIndex(buildForwardedArgs(process.argv, new Set(hosts)));
     if (!forwarded.includes('--json'))
         forwarded.push('--json');
     const { sessions } = await gatherRemoteList(forwarded, hosts);
     process.stdout.write(serializeSessionsJson(sessions));
 }
-/** Parse one peer's computer-run array without accepting banners or partial
- * JSON. The fan-out boundary supplies the machine name when an older peer row
- * omitted it. */
 export function parseRemoteComputerSessionRows(stdout, machine) {
     try {
         const value = JSON.parse(stdout);
@@ -1083,9 +346,6 @@ export function parseRemoteComputerSessionRows(stdout, machine) {
         return { items: [], valid: false };
     }
 }
-/** Collect computer history from named peers, or every automatic peer when
- * hosts is omitted. Every peer is forced to JSON and receives the recursion
- * guard through the shared fleet transport. */
 async function gatherRemoteComputerSessionRows(hosts) {
     const hostSet = new Set(hosts ?? []);
     const forwarded = buildForwardedArgs(process.argv, hostSet);
@@ -1101,515 +361,31 @@ async function gatherRemoteComputerSessionRows(hosts) {
     });
     return result.items;
 }
-/**
- * `running N · idle N · waiting N · queued N · closed N · abandoned N · unknown N`
- * for a bucket of sessions (zero buckets omitted). Same bucketing as the summary so
- * per-group counts reconcile with the `(total)` beside the header — the `unknown`
- * bucket is what keeps an alive-but-opaque row from silently vanishing from the
- * tally. Empty when nothing.
- */
-function groupTally(sessions) {
-    const running = sessions.filter(s => s.status === 'running').length;
-    const idle = sessions.filter(s => s.status === 'idle').length;
-    const waiting = sessions.filter(s => s.status === 'input_required').length;
-    // Counted by status, deliberately: an orphaned session gets its own bucket
-    // below, so counting it here too would double-count it in the tally.
-    const queued = sessions.filter(s => s.status === 'queued').length;
-    const closed = sessions.filter(s => s.status === 'closed').length;
-    const abandoned = sessions.filter(s => s.status === 'abandoned').length;
-    // Without these two the tally silently loses rows: every status must have a
-    // bucket or "N active (…)" stops adding up to what the list shows.
-    const orphaned = sessions.filter(s => s.status === 'orphaned').length;
-    const crashed = sessions.filter(s => s.status === 'crashed').length;
-    const unknown = sessions.filter(s => s.status === 'unknown').length;
-    const parts = [];
-    if (running)
-        parts.push(`${running} running`);
-    if (idle)
-        parts.push(`${idle} idle`);
-    if (waiting)
-        parts.push(`${waiting} waiting`);
-    if (queued)
-        parts.push(`${queued} queued`);
-    if (closed)
-        parts.push(`${closed} closed`);
-    if (abandoned)
-        parts.push(`${abandoned} abandoned`);
-    if (orphaned)
-        parts.push(`${orphaned} orphaned`);
-    if (crashed)
-        parts.push(`${crashed} crashed`);
-    if (unknown)
-        parts.push(`${unknown} unknown`);
-    return parts.join(' · ');
-}
-/** Print one machine's workspace tree, indented under its machine header. */
-function renderWorkspaceLayout(layout, base, machineKey) {
-    let first = true;
-    for (const ws of layout.workspaces) {
-        if (!first)
-            console.log();
-        first = false;
-        // Under the top-level "cloud" machine group the __cloud__ workspace header is
-        // redundant ("▸ cloud" then "cloud") — render its rows flat under the machine
-        // header instead. Row indent collapses by one level to match.
-        const redundantCloud = ws.key === '__cloud__' && machineKey === CLOUD_MACHINE_KEY;
-        const rowBase = redundantCloud ? base : base + '  ';
-        if (!redundantCloud) {
-            const header = ws.key === '__cloud__'
-                ? chalk.magenta.bold('cloud')
-                : ws.key === '__unknown__'
-                    ? chalk.gray.bold('unknown')
-                    : chalk.cyan.bold(shortCwd(ws.key));
-            const wsSessions = [...ws.windows.flatMap(w => w.sessions), ...ws.flat];
-            const tally = groupTally(wsSessions);
-            console.log(`${base}${header} ${chalk.gray(`(${ws.total})`)}${tally ? chalk.gray(`  ${tally}`) : ''}`);
-        }
-        for (const win of ws.windows) {
-            // Host is per-process, but every terminal in the same IDE window shares
-            // an ancestor — take the first non-empty host as the window's label.
-            const host = win.sessions.find((s) => s.host)?.host ?? 'terminal';
-            const winHeader = `${chalk.gray(host)} ${chalk.gray('·')} ${chalk.gray(shortWindowLabel(win.windowId))} ${chalk.gray(`(${win.sessions.length})`)}`;
-            console.log(rowBase + winHeader);
-            for (const s of win.sessions)
-                printActiveRow(s, rowBase + '  ');
-        }
-        for (const s of ws.flat)
-            printActiveRow(s, rowBase);
-    }
-}
-/** Machine header: `▸ <name> ← this machine` for the local box (cyan), matching
- * the `ag devices list` treatment; a plain `▸ <name>` for remotes. */
-function printMachineHeader(mg) {
-    // The synthetic "cloud" group isn't a device — tint it magenta (matching the
-    // cloud row/label styling) so it reads as a category, not a machine.
-    const isCloud = mg.machine === CLOUD_MACHINE_KEY;
-    const marker = mg.isLocal ? chalk.cyan('▸ ') : isCloud ? chalk.magenta('▸ ') : chalk.gray('▸ ');
-    const name = mg.isLocal ? chalk.bold.cyan(mg.machine) : isCloud ? chalk.bold.magenta(mg.machine) : chalk.bold(mg.machine);
-    const here = mg.isLocal ? chalk.cyan('  ← this machine') : '';
-    console.log(`${marker}${name} ${chalk.gray(`(${mg.total})`)}${here}`);
-}
-/**
- * Attach display-only jump locators onto LOCAL sessions: the Ghostty tab number
- * (one batched read-only osascript, only when a local ghostty session exists)
- * and the tmux `session:window.pane` target (one `list-panes -a` per socket).
- * Every step is best-effort and swallowed — a failure just leaves the raw pane
- * id / no tab number, and the rows render as before. Mutates the sessions.
- */
-async function enrichLocalLocators(local) {
-    // Ghostty tab numbers.
-    try {
-        const ghostty = local.filter(s => s.host === 'ghostty' && s.provenance?.transport !== 'ssh');
-        if (ghostty.length > 0) {
-            const surfaces = await enumerateGhosttyTabs();
-            for (const [sess, tab] of assignGhosttyTabs(ghostty, surfaces))
-                sess.ghosttyTab = tab;
-        }
-    }
-    catch { /* non-fatal */ }
-    // One Ghostty enumeration shared across every socket's viewing-in resolve
-    // (a tmux client can be attached from a Ghostty tab).
-    await enrichTmuxLocators(local, await enumerateGhosttyTabsQuietly());
-}
-/** {@link enumerateGhosttyTabs}, best-effort — an osascript failure yields no surfaces. */
-async function enumerateGhosttyTabsQuietly() {
-    try {
-        return await enumerateGhosttyTabs();
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * The tmux half of {@link enrichLocalLocators}: the `session:window.pane` attach
- * target and "viewing in <app> tab N" / detached, one batched query per socket.
- *
- * Split out because it is the only locator the `--json` path can afford. It costs
- * tmux queries and a `ps` read — no osascript — so scriptable output stays cheap
- * while still answering the question a consumer actually needs: is anyone looking
- * at this session, or is it running orphaned? Without `surfaces`, a Ghostty-attached
- * client still resolves as attached, just without its tab number.
- */
-async function enrichTmuxLocators(local, surfaces = []) {
-    try {
-        const tmux = local.filter(s => s.provenance?.mux?.kind === 'tmux' && s.provenance.mux.pane);
-        if (tmux.length > 0) {
-            const sockets = new Set(tmux.map(s => s.provenance.mux.socket));
-            for (const socket of sockets) {
-                const paneMap = await mapPanesToTargets(socket);
-                if (paneMap.size === 0)
-                    continue;
-                const clients = await listClients(socket);
-                for (const s of tmux) {
-                    if (s.provenance.mux.socket !== socket)
-                        continue;
-                    const target = paneMap.get(s.provenance.mux.pane);
-                    if (target)
-                        s.tmuxTarget = target;
-                    s.viewingIn = await resolveViewingIn(s, clients, { paneToTarget: paneMap, ghosttySurfaces: surfaces });
-                }
-            }
-        }
-    }
-    catch { /* non-fatal */ }
-}
-/** Normalize a `--device` token (`alias`, `user@host`, `host.domain`)
- * to the machine id the fan-out and registry key off. */
-function hostToken(h) {
-    return normalizeHost(h.split('@').pop() || h);
-}
-/**
- * Whether the local machine's sessions belong in an `--active` view. Local is
- * included by default; an explicit `--device` list scopes the view to
- * exactly those machines, so local is dropped unless it is itself named (by
- * alias or `user@host`, matched on the normalized machine id). Exported for
- * unit testing without touching SSH or the live process table.
- */
-export function shouldIncludeLocal(hosts, self) {
-    if (!hosts || hosts.length === 0)
-        return true;
-    return hosts.some(h => hostToken(h) === self);
-}
-/**
- * The peers to dial for an `--active` view. No `--device` → `undefined`, which
- * tells `gatherRemoteActive` to sweep the registered online devices. An
- * explicit list → exactly those, minus this machine (its sessions come from the
- * local seed, so dialing self would be a wasted SSH and a spurious "unreachable"
- * note). Returns `[]` when the only named host is self — the caller then skips
- * the remote fan-out entirely rather than letting `[]` trigger the sweep.
- * Exported for unit testing.
- */
-export function remoteHostsToDial(hosts, self) {
-    if (!hosts || hosts.length === 0)
-        return undefined;
-    return hosts.filter(h => hostToken(h) !== self);
-}
-/**
- * The fleet-wide live-session set behind every `--active` surface. Local sessions
- * come from `getActiveSessions()` and (unless `--local`) the registered online
- * devices from `ag devices` are folded in over SSH. An explicit `--device`
- * list SCOPES the sweep to exactly those machines — the local machine is included
- * only when it is itself named — so `--device` is a filter, not an addition.
- *
- * This is the single gather: the static renderer AND the interactive browser both
- * call it, so the browser can never disagree with `--active --json` about which
- * sessions are live (it used to call the local-only `getActiveSessions()` directly
- * and silently hid every remote session).
- *
- * RUSH-2062: default path is cache-first against the daemon-warmed shared
- * snapshot (`session-cache.ts`). Menubar / Factory / watchdog / CLI share one
- * warm result instead of each re-running the full SSH fan-out. `forceRefresh`
- * (or `AGENTS_SESSIONS_FORCE_REFRESH=1`) re-gathers live; scoped `--device` lists
- * always gather live so a filter never returns a wrong unscoped snapshot.
- */
-export async function gatherActiveSessions(opts = {}) {
-    const forceRefresh = opts.forceRefresh === true
-        || process.env.AGENTS_SESSIONS_FORCE_REFRESH === '1';
-    // Scoped host lists are not represented in the unscoped fleet/local snapshot
-    // — always gather live so a filter cannot return the wrong set.
-    const scoped = (opts.hosts?.length ?? 0) > 0;
-    if (opts.local && !scoped) {
-        const loaded = await loadLocalActiveSessions({
-            forceRefresh,
-            gather: async () => {
-                const rows = await getActiveSessions({ localOnly: true });
-                const self = machineId();
-                for (const s of rows)
-                    if (!s.machine)
-                        s.machine = self;
-                return rows;
-            },
-        });
-        return { sessions: loaded.sessions, remoteDeviceCount: 0 };
-    }
-    if (!opts.local && !scoped) {
-        const loaded = await loadFleetActiveSessions({
-            forceRefresh,
-            gather: () => gatherActiveSessionsLive({ local: false }),
-        });
-        return {
-            sessions: loaded.sessions,
-            remoteDeviceCount: loaded.remoteDeviceCount,
-            remoteSkipped: loaded.remoteSkipped,
-            remoteDiscoveryFailed: loaded.remoteDiscoveryFailed,
-        };
-    }
-    return gatherActiveSessionsLive(opts);
-}
-/**
- * Live (uncached) gather — the work the daemon / force-refresh path pays once
- * so other surfaces can share the snapshot. Kept separate so the cache layer
- * never recursively re-enters itself.
- */
-async function gatherActiveSessionsLive(opts = {}) {
-    const self = machineId();
-    // An explicit --host/--device list scopes the view: seed local sessions only
-    // when no hosts are named, or when this machine is one of the named targets.
-    // `localOnly: opts.local` (RUSH-2118) keeps a `--local` query from dialing a
-    // remote-host teammate over ssh even for this machine's OWN local gather —
-    // "this machine only" must mean zero ssh, not just "skip the cross-machine
-    // device fan-out below".
-    const local = shouldIncludeLocal(opts.hosts, self)
-        ? await getActiveSessions({ localOnly: opts.local })
-        : [];
-    for (const s of local)
-        if (!s.machine)
-            s.machine = self;
-    let remoteDeviceCount = 0;
-    let remoteSkipped = [];
-    let remoteDiscoveryFailed = false;
-    let merged = local;
-    if (!opts.local) {
-        const remoteHosts = remoteHostsToDial(opts.hosts, self);
-        // An explicit list naming only self leaves nothing remote to dial — skip the
-        // fan-out rather than let an empty list fall through to the device sweep.
-        if (!opts.hosts?.length || (remoteHosts && remoteHosts.length > 0)) {
-            const remote = await gatherRemoteActive(remoteHosts);
-            remoteDeviceCount = remote.deviceCount;
-            remoteSkipped = remote.skipped;
-            remoteDiscoveryFailed = remote.discoveryFailed;
-            merged = dedupeByMachineSession([...local, ...remote.sessions]);
-        }
-    }
-    // Asking a box is not the same as a session running there: a host-dispatched
-    // run is reported by its dispatcher while executing on the peer. Scope on the
-    // machine the session runs on so `--device X` never lists someone else's work
-    // (RUSH-2479). Applied here, in the single gather, so the interactive browser
-    // gets the same answer as `--active --json`.
-    return {
-        sessions: filterActiveSessionsByHostScope(merged, opts.hosts, self),
-        remoteDeviceCount,
-        remoteSkipped,
-        remoteDiscoveryFailed,
-    };
-}
-/**
- * Explain an empty `--active` result instead of the old flat
- * "No active agent sessions." either way (RUSH-2507: a live fleet sweep found
- * ~41 running agents while this printed the same line as a genuinely idle
- * fleet). Re-probes local tmux health only now, on the empty path, and names
- * any remote peer that went unheard rather than silently folding it into
- * "nothing running".
- */
-async function describeEmptyActiveDiscovery(opts, remoteSkipped, remoteDiscoveryFailed) {
-    const parts = [];
-    if (!opts.hosts?.length || opts.local) {
-        const health = await describeActiveDiscoveryHealth();
-        if (health.degradedSources.length > 0) {
-            parts.push(`local discovery is degraded (${health.degradedSources.join(', ')} unreachable) — sessions may be hidden, run \`agents doctor\` to diagnose`);
-        }
-    }
-    if (remoteDiscoveryFailed) {
-        parts.push('the device list could not be loaded — no peer was reachable to sweep');
-    }
-    else if (remoteSkipped && remoteSkipped.length > 0) {
-        parts.push(`${remoteSkipped.length} peer(s) went unheard (${remoteSkipped.join(', ')}) — sessions there may be hidden`);
-    }
-    if (parts.length === 0)
-        return 'No active agent sessions.';
-    return `No active agent sessions found, but discovery was degraded: ${parts.join('; ')}.`;
-}
-/**
- * Render the unified active-session view, grouped by machine. Scoping and the
- * fleet sweep live in {@link gatherActiveSessions}; this owns the presentation
- * (the `--waiting` gate, JSON, and the grouped table). A tip is shown when there
- * are no other machines to include.
- */
-async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
-    const self = machineId();
-    const gathered = await gatherActiveSessions(opts);
-    const { remoteDeviceCount, remoteSkipped, remoteDiscoveryFailed } = gathered;
-    // Backfill agent version, refs, created time, and routine provenance from the
-    // historical index. Routine filtering needs that provenance before it narrows
-    // the live pool; doing it here also enriches both JSON and human output.
-    backfillActiveRowsFromIndex(gathered.sessions);
-    // --bookmarks narrows the live view too. Applied HERE, not only in the
-    // browser: the browser is skipped for --json, --waiting, a pipe, a multi-host
-    // scope, and an SSH-fanout peer, and the flag silently did nothing on every
-    // one of those paths — including `--active --bookmarks --json`, which is
-    // exactly what the browser's own `y` copy-cmd hands to an agent.
-    const merged = opts.bookmarksOnly
-        ? gathered.sessions.filter((s) => !!s.sessionId && listBookmarks().has(s.sessionId))
-        : gathered.sessions;
-    const routineFiltered = filterActiveSessionsByRoutine(merged, opts.routine);
-    // Status flags form a union. --waiting additionally retains its scriptable
-    // gate: exit non-zero when the union contains a session awaiting the user.
-    const statusFiltered = opts.statuses?.length
-        ? routineFiltered.filter((session) => opts.statuses.some((status) => matchesLiveStatus(session, status)))
-        : routineFiltered.filter(isRunningLiveSession);
-    const sessions = statusFiltered;
-    if (asJson) {
-        // Resolve who is watching each local tmux pane before serializing: `viewingIn`
-        // is how a consumer distinguishes a session someone is looking at from one
-        // running orphaned after its terminal died. tmux-only (no osascript) so the
-        // scriptable path stays cheap — see enrichTmuxLocators.
-        await enrichTmuxLocators(sessions.filter(s => sessionProcessIsLocal(s, self)));
-        process.stdout.write(JSON.stringify(serializeActiveSessionsForJson(sessions), null, 2) + '\n');
-        if (waitingOnly && sessions.some(isAwaitingUser))
-            process.exitCode = 1;
-        return;
-    }
-    if (sessions.length === 0) {
-        if (waitingOnly) {
-            console.log(chalk.gray('No sessions waiting on input.'));
-            return;
-        }
-        console.log(chalk.gray(await describeEmptyActiveDiscovery(opts, remoteSkipped, remoteDiscoveryFailed)));
-        if (!opts.local && !opts.hosts?.length && remoteDeviceCount === 0)
-            printCrossMachineTip();
-        return;
-    }
-    // Enrich LOCAL sessions with jump locators (display-only, after the --json /
-    // --waiting gates so scriptable output stays osascript-free). Remote sessions
-    // keep their raw pane id — their tmux/Ghostty live on the other machine.
-    await enrichLocalLocators(sessions.filter(s => sessionProcessIsLocal(s, self)));
-    const grouped = groupSessionsByMachine(sessions, self);
-    let firstMachine = true;
-    for (const mg of grouped.machines) {
-        if (!firstMachine)
-            console.log();
-        firstMachine = false;
-        printMachineHeader(mg);
-        renderWorkspaceLayout(mg.layout, '  ', mg.machine);
-    }
-    const parts = groupTally(sessions).split(' · ').filter(Boolean);
-    // The synthetic "cloud" group is a category, not a machine — exclude it from the
-    // machine count and note it separately so the tally stays truthful.
-    const realMachines = grouped.machines.filter((m) => m.machine !== CLOUD_MACHINE_KEY).length;
-    const hasCloud = grouped.machines.some((m) => m.machine === CLOUD_MACHINE_KEY);
-    const machineWord = realMachines === 1 ? 'machine' : 'machines';
-    const cloudNote = hasCloud ? ' + cloud' : '';
-    console.log(chalk.gray(`\n${sessions.length} active (${parts.join(', ')}) across ${realMachines} ${machineWord}${cloudNote}.`));
-    // Tip only when nothing else could be included and the user didn't opt out.
-    if (!opts.local && !opts.hosts?.length && remoteDeviceCount === 0)
-        printCrossMachineTip();
-    // Scriptable gate: a non-zero exit when anything is waiting on the user.
-    if (waitingOnly && sessions.some(isAwaitingUser))
-        process.exitCode = 1;
-}
-/** Apply the routine selector to enriched live rows for every non-browser active view. */
-export function filterActiveSessionsByRoutine(sessions, routine) {
-    if (!routine)
-        return sessions;
-    const routineSessions = sessions.filter((session) => session.origin === 'routine' || !!session.routineName);
-    if (typeof routine !== 'string')
-        return routineSessions;
-    const names = [...new Set(routineSessions.map((session) => session.routineName).filter((name) => !!name))];
-    const selected = resolveRoutineName(routine, names);
-    return selected
-        ? routineSessions.filter((session) => session.routineName === selected)
-        : [];
-}
-/** Match the status words users see, preserving activity's richer working signal. */
-export function matchesLiveStatus(session, status) {
-    if (status === 'working')
-        return session.activity === 'working' || (!session.activity && session.status === 'running');
-    if (status === 'waiting')
-        return isAwaitingUser(session);
-    return session.status === status;
-}
-/** Resolve convenience flags once. Multiple flags intentionally form a union. */
-export function requestedLiveStatuses(options) {
-    const statuses = [];
-    if (options.working)
-        statuses.push('working');
-    if (options.idle)
-        statuses.push('idle');
-    if (options.waiting)
-        statuses.push('waiting');
-    if (options.orphan || options.orphaned)
-        statuses.push('orphaned');
-    if (options.crashed)
-        statuses.push('crashed');
-    if (options.closed)
-        statuses.push('closed');
-    if (options.abandoned)
-        statuses.push('abandoned');
-    if (options.queued)
-        statuses.push('queued');
-    if (options.unknown)
-        statuses.push('unknown');
-    return [...new Set(statuses)];
-}
-/** Nudge shown when `--active` has no other machines to fold in. */
-function printCrossMachineTip() {
-    console.log(chalk.gray("\nTip: include sessions from your other machines — register them with 'ag devices sync', then rerun. Use --local to skip."));
-}
-/**
- * True when the interactive session browser should open instead of a printed
- * listing: a real TTY, no `--json`, and `--no-interactive` not set. The bare
- * listing and `--active` both default to it; scripts/pipes/agents fall through
- * to the existing printed/JSON paths.
- */
 function useInteractiveBrowser(options) {
     return options.interactive !== false && !options.json && isInteractiveTerminal();
 }
-/**
- * A bare interactive fleet listing — no query, no render/filter flag — that the
- * `runSessionBrowser` picker can represent. The single predicate shared by the
- * bare-browser branch and the `--device` early-return guard so they can't drift:
- * when this holds, an explicit `--device` scope is folded into the
- * browser (preview-rich, selectable) instead of the legacy per-host raw stream.
- */
 function isBareBrowserListing(options, query) {
     return (useInteractiveBrowser(options) &&
-        // A peer answering a fan-out must never open a TUI. It has no TTY either, so
-        // this is the explicit half of a guard that otherwise rests on the implicit
-        // invariant that peers are always dialed with --json (see remote-list.ts).
         process.env.AGENTS_SESSIONS_LOCAL !== '1' &&
         hasNoBrowserDisqualifyingFlags(options, query));
 }
-/**
- * Pure flag-gate half of {@link isBareBrowserListing} (TTY-independent, so it is
- * unit-testable): true when no query, render, or filter flag is present that the
- * `runSessionBrowser` picker cannot represent.
- */
 export function hasNoBrowserDisqualifyingFlags(options, query) {
     return (!query &&
-        // A named team view is a flat selectable pool; the bare --teams report
-        // stays grouped and printed because the browser cannot preserve its shape.
         (!options.teams || !!options.inTeam) &&
         !options.flat &&
         !options.tree &&
         !options.markdown &&
         !options.until &&
         !options.project &&
-        // The interactive browser picker is a fuzzy-search TUI over the discovered
-        // pool, not a SQL-filtered listing — it cannot represent a skill/plugin
-        // scope. Falling through to it here would silently drop the filter and
-        // show the unfiltered pool instead (same reasoning as --project/--sort).
         !options.skill &&
         !options.plugin &&
         !options.sort &&
-        // --routine without a name owns a two-stage picker (routine -> run ->
-        // session), and a named routine owns the run-grouped overview. The generic
-        // browser can only flatten routine sessions into its ordinary row list, so
-        // routing this flag there silently bypasses both routine-specific views.
         !options.routine &&
         !options.artifacts &&
         options.artifact === undefined &&
-        // --cloud lists a provider's tasks, not the transcript index, and
-        // runCloudSessions has no host scope — letting a `--device X --cloud` fall
-        // through to the browser gate would silently drop the X the user asked for.
         !options.cloud &&
-        // The browser carries ONE device in its filter and `y` copies back exactly
-        // one --device, so a multi-host scope can't round-trip. Those stay on the
-        // legacy per-host stream, which prints each peer under its own banner.
         (options.host?.length ?? 0) <= 1);
 }
-/** Resolve a typed routine selector by exact name, substring, or one unambiguous typo. */
-export function resolveRoutineName(query, names) {
-    const normalized = query.trim().toLowerCase();
-    if (!normalized)
-        return null;
-    const exact = names.find((name) => name.toLowerCase() === normalized);
-    if (exact)
-        return exact;
-    const containing = names.filter((name) => name.toLowerCase().includes(normalized));
-    if (containing.length === 1)
-        return containing[0];
-    return fuzzyMatch(query, names, FUZZY_PRESETS.dynamic);
-}
 export function buildRoutineRunGroups(sessions) {
     const byRun = new Map();
     for (const session of sessions) {
@@ -1641,10 +417,6 @@ export function buildRoutineChoices(sessions, runOnlyNames = []) {
             latestRunSessionCount: runs[0].sessions.length,
         };
     });
-    // Routines whose only attempts are pre-session (blocked/skipped/failed-before-
-    // spawn) have run records but no transcript. Surface them so the picker is
-    // built from definitions+runs, never only transcripts — otherwise a routine
-    // that has never produced a session reads as "No routines match" (the plan).
     const seen = new Set(choices.map((c) => c.name));
     for (const name of runOnlyNames) {
         if (seen.has(name))
@@ -1683,7 +455,6 @@ async function selectRoutineName(sessions) {
     });
     return picked?.item.name ?? null;
 }
-/** `listJobsWithRuns` but never throws into the sessions reader (best-effort). */
 function safeListJobsWithRuns() {
     try {
         return [...new Set([...listJobs().map((job) => job.name), ...listJobsWithRuns()])];
@@ -1692,17 +463,6 @@ function safeListJobsWithRuns() {
         return [];
     }
 }
-/**
- * Resolve which routine the user is targeting for `--routine`. Returns `null` to
- * ABORT the command (a bad `--routine <name>` printed an error, or the user
- * cancelled the interactive pick). `{ name: null }` means "no routine was
- * selected, don't filter" — the degenerate bare `--routine` piped to a
- * non-interactive sink. `{ name }` is a chosen routine.
- *
- * The name universe is transcripts UNION every routine with a definition or a
- * run record (`safeListJobsWithRuns`), so a command-only or never-ran routine —
- * which produces no `SessionMeta` — still resolves and drills down.
- */
 async function selectRoutineTarget(sessions, routine, interactive) {
     const routineNames = [...new Set([
             ...sessions.map((session) => session.routineName).filter((name) => !!name),
@@ -1742,10 +502,6 @@ export function executionKind(meta) {
         return 'agent';
     return 'command';
 }
-/**
- * Reconcile a routine's canonical run records (`listRuns`, local disk) with the
- * indexed sessions for that routine (fleet-wide, keyed by `routineRunId`).
- */
 function buildRoutineDrilldown(name, sessions) {
     const runs = listRuns(name);
     const forRoutine = sessions.filter((s) => s.routineName === name);
@@ -1760,7 +516,6 @@ function buildRoutineDrilldown(name, sessions) {
         meta,
         sessions: (byRun.get(meta.runId) ?? []).sort((a, b) => (a.timestamp < b.timestamp ? 1 : -1)),
     }))
-        // Newest run first: `startedAt`, then run id (an ISO-derived slot) as a tie-break.
         .sort((a, b) => {
         const at = a.meta.startedAt || a.meta.runId;
         const bt = b.meta.startedAt || b.meta.runId;
@@ -1773,13 +528,9 @@ function buildRoutineDrilldown(name, sessions) {
         orphanSessions,
         runRecordCount: runs.length,
         linkedSessionCount: forRoutine.length,
-        // "Agent routine" = anything that isn't purely command runs. A workflow run
-        // carries no `agent` field but still expects a session, so key off
-        // executionKind, not `agent` alone.
         isAgentRoutine: runs.some((r) => executionKind(r) !== 'command') || forRoutine.length > 0,
     };
 }
-/** Glyph + word for a run's terminal status. */
 function runStatusCell(status) {
     switch (status) {
         case 'completed': return `${chalk.green('✓')} ${chalk.green('completed')}`;
@@ -1792,7 +543,6 @@ function runStatusCell(status) {
         default: return chalk.gray(status);
     }
 }
-/** Where a run's body executed: a host, a cloud provider, or this machine. */
 function runPlacement(meta) {
     if (meta.host)
         return `host:${meta.host}`;
@@ -1800,13 +550,11 @@ function runPlacement(meta) {
         return `cloud:${meta.cloudProvider}`;
     return 'local';
 }
-/** The trigger clause: kind + who triggered it (dropping the noisy UNRESOLVED). */
 function runTrigger(meta) {
     const kind = meta.triggerKind ?? 'schedule';
     const who = meta.triggeredBy && !meta.triggeredBy.startsWith('UNRESOLVED') ? ` by ${meta.triggeredBy}` : '';
     return `${kind}${who}`;
 }
-/** The tail clause explaining a run's outcome (exit code / error / skip reason). */
 function runOutcomeDetail(meta) {
     if (meta.status === 'skipped' && meta.skipReason) {
         const ref = meta.activeRunId ? ` → ${meta.activeRunId}` : '';
@@ -1819,13 +567,10 @@ function runOutcomeDetail(meta) {
         return 'daemon down at fire time';
     if (meta.errorMessage)
         return meta.errorMessage;
-    // A clean `exit 0` is already implied by the green "completed" status — only a
-    // non-zero code carries information worth a tail clause.
     if (typeof meta.exitCode === 'number' && meta.exitCode !== 0)
         return `exit ${meta.exitCode}`;
     return '';
 }
-/** Compact per-session metadata line under a linked session row. */
 function linkedSessionMeta(session) {
     const parts = [];
     const shown = sessionDisplayAgent(session);
@@ -1846,19 +591,11 @@ function linkedSessionMeta(session) {
         parts.push(`${session.toolCallCount} tools`);
     return chalk.gray('      ' + parts.join(' · '));
 }
-/**
- * Render the routine drilldown: canonical run history first, each run linked to
- * its indexed agent session(s). This is the run/session seam made visible — a
- * command routine shows its runs and states plainly that no session is expected;
- * an agent routine shows the same runs plus each run's session metadata.
- */
 export function printRoutineDrilldown(drill, liveIndex, opts = {}) {
     const runWord = drill.runRecordCount === 1 ? 'run record' : 'run records';
     const sessWord = drill.linkedSessionCount === 1 ? 'linked session' : 'linked sessions';
     console.log(`${chalk.cyan.bold(drill.name)}  ` +
         chalk.gray(`${drill.runRecordCount} ${runWord} · ${drill.linkedSessionCount} ${sessWord}`));
-    // A routine with no session ever produced is a command routine — say so up
-    // front so the empty session column reads as expected, not as missing data.
     if (!drill.isAgentRoutine) {
         console.log(chalk.gray('Command routine — runs execute a shell command; no agent session is produced.'));
     }
@@ -1881,9 +618,6 @@ export function printRoutineDrilldown(drill, liveIndex, opts = {}) {
         if (outcome)
             detailParts.push(outcome);
         console.log(chalk.gray('    ' + detailParts.join(' · ')));
-        // Log/report access — both are children of the run dir that a pre-execution
-        // terminal (blocked/skipped/missed) never wrote, so gate each on existence
-        // rather than pointing at a file that isn't there.
         const runDir = getRunDir(drill.name, m.runId);
         const logHints = [];
         if (fs.existsSync(path.join(runDir, 'stdout.log')))
@@ -1899,8 +633,6 @@ export function printRoutineDrilldown(drill, liveIndex, opts = {}) {
             }
         }
         else if (kind !== 'command') {
-            // An agent run that produced no session — say why (the run terminal
-            // explains it), never fake a session row.
             console.log(chalk.gray('      no agent session archived for this run'));
         }
         console.log();
@@ -1918,16 +650,11 @@ export function printRoutineDrilldown(drill, liveIndex, opts = {}) {
         }
     }
     console.log(chalk.gray(`Run history from .history/runs/${drill.name}/ · resume a session with agents sessions resume <id>.`));
-    // Every listing path must say what it dropped (sessions.ts invariant). Under
-    // --routine team-origin sessions are shown (hiddenCount is 0), but unmanaged
-    // installs may still be hidden — surface both footers when non-zero.
     if (opts.hiddenCount && opts.hiddenCount > 0)
         console.log(chalk.gray(formatTeamHiddenFooter(opts.hiddenCount)));
     if (opts.hiddenUnmanaged && opts.hiddenUnmanaged > 0)
         console.log(chalk.gray(formatUnmanagedHiddenFooter(opts.hiddenUnmanaged)));
 }
-/** The canonical `ag sessions …` command for a set of flags — the twin of the
- * browser's `y` hotkey (see --print-cmd). Normalizes to the stable flag form. */
 function canonicalSessionsCommand(query, options) {
     const a = ['sessions'];
     if (options.active)
@@ -1984,31 +711,8 @@ function canonicalSessionsCommand(query, options) {
         a.push(JSON.stringify(q));
     return 'ag ' + a.join(' ');
 }
-/** Bound on the `details.messages` array and on each message's `text` — this
- * rides a cached JSON payload (and, for the remote fast path, an SSH capture
- * with its own byte cap), so it is capped independently of either. */
 const SESSION_DETAIL_MAX_MESSAGES = 8;
 const SESSION_DETAIL_MESSAGE_MAX_CHARS = 4_000;
-/**
- * The additive `details` block on `sessions preview --json` (PHNX-3999):
- * `request`/`timeline`/`files` are read FIRST from the existing
- * `session_timelines` projection (`readSessionTimelineAny` — the daemon's own
- * bounded, incrementally-folded cache, `SessionTimelineProjection` in
- * `lib/session/db.ts`), so a session the daemon has already reached costs
- * nothing extra here. When that projection is missing (daemon hasn't reached
- * this session yet), this does an ON-DEMAND fold using the EXACT same pure,
- * already-redacting pipeline the daemon uses (`foldTimeline` /
- * `projectTimeline` / `projectSessionFiles`, `timeline.ts`) over whatever
- * events are cheaply available: the fresh-parse `events` from
- * `loadSessionPreviewDigest` when there is one, else a bounded 128 KiB tail
- * read (`readSessionTail`, Claude/Codex only — the same bounded reader the
- * local preview's over-cap fallback uses) so a WARM cache hit (no fresh parse)
- * still gets real, on-demand content instead of falling back to a 2-message
- * digest summary. This is genuinely bounded either way: it folds only events
- * already in hand or a fixed 128 KiB window, never a fresh whole-file parse.
- * `partial`/`reason` say when this happened (`daemon-pending: on-demand
- * bounded fold`) versus a session with no transcript at all.
- */
 function sessionTranscriptStamp(session) {
     try {
         if (!session.filePath)
@@ -2025,13 +729,6 @@ export function buildSessionDetailBlock(session, digest, events, sourceStamp) {
     const stamp = sourceStamp ?? sessionTranscriptStamp(session);
     const canDateEvents = sourceStamp !== undefined || events.length === 0;
     const daemonProjection = stamp ? readSessionTimelineAny(session.id, stamp) : undefined;
-    // A bounded tail read backs `messages` on EVERY warm cache hit (no fresh
-    // parse this call), REGARDLESS of whether the daemon projection is already
-    // present — this is what fixes a real bug review caught: a warm digest hit
-    // whose daemon timeline HAD landed still fell through to the 2-message
-    // digest summary below, because the tail-read used to be gated on the
-    // on-demand-fold branch only. `messages` and the on-demand fold are two
-    // independent uses of the same cheap, bounded events window.
     let foldEvents = events;
     if (foldEvents.length === 0 && session.filePath) {
         foldEvents = readSessionTail(session.filePath, session.agent);
@@ -2079,22 +776,7 @@ export function buildSessionDetailBlock(session, digest, events, sourceStamp) {
         reason,
     };
 }
-/** Resolve a session by id/query globally and print its compact preview (no pager).
- * Backs `--preview` — the fast path for the "peek before resume" hot loop. */
 export async function renderSessionPreview(query, scope) {
-    // Exact ID + exactly one named, non-local device: the canonical bounded
-    // preview loader (PHNX-3999) answers in ONE ssh hop plus a durable local
-    // cache, instead of the general resolver's metadata fan-out followed by a
-    // second render hop. Scoped tightly on purpose — a short id/label is not a
-    // stable cache key across devices, and this never touches local discovery.
-    //
-    // Gated on `isCompleteSessionId`, NOT a bare-UUID regex: measured over this
-    // fleet's own index, a "full session id" is a bare UUID for most harnesses
-    // but `session_<uuid>` for kimi/rush and `ses_<ulid>` for opencode
-    // (discover.ts). A bare-UUID-only check would silently skip this fast path
-    // (falling through to the slower general resolver, never wrong, but wrong
-    // to claim as "the fast path" for those harnesses) for a real, exact,
-    // caller-supplied full id on those three.
     if (scope.json && !scope.local && scope.hosts?.length === 1
         && scope.hosts[0] !== machineId() && isCompleteSessionId(query.trim())) {
         const { getRemoteSessionPreview } = await import('../lib/session/remote-preview-cache.js');
@@ -2106,37 +788,15 @@ export async function renderSessionPreview(query, scope) {
         console.log(JSON.stringify({
             schemaVersion: 1,
             session: envelope?.session ?? null,
-            // `active` is a live snapshot the PEER computed at the moment it ran
-            // `sessions preview --local --json` — meaningful only for that instant.
-            // When this response is served from the durable cache (`cache.source ===
-            // 'cache'`, which can be up to 45s old, or indefinitely old under a
-            // matched --revision), presenting that stale snapshot under the same
-            // `active` key would read as the session's CURRENT working/idle status
-            // when it may no longer be. Null it out rather than relabel it with an
-            // age stamp: the caller already has `cache.fetchedAt`/`cache.stale` to
-            // reason about staleness, and getting a fresh `active` read costs
-            // another SSH round trip this fast path exists specifically to avoid.
             active: result.cache.source === 'live' ? (envelope?.active ?? null) : null,
             preview: envelope?.preview ?? null,
             error: envelope?.error ?? (envelope ? null : result.cache.reason),
-            // The peer's own `sessions preview --local --json` already computed
-            // `details` (request/timeline/files/messages) with its own bounded reader
-            // (see buildSessionDetailBlock) — this hop just forwards it verbatim,
-            // never re-derives it, so a metadata-only/no-transcript peer row's
-            // explicit unavailable reason survives the hop unchanged.
             details: envelope?.details ?? null,
             cache: result.cache,
         }));
         return;
     }
     let outcome = await resolveSessionMetadataValue(query, scope);
-    // resolveSessionMetadataValue already consults the live registry for a running
-    // session with no transcript row (RUSH-2682), so a live session resolves above.
-    // This block still repairs the residual case — a session whose transcript is on
-    // disk but not yet indexed (e.g. one that just ended). `waitForScan` makes the
-    // repair honest: when another process holds the scan claim it waits for that
-    // scan instead of returning the stale read. Also preserves Claude history-alias
-    // discovery.
     if (outcome.kind !== 'resolved'
         && (!scope.hosts?.length || shouldIncludeLocal(scope.hosts, machineId()))) {
         const discovered = applyScopeFilters(await discoverSessions({ all: true, cwd: process.cwd(), limit: 5000, waitForScan: true }), scope);
@@ -2151,10 +811,6 @@ export async function renderSessionPreview(query, scope) {
         }
     }
     if (outcome.kind === 'partial') {
-        // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
-        // resolver already resolves an id found on the reachable fleet (SES-9a),
-        // so reaching here means the session was not found on any device we COULD
-        // reach — it may live on an unreachable peer, which we could not check.
         const offline = outcome.failedPeers;
         console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
         console.error(chalk.red(`No session matching "${query}" on any reachable device (${offline.length} unreachable, not checked).`));
@@ -2191,17 +847,12 @@ export async function renderSessionPreview(query, scope) {
         }
         return;
     }
-    // Lead with the live status when the session is still running, so the preview
-    // says working / waiting / idle up front — not just the historical transcript.
-    // The shared snapshot is accepted for at most 15 seconds. The durable preview
-    // below contains no live status, so a long-lived process can never keep a
-    // stale working/waiting headline in its transcript cache.
     let live;
     try {
         const loaded = await loadLocalActiveSessions();
         live = indexActiveBySessionId(loaded.sessions).get(session.id);
     }
-    catch { /* plain preview on any probe failure */ }
+    catch { }
     if (scope.json) {
         const sourceStamp = sessionTranscriptStamp(session);
         const { digest, error, events } = loadSessionPreviewDigest(session);
@@ -2249,27 +900,12 @@ export async function renderSessionPreview(query, scope) {
         console.log(headline);
     console.log(buildPreview(session));
 }
-/**
- * The one-line live status banner shown above a session preview: the glyph, the
- * status word, and — when the session needs a human or has LOST one — a plain
- * sentence saying so. Shared by `--preview` and the interactive browser's preview
- * pane so both explain a state the same way.
- *
- * `crashed` and `orphaned` are the states a glyph alone cannot carry: nobody
- * reads "orphan" and knows it means "still running in tmux with no window
- * attached", so those two spell it out.
- */
 export function formatLiveStatusHeadline(live, bookmarked = false) {
     const star = bookmarked ? chalk.yellow('★ ') : '';
-    // With no live row there is no status to lead with, so the star has to say
-    // what it means on its own — a bare `★` above a preview reads as noise.
     if (!live)
         return bookmarked ? chalk.yellow('★ bookmarked') : '';
     const { glyph } = liveGlyphAndPreview(live);
     const word = liveStatusWord(live) || live.status;
-    // One definition, shared with `--waiting`. A second local copy drifted: the
-    // preview said "needs you" for a dead session that `--waiting` had (rightly)
-    // stopped counting, so the human and the script disagreed about the same row.
     const needsYou = isAwaitingUser(live);
     const reason = live.awaitingReason ? ` (${live.awaitingReason.replace('_', ' ')})` : '';
     let suffix = needsYou ? chalk.yellow(`  ← needs you${reason}`) : '';
@@ -2277,16 +913,12 @@ export function formatLiveStatusHeadline(live, bookmarked = false) {
         suffix = chalk.redBright('  ← the host app or connection went away and took the agent with it');
     }
     else if (live.status === 'orphaned') {
-        // Keep the needs-you half. A session sitting on a real question with nobody
-        // attached is strictly worse than either fact alone, and replacing the
-        // question with the generic orphan line undersells exactly that case.
         suffix = needsYou
             ? chalk.yellow(`  ← waiting on you${reason}, and no client is attached to answer it`)
             : chalk.yellow('  ← still running, but no client is attached — nothing is showing it');
     }
     return `${star}${glyph} ${statusColor(live.status)(word)}${suffix}`;
 }
-/** Merge local and peer envelopes without changing the versioned JSON shape. */
 export function mergeToolSearchEnvelopes(local, remotes) {
     const all = [local, ...remotes];
     const sessions = new Map();
@@ -2333,7 +965,6 @@ export function mergeToolProgramCountEnvelopes(local, remotes) {
         machines: all.flatMap((envelope) => envelope.machines),
     };
 }
-/** Partition a fleet query by transcript origin so synced mirrors cannot duplicate results. */
 export function toolOriginSessions(sessions, machine, originOnly) {
     return originOnly
         ? sessions.filter((session) => (session.machine ?? machine) === machine)
@@ -2355,7 +986,6 @@ export function toolSearchFleetSortError(sort, spansDevices) {
         return undefined;
     return 'Tool search across devices supports only --sort recent; cost and duration are local-only.';
 }
-/** Compact grouped evidence for humans; JSON retains every bounded field. */
 function printToolSearch(envelope) {
     for (const session of envelope.sessions) {
         const machineName = session.machine
@@ -2394,14 +1024,7 @@ function printToolSearch(envelope) {
         console.log(chalk.yellow(`Tool index coverage is partial: ${envelope.coverage.remainingFiles} transcript${envelope.coverage.remainingFiles === 1 ? '' : 's'} remain.${skipped}${limited}${retry}`));
     }
 }
-/** Main action handler for `agents sessions`. Routes to picker, table, or single-session render. */
-async function sessionsAction(query, options, 
-/**
- * Where commander got `--limit` from: 'cli'/'env' when the user supplied it,
- * 'default' when it filled in its own. Truthiness can't tell those apart,
- * because the default arrives as a string like any typed value.
- */
-limitSource) {
+async function sessionsAction(query, options, limitSource) {
     const queryClauses = options.query ?? [];
     const liveStatuses = requestedLiveStatuses(options);
     const liveOnly = options.active === true || liveStatuses.length > 0;
@@ -2418,8 +1041,6 @@ limitSource) {
             process.exitCode = 1;
             return;
         }
-        // Outside tool evidence mode, --query retains its original positional-search
-        // meaning. The collector only makes it repeatable for tool clauses.
         query = query ?? queryClauses[0];
     }
     if (options.fleet && !toolEvidenceMode) {
@@ -2468,9 +1089,6 @@ limitSource) {
             return;
         }
     }
-    // Normalize convenience flags before any routing reads them: per-agent
-    // shorthands fold into --agent; --device and --devices (both
-    // resolve against the same device registry).
     applyAgentShorthands(options);
     try {
         query = applyVersionFilters(query, options);
@@ -2480,32 +1098,17 @@ limitSource) {
         process.exitCode = 1;
         return;
     }
-    // --device / --devices values are merged into options.host for internal routing. A bare `all` / `fleet` sentinel means
-    // "search every peer" — which is already the default for `--active` and the
-    // interactive listing — so it resolves to no explicit host set rather than
-    // erroring on a device literally named "all".
     const rawDeviceTargets = [...(options.device ?? []), ...(options.devices ?? [])];
-    // But the HISTORICAL `--json` listing does NOT fan out by default (it stays a
-    // deterministic local slice for scripts), so the sentinel would otherwise be
-    // silently dropped and the fleet never reached (PHNX-2673). Remember it so that
-    // path can sweep every peer, exactly as the interactive listing already does.
     const fleetWide = rawDeviceTargets.some(t => t.toLowerCase() === 'all' || t.toLowerCase() === 'fleet');
     const deviceTargets = rawDeviceTargets
         .filter(t => t.toLowerCase() !== 'all' && t.toLowerCase() !== 'fleet');
     if (deviceTargets.length > 0) {
         options.host = [...(options.host ?? []), ...deviceTargets];
     }
-    // --print-cmd: echo the canonical `ag sessions …` for the given flags and exit.
-    // The non-interactive twin of the browser's `y` hotkey — lets an agent compose
-    // (or a human copy) the exact command a view maps to.
     if (options.printCmd) {
         process.stdout.write(canonicalSessionsCommand(query, options) + '\n');
         return;
     }
-    // --roots: emit the local session-scan directories, per agent, as JSON. A pure
-    // machine-readable query (no listing/render) — external watchers (the Factory
-    // extension's fs.watch) read it to track the same dirs the CLI scans, instead
-    // of hardcoding `~/.claude|.codex|.gemini`. Always local; ignores other flags.
     if (options.roots) {
         process.stdout.write(JSON.stringify(getSessionRoots(), null, 2) + '\n');
         return;
@@ -2521,9 +1124,6 @@ limitSource) {
         process.stdout.write(JSON.stringify({ launchId, sessionId: record?.session_id ?? null }) + '\n');
         return;
     }
-    // --resolve is the metadata-only contract for downstream context workflows.
-    // It reads indexed SessionMeta rows and never calls renderSession, buildPreview,
-    // parseSession, or any other transcript renderer/parser.
     if (options.resolve !== undefined || options.resolveSafeV1 !== undefined) {
         if (options.resolveSafeV1 !== undefined && process.env[NO_FANOUT_ENV] !== '1') {
             console.error(chalk.red('--resolve-safe-v1 is an internal fleet protocol.'));
@@ -2560,16 +1160,7 @@ limitSource) {
         console.error(chalk.gray('Drop one — `--device <box>` to read that machine, `--local` to stay on this one.'));
         process.exit(1);
     }
-    // --host WITHOUT --active. `--json` fans the recent listing out and emits ONE
-    // clean merged SessionMeta[] array (same shape as the local --json path), for
-    // scripts/extensions that JSON.parse a remote's history. Without --json it
-    // keeps the legacy per-host stream (each remote's raw stdout under a
-    // `── host ──` banner). With --active, the hosts are folded into the merged
-    // machine-grouped view instead (handled below).
     if (options.host && options.host.length > 0 && !liveOnly && !toolEvidenceMode) {
-        // --local means "skip the SSH fan-out"; --host means "look only over there".
-        // Together they ask for a peer's sessions without dialing the peer, which can
-        // only ever be empty — so say that instead of rendering a blank list.
         if (options.local === true && !shouldIncludeLocal(options.host, machineId())) {
             console.error(chalk.red('--local and --device name opposite scopes: --local skips the SSH fan-out that --device needs.'));
             console.error(chalk.gray('Drop one — `--device <box>` to read that machine, `--local` to stay on this one.'));
@@ -2579,11 +1170,6 @@ limitSource) {
             await runRemoteSessionsJson(options.host);
             return;
         }
-        // A bare interactive `--device`/`--device <box>` listing falls through to the
-        // fleet browser below, which folds the named host(s) into the same merged,
-        // preview-rich, selectable view as the local listing (via gatherRemoteList).
-        // A query, a render/filter flag, or a non-interactive caller keeps the legacy
-        // per-host raw stream under a `── host ──` banner.
         if (!isBareBrowserListing(options, query)) {
             try {
                 runRemoteSessions(options.host);
@@ -2595,9 +1181,6 @@ limitSource) {
             return;
         }
     }
-    // --preview <id/query>: resolve one session and print its compact preview, then
-    // exit — checked before --active so `--active --preview <id>` peeks the id
-    // rather than being swallowed by the active listing.
     if (options.preview) {
         if (!query) {
             console.error(chalk.red('--preview requires a session id or query.'));
@@ -2607,63 +1190,18 @@ limitSource) {
         return;
     }
     if (liveOnly) {
-        // The running view is built from the live scan, which carries no team lineage
-        // (that comes off the transcript index and the teams meta dir), so --in-team
-        // has nothing to match on here. Say so rather than ignoring the flag.
         if (options.inTeam) {
             console.error(chalk.red('--in-team does not apply to --active: the running view carries no team lineage.'));
             console.error(chalk.gray('Drop --active to filter by team, or use `agents teams status <name>` for a live team.'));
             process.exit(1);
         }
-        // On a TTY (and not a scripting path), open the interactive browser seeded to
-        // running-only. --json / --waiting / --no-interactive / a peer fan-out keep the
-        // static dump untouched, so scripts and agents are unaffected. An explicit
-        // --since seeds the window; --until / --project (no browser field) or a
-        // multi-host scope fall through to the static dump that already honors them.
-        if (useInteractiveBrowser(options) &&
-            liveStatuses.length === 0 &&
-            !options.until &&
-            !options.project &&
-            !options.sort &&
-            (options.host?.length ?? 0) <= 1 &&
-            process.env.AGENTS_SESSIONS_LOCAL !== '1') {
-            const { runSessionBrowser, activeBrowserSeed } = await import('./sessions-browser.js');
-            await runSessionBrowser(activeBrowserSeed({
-                teams: options.teams,
-                agent: options.agent,
-                host: options.host,
-                since: options.since,
-                all: options.all,
-                bookmarks: options.bookmarks,
-                routine: options.routine,
-            }), { local: options.local === true, hosts: options.host });
-            return;
-        }
-        // AGENTS_SESSIONS_LOCAL is set by a parent fan-out invocation (see
-        // remote-active.ts) so a peer answers for itself without recursing.
-        const forceLocal = options.local === true || process.env.AGENTS_SESSIONS_LOCAL === '1';
-        await renderActiveSessions(options.json === true, options.waiting === true, {
-            local: forceLocal,
-            hosts: options.host,
-            bookmarksOnly: options.bookmarks === true,
-            statuses: liveStatuses,
-            routine: options.routine,
-        });
+        await runLiveRoster(options);
         return;
     }
     if (options.cloud) {
         await runCloudSessions(query, options);
         return;
     }
-    // Bare interactive listing → the interactive fleet browser (humans). A query,
-    // a render/filter flag, --flat/--tree, --json, --until, --project (a named-project
-    // filter the browser can't represent), or --no-interactive keep the existing
-    // printed/render paths (agents and scripts unaffected). An explicit --since seeds
-    // the browser's window so the flag is honored, not swallowed.
-    //
-    // Bare `--teams` still diverts to the printed team-grouped report because the
-    // flat picker cannot preserve that shape. `--in-team <name> --teams` is one
-    // flat lineage, so it qualifies through hasNoBrowserDisqualifyingFlags.
     if (isBareBrowserListing(options, query)) {
         const { runSessionBrowser, bareBrowserSeed } = await import('./sessions-browser.js');
         await runSessionBrowser(bareBrowserSeed({
@@ -2687,7 +1225,6 @@ limitSource) {
         process.exit(1);
     }
     const { agent, version } = parseAgentFilter(options.agent);
-    // Path-like queries filter by project directory instead of text search.
     let pathFilter;
     let searchQuery;
     if (query && looksLikePath(query)) {
@@ -2702,53 +1239,28 @@ limitSource) {
     else {
         searchQuery = query;
     }
-    // Artifact flags require a session query.
     if ((options.artifacts || options.artifact !== undefined) && !query) {
         console.error(chalk.red('--artifacts and --artifact require a session ID or query.'));
         process.exit(1);
     }
     const mode = resolveViewMode(options, filterOpts);
-    // --markdown or any filter flag forces single-session render.
     const wantsRender = !toolEvidenceMode && (mode === 'markdown' || hasAnyFilter(filterOpts));
-    // Artifact-list or artifact-read paths: widen scope and resolve session globally.
     if ((options.artifacts || options.artifact !== undefined) && searchQuery) {
         await renderArtifactsGlobal(searchQuery, options.artifacts ?? false, options.artifact, artifactLookupScope(options.agent, options.project, options.routine));
         return;
     }
-    // A supplied ID is already the lookup key. Resolve it directly from SQLite
-    // and, when needed, the peer indexes before any broad transcript discovery.
     if (!toolEvidenceMode && searchQuery && looksLikeSessionId(searchQuery)) {
         await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, routine: options.routine, filter: filterOpts, redact: options.redact, local: options.local, hosts: options.host });
         return;
     }
-    // When the user explicitly asks to render (via mode flag), resolve the
-    // query globally so sessions outside the default cwd/30d window are found.
     if (wantsRender && searchQuery) {
         await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, routine: options.routine, filter: filterOpts, redact: options.redact, local: options.local, hosts: options.host });
         return;
     }
-    // Interactive picker loads a deep pool but shows only recent sessions
-    // until the user starts typing. Non-interactive/JSON uses the explicit limit.
     const isInteractive = !options.json && isInteractiveTerminal();
-    // The grouped project overview is the default for a bare interactive listing:
-    // no query, no path drill-in, not explicitly --flat/--tree. It drops the silent
-    // cwd-scope + 50-cap + 30-day window that hide most of a large index.
     const wantsOverview = isInteractive && !searchQuery && !pathFilter && !options.flat && !options.tree;
-    // --in-team asks for ONE team's whole lineage, which is a handful of rows that
-    // can sit anywhere in history. Bounding it by the default top-50 / 30-day window
-    // silently returns nothing for any team older than that — so the flag widens its
-    // own scope, the way --all does, unless the caller set an explicit --limit.
     const wantsWholeTeam = !!options.inTeam;
-    // A routine is not tied to the shell's cwd: its archived sessions retain the
-    // working directory in which the scheduled agent actually ran. Scope the
-    // routine catalog across directories so invoking it from ~/.agents/.system,
-    // a project repo, or $HOME yields the same routine history.
     const wantsWholeRoutine = !!options.routine;
-    // `--limit` has a commander default, so an untouched flag still arrives as a
-    // string and truthiness can't tell it from a typed one. Commander records where
-    // each value came from, which is the only signal that distinguishes an explicit
-    // `--limit 50` from no flag at all — a script asking for 50 must get 50, not the
-    // whole-team pool.
     const userSetLimit = limitSource === 'cli' || limitSource === 'env';
     const limit = wantsOverview
         ? OVERVIEW_POOL_LIMIT
@@ -2758,8 +1270,6 @@ limitSource) {
         process.exitCode = 1;
         return;
     }
-    // Overview: recency order across the whole index, no default window; an explicit
-    // --since still narrows. Non-overview keeps the prior interactive-30d default.
     const since = wantsOverview
         ? options.since
         : (options.since ?? (isInteractive && !options.all && !wantsWholeTeam && !wantsWholeRoutine ? '30d' : undefined));
@@ -2774,23 +1284,12 @@ limitSource) {
     const spinner = options.json ? null : ora().start();
     const tracker = createScanProgressTracker(LOAD_VERBS, 'sessions', spinner);
     try {
-        // Team-origin filter is pushed down to SQL so the LIMIT applies AFTER it.
-        // Without this, a dev dir with heavy SDK spawn activity (Task subagents,
-        // `agents run`, team agents) can fill the top-N window entirely with
-        // hidden rows and make real CLI sessions appear to vanish.
-        // 'recent' is the user-facing alias for the default timestamp sort.
         const sortBy = options.sort === 'cost' ? 'cost' : options.sort === 'duration' ? 'duration' : 'timestamp';
         const scope = {
             agent,
             version,
-            // --in-team spans directories by construction: a team's teammates run in
-            // their own worktrees, so scoping to the current cwd hides most of the
-            // lineage the flag exists to show.
             all: pathFilter ? undefined : options.all || wantsWholeTeam || wantsWholeRoutine || toolSpansDevices,
             cwd: process.cwd(),
-            // Default overview scopes to the current repo SUBTREE (prefix match), so a
-            // monorepo shows its sub-projects grouped instead of collapsing to the one
-            // exact-cwd project. `--all` clears the prefix and spans the whole index.
             cwdPrefix: pathFilter ?? (wantsOverview && !options.all && !wantsWholeTeam && !wantsWholeRoutine && !toolSpansDevices ? process.cwd() : undefined),
             project: options.project,
             since,
@@ -2835,22 +1334,10 @@ limitSource) {
         }
         tracker.stop();
         spinner?.stop();
-        // Version filter is pushed down to SQL via scope.version above; no
-        // post-filter needed. Defensive: the team-origin SQL filter covers the
-        // ~100% case, but classifyTeamSession also recognizes sessions with a
-        // meta.json in ~/.agents/teams/agents whose is_team_origin flag was
-        // never set (legacy rows). Keep the in-memory pass so those are still
-        // enriched/hidden.
         const { visible: visibleSessions } = filterTeamSessions(sessions, shouldShowTeamSessions(options));
         sessions = visibleSessions;
-        // --in-team spans both ends of the lineage, so it can't be one SQL predicate:
-        // the orchestrator matches on the scan-derived `spawnedTeam` column, while a
-        // teammate only knows its team from the meta.json filterTeamSessions just
-        // read. Match either, after that pass has populated `teamOrigin`.
         if (options.inTeam)
             sessions = sessions.filter((s) => matchesTeam(s, options.inTeam));
-        // --bookmarks narrows to the bookmarked set. Applied here, before the JSON
-        // emit, so `--bookmarks --json` is the machine-readable twin of the `b` key.
         if (options.bookmarks) {
             const bookmarks = listBookmarks();
             sessions = sessions.filter((s) => bookmarks.has(s.id));
@@ -2911,28 +1398,15 @@ limitSource) {
             }
             return;
         }
-        // Under --in-team the visible list is one team, so the whole-index team-origin
-        // count would be a non-sequitur next to it.
         const hiddenCount = shouldShowTeamSessions(options) || options.inTeam
             ? 0
             : countSessionsInScope({ ...scope, onlyTeamOrigin: true });
-        // A typed routine scope must apply before smart ID routing. Otherwise an ID
-        // from another routine resolves and renders before the routine filter below.
         if (typeof options.routine === 'string') {
             const filteredByRoutine = await filterSessionsByRoutine(sessions, options.routine, false);
             if (!filteredByRoutine)
                 return;
             sessions = filteredByRoutine;
         }
-        // Smart ID routing: a bare query that resolves to one session renders
-        // directly. If nothing matches in the scoped window and the query looks
-        // like a session ID, widen to global scope (incl. Claude /resume history).
-        //
-        // Exception: a PEER answering a parent's `--json` locate sweep
-        // (AGENTS_SESSIONS_LOCAL=1) must return the SessionMeta[] ROW for the id, not
-        // render its transcript — the sweep parses an array (parseRemoteList). So when
-        // we are that peer and --json is set, skip the single-session short-circuit and
-        // fall through to the array-emitting --json block below.
         const answeringJsonSweep = options.json === true && process.env[NO_FANOUT_ENV] === '1';
         if (searchQuery && !answeringJsonSweep) {
             const idMatches = resolveSessionById(sessions, searchQuery);
@@ -2952,25 +1426,11 @@ limitSource) {
                     return;
                 sessions = filteredByRoutine;
             }
-            // An id-shaped query resolves by id ONLY — the same rule the render path
-            // uses (resolveSessionQuery). Without this a `--json <uuid>` (as issued by
-            // the fleet locate sweep, which runs `sessions <uuid> --json --local` on
-            // each peer) would fall to FTS content search and return every transcript
-            // that merely MENTIONS the id, defeating exact remote resolution. A genuine
-            // search phrase keeps the ranked metadata+content path.
             let filtered = searchQuery
                 ? resolveSessionQuery(sessions, searchQuery, {
                     scope: { agent: options.agent, project: options.project, routine: options.routine },
                 }).matches
                 : sessions;
-            // `--device all`/`--fleet` on a historical `--json` query fans out to every
-            // peer and merges their rows in — the SAME SSH sweep the interactive listing
-            // below uses, and the whole-fleet twin of the explicit `--device <host>
-            // --json` path (`runRemoteSessionsJson`). Without this the documented
-            // "search the whole fleet" flag returned local rows only (PHNX-2673). Guarded
-            // to the sentinel so a bare `--json` stays a deterministic local slice for
-            // scripts, and skipped under `--local`/the peer recursion guard. Dead peers
-            // are skipped by the fan-out, never fatal — enrichment, not a dependency.
             const forceLocalJson = options.local === true || process.env[NO_FANOUT_ENV] === '1';
             if (fleetWide && !forceLocalJson) {
                 const forwarded = ensureWholeIndex(buildForwardedArgs(process.argv, new Set(options.host ?? [])));
@@ -2984,15 +1444,11 @@ limitSource) {
                     }
                 }
                 catch {
-                    // fan-out is an enrichment, never a hard dependency
                 }
                 finally {
                     fanSpinner?.stop();
                 }
             }
-            // JSON is the canonical picker contract: enrich the durable rows once
-            // from the shared live cache so every consumer gets lifecycle/recovery
-            // metadata without performing its own join or transcript scan.
             const live = await gatherActiveSessions({
                 local: forceLocalJson,
                 hosts: options.host,
@@ -3000,19 +1456,8 @@ limitSource) {
             process.stdout.write(serializeSessionsJson(serializeSessionPickerRows(filtered, live.sessions)));
             return;
         }
-        // Cross-machine fan-out: unless --local (or we ARE a peer answering a
-        // parent's sweep), fold in other online machines' sessions live over SSH so
-        // the list spans the fleet without any sync — each remote row carries the
-        // machine it came from, and the picker/table label + group by it. Only the
-        // interactive picker and the printed table get this; --json and single-id
-        // resolution above stay local (a peer answers for itself; scripts get a
-        // deterministic local slice). Best-effort: a fan-out failure leaves the
-        // local list intact rather than erroring the whole command.
         const forceLocal = options.local === true || process.env[NO_FANOUT_ENV] === '1';
         if (!forceLocal) {
-            // Pass the hosts set so a variadic `--host a b` never leaks a host as a
-            // query (defensive: the --host-without-active early return above already
-            // means we only get here in auto-discovery mode, with no --host in argv).
             const forwarded = buildForwardedArgs(process.argv, new Set(options.host ?? []));
             if (!forwarded.includes('--json'))
                 forwarded.push('--json');
@@ -3024,7 +1469,6 @@ limitSource) {
                 }
             }
             catch {
-                // fan-out is an enrichment, never a hard dependency
             }
             finally {
                 fanSpinner?.stop();
@@ -3033,32 +1477,21 @@ limitSource) {
         if (options.routine) {
             const target = await selectRoutineTarget(sessions, options.routine, isInteractive);
             if (!target)
-                return; // bad --routine <name> or cancelled pick (message printed)
+                return;
             if (target.name) {
                 sessions = sessions.filter((s) => s.routineName === target.name);
-                // A routine browse renders the run-first drilldown — canonical run history
-                // plus each run's linked session — instead of dead-ending a
-                // command/pre-session routine into the generic empty copy. An explicit
-                // --flat/--tree or a search query keeps the scoped session listing/picker,
-                // so `--routine x --flat` prints the plain table and `--routine x <id>`
-                // resolves a specific session within the routine.
                 if (!searchQuery && !options.flat && !options.tree) {
                     const liveIndex = await maybeLiveIndex(options);
                     printRoutineDrilldown(buildRoutineDrilldown(target.name, sessions), liveIndex, { hiddenCount, hiddenUnmanaged });
                     return;
                 }
             }
-            // target.name === null: bare `--routine` piped to a non-interactive sink —
-            // no routine chosen, fall through to the normal listing unfiltered.
         }
         if (sessions.length === 0) {
             if (pathFilter) {
                 console.log(chalk.gray(`No sessions found for ${pathFilter}.`));
             }
             else if (options.routine) {
-                // A routine scoped to a flat/tree/query listing with no matching session
-                // (e.g. a command routine has none) — say so in routine terms, not the
-                // generic cwd/--all copy, and point at the run-history drilldown.
                 console.log(chalk.gray('No indexed agent sessions for this routine. Drop --flat/--tree to see its run history.'));
             }
             else {
@@ -3072,27 +1505,16 @@ limitSource) {
             }
             return;
         }
-        // `--teams` prints the team-grouped report: teammates under their team (with
-        // spawner + spawn time), bare SDK spawns in their own bucket. --flat/--tree
-        // keep their inline table rendering; a search query keeps the picker. Placed
-        // before the project overview and picker so it wins the bare `--teams` case.
         if (options.teams && !options.flat && !options.tree && !searchQuery && !pathFilter) {
             const liveIndex = await maybeLiveIndex(options);
             printTeamsView(sessions, liveIndex, hiddenUnmanaged);
             return;
         }
-        // The grouped project overview is the bare interactive default: a scannable
-        // dashboard of the whole fleet grouped by project, newest-active first.
-        // Interact/resume via `agents sessions <project>` or `agents sessions resume`.
         if (wantsOverview) {
             const liveIndex = await maybeLiveIndex(options);
-            // Per-project row cap is fixed (--limit carries a default of 50 and drives
-            // the fetch pool, not the display); `--all` expands every group instead.
             printSessionOverview(sessions, hiddenCount, liveIndex, { perProjectCap: OVERVIEW_ROWS_PER_PROJECT, expand: !!options.all, hiddenUnmanaged });
             return;
         }
-        // --tree / --flat are printed listings, not an interactive pick — render them
-        // directly even in a TTY. A search query keeps the interactive picker.
         if (isInteractiveTerminal() && !options.tree && !options.flat) {
             const message = pathFilter
                 ? `Search sessions (${path.basename(pathFilter)}):`
@@ -3104,7 +1526,6 @@ limitSource) {
             }
             return;
         }
-        // Non-interactive fallback (piped output) or --flat/--tree.
         const filtered = searchQuery
             ? filterSessionsByQuery(sessions, searchQuery, {
                 agent: options.agent,
@@ -3114,8 +1535,6 @@ limitSource) {
             : sessions;
         const liveIndex = await maybeLiveIndex(options);
         printSessionTable(filtered, hiddenCount, options.tree === true, liveIndex);
-        // Every listing path must say what it dropped — a hidden default that stays
-        // silent in one render mode is the failure this footer exists to prevent.
         if (hiddenUnmanaged > 0)
             console.log(chalk.gray(formatUnmanagedHiddenFooter(hiddenUnmanaged)));
     }
@@ -3126,13 +1545,6 @@ limitSource) {
         process.exit(1);
     }
 }
-/**
- * Prefix marking a row as somebody's teammate: `[<team>/<handle>] `, falling back
- * to the handle alone when the record predates team-name capture. The mode is
- * deliberately dropped here (it survives in the preview pane) — this tag is
- * folded into the topic cell, whose floor is 16 columns, so every character it
- * takes is one the actual prompt loses.
- */
 function teamTag(session) {
     const origin = session.teamOrigin;
     if (!origin)
@@ -3143,32 +1555,14 @@ function teamTag(session) {
         return `[${team}${handle ? `/${handle}` : ''}] `;
     return handle ? `[${handle}] ` : '[team] ';
 }
-/**
- * Whether a session belongs to `team`, from either end: it spawned the team, or
- * it is one of the team's teammates. Case-insensitive, matching the SQL
- * predicate behind `querySessions({ spawnedTeam })`.
- */
 export function matchesTeam(session, team) {
-    // The needle is peer-derived in the browser: `f.team` comes off the team cycle,
-    // which is built from rows another machine sent. Guard it the same way as the
-    // fields it is compared against, so a non-string can't throw out of a filter
-    // that runs over every row.
     const want = safeTeamText(team)?.trim().toLowerCase();
     if (!want)
         return true;
     return (safeTeamText(session.spawnedTeam)?.toLowerCase() === want ||
         safeTeamText(session.teamOrigin?.team)?.toLowerCase() === want);
 }
-/** Longest team name rendered in the `team:` row badge before truncation. */
 const TEAM_BADGE_MAX = 10;
-/**
- * The `team:<name>` badge for a session that SPAWNED a team — the orchestrator
- * end of the lineage, from the scan-derived `spawnedTeam`. Returned as a plain
- * (uncolored) string plus its display width so callers can reserve the width
- * from the topic budget and color it as their own segment: folding it into the
- * topic string would lose the color, since renderTopicCell strips ANSI and
- * re-whitens every slice.
- */
 export function teamBadge(session) {
     const team = safeTeamText(session.spawnedTeam);
     if (!team)
@@ -3181,7 +1575,6 @@ function originTag(session) {
         return '';
     return `[routine${session.routineName ? ` · ${session.routineName}` : ''}] `;
 }
-/** Adapt a SessionMeta's persisted signals to the badge renderer's shape. */
 function metaSignals(s) {
     return {
         pr: s.prUrl ? { url: s.prUrl, number: s.prNumber } : undefined,
@@ -3189,23 +1582,7 @@ function metaSignals(s) {
         ticket: s.ticketId ? { id: s.ticketId } : undefined,
     };
 }
-/**
- * Narrowest topic a row is willing to render. The time cell drops its creation
- * field rather than squeeze the topic past this — a row that wraps is worse than
- * a row missing one field.
- */
 const MIN_TOPIC_W = 16;
-/**
- * The trailing time cell, as two fields: `3d → 2 hours ago` — when the session
- * was created, then when it was last active. One label answers neither "is this
- * the old session I'm looking for" nor "how long did it run", since a session
- * touched an hour ago may have started last week.
- *
- * Collapses to last-activity alone when the session ran under a minute (both
- * halves would name the same moment) or when `topicSlack` — the columns the row
- * has left for its topic — cannot spare the extra width. `extraW` is what the
- * creation field cost, for the caller to take off the topic budget.
- */
 function timeCell(age, topicSlack) {
     const lastOnly = { plain: age.last, text: chalk.gray(age.last), extraW: 0 };
     if (!age.created)
@@ -3216,12 +1593,6 @@ function timeCell(age, topicSlack) {
         return lastOnly;
     return { plain: prefix + age.last, text: chalk.dim(prefix) + chalk.gray(age.last), extraW };
 }
-/** One flat table row:
- *   shortId · agent · version · model · project · [glyph] label·doing · [ticket] · [wt] · time
- * `doing` is the live preview when running, else the topic. The `ticket` column
- * (tracker/PR ref, pulled out of the badge blob so refs align) is only rendered
- * when `showTicket` — otherwise a listing with no refs would waste a column of
- * dashes and needlessly truncate the topic. Worktree stays a trailing badge. */
 export function flatSessionRow(session, live, showTicket = false, cols = {}, bookmarked = false) {
     const shown = sessionDisplayAgent(session);
     const agentColor = colorAgent(shown);
@@ -3230,18 +1601,12 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
     const tag = originTag(session) || teamTag(session);
     const label = session.label;
     const { glyph, preview } = liveGlyphAndPreview(live);
-    // A running session's live preview (via liveGlyphAndPreview → buildSessionDescription)
-    // already folds in ActiveSession.todos. For resting / not-live rows, surface
-    // SessionMeta.todos when the scan attached it.
     const restingTodo = !live ? formatTodoCompact(session.todos) : '';
     const topicBase = tag ? `${tag}${session.topic ?? ''}` : session.topic;
     const doing = [restingTodo, preview || topicBase].filter(Boolean).join(' · ') || undefined;
     const wt = session.worktreeSlug ? chalk.magenta(`wt:${session.worktreeSlug}`) : '';
     const team = teamBadge(session);
     const teamSeg = team.plain ? chalk.green(team.plain) : '';
-    // The machine column only earns its width when the listing spans more than one
-    // box (i.e. the cross-machine fan-out folded remotes in) — same rule and
-    // pool-derived width as the picker.
     const machineColW = cols.machineWidth ?? PICKER_MACHINE_W;
     const machineCell = cols.showMachine
         ? chalk.gray(padToWidth(truncateToWidth((cols.machineLabel?.(session.machine ?? '') ?? session.machine ?? '') || '-', machineColW - 1), machineColW))
@@ -3250,8 +1615,6 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
     const ticketCell = showTicket
         ? chalk.blue(linkTicketCell(session, padToWidth(truncateToWidth(ticketLabel(session) || '-', TICKET_W), TICKET_W + 1)))
         : '';
-    // Live status word (working / waiting / idle) next to the glyph — the default
-    // list is no longer a bare glyph. Empty (zero width) for resting rows.
     const { cell: statusCell, width: statusW } = liveStatusCell(live);
     const glyphW = glyph ? 2 : 0;
     const machineW = cols.showMachine ? machineColW : 0;
@@ -3259,11 +1622,8 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
     const wtW = wt ? stringWidth(wt) + 1 : 0;
     const width = terminalWidth();
     const requestedModelW = cols.showModel ? (cols.modelWidth ?? PICKER_MODEL_MAX) : 0;
-    // Same conditional 2 cells as the picker's marker, for the same reason.
     const bookmarkW = cols.showBookmark ? 2 : 0;
     const bookmarkCell = cols.showBookmark ? (bookmarked ? chalk.yellow('★ ') : '  ') : '';
-    // Sized against the last-activity label alone, so the creation field is an
-    // additive decision the row makes only once it knows what space is left.
     const fixedW = bookmarkW + (10 + 9 + 8 + 16) + glyphW + statusW + machineW + ticketW + wtW + team.width + stringWidth(age.last) + 1;
     const modelSlack = width - fixedW - MIN_TOPIC_W;
     const modelW = requestedModelW <= modelSlack
@@ -3286,7 +1646,6 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
         (wt ? wt + ' ' : '') +
         when.text);
 }
-/** One tree-mode row (grouped under a dir header): id · agent · badges · topic · time. No version/project column. */
 function treeSessionRow(session, live) {
     const shown = sessionDisplayAgent(session);
     const agentColor = colorAgent(shown);
@@ -3294,8 +1653,6 @@ function treeSessionRow(session, live) {
     const tag = originTag(session) || teamTag(session);
     const label = session.label;
     const { glyph, preview } = liveGlyphAndPreview(live);
-    // Match flatSessionRow: live preview already folds ActiveSession.todos; resting
-    // rows surface SessionMeta.todos when present (RUSH-2045).
     const restingTodo = !live ? formatTodoCompact(session.todos) : '';
     const topicBase = preview || (tag ? `${tag}${session.topic ?? ''}` : session.topic);
     const topic = [restingTodo, topicBase].filter(Boolean).join(' · ') || '-';
@@ -3319,38 +1676,16 @@ function treeSessionRow(session, live) {
         padToWidth(chalk.white(truncateToWidth(head, topicW)), topicW) +
         ' ' + when.text);
 }
-/**
- * Live-session index for enriching the default listing, or undefined when
- * enrichment is off (`--no-live`) or irrelevant (`--json`, which serializes
- * SessionMeta). Full detection (incl. the headless `ps` scan) is deliberate:
- * bare-CLI and tmux agents are the common case here, and skipping them would
- * leave the glyph almost never showing. The listing is a one-shot user action,
- * not a hot loop, so the `ps`/`lsof` cost is acceptable; `--no-live` is the
- * escape hatch. Never throws — a probe failure just yields a plain listing.
- */
 export async function maybeLiveIndex(options) {
     if (options.live === false || options.json)
         return undefined;
     try {
-        // `--local` promises "this machine only" for the default listing too (see
-        // the `--local` help text), so it must gate the live-enrichment probe the
-        // same way `--active --local` does — never dial a remote-host teammate
-        // over ssh here either (RUSH-2118).
         return indexActiveBySessionId(await getActiveSessions({ localOnly: options.local === true }));
     }
     catch {
         return undefined;
     }
 }
-/**
- * Group key for the overview: resolve the cwd through the same canonical
- * resolver the `agents feed` timeline groups by — a defined project's name
- * when `defs` contains the cwd (multi-repo projects read as one group), else
- * the repo-level key, so a monorepo subdir (`<repo>/apps/cli`) reads as
- * `<repo>` in both views. Falls back to the indexed project name (stamped at
- * scan time) when the cwd carries nothing usable, e.g. a remote path this
- * machine cannot see still folds by basename through the same resolver.
- */
 export function overviewProjectKey(s, defs) {
     const resolved = defs?.length ? resolveProjectNameForCwd(s.cwd, defs) : resolveProjectKey(s.cwd);
     if (resolved)
@@ -3359,12 +1694,6 @@ export function overviewProjectKey(s, defs) {
         return s.project.trim();
     return '(no project)';
 }
-/**
- * Turn a recency-descending pool into project groups: each group shows its
- * `perProjectCap` most-recent sessions (the rest become `· N more`), and groups
- * are ordered by their most-recent session so the newest-active project leads.
- * `perProjectCap = Infinity` expands every group. Pure — unit-tested.
- */
 export function buildOverviewGroups(pool, perProjectCap, defs) {
     const byKey = new Map();
     for (const s of pool) {
@@ -3374,17 +1703,12 @@ export function buildOverviewGroups(pool, perProjectCap, defs) {
     const cap = Math.max(1, perProjectCap);
     const groups = [];
     for (const [key, rows] of byKey) {
-        const shown = rows.slice(0, cap); // rows are recency-desc (pool was sorted)
+        const shown = rows.slice(0, cap);
         groups.push({ key, total: rows.length, shown, more: rows.length - shown.length, maxTs: rows[0].lastActivity ?? rows[0].timestamp });
     }
     groups.sort((a, b) => (a.maxTs < b.maxTs ? 1 : a.maxTs > b.maxTs ? -1 : a.key.localeCompare(b.key)));
     return { groups, projectCount: byKey.size };
 }
-/**
- * The grouped project overview — the bare interactive default. Shows the latest
- * sessions grouped under their project, newest-active project first, with a
- * `· N more` per project and a `+N more projects` when the list is capped.
- */
 function printSessionOverview(pool, hiddenCount, liveIndex, opts) {
     const { groups } = buildOverviewGroups(pool, opts.expand ? Infinity : opts.perProjectCap, listProjectDefs());
     const shownGroups = opts.expand ? groups : groups.slice(0, OVERVIEW_MAX_PROJECTS);
@@ -3419,8 +1743,6 @@ function printSessionOverview(pool, hiddenCount, liveIndex, opts) {
 }
 function printSessionTable(sessions, hiddenCount = 0, tree = false, liveIndex) {
     if (tree) {
-        // Group by directory; drop the id/version columns from view. The short id
-        // stays as each row's leading handle (the address to read/resume it).
         const byDir = new Map();
         for (const s of sessions) {
             const key = s.cwd || s.project || 'unknown';
@@ -3448,9 +1770,6 @@ function printSessionTable(sessions, hiddenCount = 0, tree = false, liveIndex) {
             console.log(chalk.gray(formatTeamHiddenFooter(hiddenCount)));
         return;
     }
-    // Only show the ticket column when at least one row carries a ref — otherwise
-    // it's a column of dashes that steals width from every topic. The machine
-    // column (and its compact labels) is computed the same way the picker does it.
     const showTicket = sessions.some((s) => ticketLabel(s) !== '');
     const cols = pickerColumnsFor(sessions);
     const bookmarks = listBookmarks();
@@ -3463,17 +1782,8 @@ function printSessionTable(sessions, hiddenCount = 0, tree = false, liveIndex) {
         console.log(chalk.gray(formatTeamHiddenFooter(hiddenCount)));
     }
 }
-/** Width of the mode cell (plan/edit/auto/skip) in a team-member row. */
 const TEAM_MODE_W = 5;
-/** Longest teammate handle folded into a team-member row before it truncates. */
 const TEAM_HANDLE_W = 16;
-/**
- * One row under a team group: `shortId · agent · mode · handle · doing · time`.
- * Unlike {@link flatSessionRow}/{@link treeSessionRow} it drops the
- * `[team/handle]` topic prefix — the group header already names the team — and
- * promotes the teammate's mode and handle to their own cells, the richer
- * identity the `--teams` view exists to show (RUSH-1997).
- */
 function teamMemberRow(session, live) {
     const shown = sessionDisplayAgent(session);
     const agentColor = colorAgent(shown);
@@ -3482,8 +1792,6 @@ function teamMemberRow(session, live) {
     const handle = safeTeamText(origin?.handle) ?? session.shortId;
     const mode = safeTeamText(origin?.mode) ?? '';
     const { glyph, preview } = liveGlyphAndPreview(live);
-    // Match flatSessionRow: a live preview already folds ActiveSession.todos; a
-    // resting row surfaces SessionMeta.todos when the scan attached it.
     const restingTodo = !live ? formatTodoCompact(session.todos) : '';
     const doing = [restingTodo, preview || session.topic || ''].filter(Boolean).join(' · ');
     const shownHandle = truncateToWidth(handle, TEAM_HANDLE_W);
@@ -3506,14 +1814,9 @@ function teamMemberRow(session, live) {
         ' ' +
         when.text);
 }
-/** The header line for one team group (or the residual no-team bucket). */
 function teamGroupHeader(g, glyph, labelById) {
     const count = chalk.gray(`(${g.sessions.length})`);
     if (g.kind === 'noTeam') {
-        // These carry the isTeamOrigin flag but no teammate meta.json — a Task
-        // sub-agent's transcript is never indexed, so in practice this bucket is
-        // headless `agents run` spawns or teammates whose meta aged out. Named
-        // honestly rather than claimed as real teammates.
         return (chalk.magenta('▸') + ' ' + chalk.magenta.bold(NO_TEAM_GROUP_KEY) + '  ' + count +
             '  ' + chalk.gray('team-flagged spawns with no team record (`agents run`, or aged-out teammates)'));
     }
@@ -3527,14 +1830,6 @@ function teamGroupHeader(g, glyph, labelById) {
     bits.push(chalk.gray(`spawned ${formatRelativeTime(g.firstSpawnTs)}`));
     return bits.join('  ');
 }
-/**
- * The `agents sessions --teams` view: team-origin sessions grouped by team, the
- * richer display RUSH-1997 asks for. Each named team names its spawner (the
- * orchestrator session that created it) and spawn time, with its teammates'
- * mode + handle under it; team-flagged spawns that carry no teammate record fall
- * into a trailing no-team bucket, so a real teammate and a bare spawn are never
- * conflated. A printed report like `--tree`, not an interactive pick.
- */
 function printTeamsView(pool, liveIndex, hiddenUnmanaged = 0) {
     const groups = groupSessionsByTeam(pool);
     if (groups.length === 0) {
@@ -3542,9 +1837,6 @@ function printTeamsView(pool, liveIndex, hiddenUnmanaged = 0) {
         console.log(chalk.gray('Team sessions are spawned by `agents teams` — see `agents teams status`.'));
         return;
     }
-    // Resolve a spawner session id to its human label from the pool. The
-    // orchestrator may or may not be in view; fall back to the short id, the same
-    // degradation the --active teams rows use (active.ts resolveOrchestratorLabels).
     const labelById = new Map();
     for (const s of pool) {
         const label = sessionHeadline(s);
@@ -3604,11 +1896,6 @@ function buildFilterOptions(options) {
 function hasAnyFilter(opts) {
     return !!(opts.include?.length || opts.exclude?.length || opts.first !== undefined || opts.last !== undefined);
 }
-/**
- * Default is summary. Any explicit format flag wins. When filters are present
- * without a format, default to markdown since summary is an aggregate view
- * that filters don't meaningfully narrow.
- */
 function resolveViewMode(options, filters) {
     if (options.markdown)
         return 'markdown';
@@ -3618,35 +1905,13 @@ function resolveViewMode(options, filters) {
         return 'markdown';
     return 'summary';
 }
-/**
- * Render a resolved session to stdout — the non-follow view behind
- * `agents logs <sessionId>`. Defaults to the concise `summary` digest (same as
- * `agents sessions <id>`); pass `'markdown'` for the full transcript
- * (`agents logs <id> --full`). Reuses the shared `renderSession` renderer.
- */
 export async function renderSessionLog(session, mode = 'summary') {
     await renderSession(session, mode, {});
 }
-/**
- * Emit one session exactly as `agents sessions <id> --json` does — the same
- * redact-by-default `{ session, events }` shape — so `agents logs <id> --json`
- * shares one machine-readable session contract instead of inventing another.
- */
 export async function renderSessionLogJson(session) {
     await renderSession(session, 'json', {});
 }
-/**
- * Render a file-gone (archived) session from the local DB (RUSH-2436). The
- * transcript file is deleted, but the user turns survive in session_text and the
- * last-computed digest in session_preview_cache — serve those so `agents sessions
- * <id>` still shows the prompts instead of an empty metadata dump. User-turn text
- * is the durable content every harness stores; assistant text survives only as
- * the cached digest's `lastAssistant` snippet, shown when present.
- */
 function renderArchivedSession(session, mode, options = {}) {
-    // Redact by default, mirroring the live render path (render.ts renderConversationMarkdown):
-    // session_text stores raw user text, so masking is render-time. `--no-redact`
-    // opts out, same as the live path.
     const redact = (text) => options.redact !== false ? redactSecrets(text) : text;
     const content = redact((readSessionContent(session.id) ?? '').trim());
     const digestRaw = readArchivedSessionPreview(session.id);
@@ -3654,12 +1919,6 @@ function renderArchivedSession(session, mode, options = {}) {
         ? { ...digestRaw, lastAssistant: redact(digestRaw.lastAssistant ?? '') }
         : undefined;
     if (mode === 'json') {
-        // Minimal machine shape for a file-gone session: the durable user content
-        // plus the cached preview digest, tagged archived. Deliberately NOT the full
-        // { session, events } contract — there are no events to parse. Redact the
-        // first-message-excerpt meta fields (topic/label/plan) too, matching the live
-        // single-session --json (render.ts redactJson), so `--json` masks them unless
-        // --no-redact is passed.
         console.log(JSON.stringify({
             session: {
                 ...session,
@@ -3699,13 +1958,8 @@ function renderArchivedSession(session, mode, options = {}) {
 async function renderSession(session, mode, filters, options = {}) {
     const { hydrateSessionTranscript, findLocalSessionTranscripts } = await import('../lib/session/discover.js');
     session = await hydrateSessionTranscript(session);
-    // OpenCode stores sessions in SQLite; filePath is "db_path#session_id"
     const realPath = session.filePath.split('#')[0];
     if (!fs.existsSync(realPath)) {
-        // The transcript file is gone, but the session's user turns are stored
-        // durably in the local DB (session_text), so serve those instead of a bare
-        // metadata dump (RUSH-2436). This is what makes an archived session still
-        // render its prompts after `agents remove` / rm / a box reimage.
         const archivedContent = readSessionContent(session.id);
         if (archivedContent && archivedContent.trim() !== '') {
             renderArchivedSession(session, mode, options);
@@ -3735,9 +1989,6 @@ async function renderSession(session, mode, filters, options = {}) {
         const modelStr = stats.models.length > 0 ? chalk.yellow(`  ${stats.models.join(', ')}`) : '';
         const branchStr = session.gitBranch ? chalk.gray(` (${session.gitBranch})`) : '';
         const absTime = formatAbsoluteTime(session.timestamp);
-        // Auto-inferred title headline (user /rename > Claude ai-title >
-        // daemon-generated title > first-prompt topic) — the fastest way to
-        // recognize which task this session is.
         const title = sessionHeadline(session);
         if (title) {
             const badges = signalBadges(metaSignals(session));
@@ -3766,13 +2017,6 @@ async function renderSession(session, mode, filters, options = {}) {
         process.stdout.write(renderMarkdown(renderConversationMarkdown(events, { redact: options.redact !== false })));
         return;
     }
-    // json — normalized events plus the durable session signals from the state
-    // engine (plan text, PR, worktree, ticket). Pre-1.20.51 emitted a bare event
-    // array; consumers that JSON.parse this now read `output.events` for the
-    // array. See issue #743 (plan surfaced) and CHANGELOG for the shape change.
-    // `todos` (RUSH-1503) is computed from the UNFILTERED transcript so the
-    // checklist reflects true session state regardless of any `--include` filter;
-    // it lets the Factory panel read the CLI's checklist instead of re-parsing.
     const todos = inferSessionState(parsedEvents, { cwd: session.cwd }).todos;
     process.stdout.write(renderJson(events, todos ? { ...session, todos } : session, { redact: options.redact !== false }));
 }
@@ -3781,8 +2025,6 @@ function renderTopicCell(label, topic, query, visibleWidth, paddedWidth) {
     const tpc = (topic ?? '').trim();
     const sep = ' · ';
     const raw = lbl && tpc ? `${lbl}${sep}${tpc}` : (lbl || tpc);
-    // Width-aware: measure/truncate/pad by display cells, not String.length, so
-    // ANSI escapes and wide (CJK/emoji) glyphs don't drift the column.
     const visible = truncateToWidth(raw, visibleWidth);
     const padding = ' '.repeat(Math.max(0, paddedWidth - stringWidth(visible)));
     const labelEnd = lbl ? Math.min(lbl.length, visible.length) : 0;
@@ -3817,17 +2059,11 @@ function renderTopicCell(label, topic, query, visibleWidth, paddedWidth) {
     }
     return out + padding;
 }
-/** Fallback machine-column width when a pool-derived width isn't supplied.
- * `pickerColumnsFor` normally computes `machineWidth` sized to the actual
- * hostnames, floored/capped by these bounds so common ids like `yosemite-s0`
- * (11) fit whole while a pathological hostname can't devour the topic column. */
 const PICKER_MACHINE_W = 11;
 const PICKER_MACHINE_MIN = 8;
 const PICKER_MACHINE_MAX = 18;
 const PICKER_MODEL_MIN = 6;
 const PICKER_MODEL_MAX = 13;
-/** Column width that shows every compacted hostname in `machines` whole (one
- * trailing space for separation), bounded by MIN/MAX. */
 function machineColumnWidth(machines, label) {
     const widest = machines.reduce((w, m) => Math.max(w, stringWidth(label(m))), 0);
     return Math.min(PICKER_MACHINE_MAX, Math.max(PICKER_MACHINE_MIN, widest + 1));
@@ -3836,12 +2072,6 @@ function modelColumnWidth(sessions) {
     const widest = sessions.reduce((width, session) => (Math.max(width, session.model ? stringWidth(modelLabel(session.model)) : 0)), 0);
     return Math.min(PICKER_MODEL_MAX, Math.max(PICKER_MODEL_MIN, widest + 1));
 }
-/**
- * Compact display form for machine ids: strip the longest shared dash-delimited
- * prefix so "yosemite-s0"/"yosemite-s1" read as "s0"/"s1" while unrelated ids
- * ("zion", "mac-mini") stay whole. Stripping a *common* prefix can't collide,
- * and at least one segment is always kept.
- */
 export function machineLabeler(machines) {
     const uniq = [...new Set(machines.filter(Boolean))];
     if (uniq.length < 2)
@@ -3858,11 +2088,6 @@ export function machineLabeler(machines) {
         return p.length > shared ? p.slice(shared).join('-') : m;
     };
 }
-/**
- * Column flags for a picker, computed once over the whole pool so every row
- * aligns: the machine column only earns its width when the listing spans more
- * than one box, the ticket column only when some row carries a PR/ticket ref.
- */
 export function pickerColumnsFor(sessions) {
     const machines = sessions.map((s) => s.machine).filter((m) => !!m);
     const distinct = [...new Set(machines)];
@@ -3875,22 +2100,12 @@ export function pickerColumnsFor(sessions) {
         modelWidth: modelColumnWidth(sessions),
         showTicket: sessions.some((s) => ticketLabel(s) !== ''),
         showBookmark: (() => {
-            // One read of the store per pool, not one per row.
             const bookmarks = listBookmarks();
             return bookmarks.size > 0 && sessions.some((s) => bookmarks.has(s.id));
         })(),
     };
 }
-/** Width of the host-program column (`tmux→ghostty` is the long realistic case). */
 const PICKER_HOST_W = 14;
-/**
- * Which program a live session is running in, for the picker's host column: the
- * immediate host app (`codium`, `ghostty`, `tmux`, `iterm`, …) and — when a tmux
- * session is currently being watched through a different app — the app it is
- * viewed in, as `tmux→ghostty`. A tmux session with no attached client stays a
- * bare `tmux`, which is exactly "running detached". Empty when the session has no
- * resolvable host (cloud rows, an unreadable process env).
- */
 export function liveHostLabel(a) {
     if (!a?.host)
         return '';
@@ -3902,16 +2117,9 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', bookmarke
     const agentColor = colorAgent(shown);
     const age = sessionAgeParts(s.timestamp, s.lastActivity);
     const project = s.project || '-';
-    // SSH-launch origin (live rows only): mirrors the flat listing's `ssh←<device>`
-    // badge. Rendered as its OWN red segment before the topic cell — folding it into
-    // the topic string loses the colour, because renderTopicCell strips ANSI and
-    // re-whitens every slice. Its width is reserved from the topic budget below
-    // (exactly like `wt`), so the fixed-width columns stay aligned.
     const sshPlain = ssh ? (ssh.device ? `ssh←${ssh.device} ` : 'ssh ') : '';
     const sshSeg = sshPlain ? chalk.red(sshPlain) : '';
     const sshW = sshPlain ? stringWidth(sshPlain) : 0;
-    // Orchestrator badge — same own-segment treatment as `ssh` above, for the same
-    // reason: renderTopicCell would strip its colour if it rode inside the topic.
     const team = teamBadge(s);
     const teamSeg = team.plain ? chalk.green(team.plain) : '';
     const tag = originTag(s) || teamTag(s);
@@ -3927,42 +2135,23 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', bookmarke
     const ticketCell = cols.showTicket
         ? chalk.blue(padRight(truncate(ticketLabel(s) || '-', TICKET_W), TICKET_W + 1))
         : '';
-    // Which terminal/editor the session runs in — a tab in Ghostty vs a VS Code
-    // panel vs a detached tmux pane is the thing you need to know to go find it.
     const hostCell = cols.showHost
         ? chalk.gray(padRight(truncate(host || '-', PICKER_HOST_W - 1), PICKER_HOST_W))
         : '';
-    // The picker prepends a gutter (cursor, plus a checkbox in multi-select mode);
-    // reserve it, plus the conditional columns, so the topic shrinks to fit and
-    // rows never wrap.
     const gutter = cols.gutter ?? 2;
     const machineColW = cols.showMachine ? machineW : 0;
     const ticketW = cols.showTicket ? TICKET_W + 1 : 0;
     const hostW = cols.showHost ? PICKER_HOST_W : 0;
     const wtW = wt ? stringWidth(wt) + 1 : 0;
-    // Within a pool that HAS bookmarked rows the marker holds its 2 cells whether
-    // this row is bookmarked or not, so the columns after it never jog; a pool
-    // with none drops the column entirely (`showBookmark`) and costs nothing.
     const bookmarkW = cols.showBookmark ? 2 : 0;
     const bookmarkCell = cols.showBookmark ? (bookmarked ? chalk.yellow('★ ') : '  ') : '';
-    // The same status word the flat listing shows, so a session that is `orphan`
-    // or `crashed` reads that way in the browser too — not only in its preview.
-    // Constant width whenever the column is on. `liveStatusCell` already pads its
-    // word to LIVE_STATUS_W but returns an EMPTY cell (width 0) for a row with no
-    // live match — blanks fill in for those, so the topic column does not jog on
-    // exactly the rows that are not running.
     const status = cols.showStatus ? liveStatusCell(live) : { cell: '', width: 0 };
     const statusW = cols.showStatus ? LIVE_STATUS_W : 0;
     const statusCell = cols.showStatus ? (status.cell || ' '.repeat(LIVE_STATUS_W)) : '';
-    // Sized against the last-activity label alone; the creation field is then an
-    // additive decision made against whatever width is left (see the flat listing).
     const baseTopicW = terminalWidth() - gutter - bookmarkW - statusW - (10 + 9 + 8 + 16) - machineColW - hostW - ticketW - wtW - sshW - team.width - stringWidth(age.last) - 1;
     const when = timeCell(age, baseTopicW);
     const topicW = Math.max(MIN_TOPIC_W, baseTopicW - when.extraW);
     return (bookmarkCell +
-        // Truncated, not just padded: an indexed shortId is always 8 chars, but a
-        // live row with no session id is named by its pid or cloud task, which can
-        // run past the column and shunt every later column out of alignment.
         chalk.white(padRight(truncate(s.shortId, 9), 10)) +
         agentColor(padRight(truncate(shown, 8), 9)) +
         chalk.yellow(padRight(truncate(versionStr, 7), 8)) +
@@ -3977,24 +2166,16 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', bookmarke
         (wt ? wt + ' ' : '') +
         when.text);
 }
-/** Hints rotated above the picker so the flags/features stay discoverable. */
 const PICKER_TIPS = [
     'Tip: narrow with -a/--agent (e.g. -a codex), or --project <name> for another folder.',
     "Tip: --all searches every directory; -D/--device <machine> folds in another box's sessions.",
     'Tip: just type to fuzzy-search prompts and responses; press space to preview a session.',
     'Tip: --since 2d / --until <date> bound the time window; pass a session id to open it directly.',
 ];
-/**
- * Pick a hint to show above the picker. Deterministic (keys off the pool size)
- * so it stays fixed across the picker's re-renders within a single run.
- */
 export function formatPickerTip(sessions) {
     return chalk.gray(PICKER_TIPS[sessions.length % PICKER_TIPS.length]);
 }
 export async function pickSessionInteractive(sessions, message = 'Search sessions:', initialSearch, hiddenCount = 0, enterHint, scope) {
-    // The hidden-session footer is console.log'd above the Inquirer prompt, so it
-    // scrolls the viewport the picker can't measure; tell the picker to reserve for
-    // it (see pickerPageSize) so the preview and the footer stay on screen together.
     let linesAbovePrompt = 0;
     if (hiddenCount > 0) {
         console.log(chalk.gray(formatTeamHiddenFooter(hiddenCount)));
@@ -4007,8 +2188,6 @@ export async function pickSessionInteractive(sessions, message = 'Search session
             subtitle: formatPickerTip(sessions),
             sessions,
             filter: (query) => {
-                // No query: show the full pool (picker viewport still paginates via pageSize).
-                // Typing: search the full pool.
                 if (!query.trim())
                     return sessions;
                 return filterSessionsByQuery(sessions, query, scope);
@@ -4026,36 +2205,21 @@ export async function pickSessionInteractive(sessions, message = 'Search session
         throw err;
     }
 }
-/** True when the peer wasn't a dialable device; prints one clear line so a
- * remote pick never dead-ends silently. */
 function warnNoPeerTarget(machine, session) {
     console.log(chalk.yellow(`Session ${session.shortId} lives on ${machine}, which isn't a reachable device right now.`));
     console.log(chalk.gray(`Register/wake it (ag devices), or run there: agents ssh ${machine}`));
 }
-/**
- * Row-id prefix for a live session whose agent has not reported a session id yet
- * (a booting harness, a queued teammate). The browser lists these so nothing live
- * is hidden, but they address no transcript — {@link isIdlessLiveRow} is what the
- * pick handler checks before trying to read or resume one.
- */
 export const LIVE_ROW_PREFIX = 'live:';
 function isIdlessLiveRow(s) {
     return s.id.startsWith(LIVE_ROW_PREFIX);
 }
 export async function handlePickedSession(picked) {
-    // A live row with no session id has no transcript to open and no id to resume
-    // by; say where the process is instead of dead-ending on an unreadable path.
     if (isIdlessLiveRow(picked.session)) {
         const where = picked.session.machine ? ` on ${picked.session.machine}` : '';
         console.log(chalk.yellow(`This session hasn't reported a session id yet — nothing to open${where}.`));
         console.log(chalk.gray(`Watch for it with: agents sessions --active${picked.session.machine ? ` --device ${picked.session.machine}` : ''}`));
         return;
     }
-    // Reading and resuming are on DIFFERENT machines' terms, and conflating them
-    // is what RUSH-2022 was. Reading follows the FILE: a synced mirror sits on
-    // this disk, so a peer-owned row with no readable local transcript has to be
-    // read on the peer. Resuming follows the HARNESS STATE, which is on the
-    // owning machine whatever the transcript's location — a mirror included.
     if (picked.action === 'view') {
         const readFrom = transcriptOnPeerOf(picked.session);
         if (readFrom) {
@@ -4071,22 +2235,11 @@ export async function handlePickedSession(picked) {
         return;
     await resumeSessionInPlace(picked.session);
 }
-/**
- * Resume `session` on the machine that owns it, when that is not this one.
- * Returns true when it handled the resume (hopped, or reported an unreachable
- * owner), false when the session is local and the caller should take over here.
- *
- * The one hop for a foreground, one-session-at-a-time resume — shared by the
- * `agents sessions` picker and by `sessions resume`'s no-tab-backend path, which
- * would otherwise reach `resumeSessionInPlace` and be refused (RUSH-2022).
- */
 async function resumeOnOwnerIfRemote(session) {
     const owner = sessionOwnerDevice(session);
     if (!owner)
         return false;
     console.log(chalk.gray(`Resuming ${session.shortId} on ${owner} over SSH...`));
-    // `agents sessions resume <id>` is the strict single-session path — one pick, one
-    // resume.
     const rc = await runOnPeer(['sessions', 'resume', session.id], owner, {
         tty: true,
         env: { [RESUME_PINNED_ENV]: '1' },
@@ -4096,21 +2249,7 @@ async function resumeOnOwnerIfRemote(session) {
         warnNoPeerTarget(owner, session);
     return true;
 }
-/**
- * Resume a session in the current terminal — a foreground takeover of this
- * process. Used by the single-select picker and by `sessions resume` when the
- * chosen destination is "in place" (unknown emulator / off-macOS, single pick).
- * Falls back to the same resume invocation against the current version when the
- * version-pinned launcher is genuinely missing.
- */
 export async function resumeSessionInPlace(session) {
-    // This function is the LOCAL takeover, and every caller is responsible for
-    // routing a peer-owned session before it gets here (the picker above,
-    // `agents sessions resume`). Reaching it with one anyway means a
-    // caller skipped that step, so refuse rather than start the harness against
-    // state this box does not have — the `fs.existsSync(session.cwd)` fallback
-    // just below is exactly how that used to pass unnoticed, quietly swapping in
-    // `process.cwd()` when the recorded directory was a peer's path (RUSH-2022).
     const owner = sessionOwnerDevice(session);
     if (owner) {
         console.error(chalk.red(`Session ${session.shortId} belongs to ${owner} — it cannot resume on this machine.`));
@@ -4125,12 +2264,6 @@ export async function resumeSessionInPlace(session) {
     console.log(chalk.gray(`Resuming: ${resume.join(' ')} (cwd: ${cwd})`));
     await spawnResumeCommand(resume, cwd);
 }
-/**
- * Relaunch this CLI's one recovery path. The owning device resolves account
- * health and either performs exact-home native resume or same-harness
- * `/continue`; callers never guess which version home can see the transcript.
- * `portable` is for an SSH/terminal-engine command that executes on a peer.
- */
 export function buildSessionRecoveryCommand(session, portable = false) {
     const args = sessionRecoveryRunArgs(session);
     if (portable)
@@ -4138,17 +2271,6 @@ export function buildSessionRecoveryCommand(session, portable = false) {
     const invocation = getAgentsInvocation(args);
     return [invocation.command, ...invocation.args];
 }
-/**
- * Map a resume argv to the spawn(command, args, {shell}) triple.
- *
- * On Windows the agent launcher is a `.cmd`/PATHEXT shim and needs shell:true.
- * With shell:true, Node concatenates args into the cmd.exe line unescaped
- * (DEP0190 + injection). A session.id derived from a filename can carry
- * metacharacters (`&|<>`); compose a fully-quoted line and pass an EMPTY args
- * array so cmd.exe cannot reparse them (RUSH-1753). See composeWin32CommandLine.
- *
- * `platform` is injectable so the win32 shell path is unit-testable on any host.
- */
 export function resumeSpawnInvocation(cmd, platform = process.platform) {
     const shell = needsWindowsShell(cmd[0], platform);
     if (shell) {
@@ -4160,17 +2282,6 @@ export function resumeSpawnInvocation(cmd, platform = process.platform) {
     }
     return { command: cmd[0], args: cmd.slice(1), shell: false };
 }
-/**
- * Spawn a resume command as a foreground takeover (inherited stdio), resolving
- * when it exits. On Windows the agent launcher is a `.cmd`/PATHEXT shim that
- * `spawn` can't exec directly — a bare-name `shell:false` spawn throws
- * `EFTYPE`/`ENOENT` there — so we go through the shell via `needsWindowsShell`.
- * When shell:true, argv is composed via resumeSpawnInvocation (quoted line +
- * empty args) so an untrusted session.id cannot inject through cmd.exe.
- * The spawn is guarded because such a failure can be thrown synchronously;
- * without the guard it would surface under an unrelated "Failed to discover
- * sessions" catch upstream instead of a truthful launch error.
- */
 function spawnResumeCommand(cmd, cwd) {
     return new Promise((resolve) => {
         let child;
@@ -4197,40 +2308,15 @@ function spawnResumeCommand(cmd, cwd) {
         child.on('close', () => resolve());
     });
 }
-/**
- * Build the shell command that resumes a picked session.
- *
- * When the session's originating version is known, uses the version-pinned
- * binary (e.g. `claude@2.1.138`) so the resume always runs in the same
- * isolated HOME where the JSONL was written — regardless of which version is
- * currently the default. Falls back to the bare shim when version is unknown.
- *
- */
-/**
- * The agent's own resume invocation, given whichever launcher we resolved.
- * Keeping the verb in one place is what lets the version-pinned and fallback
- * paths stay in agreement — they previously drifted into `/continue`, which is
- * not a command either CLI has.
- */
 function resumeArgv(agent, id, launcher) {
     switch (agent) {
         case 'claude': return [launcher, '--resume', id];
         case 'codex': return [launcher, 'resume', id];
         case 'opencode': return [launcher, '--session', id];
-        // Muse interactive resume is a subcommand: `muse resume <uuid>`.
         case 'muse': return [launcher, 'resume', id];
         default: return null;
     }
 }
-/**
- * Absolute path of the on-disk versioned alias, or null when it isn't there.
- *
- * Resume must not resolve `<cli>@<version>` by bare name. The shims directory is
- * deliberately absent from PATH for an isolated install — that is precisely what
- * `--isolated` promises — so a PATH lookup can never find the alias, and resume
- * degraded to the fallback 100% of the time for isolated copies. Mirrors the
- * resolution `buildExecCommand` already does for `agents run`.
- */
 function versionedAliasIfPresent(agent, version) {
     const cli = AGENTS[agent]?.cliCommand ?? agent;
     const base = path.join(getShimsDir(), `${cli}@${version}`);
@@ -4244,8 +2330,6 @@ export function buildResumeCommand(session) {
     if (!sessionAgentSupportsResume(session.agent))
         return null;
     switch (session.agent) {
-        // opencode sessions are shared across versions, so resume is deliberately NOT
-        // version-pinned — it always goes through the plain launcher.
         case 'opencode':
             return resumeArgv('opencode', session.id, 'opencode');
         case 'claude':
@@ -4254,8 +2338,6 @@ export function buildResumeCommand(session) {
             const cli = AGENTS[session.agent]?.cliCommand ?? session.agent;
             if (session.version) {
                 const alias = versionedAliasIfPresent(session.agent, session.version);
-                // Absolute path when the alias exists; otherwise the bare versioned name,
-                // which still resolves for a non-isolated install whose shims are on PATH.
                 return resumeArgv(session.agent, session.id, alias ?? `${cli}@${session.version}`);
             }
             return resumeArgv(session.agent, session.id, cli);
@@ -4264,15 +2346,6 @@ export function buildResumeCommand(session) {
             return null;
     }
 }
-// ---------------------------------------------------------------------------
-// Cloud session source (--cloud)
-// ---------------------------------------------------------------------------
-/**
- * Handle `agents sessions --cloud [id] [filters]`.
- * - Without id: list captured cloud-runs, optionally as JSON.
- * - With id: fetch the jsonl, parse with the recorded format, render via
- *   the same pipeline as local sessions (summary / markdown / json).
- */
 async function runCloudSessions(query, options) {
     const { discoverCloudSessions, ensureCloudSessionCached } = await import('../lib/session/cloud.js');
     let filterOpts;
@@ -4331,11 +2404,8 @@ async function runCloudSessions(query, options) {
         process.exit(1);
     }
     cachedSpinner?.stop();
-    // Ensure the SessionMeta points at the local cache path for renderSession.
     await renderSession({ ...meta, filePath: cachedPath }, mode, filterOpts, options);
 }
-/** Resolve the harness portion of a sessions selector with the CLI's canonical
- * alias and single-typo rules. Kept pure so focus and the browser cannot drift. */
 export function resolveSessionAgentName(name) {
     const normalized = name.toLowerCase();
     if (SESSION_AGENTS.includes(normalized)) {
@@ -4368,41 +2438,18 @@ function formatSearchMessage(options) {
         return 'Search sessions:';
     return `Search sessions (${filters.join(', ')}):`;
 }
-/**
- * The single entry point for turning a `sessions <query>` argument into rows.
- *
- * An id-shaped query — a complete id OR a hex short-id/prefix (looksLikeSessionId)
- * — resolves by id alone, through the index, and never falls back to content
- * search (a bare id must not surface every transcript that merely mentions it).
- * A genuine search phrase keeps the ranked metadata+content search.
- */
 export function resolveSessionQuery(pool, query, options = {}) {
-    // Normalize ONCE here. isCompleteSessionId trims but resolveSessionById does
-    // not, so a padded id ("<uuid> ", e.g. pasted from a terminal) would classify
-    // as complete and then miss the id lookup — reporting a session that IS on
-    // this machine as absent.
     const normalized = query.trim();
     const completeId = isCompleteSessionId(normalized);
     const byIdMatches = resolveSessionById(pool, normalized);
     if (byIdMatches.length > 0)
         return { matches: byIdMatches, byId: true, completeId };
     if (looksLikeSessionId(normalized)) {
-        // Any id-shaped query — a complete id OR a bare hex short-id/prefix —
-        // resolves by id ONLY, never by content. The pool is a minority of the
-        // index (measured: 2,798 of 7,614 rows) because it re-reads live agent homes
-        // and skips whole classes of indexed session, so a pool miss isn't absence:
-        // ask the index directly, the same authoritative lookup `fork` and `exec`
-        // use. And an id that resolves to nothing must report "no session with that
-        // id" — NOT fall back to fuzzy content search. A short id like "d3470b57"
-        // otherwise surfaces every transcript that merely MENTIONS the string (a
-        // resume prompt echoes the parent id into the body of many later sessions).
         const matches = options.indexFallback === false ? [] : findSessionsById(normalized);
         return { matches, byId: true, completeId };
     }
     return { matches: filterSessionsByQuery(pool, normalized, options.scope), byId: false, completeId };
 }
-/** Explain an ambiguous resolution. Only a short id can be lengthened: a complete
- * id is already maximal, and a search phrase was never an id to begin with. */
 function ambiguityHint(byId, completeId) {
     if (completeId)
         return 'That is already a complete id — these rows share it as a prefix.';
@@ -4410,18 +2457,9 @@ function ambiguityHint(byId, completeId) {
         ? 'Pass a longer ID to narrow it down.'
         : 'That matched on text, not an id. Pass a session id, or narrow the search.';
 }
-/** Explain a complete-id miss, which no local rephrasing can fix. Echoes the
- * normalized id so a pasted, padded argument doesn't produce an unrunnable hint.
- * Used only where NO fleet sweep ran (a `--local` lookup, an `--artifacts`
- * listing, or a peer answering a parent's sweep) — the fleet-swept miss uses
- * {@link fleetNotFoundMessage}. Never tells the user to pass `--device`: fleet
- * search is already the default, so a device flag can't find what the id missed. */
 function notFoundByIdMessage(query) {
     return [chalk.red(`No session with id ${query.trim()} on this machine.`)];
 }
-/** Honest result of a fleet sweep that found nothing: it says what the sweep
- * actually did — how many peers answered, which were unreachable — instead of
- * dead-ending on "search with --device <host>" after the search already ran. */
 export function fleetNotFoundMessage(query, deviceCount, unreachable) {
     const id = query.trim();
     if (deviceCount === 0) {
@@ -4437,7 +2475,6 @@ export function fleetNotFoundMessage(query, deviceCount, unreachable) {
     }
     return lines;
 }
-/** Filter and rank sessions by a multi-term search query across metadata and content. */
 export function filterSessionsByQuery(sessions, query, scope) {
     const trimmed = query?.trim().toLowerCase() || '';
     if (!trimmed)
@@ -4448,20 +2485,12 @@ export function filterSessionsByQuery(sessions, query, scope) {
         return sessions.filter((session) => session.agent === agent && session.version === version);
     }
     const terms = trimmed.split(/\s+/).filter(Boolean);
-    // Hydrate FTS hits missing from the pool (PHNX-2767), then drop hits that
-    // fail --project/--agent/--routine so those flags are not undone by the union.
     const contentIndex = scopedContentIndex(sessions, trimmed, scope);
-    // If the query exactly matches a session label, short-circuit the structural
-    // scorer (which would otherwise surface every session whose topic happens to
-    // contain the same words) and return only the label hits.
     const EXACT_LABEL_SCORE = 1_000_000;
     const exactLabelHits = [...contentIndex.values()].filter(s => (s._bm25Score ?? 0) >= EXACT_LABEL_SCORE);
     if (exactLabelHits.length > 0) {
         return exactLabelHits.sort((a, b) => (b._bm25Score ?? 0) - (a._bm25Score ?? 0));
     }
-    // The listing pool is a page of the index. FTS hits the whole index. Union
-    // so a grep-visible transcript is returned even when it missed the page
-    // (PHNX-2767).
     const poolById = new Map(sessions.map(s => [s.id, s]));
     for (const [id, hit] of contentIndex) {
         if (!poolById.has(id))
@@ -4470,7 +2499,6 @@ export function filterSessionsByQuery(sessions, query, scope) {
     return [...poolById.values()]
         .map(session => ({ session, score: scoreSessionQuery(session, terms) }))
         .filter(entry => {
-        // Include if scored by topic/project/etc, or matched by content search
         if (entry.score > 0)
             return true;
         const contentMatch = contentIndex.get(entry.session.id);
@@ -4491,7 +2519,6 @@ export function filterSessionsByQuery(sessions, query, scope) {
         return new Date(b.session.timestamp).getTime() - new Date(a.session.timestamp).getTime();
     })
         .map(entry => {
-        // Attach content match terms for highlighting
         const cm = contentIndex.get(entry.session.id);
         if (cm && cm._matchedTerms) {
             return { ...cm };
@@ -4539,17 +2566,6 @@ function scoreSessionQuery(session, terms) {
     }
     return score;
 }
-/**
- * Narrow a session list by --project and --agent before search resolution.
- * Without this, a query like "scoped search" could match sessions in BOTH
- * the project you specified AND elsewhere, producing an ambiguity error
- * even though the user already pointed at the correct scope.
- *
- * PHNX-2767 hydrates FTS hits missing from the listing pool *after* this
- * runs, so callers that search must also pass the same scope into
- * `filterSessionsByQuery` / `scopedContentIndex` or the union
- * reintroduces the rows this function just dropped.
- */
 export function applyScopeFilters(sessions, scope) {
     let filtered = sessions;
     if (scope.project) {
@@ -4561,7 +2577,6 @@ export function applyScopeFilters(sessions, scope) {
         });
     }
     if (scope.agent) {
-        // Accept "claude" or "claude@2.1.112" / "claude@default" / "claude@latest". Version suffix narrows further.
         const [wantAgent, rawVersion] = scope.agent.split('@');
         const resolvedAgent = resolveAgentName(wantAgent);
         const wantVersion = resolvedAgent ? resolveVersionAliasLoose(resolvedAgent, rawVersion) : rawVersion;
@@ -4585,12 +2600,6 @@ export function applyScopeFilters(sessions, scope) {
     }
     return filtered;
 }
-/**
- * PHNX-2767 hydrates FTS hits missing from the listing pool. That union is
- * unscoped on purpose (cwd/limit are a page of the index, not a filter).
- * `--project` / `--agent` / `--routine` ARE filters: drop hydrated hits that
- * fail them so content search cannot undo a scope the user already set.
- */
 function scopedContentIndex(sessions, query, scope) {
     const hits = searchContentIndex(sessions, query);
     if (!scope || (!scope.agent && !scope.project && !scope.routine))
@@ -4651,19 +2660,12 @@ async function renderOneSession(query, mode, scope) {
     if (looksLikeSessionId(query)) {
         const outcome = await resolveSessionMetadataValue(query, scope);
         if (outcome.kind === 'partial') {
-            // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
-            // resolver already resolves an id found on the reachable fleet (SES-9a),
-            // so reaching here means the session was not found on any device we
-            // COULD reach — it may live on an unreachable peer we could not check.
             const offline = outcome.failedPeers;
             console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
             console.error(chalk.red(`No session matching "${query}" on any reachable device (${offline.length} unreachable, not checked).`));
             console.error(chalk.gray('  If it lives on an offline box, wake it (agents devices) or run there: agents ssh <device>'));
             process.exit(1);
         }
-        // An index miss can be a transcript created since the last incremental
-        // scan, or a Claude history alias. Fall through to the established
-        // discovery/history resolver below only on that cold miss.
         if (outcome.kind === 'ambiguous') {
             console.error(chalk.red(`Multiple sessions match "${query}" across the fleet:`));
             for (const candidate of outcome.candidates) {
@@ -4719,13 +2721,6 @@ async function renderOneSession(query, mode, scope) {
         let queryMatches = resolution.matches;
         let byId = resolution.byId;
         const completeId = resolution.completeId;
-        // Widen to the transcript content index only for a genuine search phrase.
-        // ANY id-shaped query (a complete id OR a hex short-id/prefix) names a
-        // specific session; widening could only surface a DIFFERENT session that
-        // happens to MENTION the id — which is what made `sessions <uuid>` render an
-        // unrelated transcript and `sessions <shortid>` list every session that
-        // echoes the id in a resume prompt. Gate on looksLikeSessionId, not just
-        // completeId, so a short id resolves to "no match" rather than fuzzy content.
         if (queryMatches.length === 0 && !looksLikeSessionId(query)) {
             const contentResults = scopedContentIndex(allSessions, query, scope);
             if (contentResults.size > 0) {
@@ -4754,22 +2749,12 @@ async function renderOneSession(query, mode, scope) {
                 }
             }
             else if (byId) {
-                // Not on this machine. A UUID names ONE session, so before giving up ask
-                // the fleet — the session may live only on a peer (the whole point of
-                // RUSH-2024). Skip the sweep when the caller pinned --local, or when we
-                // are ourselves a peer answering a parent's sweep (AGENTS_SESSIONS_LOCAL),
-                // so a locate never recurses. On a single remote hit we hand rendering to
-                // that peer; a multi-host hit surfaces the conflict; a miss keeps the
-                // local not-found message. No FTS fallback either way.
                 if (shouldFanOutForId(query, scope.local)) {
                     const outcome = await resolveSessionAcrossFleet(query, mode, scope.hosts);
                     if (outcome.kind === 'rendered')
                         return;
                     if (outcome.kind === 'conflict')
                         process.exit(1);
-                    // The fleet sweep already ran and found nothing — report what actually
-                    // happened, never "search with --device <host>" (fleet search is the
-                    // default, so a device flag would only re-run the same miss).
                     fleetNotFoundMessage(query, outcome.deviceCount, outcome.unreachable).forEach(l => console.error(l));
                     process.exit(1);
                 }
@@ -4811,19 +2796,6 @@ async function renderOneSession(query, mode, scope) {
         process.exit(1);
     }
 }
-/**
- * Whether a missed local id lookup should widen to a cross-machine sweep.
- *
- * Gate (all must hold):
- *   - the query is id-shaped (`looksLikeSessionId`) — only an identifier resolves
- *     across the fleet; a search phrase never does.
- *   - not `--local` — the caller opted out of cross-machine lookup (deterministic
- *     local behavior for scripts, RUSH-2024 acceptance: "--local still restricts").
- *   - `AGENTS_SESSIONS_LOCAL` is unset — we are not ourselves a peer answering a
- *     parent's sweep, so a locate can never recurse (RUSH-2024: avoid double-fan-out).
- *
- * Pure + exported so the gate is unit-tested without driving discovery / SSH.
- */
 function shouldFanOutForId(query, local) {
     if (local === true)
         return false;
@@ -4831,45 +2803,15 @@ function shouldFanOutForId(query, local) {
         return false;
     return looksLikeSessionId(query);
 }
-/** The render-mode flag a peer's `agents sessions <id>` must carry so the remote
- * summary matches the mode the user asked for. `summary` is the peer's default,
- * so it needs no flag; the others map 1:1 to a CLI flag. */
 function modeFlag(mode) {
     if (mode === 'markdown')
         return '--markdown';
     if (mode === 'json')
         return '--json';
-    return undefined; // summary — the peer's default render
+    return undefined;
 }
 const FULL_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Width of `SessionMeta.shortId` / the hex a tmux alias embeds (`deriveShortId`). */
 const SHORT_SESSION_ID_RE = /^[0-9a-f]{8}$/i;
-/**
- * A match unique enough to resolve on the FIRST peer that returns it and cancel
- * the rest of the fleet sweep: a full session UUID (globally unique), a live
- * tmux alias, or a bare 8-hex short id — all three name at most one session PER
- * ANSWERING peer, so the first reachable hit is enough (PHNX-3292: the alias/
- * short-id case is exactly what `agents tmux ls` prints, and it used to stay
- * all-settle right alongside a genuine keyword search).
- *
- * A session **label** is deliberately NOT definitive here even on an exact
- * match: labels are free-form and can collide, so a distinct session may carry
- * the same label on a peer that has not answered yet — early-exiting on the
- * first would silently, and nondeterministically, resume the wrong session
- * (whichever peer replied first). Labels therefore stay all-settle so a
- * cross-machine label conflict surfaces as an ambiguity, and a short-id PREFIX
- * *shorter* than the full 8-hex width stays all-settle for the same reason
- * (RUSH-2203).
- *
- * This is about cancelling a sweep that is still IN FLIGHT, where a peer that
- * has not answered yet is still expected to. It is deliberately stricter than
- * `isUniqueEnoughSelector`, which decides what to do once the sweep is OVER and
- * a peer has definitively not answered — see SES-9a. A collision between two
- * peers that BOTH answer before the abort lands is still caught by the ordinary
- * uniqueness gate in `metadataResolveOutcome`/`fleetCandidatesByQuery`; only a
- * peer that has not answered yet, at the moment of the FIRST hit, is the
- * accepted risk (documented in the PHNX-3292 plan).
- */
 export function isDefinitiveMatch(session, selector) {
     const trimmed = selector.trim();
     if (FULL_SESSION_ID_RE.test(trimmed)) {
@@ -4878,27 +2820,11 @@ export function isDefinitiveMatch(session, selector) {
     const shortId = shortIdFromName(trimmed) ?? (SHORT_SESSION_ID_RE.test(trimmed) ? trimmed : undefined);
     return !!shortId && session.shortId.toLowerCase() === shortId.toLowerCase();
 }
-/**
- * Whether a selector may enable early-exit on the cancellable fan-out: a full
- * UUID, a tmux alias, or an exact 8-hex short id — every shape that is globally
- * unique enough for the first hit to be the only hit worth waiting for. Labels,
- * keywords, and short-id prefixes narrower than 8 hex stay all-settle: their
- * uniqueness (or conflict) is only knowable once every peer has answered. See
- * {@link isDefinitiveMatch}.
- */
 export function selectorAllowsEarlyExit(selector) {
     const trimmed = selector.trim();
     return FULL_SESSION_ID_RE.test(trimmed) || isAgentTmuxAlias(trimmed) || SHORT_SESSION_ID_RE.test(trimmed);
 }
-/** Resolve a fleet sweep through the same canonical full-id / prefix resolver as
- * local lookups, then group copies by logical session id. Synced mirrors of one
- * session therefore stay one candidate even when several machines report them;
- * distinct ids sharing a prefix remain distinct ambiguity candidates. */
 export function fleetCandidatesByQuery(rows, query, trustResolvedRows = false) {
-    // An id selector must still be prefix-filtered defensively against older peers
-    // returning content mentioners. Keyword rows, however, were already matched by
-    // each peer's own FTS index; the parent does not own that transcript/index and
-    // must not re-run metadata-only filtering that could discard a content hit.
     const matched = !trustResolvedRows && looksLikeSessionId(query)
         ? resolveSessionQuery(rows, query, { indexFallback: false }).matches
         : rows;
@@ -4906,7 +2832,7 @@ export function fleetCandidatesByQuery(rows, query, trustResolvedRows = false) {
     for (const session of matched) {
         const machine = session.machine;
         if (!machine)
-            continue; // an untagged row can't be routed back to a peer
+            continue;
         const logicalId = session.id.toLowerCase();
         let byMachine = byId.get(logicalId);
         if (!byMachine) {
@@ -4921,7 +2847,6 @@ export function fleetCandidatesByQuery(rows, query, trustResolvedRows = false) {
         return { id: hits[0].session.id, hits };
     });
 }
-/** Resolve through the canonical metadata+content union used by keyword search. */
 function resolveIndexedMetadataRows(indexed, selector, scope) {
     const alias = resolveSessionAlias(selector);
     if (alias.kind === 'resolved') {
@@ -4933,18 +2858,12 @@ function resolveIndexedMetadataRows(indexed, selector, scope) {
     }
     return resolveSessionQuery(indexed, selector, { indexFallback: false, scope }).matches;
 }
-/**
- * ID-shaped selectors go straight to SQLite's primary-key/short-id lookup.
- * Keyword and label selectors still need the broader metadata pool.
- */
 function indexedRowsForSelector(selector, scope) {
     const indexed = looksLikeSessionId(selector)
         ? findSessionsById(selector)
         : querySessions();
     return applyScopeFilters(indexed, scope);
 }
-/** Fixed peer argv for the metadata resolver. Scope flags compose identically on
- * every host; `--all` removes the SSH login cwd/time window, not agent/project filters. */
 export function metadataResolveForwardedArgs(selector, scope) {
     const args = ['sessions', '--resolve-safe-v1', selector, '--json', '--all', '--local'];
     if (scope.agent)
@@ -4953,7 +2872,6 @@ export function metadataResolveForwardedArgs(selector, scope) {
         args.push('--project', scope.project);
     return args;
 }
-/** Build the local-only peer argv for a distributed tool search. */
 export function toolSearchForwardedArgs(argv, hosts) {
     const args = ensureWholeIndex(buildForwardedArgs(argv, new Set(hosts)).filter((arg) => arg !== '--fleet'));
     if (!args.includes('--json'))
@@ -4962,19 +2880,7 @@ export function toolSearchForwardedArgs(argv, hosts) {
         args.push('--local');
     return args;
 }
-/** Width of the short id the CLI prints everywhere (`SessionMeta.shortId`):
- * 8 hex chars / 32 bits. A selector shorter than this is treated as a keyword,
- * not an identifier. */
 const SHORT_SESSION_ID_WIDTH = 8;
-/**
- * Whether a selector names ONE session precisely enough to resolve from the
- * reachable fleet alone when some peer did not answer (SES-9a).
- *
- * Deliberately stricter than `looksLikeSessionId`, which accepts any 6+ char
- * `[0-9a-f-]` run and so matches ordinary words (`facade`, `decade`, `beaded`).
- * Those are keywords a user typed as a search, not identifiers, and they must
- * keep waiting for every peer.
- */
 export function isUniqueEnoughSelector(selector) {
     const trimmed = selector.trim();
     if (isCompleteSessionId(trimmed))
@@ -4982,35 +2888,8 @@ export function isUniqueEnoughSelector(selector) {
     return /^[0-9a-f-]+$/i.test(trimmed)
         && trimmed.replace(/-/g, '').length >= SHORT_SESSION_ID_WIDTH;
 }
-/** Resolution fails closed for keywords and labels when a peer did not answer.
- * An id-shaped selector at least `SHORT_SESSION_ID_WIDTH` hex chars wide (or a
- * complete id) resolves from a single reachable hit even when an unrelated
- * registered device is offline — see SES-9a for the accepted collision risk. */
 export function metadataResolveOutcome(localMatches, remote, selector) {
-    // Every peer answered through --resolve-safe-v1, so its native-id row is
-    // already the result of resolving the original selector. Re-filtering by the
-    // selector would discard alias suffixes such as c1f3d813 because the native
-    // UUID intentionally has a different prefix.
     const candidates = fleetCandidatesByQuery([...localMatches, ...remote.sessions], selector, true);
-    // One hit on the REACHABLE fleet resolves a precise-enough id selector even
-    // when a peer is offline (SES-9a). This is a deliberate, bounded trade, not a
-    // claim that prefixes cannot collide — they can, which is why the `ambiguous`
-    // branch below still exists for peers that DID answer:
-    //   - refusing costs 100% of lookups on any fleet with a permanently offline
-    //     device (9 of them here), to avoid a prefix collision that ALSO has to
-    //     land on the one box that did not answer. Rate depends on the id type:
-    //     a UUIDv4 short id is unique in practice, while a time-ordered
-    //     UUIDv7/ULID prefix is largely a timestamp and collides much more
-    //     readily (see deriveShortId in session/db.ts);
-    //   - `isUniqueEnoughSelector` keeps this off keyword-shaped queries, so a
-    //     6-char word like `facade` or `decade` is not treated as an identifier.
-    // A label stays fail-closed at any length: labels are free-form and collide by
-    // design, so one hit there really is a guess.
-    // (RUSH-2203's early-exit — see isDefinitiveMatch — cancels the sweep
-    // mid-flight, where a peer that has not answered YET is still expected to
-    // answer, so it stays narrower than this post-sweep gate even though
-    // PHNX-3292 widened it past UUID to alias/8-hex too. Here the sweep is
-    // already over.)
     if (isUniqueEnoughSelector(selector) && candidates.length === 1) {
         return { kind: 'resolved', session: candidates[0].hits[0].session };
     }
@@ -5022,74 +2901,17 @@ export function metadataResolveOutcome(localMatches, remote, selector) {
         return { kind: 'ambiguous', candidates };
     return { kind: 'resolved', session: candidates[0].hits[0].session };
 }
-/**
- * Whether a local candidate answers a full-UUID selector **definitively** — i.e.
- * whether finding it on this box is the whole answer, so the fleet fan-out can be
- * skipped (PHNX-3890).
- *
- * Two shapes qualify, and both are claims this box can actually back:
- *
- * - **A real transcript on this disk** (`filePath`). It renders locally, whoever
- *   owns it — a local session or a fleet-synced mirror — so no SSH hop is needed.
- * - **A genuine peer attribution** (`machine` names another box). The row already
- *   routes the read to its owner through `transcriptOnPeerOf`, so the peer that
- *   would answer the fan-out is the peer the render already dials.
- *
- * What does NOT qualify is the launcher-shim shape: a transcript-less live row
- * whose `machine` is this box only because it DEFAULTED there
- * (`activeSessionToSessionMeta`'s `active.machine ?? self`,
- * `computeLocalMetadataMatches`'s `machine || localMachine`). A dispatcher holds
- * exactly that row for a session whose agent and transcript live on a peer: the
- * launch process is here, the conversation is not. Treating it as definitive is
- * what dead-ended `agents sessions preview <full-uuid>` on the local
- * "Live session — full transcript not indexed here." stub while a passive peer —
- * which has no local row at all, so it fans out — rendered the real digest.
- * Process locality is not transcript locality.
- */
 export function isLocallyDefinitiveMatch(session, self) {
     if (session.filePath)
         return true;
     return !!session.machine && session.machine !== self;
 }
-/**
- * Drop the launcher-shim local rows that a peer has since answered for
- * (PHNX-3890). `fleetCandidatesByQuery` groups a logical session's copies per
- * machine and every consumer reads `hits[0]`, with local rows passed first — so
- * simply fanning out is not enough: the self-defaulted shim would still win the
- * attribution and route the read back to a box with no transcript. When the peer
- * that actually owns the session has answered the sweep, its row is the strictly
- * better one, and the shim carries no information the candidate loses (same
- * logical id, so the candidate — and any ambiguity it is part of — survives
- * through the remote hit).
- *
- * A row that is {@link isLocallyDefinitiveMatch} is never dropped, so a locally
- * readable transcript or a synced mirror still renders here with no SSH hop. When
- * no peer answered for that id, the shim is kept: with no fleet evidence, a
- * transcript-less self-attributed row is indistinguishable from a session THIS box
- * just started, and dropping it would re-break the cold-index lookup RUSH-2682
- * fixed.
- */
 export function preferOwnerAttribution(localMatches, remoteSessions, self) {
     if (remoteSessions.length === 0)
         return localMatches;
     const answeredByPeer = new Set(remoteSessions.map(session => session.id.toLowerCase()));
     return localMatches.filter(session => isLocallyDefinitiveMatch(session, self) || !answeredByPeer.has(session.id.toLowerCase()));
 }
-/**
- * Local metadata candidates for a selector: the indexed SQLite rows, plus — when
- * an id-shaped selector misses the index entirely — the live-session registry
- * (RUSH-2682).
- *
- * Indexing is lazy (it only runs inside `discoverSessions`), so a session THIS
- * box just started is "running" in `agents sessions --active` minutes before its
- * transcript reaches the local index. Every id resolver (`preview`, `resume`,
- * `focus`, and the fan-out peer that answers `--resolve-safe-v1`) therefore
- * consults the SAME live registry `--active` reads before declaring a running
- * session non-existent. It reshapes process state the registry already computed;
- * it parses no transcript and renders nothing. The live path is entered ONLY on a
- * cold id miss, so an indexed hit keeps its richer row and keyword resolution is
- * unchanged.
- */
 export async function computeLocalMetadataMatches(selector, scope, deps = {}) {
     const localMachine = machineId();
     const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
@@ -5126,22 +2948,9 @@ export async function computeLocalMetadataMatches(selector, scope, deps = {}) {
     }
     return hydrated;
 }
-/**
- * Resolve an id-shaped selector against the local live-session registry
- * (RUSH-2682). Reads the daemon-warmed active snapshot first (cheap); if that
- * snapshot predates a just-started session and misses, it forces ONE fresh
- * gather before conceding, so a session started seconds ago resolves
- * synchronously. Never throws — a degraded registry read yields no candidates,
- * so the caller falls through to the ordinary not-found path.
- */
 export async function liveMetadataMatches(selector, scope, self, deps = {}) {
     const load = deps.loadActive ?? loadLocalActiveSessions;
     const loadFleet = deps.loadFleetActive ?? (() => readActiveSessionsCache('fleet')?.sessions ?? []);
-    // A launcher-shim row whose `machine` self-defaulted to this box gets its true
-    // EXECUTION host from the fleet snapshot, so a session dispatched to a peer is
-    // read on that peer instead of dead-ending on the local stub (PHNX-3890). The
-    // read is best-effort: an absent/cold snapshot leaves the row untouched and the
-    // fleet fan-out in resolveSessionMetadataValue supplies the owner instead.
     let fleetExecMachine;
     try {
         fleetExecMachine = fleetExecutionMachineById(loadFleet());
@@ -5162,23 +2971,9 @@ export async function liveMetadataMatches(selector, scope, self, deps = {}) {
         return [];
     }
 }
-/** Reusable local-first resolver for `agents run --resume` and `agents sessions resume`.
- * Full UUIDs hit the local SQLite index without any SSH fan-out. */
 export async function resolveSessionMetadataValue(selector, scope = {}, deps = { gatherRemoteList }) {
     const localMatches = await computeLocalMetadataMatches(selector, scope, deps);
     const localMachine = machineId();
-    // A full-UUID local hit resolves with ZERO SSH: a UUID is globally unique, so
-    // finding it locally is the whole answer and no peer is dialed. (A label is
-    // NOT resolved local-only here — it can collide with a same-label session on a
-    // peer, so it must consult the fleet; see isDefinitiveMatch, RUSH-2203.) The
-    // local index lookup is synchronous and completes before any fan-out spawns,
-    // so this local hit never waits on a peer.
-    //
-    // "Found it locally" must mean this box can actually ANSWER for it, though —
-    // see isLocallyDefinitiveMatch. A transcript-less launcher shim for a session
-    // executing on a peer is a local row that is not a local answer, and
-    // short-circuiting on it skipped the one fan-out that could have named the
-    // owner (PHNX-3890).
     if (FULL_SESSION_ID_RE.test(selector)) {
         const localOutcome = metadataResolveOutcome(localMatches, { sessions: [], unreachable: [] }, selector);
         if (localOutcome.kind === 'resolved' && isLocallyDefinitiveMatch(localOutcome.session, localMachine)) {
@@ -5189,10 +2984,6 @@ export async function resolveSessionMetadataValue(selector, scope = {}, deps = {
         return metadataResolveOutcome(localMatches, { sessions: [], unreachable: [] }, selector);
     try {
         const forwarded = metadataResolveForwardedArgs(selector, scope);
-        // Definitive lookups (full UUID / exact label) opt into early-exit: the
-        // first peer holding the match resolves the sweep and SIGTERMs the rest, so
-        // a fast peer's hit is not bounded by the slowest/unreachable peer. Short-id
-        // prefixes stay all-settle (ambiguity is only known once every peer answers).
         const remote = await deps.gatherRemoteList(forwarded, scope.hosts, selectorAllowsEarlyExit(selector)
             ? { isDefinitive: (session) => isDefinitiveMatch(session, selector) }
             : undefined);
@@ -5202,30 +2993,14 @@ export async function resolveSessionMetadataValue(selector, scope = {}, deps = {
         return metadataResolveOutcome(localMatches, { sessions: [], unreachable: [error?.message ?? 'fleet fan-out'] }, selector);
     }
 }
-/** Resolve one selector to indexed metadata across the fleet without reading or
- * rendering transcript events. A peer answering the parent sweep returns every
- * local candidate; the parent performs the one logical-session uniqueness gate.
- * Backs `agents sessions --resolve <selector> --json`. Exported (deps already
- * injectable) so tests can drive this real call site against a fake fan-out
- * instead of only the pure resolver it wraps. */
 export async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList }) {
-    // Same local candidate set as resolveSessionMetadataValue, so the peer
-    // answering a fan-out (`--resolve-safe-v1`, NO_FANOUT) surfaces a running
-    // session its own index has not caught yet — the cross-device half of the
-    // RUSH-2682 fix, since the parent's fan-out reads this box's answer.
     const localMatches = await computeLocalMetadataMatches(selector, scope, deps);
-    // A peer is already inside gatherRemoteList. Return all local candidates so
-    // the parent can distinguish a fleet-wide unique match from an ambiguity.
     if (process.env[NO_FANOUT_ENV] === '1') {
         process.stdout.write(serializeResolvedSessionsJson(localMatches));
         return;
     }
     const outcome = await resolveSessionMetadataValue(selector, scope, deps);
     if (outcome.kind === 'partial') {
-        // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
-        // resolver already resolves an id found on the reachable fleet (SES-9a),
-        // so reaching here means the session was not found on any device we
-        // COULD reach — it may live on an unreachable peer we could not check.
         const offline = outcome.failedPeers;
         console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
         console.error(chalk.red(`No session matching "${selector}" on any reachable device (${offline.length} unreachable, not checked).`));
@@ -5254,11 +3029,6 @@ async function resolveSessionAcrossFleet(query, mode, hosts, deps = { gatherRemo
     let deviceCount = 0;
     let unreachable = [];
     try {
-        // Force whole-index scope (--all): the peer runs in its SSH-login home dir,
-        // whose cwd would otherwise silently narrow the lookup and hide the row.
-        // --json so each peer answers a parseable array; --local so it answers for
-        // itself and never re-fans-out (belt-and-suspenders with the parent's
-        // AGENTS_SESSIONS_LOCAL, which remote-list also sets on the peer).
         const forwarded = ['sessions', query, '--json', '--all', '--local'];
         const remote = await deps.gatherRemoteList(forwarded, hosts, selectorAllowsEarlyExit(query)
             ? { isDefinitive: (session) => isDefinitiveMatch(session, query) }
@@ -5268,8 +3038,6 @@ async function resolveSessionAcrossFleet(query, mode, hosts, deps = { gatherRemo
         unreachable = remote.unreachable;
     }
     catch {
-        // A fan-out failure is not an exact resolution — treat as not-found so the
-        // caller prints the honest message rather than a half-answer.
         candidates = [];
     }
     finally {
@@ -5290,10 +3058,6 @@ async function resolveSessionAcrossFleet(query, mode, hosts, deps = { gatherRemo
     }
     const candidate = candidates[0];
     const { machine } = candidate.hits[0];
-    // Render the remote summary by re-running `sessions <id>` ON the peer. --local
-    // keeps that render on the peer (it owns the transcript); the mode flag matches
-    // the mode the user asked for. No TTY: a summary/markdown/json render is a
-    // one-shot capture, not an interactive resume.
     const peerArgs = ['sessions', candidate.id, '--local'];
     const flag = modeFlag(mode);
     if (flag)
@@ -5302,11 +3066,10 @@ async function resolveSessionAcrossFleet(query, mode, hosts, deps = { gatherRemo
     if (result === 'no-target') {
         console.error(chalk.red(`Session ${candidate.id} is on ${machine}, but it is not a reachable registered device.`));
         console.error(chalk.gray('Register it with `agents devices` or run the command on that machine.'));
-        return { kind: 'conflict' }; // a definitive answer (found, un-renderable) — do NOT fall to the local not-found line
+        return { kind: 'conflict' };
     }
     return { kind: 'rendered' };
 }
-/** Register the `agents sessions` command with all its options and help text. */
 export function registerSessionsCommands(program) {
     const sessionsCmd = program
         .command('sessions')
@@ -5480,15 +3243,10 @@ export function registerSessionsCommands(program) {
     });
     sessionsCmd.action(async (query, options, command) => {
         if (options.browser) {
-            // Alias for `agents browser sessions`: a profile positional narrows to one
-            // profile. `--no-interactive` is already a top-level sessionsCmd option
-            // (options.interactive), so it carries through for free.
             await runBrowserSessionsCommand({ profile: query, json: options.json, interactive: options.interactive });
             return;
         }
         if (options.computer) {
-            // Alias for `agents computer sessions`: a machine positional narrows to
-            // one machine. `--no-interactive` carries through the same way.
             const limit = options.limit === undefined ? undefined : Number.parseInt(options.limit, 10);
             const deviceArgs = [...(options.device ?? []), ...(options.devices ?? [])];
             const allFleet = deviceArgs.some((host) => ['all', 'fleet'].includes(host.toLowerCase()));
@@ -5668,13 +3426,11 @@ function findClaudeSessionsInProject(sessions, historyEntry) {
 function findClaudeProjectSessions(sessions, historyEntry) {
     if (!historyEntry.project)
         return [];
-    // Resolve symlinks (e.g. macOS /var -> /private/var) so we match sessions
-    // whose cwd was canonicalized at scan time.
     let projectRoot = historyEntry.project;
     try {
         projectRoot = fs.realpathSync(projectRoot);
     }
-    catch { /* dir gone */ }
+    catch { }
     return sessions.filter(session => session.agent === 'claude' &&
         typeof session.cwd === 'string' &&
         isWithinProject(session.cwd, projectRoot));
@@ -5742,8 +3498,6 @@ function findClaudeResumeTimestamp(filePath, targetTimestampMs) {
     }
 }
 function isWithinProject(sessionCwd, projectRoot) {
-    // Compare separator- and case-normalized (Windows folds `\`→`/` and lowercases)
-    // so a backslash session cwd matches a forward-slash project root and vice versa.
     const cwd = toComparablePath(sessionCwd);
     const root = toComparablePath(projectRoot);
     return cwd === root || cwd.startsWith(root + '/');
@@ -5756,9 +3510,6 @@ function sessionDistance(session, historyEntry) {
         return Number.MAX_SAFE_INTEGER;
     return Math.abs(sessionTime - historyEntry.timestampMs);
 }
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
 function formatAbsoluteTime(isoTimestamp) {
     const d = new Date(isoTimestamp);
     if (isNaN(d.getTime()))