@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/commands/sessions-export.js

@@ -20,7 +20,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
-import { discoverSessions, resolveSessionById, isCompleteSessionId } from '../lib/session/discover.js';
+import { discoverSessions, resolveSessionById, looksLikeSessionId } from '../lib/session/discover.js';
 import { findSessionsById } from '../lib/session/db.js';
 import { filterSessionsByQuery, parseAgentFilter } from './sessions.js';
 import { listLocalTranscripts, SYNC_AGENTS } from '../lib/session/sync/agents.js';
@@ -222,8 +222,8 @@ function resolveAgentShorthand(g) {
         return 'antigravity';
     return undefined;
 }
-/** ids > query > everything-in-scope. */
-function selectSessions(metas, selectors) {
+/** ids > query > everything-in-scope. Exported for the id-resolution test. */
+export function selectSessions(metas, selectors) {
     if (selectors.length === 0)
         return metas;
     const byId = [];
@@ -231,9 +231,11 @@ function selectSessions(metas, selectors) {
     for (const sel of selectors) {
         const trimmed = sel.trim();
         // Same reason as resolveSessionQuery: the discovered pool is a minority of
-        // the index, so a complete id absent from it may still be indexed here.
+        // the index, so an id-shaped selector absent from it may still be indexed
+        // here. Gate on looksLikeSessionId, not isCompleteSessionId, so a SHORT id
+        // ("d3470b57") also resolves through the index instead of falling to content.
         const hits = resolveSessionById(metas, trimmed);
-        const resolved = hits.length > 0 || !isCompleteSessionId(trimmed) ? hits : findSessionsById(trimmed);
+        const resolved = hits.length > 0 || !looksLikeSessionId(trimmed) ? hits : findSessionsById(trimmed);
         if (resolved.length > 0)
             byId.push(...resolved);
         else
@@ -243,11 +245,12 @@ function selectSessions(metas, selectors) {
         const seen = new Set();
         return byId.filter(s => (seen.has(s.id) ? false : (seen.add(s.id), true)));
     }
-    // A selector that is a COMPLETE session id and still missed cannot be widened:
-    // the id is unique, so the text query below could only bundle sessions that
-    // merely mention it. Bundling those would ship unrelated transcripts to
-    // whoever receives the export, so select nothing and let the caller report it.
-    const missingIds = unmatched.filter(isCompleteSessionId);
+    // A selector that is an id (complete OR a short hex id/prefix) and still missed
+    // cannot be widened: the id is unique, so the text query below could only bundle
+    // sessions that merely mention it. Bundling those would ship unrelated
+    // transcripts to whoever receives the export, so select nothing and let the
+    // caller report it — a short id like "d3470b57" must never content-search.
+    const missingIds = unmatched.filter(looksLikeSessionId);
     if (missingIds.length > 0) {
         process.stderr.write(chalk.red(`No session with id ${missingIds.join(', ')} on this machine.\n`));
         return [];

package/dist/commands/sessions-inject.d.ts

@@ -4,10 +4,13 @@
  * (`injectIntoTerminal`, src/lib/terminal/inject.ts), so a native watchdog
  * (RUSH-1415) can shell out to nudge a stalled agent with "continue".
  *
- * Resolution: find the active session by id, map its `provenance.reply` rail
- * (provenance.ts:47) to an engine `InjectTarget` and inject. Today only tmux rails
- * are externally addressable; `--pane`/`--pty` target a backend directly when the
- * handle is already known (skipping the session lookup).
+ * Resolution: find the active session by id, then resolve its exact split through
+ * the SAME canonical resolver the watchdog uses — `resolveInjectTargetForSession`
+ * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium > pty. Sharing one
+ * resolver keeps the manual unblock path and the watchdog in agreement on which
+ * sessions are addressable (a prior duplicate resolver read only `provenance.reply`
+ * and could not address a VSCodium/Cursor terminal the watchdog handled fine).
+ * `--pane`/`--pty` target a backend directly when the handle is already known.
  */
 import type { Command } from 'commander';
 /** Attach the `inject` subcommand to an existing `sessions` command. */

package/dist/commands/sessions-inject.js

@@ -4,33 +4,32 @@
  * (`injectIntoTerminal`, src/lib/terminal/inject.ts), so a native watchdog
  * (RUSH-1415) can shell out to nudge a stalled agent with "continue".
  *
- * Resolution: find the active session by id, map its `provenance.reply` rail
- * (provenance.ts:47) to an engine `InjectTarget` and inject. Today only tmux rails
- * are externally addressable; `--pane`/`--pty` target a backend directly when the
- * handle is already known (skipping the session lookup).
+ * Resolution: find the active session by id, then resolve its exact split through
+ * the SAME canonical resolver the watchdog uses — `resolveInjectTargetForSession`
+ * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium > pty. Sharing one
+ * resolver keeps the manual unblock path and the watchdog in agreement on which
+ * sessions are addressable (a prior duplicate resolver read only `provenance.reply`
+ * and could not address a VSCodium/Cursor terminal the watchdog handled fine).
+ * `--pane`/`--pty` target a backend directly when the handle is already known.
  */
 import chalk from 'chalk';
 import { getActiveSessions } from '../lib/session/active.js';
-import { injectTargetFromReplyRail } from '../lib/session/inject.js';
+import { resolveInjectTargetForSession } from '../lib/terminal/resolve.js';
 import { injectIntoTerminal } from '../lib/terminal/index.js';
 import { setHelpSections } from '../lib/help.js';
-/** Resolve a session id (short or full) to an addressable terminal target. */
+/** Resolve a session id (short or full) to an addressable terminal target, via the
+ * same resolver the watchdog uses so both agree on what is reachable. */
 async function resolveTarget(sessionId) {
     const sessions = await getActiveSessions();
     const match = sessions.find((s) => s.sessionId === sessionId || (s.sessionId != null && s.sessionId.startsWith(sessionId)));
     if (!match)
         return { target: null, reason: `No active session matches "${sessionId}".` };
-    const rail = match.provenance?.reply;
-    if (!rail) {
-        return {
-            target: null,
-            reason: `Session "${sessionId}" has no addressable reply rail (not running under tmux). Relaunch it under a tmux/pty rail to inject.`,
-        };
+    const resolution = resolveInjectTargetForSession(match);
+    if (!resolution.addressable) {
+        // Surface the resolver's precise reason (host/rail), not a generic "not tmux".
+        return { target: null, reason: `Session "${sessionId}": ${resolution.reason}` };
     }
-    const target = injectTargetFromReplyRail(rail);
-    if (!target)
-        return { target: null, reason: `Session "${sessionId}" reply rail is not injectable.` };
-    return { target };
+    return { target: resolution.target };
 }
 async function runInject(sessionId, text, options) {
     // Direct-target shortcuts skip the session lookup — the watchdog often already
@@ -97,8 +96,9 @@ export function registerSessionsInjectCommand(sessionsCmd) {
         notes: `
       - Ink-TUI Enter semantics: by default the text and Enter are two separate
         writes, which is what Claude's Ink TUI needs. --combined fuses them.
-      - Only sessions running under a tmux pane are addressable by id today
-        (provenance.ts reply rails). Use --pane/--pty for direct targeting.
+      - A session is addressable by id when it resolves to a precise split —
+        tmux, iTerm, a VSCodium/Cursor/VS Code integrated terminal, or a pty
+        (resolveInjectTargetForSession). Use --pane/--pty for direct targeting.
       - Built on the Terminal Engine (src/lib/terminal): --host runs the tmux /
         AppleScript spec over the same SSH transport the launch engine uses.
     `,

package/dist/commands/sessions-picker.d.ts

@@ -1,4 +1,5 @@
-import type { SessionMeta, TodoProgress } from '../lib/session/types.js';
+import type { SessionEvent, SessionMeta, TodoProgress } from '../lib/session/types.js';
+import { classifyFileChanges } from '../lib/session/digest.js';
 /**
  * Compact checklist tally for list rows and previews (RUSH-2045).
  * Example: `✓6/8 · A5 wiring runner`. Empty string when there is no list.
@@ -30,5 +31,18 @@ export interface SessionPickerConfig {
 }
 /** Build a cached multi-line preview string for display in the session picker. */
 export declare function buildPreview(session: SessionMeta): string;
+/** Optional dirs-touched field the parser teammate may attach; we prefer it. */
+type SessionMetaWithDirs = SessionMeta & {
+    dirsTouched?: string[];
+};
+/**
+ * Unique directories the session touched, compact and human-readable.
+ * Prefer `session.dirsTouched` when the parser teammate has populated it;
+ * otherwise derive from file-change + tool paths already available here.
+ */
+export declare function directoriesTouched(session: SessionMetaWithDirs, events: SessionEvent[], changes: ReturnType<typeof classifyFileChanges>): string[];
+/** Relativize a file path to its parent dir, short enough for one preview line. */
+export declare function relativizeDir(filePath: string, cwd?: string): string | undefined;
 /** Show an interactive session picker and return the selected session with its action (resume or view). */
 export declare function sessionPicker(config: SessionPickerConfig): Promise<PickedSession | null>;
+export {};

package/dist/commands/sessions-picker.js

@@ -11,9 +11,9 @@ import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
 import { parseSession, sanitizeForTerminal } from '../lib/session/parse.js';
 import { cleanSessionPrompt, extractSessionTopic } from '../lib/session/prompt.js';
-import { linkPath, linkUrl, relativeToCwd } from '../lib/session/render.js';
+import { linkPath, linkUrl, relativeToCwd, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
-import { extractTodoProgress } from '../lib/session/state.js';
+import { extractTodoProgress, WORKTREE_RE } from '../lib/session/state.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { itemPicker } from '../lib/picker.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
@@ -137,7 +137,7 @@ function displayAgent(agent) {
 }
 const DOT = chalk.gray(' · ');
 function formatHeader(session, events) {
-    const model = extractModel(events);
+    const model = extractModel(events) || session.model;
     const { startedAgo, duration } = extractTiming(events);
     const totalMessages = session.messageCount ?? countMessages(events);
     const totalTokens = session.tokenCount;
@@ -147,7 +147,7 @@ function formatHeader(session, events) {
     if (session.shortId)
         line1.push(chalk.dim(session.shortId));
     if (model)
-        line1.push(chalk.bold.white(model));
+        line1.push(chalk.bold.white(shortenModel(model)));
     if (session.account)
         line1.push(chalk.gray(session.account));
     // Line 2: cwd · project · branch · started X ago · lasted Y
@@ -285,6 +285,8 @@ function formatCompactPreview(events, session) {
     let planFile = '';
     /** Latest checklist from the transcript (Claude TodoWrite / Codex update_plan). */
     let latestTodos;
+    let subAgentCount = 0;
+    const toolTags = new Set();
     for (const event of events) {
         if (event.type === 'message') {
             if (event.role === 'user' && !firstUser && event.content) {
@@ -298,6 +300,11 @@ function formatCompactPreview(events, session) {
         }
         else if (event.type === 'tool_use' && !event._local) {
             const tool = event.tool || '';
+            const command = event.command || '';
+            for (const tag of classifySessionTool(tool, command))
+                toolTags.add(tag);
+            if (isSubAgentTool(tool, command))
+                subAgentCount++;
             const p = event.path || event.args?.file_path || event.args?.path || '';
             if (['Read', 'read_file', 'view_file', 'cat_file', 'get_file'].includes(tool) && p) {
                 filesRead.add(p);
@@ -369,6 +376,13 @@ function formatCompactPreview(events, session) {
     if (activity.length) {
         lines.push(chalk.cyan('Changes:  ') + activity.join(chalk.gray(' · ')));
     }
+    const metadata = [
+        ...toolTags,
+        subAgentCount ? `${subAgentCount} sub-agent${subAgentCount === 1 ? '' : 's'}` : '',
+    ].filter(Boolean);
+    if (metadata.length) {
+        lines.push(chalk.cyan('Meta:     ') + chalk.gray(metadata.join(' · ')));
+    }
     // Tool mix (top 4) — what kind of work this was.
     const hist = toolHistogram(toolCounts, 4);
     if (hist.length) {
@@ -403,12 +417,27 @@ function formatCompactPreview(events, session) {
     }
     return lines.map(l => '  ' + l).join('\n');
 }
+function classifySessionTool(tool, command) {
+    const toolName = tool.toLowerCase();
+    const commandUses = (surface) => (new RegExp(`\\b(?:agents|ag)\\b[^\\n;&|]*\\b${surface}\\b`).test(command.toLowerCase()));
+    const tags = [];
+    if (/browser|webfetch|websearch/.test(toolName) || commandUses('browser'))
+        tags.push('browser');
+    if (/computer/.test(toolName) || commandUses('computer'))
+        tags.push('computer');
+    return tags;
+}
+function isSubAgentTool(tool, command) {
+    if (/^(Agent|Task)$/i.test(tool))
+        return true;
+    return /\b(?:agents|ag)\b[^\n;&|]*\b(?:run|cloud\s+run|teams\s+(?:add|start))\b/.test(command);
+}
 /**
  * Unique directories the session touched, compact and human-readable.
  * Prefer `session.dirsTouched` when the parser teammate has populated it;
  * otherwise derive from file-change + tool paths already available here.
  */
-function directoriesTouched(session, events, changes) {
+export function directoriesTouched(session, events, changes) {
     const fromMeta = session.dirsTouched;
     if (Array.isArray(fromMeta) && fromMeta.length > 0) {
         return fromMeta
@@ -437,19 +466,73 @@ function directoriesTouched(session, events, changes) {
         .map(([d]) => d)
         .slice(0, DIRS_TOUCHED_MAX);
 }
+/**
+ * Claude names its per-project transcript store `~/.claude/projects/<slug>`, where
+ * `<slug>` is the cwd with every `/` AND `.` replaced by `-` — so `/Users/me/app`
+ * → `-Users-me-app` and `.agents/worktrees/x` → `--agents-worktrees-x`. That slug
+ * leaks into transcript paths as a leading segment (`<slug>/<session-id>/…`).
+ *
+ * The encoding is LOSSY and irreversible (`-`, `/`, and `.` all collapse to `-`),
+ * so we never try to decode it back to a path. Instead we ENCODE the comparison
+ * targets (cwd, the worktree marker) into the same slug space and match there. See
+ * {@link relativizeDir}. `encodeClaudeSlug` mirrors Claude's own transform.
+ */
+function encodeClaudeSlug(absPath) {
+    return absPath.replace(/[/.]/g, '-');
+}
+/** The `.agents/worktrees/<name>` marker, Claude-slug-encoded (`/.` → `--`). */
+const SLUG_WORKTREE_RE = /--agents-worktrees-(.+)$/;
 /** Relativize a file path to its parent dir, short enough for one preview line. */
-function relativizeDir(filePath, cwd) {
+export function relativizeDir(filePath, cwd) {
     const norm = filePath.replace(/\\/g, '/');
     if (!norm || norm.includes('node_modules') || norm.includes('/.git/') || norm.includes('/plans/')) {
         return undefined;
     }
     let dir = path.posix.dirname(norm);
+    // Claude project-slug form: a leading `-`-segment (`-home-me-…`) that carries
+    // the cwd, lossily encoded. Handle it in SLUG SPACE — never lossy-decode to a
+    // fake path. The slug is the first path segment; any real `/`-subdirs after it
+    // are Claude's internal storage (`<session-id>/scratchpad|tasks`), not code.
+    if (dir.startsWith('-')) {
+        const slash = dir.indexOf('/');
+        const slug = slash === -1 ? dir : dir.slice(0, slash);
+        // CWD FIRST: if the slug is (or is under) this session's own cwd, the leaked
+        // path is Claude's internal projects-storage scratch (`<id>/scratchpad`) —
+        // not a meaningful code dir — so drop it like node_modules. Precedence over
+        // the worktree collapse so a session editing its OWN worktree isn't relabeled.
+        if (cwd) {
+            const cwdSlug = encodeClaudeSlug(cwd.replace(/\\/g, '/').replace(/\/$/, ''));
+            if (slug === cwdSlug || slug.startsWith(cwdSlug + '-'))
+                return undefined;
+        }
+        // Only a DIFFERENT worktree than cwd reaches here: a worktree encodes its
+        // `/.agents/worktrees/<name>` marker as `--agents-worktrees-<name>`, so
+        // collapse to the worktree name to disambiguate. (The name may contain `-`;
+        // we can't losslessly re-split it, so show the whole encoded remainder.)
+        const wtSlug = slug.match(SLUG_WORKTREE_RE);
+        if (wtSlug)
+            return `⧉ ${wtSlug[1]}`;
+        // An unattributable slug: don't invent a `/`-joined fake path. Show only the
+        // trailing `-`-group as a minimal, honest token.
+        const segs = slug.split('-').filter(Boolean);
+        return segs.length ? segs[segs.length - 1] : undefined;
+    }
+    // CWD FIRST for real paths too: strip the session-cwd prefix so a session
+    // editing its OWN worktree renders the concise relative remainder (`src/lib`),
+    // not the longer `⧉ <slug>/…` collapse.
     if (cwd) {
         const base = cwd.replace(/\\/g, '/').replace(/\/$/, '');
         if (dir === base)
             return '.';
         if (dir.startsWith(base + '/'))
-            dir = dir.slice(base.length + 1);
+            return dir.slice(base.length + 1);
+    }
+    // No cwd match. If the dir is in a (different) git worktree, collapse to the
+    // worktree NAME + in-worktree remainder to disambiguate; else home→`~` + trim.
+    const wt = dir.match(WORKTREE_RE);
+    if (wt) {
+        const after = dir.slice(dir.indexOf(wt[0]) + wt[0].length).replace(/^\//, '');
+        return after ? `⧉ ${wt[1]}/${after}` : `⧉ ${wt[1]}`;
     }
     // Collapse home prefix.
     const home = (process.env.HOME || '').replace(/\\/g, '/');

package/dist/commands/sessions-resume.d.ts

@@ -1,2 +1,18 @@
 import type { Command } from 'commander';
+import { type Packing } from '../lib/terminal/index.js';
+interface ResumeOptions {
+    agent?: string;
+    all?: boolean;
+    teams?: boolean;
+    since?: string;
+    limit?: string;
+    host?: string;
+    iterm?: boolean;
+    ghostty?: boolean;
+    tmux?: boolean;
+    vscodium?: boolean;
+    splits?: boolean;
+}
 export declare function registerSessionsResumeCommand(sessionsCmd: Command): void;
+export declare function resolveResumePacking(options: Pick<ResumeOptions, 'splits'>): Packing;
+export {};

package/dist/commands/sessions-resume.js

@@ -4,9 +4,9 @@
  *
  * Unlike the single-select picker behind bare `agents sessions` (which resumes
  * one session in place), this opens a checkbox picker, then asks where the
- * chosen sessions should resume. By default they pack two-per-tab (session 1 in
- * a new tab, session 2 split beside it, session 3 a new tab, …) in the terminal
- * you're in — iTerm / Ghostty / tmux, locally or on a remote host via --host.
+ * chosen sessions should resume. By default each session opens in its own tab in
+ * the terminal you're in — iTerm / Ghostty / tmux, locally or on a remote host
+ * via --host. `--splits` opts into packing two sessions side by side per tab.
  */
 import * as fs from 'fs';
 import chalk from 'chalk';
@@ -36,25 +36,24 @@ export function registerSessionsResumeCommand(sessionsCmd) {
         .option('--ghostty', 'Force the Ghostty backend')
         .option('--tmux', 'Force the tmux backend')
         .option('--vscodium', 'Force the VSCodium agent-terminal backend (swarm-ext)')
-        .option('--tabs', 'One tab per session (default: pack two panes per tab)');
+        .option('--splits', 'Pack two sessions side by side per tab (default: one tab per session)');
     setHelpSections(cmd, {
         examples: `
-      # Pick several sessions; they pack two-per-tab in your current terminal
+      # Pick several sessions; each opens in its own tab
       agents sessions resume
 
       # Pre-filter the pool before selecting (space in the filter → use [query])
       agents sessions resume "auth middleware"
 
-      # Force a backend / one tab each / a remote host
+      # Force a backend / side-by-side splits / a remote host
       agents sessions resume --ghostty
       agents sessions resume --vscodium
-      agents sessions resume --tabs
+      agents sessions resume --splits
       agents sessions resume --host zion --tmux
     `,
         notes: `
       - space toggles a session, enter confirms; tab toggles the preview pane.
-      - Layout: two-per-tab by default (session 1 → new tab, session 2 → split beside it, …). --tabs disables splitting.
-      - VSCodium defaults to one editor tab per session (matches swarm-ext's native agent-terminal UX); the others default to two-per-tab.
+      - Layout: one tab per session by default. --splits packs session pairs side by side in each tab.
       - Backend: auto-detected from the terminal you're in (iTerm / Ghostty / tmux); override with --iterm/--ghostty/--tmux/--vscodium.
       - --vscodium opens each session as an agent terminal tab in VSCodium via the swarm-ext extension (works with --host too).
       - --host <alias> resumes on a remote machine over the same SSH transport as 'sessions --host' (defaults to tmux).
@@ -153,10 +152,9 @@ async function sessionsResumeAction(query, options) {
             await resumeSessionInPlace(it.session);
         return;
     }
-    // 5b. Fan out through the engine. Split-packing (two-per-tab) suits the
-    // terminal apps; the VSCodium backend defaults to one editor tab per session,
-    // matching swarm-ext's native agent-terminal UX. --tabs forces tabs anywhere.
-    const packing = options.tabs || backend === 'vscodium-agent' ? 'tabs' : 'two-per-tab';
+    // 5b. Fan out through the engine. Full-width tabs are the default for batch
+    // recovery; callers can explicitly opt into pairs of side-by-side panes.
+    const packing = resolveResumePacking(options);
     const where = options.host ? `${backend} on ${options.host}` : backend;
     console.log(chalk.gray(`Opening ${items.length} session${items.length === 1 ? '' : 's'} in ${where} (${packing})…`));
     const results = await openSurfaces(items.map((it) => ({ cwd: it.cwd, command: it.command })), { backend, host: options.host, packing });
@@ -174,6 +172,9 @@ async function sessionsResumeAction(query, options) {
     });
     console.log(chalk.gray(`\nOpened ${opened}/${items.length} in ${where}.`));
 }
+export function resolveResumePacking(options) {
+    return options.splits ? 'two-per-tab' : 'tabs';
+}
 /**
  * Decide which backend to launch into. Returns a concrete backend, `'inplace'`
  * (resume in the current process — no GUI/tmux available), or `'cancel'` (the

package/dist/commands/sessions.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from 'commander';
 import type { SessionAgentId, SessionMeta, ViewMode } from '../lib/session/types.js';
 import { type ActiveSession } from '../lib/session/active.js';
+import { gatherRemoteList, runOnPeer } from '../lib/session/remote-list.js';
 import { type PickedSession } from './sessions-picker.js';
 /**
  * Strip terminal/harness noise from a preview so the column stays a single line
@@ -39,12 +40,23 @@ export declare function liveGlyphAndPreview(a: ActiveSession | undefined): {
     glyph: string;
     preview: string;
 };
+/**
+ * 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 declare function liveStatusWord(a: ActiveSession | undefined): string;
 /**
  * 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 declare function ticketLabel(s: Pick<SessionMeta, 'ticketId' | 'prNumber'>): string;
+export declare function linkTicketCell(s: Pick<SessionMeta, 'ticketId' | 'prNumber' | 'prUrl'>, label: string): string;
+export declare function linkCwdCell(s: Pick<SessionMeta, 'cwd' | '_remote'>, label: string): string;
 /**
  * The row shape `agents sessions --active --json` emits. RUSH-1981: a watcher
  * joins active sessions on ticketId + project, but the raw ActiveSession nests
@@ -57,7 +69,16 @@ export declare function ticketLabel(s: Pick<SessionMeta, 'ticketId' | 'prNumber'
 export declare function serializeActiveSessionsForJson(sessions: ActiveSession[]): Array<ActiveSession & {
     ticketId: string | null;
     project: string | null;
+    prLink: string | null;
 }>;
+/**
+ * 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 declare function ownerLabel(s: ActiveSession): string;
 /** Grouped + sorted view of active sessions for the --active renderer. */
 export interface ActiveSessionsLayout {
     workspaces: Array<{
@@ -150,6 +171,32 @@ export declare function shouldIncludeLocal(hosts: string[] | undefined, self: st
  * Exported for unit testing.
  */
 export declare function remoteHostsToDial(hosts: string[] | undefined, self: string): string[] | undefined;
+/**
+ * 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).
+ */
+export declare function gatherActiveSessions(opts?: {
+    local?: boolean;
+    hosts?: string[];
+}): Promise<{
+    sessions: ActiveSession[];
+    remoteDeviceCount: number;
+}>;
+/** 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 declare function flatSessionRow(session: SessionMeta, live?: ActiveSession, showTicket?: boolean, cols?: PickerColumns): string;
 /**
  * Group key for the overview: prefer the indexed project name; else fold the cwd
  * to its repo — a worktree (`.../<repo>/.agents/worktrees/<slug>`) folds to the
@@ -201,8 +248,19 @@ export interface PickerColumns {
     /** Total width of the machine column, sized to the widest compacted hostname
      * in the pool (capped). Falls back to PICKER_MACHINE_W when absent. */
     machineWidth?: number;
+    /** Render the model column only when at least one row carries a model. */
+    showModel?: boolean;
+    /** Pool-sized model column width, including one trailing separator cell. */
+    modelWidth?: number;
     /** Render the ticket/PR column (only when at least one row carries a ref). */
     showTicket?: boolean;
+    /**
+     * Render the host-program column — which terminal/editor the session is running
+     * in (`ghostty`, `codium`, `tmux→ghostty`, …). Live-only: it comes from the
+     * active-session scan, so it is set by the running-filtered browser and stays
+     * off for a plain transcript listing, where no row has a host.
+     */
+    showHost?: boolean;
     /**
      * Cells the picker prepends before each row: 2 for the single-select cursor
      * ('> '), 6 for the multi-select cursor + checkbox ('> [x] '). Reserved from
@@ -223,13 +281,30 @@ export declare function machineLabeler(machines: string[]): (m: string) => strin
  * than one box, the ticket column only when some row carries a PR/ticket ref.
  */
 export declare function pickerColumnsFor(sessions: SessionMeta[]): PickerColumns;
-export declare function formatPickerLabel(s: SessionMeta, query: string, cols?: PickerColumns, ssh?: SshOriginTag): string;
+/**
+ * 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 declare function liveHostLabel(a: ActiveSession | undefined): string;
+export declare function formatPickerLabel(s: SessionMeta, query: string, cols?: PickerColumns, ssh?: SshOriginTag, host?: string): string;
 /**
  * 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 declare function formatPickerTip(sessions: SessionMeta[]): string;
 export declare function pickSessionInteractive(sessions: SessionMeta[], message?: string, initialSearch?: string, hiddenCount?: number, enterHint?: string): Promise<PickedSession | null>;
+/**
+ * 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 declare const LIVE_ROW_PREFIX = "live:";
+export declare function isIdlessLiveRow(s: SessionMeta): boolean;
 export declare function handlePickedSession(picked: PickedSession): Promise<void>;
 /**
  * Resume a session in the current terminal — a foreground takeover of this
@@ -285,6 +360,56 @@ export interface SessionQueryResolution {
 export declare function resolveSessionQuery(pool: SessionMeta[], query: string): SessionQueryResolution;
 /** Filter and rank sessions by a multi-term search query across metadata and content. */
 export declare function filterSessionsByQuery(sessions: SessionMeta[], query: string | undefined): SessionMeta[];
+/**
+ * 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 declare function shouldFanOutForId(query: string, local: boolean | undefined): boolean;
+/** Injectable SSH/peer boundary so the fleet-resolve logic is unit-testable
+ * without a live tailnet. Production wires these to the real remote-list infra. */
+export interface FleetResolveDeps {
+    gatherRemoteList: typeof gatherRemoteList;
+    runOnPeer: typeof runOnPeer;
+}
+/** One distinct machine that reported the id, plus its winning row. */
+interface FleetHit {
+    machine: string;
+    session: SessionMeta;
+}
+/** 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 declare function fleetHitsById(rows: SessionMeta[], id: string): FleetHit[];
+/**
+ * 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 declare function resolveSessionAcrossFleet(id: string, mode: ViewMode, hosts?: string[], deps?: FleetResolveDeps): Promise<'rendered' | 'conflict' | 'not-found'>;
 /** Register the `agents sessions` command with all its options and help text. */
 export declare function registerSessionsCommands(program: Command): void;
 export {};