@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/commands/sessions.js

@@ -26,13 +26,13 @@ import { gatherRemoteActive, NO_FANOUT_ENV } from '../lib/session/remote-active.
 import { gatherRemoteList, runOnPeer } from '../lib/session/remote-list.js';
 import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/session/width.js';
 import { inferSessionState } from '../lib/session/state.js';
-import { discoverSessions, countSessionsInScope, resolveSessionById, isCompleteSessionId, searchContentIndex, getSessionRoots } from '../lib/session/discover.js';
+import { discoverSessions, countSessionsInScope, resolveSessionById, isCompleteSessionId, looksLikeSessionId, searchContentIndex, getSessionRoots } from '../lib/session/discover.js';
 import { findSessionsById } from '../lib/session/db.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { parseSession } from '../lib/session/parse.js';
 import { runRemoteSessions, buildForwardedArgs, ensureWholeIndex } from '../lib/session/remote.js';
 import { formatRelativeTime } from '../lib/session/relative-time.js';
-import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList, linkUrl } from '../lib/session/render.js';
+import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList, linkPath, linkUrl, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { AGENTS, colorAgent, resolveAgentName } from '../lib/agents.js';
@@ -182,6 +182,11 @@ function statusColor(status) {
         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;
         // 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;
@@ -303,6 +308,10 @@ export function formatActiveRowDescription(s) {
 }
 /** 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.
+    if (s.status === 'closed' || s.status === 'abandoned')
+        return s.status;
     if (s.activity === 'waiting_input')
         return 'waiting';
     if (s.activity === 'working')
@@ -335,14 +344,54 @@ export function indexActiveBySessionId(active) {
 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.
+    if (a.status === 'abandoned')
+        return { glyph: statusColor(a.status)('⊘'), preview: buildSessionDescription(a) };
+    if (a.status === 'closed')
+        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';
-    // `◌` (dotted) = alive but un-introspectable — visually distinct from `○` idle
-    // so an opaque harness is never mistaken for a finished one.
     const unknown = a.status === 'unknown';
-    const shape = waiting ? '◐' : running ? '●' : 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;
+    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 '';
+}
+/** 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, 8)), width: 8 };
+}
 /**
  * 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
@@ -351,6 +400,21 @@ export function liveGlyphAndPreview(a) {
 export function ticketLabel(s) {
     return s.ticketId ?? (s.prNumber ? `PR#${s.prNumber}` : '');
 }
+function ticketUrl(s) {
+    if (s.ticketId)
+        return linearIssueUrl(s.ticketId);
+    return s.prNumber ? s.prUrl : undefined;
+}
+export function linkTicketCell(s, label) {
+    const url = ticketUrl(s);
+    return url && label.trim() !== '-' ? linkUrl(url, label) : label;
+}
+export function linkCwdCell(s, label) {
+    return s.cwd && !s._remote ? linkPath(s.cwd, label) : label;
+}
+function modelLabel(model) {
+    return model ? shortenModel(model) : '-';
+}
 /**
  * The row shape `agents sessions --active --json` emits. RUSH-1981: a watcher
  * joins active sessions on ticketId + project, but the raw ActiveSession nests
@@ -365,6 +429,7 @@ export function serializeActiveSessionsForJson(sessions) {
         ...s,
         ticketId: s.ticket?.id ?? null,
         project: s.cwd ? path.basename(s.cwd) : null,
+        prLink: s.pr?.url ?? null,
     }));
 }
 /**
@@ -435,11 +500,12 @@ function locatorBadge(s) {
  * terminal width so the row never wraps.
  */
 function printActiveRow(s, indent) {
-    // shortId (8-char) · agent · host · status · badges · identity+todos+snippet
+    // shortId (8-char) · agent · host · status · owner · badges · identity+todos+snippet
     const idCol = chalk.dim(padToWidth((s.sessionId?.slice(0, 8)) ?? '-', 9));
     const kindCol = colorAgent(s.kind)(padToWidth(truncateToWidth(s.kind, 8), 9));
     const hostCol = chalk.gray(padToWidth(truncateToWidth(s.host ?? '-', 8), 9));
     const statusCol = statusColor(s.status)(padToWidth(truncateToWidth(activityLabel(s), 8), 9));
+    const ownerCol = chalk.cyan(padToWidth(truncateToWidth(ownerLabel(s), 8), 9));
     const fork = s.pidCount && s.pidCount > 1 ? chalk.dim(`×${s.pidCount} `) : '';
     const badges = (fork ? fork : '') + [signalBadges(s), locatorBadge(s)].filter(Boolean).join(' ');
     // Identity (label/project/ticket clickable) + checklist + live snippet.
@@ -447,10 +513,24 @@ function printActiveRow(s, indent) {
     // via the SSH fan-out already populated (including todos when the peer has them).
     const desc = formatActiveRowDescription(s) || '-';
     // Fill the remaining width with the preview so nothing wraps under tmux/SSH.
-    const fixed = stringWidth(indent) + 9 + 9 + 9 + 9 + (badges ? stringWidth(badges) + 1 : 0);
+    const fixed = stringWidth(indent) + 9 + 9 + 9 + 9 + 9 + (badges ? stringWidth(badges) + 1 : 0);
     const room = Math.max(12, terminalWidth() - fixed - 1);
     const descCol = chalk.white(truncateToWidth(desc, room));
-    console.log(indent + idCol + kindCol + hostCol + statusCol + (badges ? badges + ' ' : '') + descCol);
+    console.log(indent + idCol + kindCol + hostCol + statusCol + ownerCol + (badges ? badges + ' ' : '') + descCol);
+}
+/**
+ * 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
@@ -666,8 +746,8 @@ async function runRemoteSessionsJson(hosts) {
     process.stdout.write(serializeSessionsJson(sessions));
 }
 /**
- * `running N · idle N · waiting N · queued N · unknown N` for a bucket of
- * sessions (zero buckets omitted). Same bucketing as the grand-total summary so
+ * `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.
@@ -677,6 +757,8 @@ function groupTally(sessions) {
     const idle = sessions.filter(s => s.status === 'idle').length;
     const waiting = sessions.filter(s => s.status === 'input_required').length;
     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;
     const unknown = sessions.filter(s => s.status === 'unknown').length;
     const parts = [];
     if (running)
@@ -687,6 +769,10 @@ function groupTally(sessions) {
         parts.push(`${waiting} waiting`);
     if (queued)
         parts.push(`${queued} queued`);
+    if (closed)
+        parts.push(`${closed} closed`);
+    if (abandoned)
+        parts.push(`${abandoned} abandoned`);
     if (unknown)
         parts.push(`${unknown} unknown`);
     return parts.join(' · ');
@@ -813,15 +899,18 @@ export function remoteHostsToDial(hosts, self) {
     return hosts.filter(h => hostToken(h) !== self);
 }
 /**
- * Render the unified active-session view, grouped by machine. With no `--host`,
- * local sessions come from `getActiveSessions()` and (unless `--local`) the
- * registered online devices from `ag devices` are folded in over SSH. An
- * explicit `--host`/`--device` list SCOPES the view to exactly those machines —
- * the local machine is included only when it is itself named — so `--host` is a
- * filter, not an addition (matching the non-`--active` listing path). A tip is
- * shown when there are no other machines to include.
+ * 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 `--host`/`--device`
+ * list SCOPES the sweep to exactly those machines — the local machine is included
+ * only when it is itself named — so `--host` 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).
  */
-async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
+export async function gatherActiveSessions(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.
@@ -841,6 +930,17 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
             merged = dedupeByMachineSession([...local, ...remote.sessions]);
         }
     }
+    return { sessions: merged, remoteDeviceCount };
+}
+/**
+ * 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 { sessions: merged, remoteDeviceCount } = await gatherActiveSessions(opts);
     // --waiting: only sessions blocked on the user. Exits non-zero when any are
     // present so a supervising agent or hook can poll it as a gate.
     const sessions = waitingOnly ? merged.filter(s => s.status === 'input_required') : merged;
@@ -944,6 +1044,21 @@ async function renderSessionPreview(query, scope) {
             console.log(chalk.gray(`No session matches "${query}".`));
         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.
+    let live;
+    try {
+        live = indexActiveBySessionId(await getActiveSessions()).get(session.id);
+    }
+    catch { /* plain preview on any probe failure */ }
+    if (live) {
+        const { glyph } = liveGlyphAndPreview(live);
+        const word = liveStatusWord(live) || live.status;
+        const needsYou = live.status === 'input_required' || live.activity === 'waiting_input';
+        const reason = live.awaitingReason ? ` (${live.awaitingReason.replace('_', ' ')})` : '';
+        const suffix = needsYou ? chalk.yellow(`  ← needs you${reason}`) : '';
+        console.log(`${glyph} ${statusColor(live.status)(word)}${suffix}`);
+    }
     console.log(buildPreview(session));
 }
 /** Main action handler for `agents sessions`. Routes to picker, table, or single-session render. */
@@ -1023,6 +1138,7 @@ async function sessionsAction(query, options) {
                 agent: options.agent,
                 host: options.host,
                 since: options.since,
+                all: options.all,
             }), { local: options.local === true, hosts: options.host });
             return;
         }
@@ -1104,7 +1220,7 @@ async function sessionsAction(query, options) {
     // 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, filter: filterOpts, redact: options.redact });
+        await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, filter: filterOpts, redact: options.redact, local: options.local, hosts: options.host });
         return;
     }
     // Interactive picker loads a deep pool but shows only recent sessions
@@ -1171,19 +1287,34 @@ async function sessionsAction(query, options) {
         // 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).
-        if (searchQuery) {
+        //
+        // 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);
             if (idMatches.length === 1) {
                 await renderSession(idMatches[0], mode, filterOpts, options);
                 return;
             }
             if (idMatches.length === 0 && looksLikeSessionId(searchQuery)) {
-                await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, filter: filterOpts, redact: options.redact });
+                await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, filter: filterOpts, redact: options.redact, local: options.local, hosts: options.host });
                 return;
             }
         }
         if (options.json) {
-            const filtered = searchQuery ? filterSessionsByQuery(sessions, searchQuery) : sessions;
+            // 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.
+            const filtered = searchQuery
+                ? resolveSessionQuery(sessions, searchQuery).matches
+                : sessions;
             process.stdout.write(serializeSessionsJson(filtered));
             return;
         }
@@ -1271,15 +1402,6 @@ async function sessionsAction(query, options) {
         process.exit(1);
     }
 }
-/** Whether a query should route to the single-session render rather than the
- * listing. The hex-ish test catches a bare id prefix; `isCompleteSessionId`
- * additionally catches the prefixed whole ids (`session_…`, `ses_…`) that the
- * hex test rejects — without it those never reach the id-only resolution and
- * still content-search. */
-function looksLikeSessionId(query) {
-    const trimmed = query.trim();
-    return /^[0-9a-f-]{6,}$/i.test(trimmed) || isCompleteSessionId(trimmed);
-}
 function teamTag(session) {
     const origin = session.teamOrigin;
     if (!origin)
@@ -1301,12 +1423,12 @@ function metaSignals(s) {
     };
 }
 /** One flat table row:
- *   shortId · agent · version · project · [glyph] label·doing · [ticket] · [wt] · time
+ *   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. */
-function flatSessionRow(session, live, showTicket = false, cols = {}) {
+export function flatSessionRow(session, live, showTicket = false, cols = {}) {
     const agentColor = colorAgent(session.agent);
     const when = formatRelativeTime(session.lastActivity ?? session.timestamp);
     const project = session.project || '-';
@@ -1329,19 +1451,31 @@ function flatSessionRow(session, live, showTicket = false, cols = {}) {
         : '';
     const TICKET_W = 10;
     const ticketCell = showTicket
-        ? chalk.blue(padToWidth(truncateToWidth(ticketLabel(session) || '-', TICKET_W), TICKET_W + 1))
+        ? 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;
     const ticketW = showTicket ? TICKET_W + 1 : 0;
     const wtW = wt ? stringWidth(wt) + 1 : 0;
-    const topicW = Math.max(16, terminalWidth() - (10 + 9 + 8 + 16) - glyphW - machineW - ticketW - wtW - stringWidth(when) - 1);
+    const width = terminalWidth();
+    const requestedModelW = cols.showModel ? (cols.modelWidth ?? PICKER_MODEL_MAX) : 0;
+    const fixedW = (10 + 9 + 8 + 16) + glyphW + statusW + machineW + ticketW + wtW + stringWidth(when) + 1;
+    const modelSlack = width - fixedW - 16;
+    const modelW = requestedModelW <= modelSlack
+        ? requestedModelW
+        : modelSlack >= PICKER_MODEL_MIN ? modelSlack : 0;
+    const topicW = Math.max(16, width - fixedW - modelW);
     return (chalk.white(padToWidth(truncateToWidth(session.shortId, 9), 10)) +
         agentColor(padToWidth(truncateToWidth(session.agent, 8), 9)) +
         chalk.yellow(padToWidth(truncateToWidth(session.version || '-', 7), 8)) +
+        (modelW ? chalk.yellow(padToWidth(truncateToWidth(modelLabel(session.model), modelW - 1), modelW)) : '') +
         machineCell +
-        chalk.cyan(padToWidth(truncateToWidth(project, 14), 16)) +
+        chalk.cyan(linkCwdCell(session, padToWidth(truncateToWidth(project, 14), 16))) +
         (glyph ? glyph + ' ' : '') +
+        statusCell +
         renderTopicCell(label, doing, '', topicW, topicW) +
         ticketCell +
         (wt ? wt + ' ' : '') +
@@ -1362,13 +1496,15 @@ function treeSessionRow(session, live) {
     const badges = signalBadges(metaSignals(session));
     const badgeW = badges ? stringWidth(badges) + 1 : 0;
     const head = label ? `${label} · ${topic}` : topic;
+    const { cell: statusCell, width: statusW } = liveStatusCell(live);
     const glyphW = glyph ? 2 : 0;
-    const topicW = Math.max(12, terminalWidth() - (2 + 9 + 8) - glyphW - badgeW - stringWidth(when) - 1);
+    const topicW = Math.max(12, terminalWidth() - (2 + 9 + 8) - glyphW - statusW - badgeW - stringWidth(when) - 1);
     return ('  ' +
         chalk.dim(padToWidth(session.shortId, 9)) +
         agentColor(padToWidth(truncateToWidth(session.agent, 7), 8)) +
         (badges ? badges + ' ' : '') +
         (glyph ? glyph + ' ' : '') +
+        statusCell +
         padToWidth(chalk.white(truncateToWidth(head, topicW)), topicW) +
         ' ' + chalk.gray(when));
 }
@@ -1485,7 +1621,9 @@ function printSessionTable(sessions, hiddenCount = 0, tree = false, liveIndex) {
                 console.log();
             first = false;
             const group = byDir.get(key);
-            console.log(`${chalk.cyan.bold(shortCwd(key))} ${chalk.gray(`(${group.length})`)}`);
+            const cwd = group.find((s) => s.cwd && !s._remote)?.cwd;
+            const header = cwd ? linkPath(cwd, shortCwd(key)) : shortCwd(key);
+            console.log(`${chalk.cyan.bold(header)} ${chalk.gray(`(${group.length})`)}`);
             for (const s of group)
                 console.log(treeSessionRow(s, liveIndex?.get(s.id)));
         }
@@ -1681,12 +1819,18 @@ function renderTopicCell(label, topic, query, visibleWidth, paddedWidth) {
 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));
 }
+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
@@ -1722,10 +1866,28 @@ export function pickerColumnsFor(sessions) {
         showMachine: distinct.length > 1,
         machineLabel,
         machineWidth: machineColumnWidth(distinct, machineLabel),
+        showModel: sessions.some((s) => !!s.model),
+        modelWidth: modelColumnWidth(sessions),
         showTicket: sessions.some((s) => ticketLabel(s) !== ''),
     };
 }
-export function formatPickerLabel(s, query, cols = {}, ssh) {
+/** 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 '';
+    const viewer = a.viewingIn?.app;
+    return viewer && viewer !== a.host ? `${a.host}→${viewer}` : a.host;
+}
+export function formatPickerLabel(s, query, cols = {}, ssh, host = '') {
     const agentColor = colorAgent(s.agent);
     const when = formatRelativeTime(s.lastActivity ?? s.timestamp);
     const project = s.project || '-';
@@ -1750,18 +1912,29 @@ export function formatPickerLabel(s, query, cols = {}, ssh) {
     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;
-    const topicW = Math.max(16, terminalWidth() - gutter - (10 + 9 + 8 + 16) - machineColW - ticketW - wtW - sshW - stringWidth(when) - 1);
-    return (chalk.white(padRight(s.shortId, 10)) +
+    const topicW = Math.max(16, terminalWidth() - gutter - (10 + 9 + 8 + 16) - machineColW - hostW - ticketW - wtW - sshW - stringWidth(when) - 1);
+    return (
+    // 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(s.agent, 8), 9)) +
         chalk.yellow(padRight(truncate(versionStr, 7), 8)) +
         machineCell +
+        hostCell +
         chalk.cyan(padRight(truncate(project, 14), 16)) +
         sshSeg +
         renderTopicCell(label, topic, query, topicW, topicW) +
@@ -1827,7 +2000,25 @@ 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:';
+export 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 ? ` --host ${picked.session.machine}` : ''}`));
+        return;
+    }
     // A session on another machine is read/resumed ON that machine over SSH — its
     // transcript and agent binary live there. Both actions execute on the peer
     // (not a local `--host` hop, which would discover locally and dead-end for a
@@ -2403,6 +2594,21 @@ 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 === 'rendered')
+                        return;
+                    if (outcome === 'conflict')
+                        process.exit(1);
+                    // 'not-found' falls through to the local message below.
+                }
                 notFoundByIdMessage(query).forEach(l => console.error(l));
                 process.exit(1);
             }
@@ -2441,6 +2647,123 @@ 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.
+ */
+export function shouldFanOutForId(query, local) {
+    if (local === true)
+        return false;
+    if (process.env[NO_FANOUT_ENV] === '1')
+        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
+}
+/** Group a fleet sweep's rows to the DISTINCT machines that hold the id. Each
+ * peer answered `sessions <id> --json --local`, which (post-fix) id-resolves and
+ * so returns the matching row(s); a peer with a synced MIRROR of the same id can
+ * emit more than one row, so we keep the first per machine. Rows the peer somehow
+ * returned that do NOT match the id (defensive against version skew) are dropped
+ * so a stray content hit can never masquerade as an exact resolution. */
+export function fleetHitsById(rows, id) {
+    const q = id.trim().toLowerCase();
+    const byMachine = new Map();
+    for (const s of rows) {
+        const machine = s.machine;
+        if (!machine)
+            continue; // an untagged row can't be routed back to a peer
+        if (s.id?.toLowerCase() !== q)
+            continue; // exact id only — never a content hit
+        if (!byMachine.has(machine))
+            byMachine.set(machine, s);
+    }
+    return Array.from(byMachine.entries()).map(([machine, session]) => ({ machine, session }));
+}
+/**
+ * Locate a full session id across the online fleet and render it from the machine
+ * that holds it. The local disk already missed; this fans `sessions <id> --json
+ * --all` out to every registered online peer (or the explicit `hosts` set),
+ * groups the rows to distinct machines, then:
+ *
+ *   - exactly one machine  → delegate rendering to that peer via `runOnPeer`
+ *     (its transcript and agent binary live there — a local `--host` hop would
+ *     re-discover locally and dead-end), returning `'rendered'`.
+ *   - more than one machine → print the conflict with machine labels so the user
+ *     can disambiguate with `--device <host>`, returning `'conflict'`.
+ *   - none                 → `'not-found'`, letting the caller print the local
+ *     "no session on this machine" message.
+ *
+ * No fuzzy/content fallback: the sweep forwards a UUID, each peer id-resolves it,
+ * and `fleetHitsById` drops anything that isn't an exact id match.
+ */
+export async function resolveSessionAcrossFleet(id, mode, hosts, deps = { gatherRemoteList, runOnPeer }) {
+    const spinner = isInteractiveTerminal() ? ora('Searching the fleet...').start() : null;
+    let hits;
+    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', id, '--json', '--all', '--local'];
+        const { sessions } = await deps.gatherRemoteList(forwarded, hosts);
+        hits = fleetHitsById(sessions, id);
+    }
+    catch {
+        // A fan-out failure is not an exact resolution — treat as not-found so the
+        // caller prints the honest local message rather than a half-answer.
+        hits = [];
+    }
+    finally {
+        spinner?.stop();
+    }
+    if (hits.length === 0)
+        return 'not-found';
+    if (hits.length > 1) {
+        console.error(chalk.red(`Session ${id} exists on multiple machines:`));
+        for (const h of hits) {
+            const s = h.session;
+            const label = s.label ?? s.topic ?? '';
+            console.error(chalk.cyan(`  ${h.machine}`) + chalk.gray(`  ${s.agent}${s.version ? ` ${s.version}` : ''}  ${label}`));
+        }
+        console.error(chalk.gray(`Pick one with: agents sessions ${id} --device <host>`));
+        return 'conflict';
+    }
+    const { machine } = 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', id, '--local'];
+    const flag = modeFlag(mode);
+    if (flag)
+        peerArgs.push(flag);
+    const result = await deps.runOnPeer(peerArgs, machine);
+    if (result === 'no-target') {
+        console.error(chalk.red(`Session ${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 'conflict'; // a definitive answer (found, un-renderable) — do NOT fall to the local not-found line
+    }
+    return 'rendered';
+}
 /** Register the `agents sessions` command with all its options and help text. */
 export function registerSessionsCommands(program) {
     const sessionsCmd = program
@@ -2455,7 +2778,7 @@ export function registerSessionsCommands(program) {
         .option('--antigravity', 'Shorthand for --agent antigravity')
         .option('--grok', 'Shorthand for --agent grok')
         .option('--opencode', 'Shorthand for --agent opencode')
-        .option('--all', 'Include sessions from every directory (not just current project)')
+        .option('--all', 'Widen every non-status filter to "all": every directory (not just this project) and all time (no window cap). Status filters like --active still compose; -a/--device/--since still narrow their axis.')
         .option('--unmanaged', "Also show sessions from your own ~/.<agent> installs (hidden once agents-cli manages that agent)")
         .option('--teams', 'Include team-spawned sessions (hidden by default)')
         .option('--routine', 'Show only sessions archived from routine runs')