@phnx-labs/agents-cli 1.20.78 → 1.20.83

package/dist/commands/sessions.d.ts

@@ -3,6 +3,66 @@ import type { SessionAgentId, SessionMeta, ViewMode } from '../lib/session/types
 import { type ActiveSession } from '../lib/session/active.js';
 import { gatherRemoteList, runOnPeer } from '../lib/session/remote-list.js';
 import { type PickedSession } from './sessions-picker.js';
+interface SessionFilterOptions {
+    agent?: string;
+    project?: string;
+    all?: boolean;
+    teams?: boolean;
+    routine?: boolean;
+    since?: string;
+    until?: string;
+}
+interface SessionsOptions extends SessionFilterOptions {
+    /** Also list sessions from the user's own unmanaged ~/.<agent> installs. */
+    unmanaged?: boolean;
+    query?: string;
+    limit?: string;
+    sort?: string;
+    json?: boolean;
+    markdown?: boolean;
+    /** Commander populates this from `--no-redact`: true by default, false when the flag is passed. */
+    redact?: boolean;
+    include?: string;
+    exclude?: string;
+    first?: string;
+    last?: string;
+    artifacts?: boolean;
+    artifact?: string;
+    active?: boolean;
+    /** Emit the on-disk session-scan directories (requires --json); for watchers. */
+    roots?: boolean;
+    cloud?: boolean;
+    host?: string[];
+    /** Group the listing by directory and drop the id/version columns. */
+    tree?: boolean;
+    /** Force the plain flat table instead of the grouped default overview. */
+    flat?: boolean;
+    /** With --active: show only sessions waiting on user input; exit 1 if any. */
+    waiting?: boolean;
+    /** Enrich the listing with live glyphs/preview for running rows. Default on;
+     * `--no-live` sets this false. Commander's `--no-` convention. */
+    live?: boolean;
+    /** Force local-only: skip the cross-machine SSH fan-out (both the default
+     * listing and --active). */
+    local?: boolean;
+    /** --device <target...> — alias for --host; resolves against the device registry. */
+    device?: string[];
+    /** Per-agent shorthands: aliases for `--agent <name>` (prioritized harnesses). */
+    claude?: boolean;
+    codex?: boolean;
+    kimi?: boolean;
+    antigravity?: boolean;
+    grok?: boolean;
+    opencode?: boolean;
+    /** Force the printed listing even on a TTY. Commander's `--no-` convention:
+     * `--no-interactive` sets this false, opting out of the interactive browser. */
+    interactive?: boolean;
+    /** Print the canonical `ag sessions …` command for the given flags and exit —
+     * the non-interactive twin of the browser's `y` hotkey. */
+    printCmd?: boolean;
+    /** Print a compact preview of the matched session and exit (no pager). */
+    preview?: boolean;
+}
 /**
  * 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
@@ -10,6 +70,16 @@ import { type PickedSession } from './sessions-picker.js';
  * a captured transcript tail. Collapses runs of whitespace.
  */
 export declare function cleanPreview(text: string): string;
+/**
+ * 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 declare function buildSessionDescription(s: ActiveSession): string;
 /**
  * Identity + checklist + live snippet for an --active / cross-machine row.
  * Surfaces agent-adjacent identity the flat table already has (label, project)
@@ -40,12 +110,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
@@ -58,7 +139,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<{
@@ -170,6 +260,27 @@ export declare function gatherActiveSessions(opts?: {
     sessions: ActiveSession[];
     remoteDeviceCount: number;
 }>;
+/**
+ * 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 `--host` early-return guard so they can't drift:
+ * when this holds, an explicit `--host`/`--device` scope is folded into the
+ * browser (preview-rich, selectable) instead of the legacy per-host raw stream.
+ */
+export declare function isBareBrowserListing(options: SessionsOptions, query: string | undefined): boolean;
+/**
+ * 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 declare function hasNoBrowserDisqualifyingFlags(options: SessionsOptions, query: string | undefined): boolean;
+/** 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
@@ -221,6 +332,10 @@ 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;
     /**

package/dist/commands/sessions.js

@@ -32,7 +32,7 @@ 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;
@@ -235,7 +240,7 @@ export function cleanPreview(text) {
  * Covers every ActiveSession context: terminal (interactive), headless, teams,
  * cloud, and sub-agent rows that share the same ActiveSession.todos field.
  */
-function buildSessionDescription(s) {
+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)}` : ''}`;
@@ -243,6 +248,11 @@ function buildSessionDescription(s) {
     }
     if (s.context === 'teams') {
         const parts = [s.teamName];
+        // 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);
         if (s.preview)
@@ -303,6 +313,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 +349,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 +405,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 +434,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 +505,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 +518,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 +751,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 +762,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 +774,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(' · ');
@@ -911,6 +1002,33 @@ function printCrossMachineTip() {
 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 `--host` early-return guard so they can't drift:
+ * when this holds, an explicit `--host`/`--device` scope is folded into the
+ * browser (preview-rich, selectable) instead of the legacy per-host raw stream.
+ */
+export function isBareBrowserListing(options, query) {
+    return useInteractiveBrowser(options) && 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 &&
+        !options.routine &&
+        !options.flat &&
+        !options.tree &&
+        !options.markdown &&
+        !options.until &&
+        !options.project &&
+        !options.sort &&
+        !options.artifacts &&
+        options.artifact === undefined);
+}
 /** 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) {
@@ -958,6 +1076,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. */
@@ -998,14 +1131,21 @@ async function sessionsAction(query, options) {
             await runRemoteSessionsJson(options.host);
             return;
         }
-        try {
-            runRemoteSessions(options.host);
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
+        // A bare interactive `--host`/`--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);
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            return;
         }
-        return;
     }
     // --preview <id/query>: resolve one session and print its compact preview, then
     // exit — checked before --active so `--active --preview <id>` peeks the id
@@ -1059,17 +1199,7 @@ async function sessionsAction(query, options) {
     // 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.
-    if (useInteractiveBrowser(options) &&
-        !query &&
-        !options.routine &&
-        !options.flat &&
-        !options.tree &&
-        !options.markdown &&
-        !options.until &&
-        !options.project &&
-        !options.sort &&
-        !options.artifacts &&
-        options.artifact === undefined) {
+    if (isBareBrowserListing(options, query)) {
         const { runSessionBrowser, bareBrowserSeed } = await import('./sessions-browser.js');
         await runSessionBrowser(bareBrowserSeed({
             teams: options.teams,
@@ -1322,12 +1452,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 || '-';
@@ -1350,19 +1480,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 + ' ' : '') +
@@ -1383,13 +1525,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));
 }
@@ -1506,7 +1650,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)));
         }
@@ -1702,12 +1848,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
@@ -1743,6 +1895,8 @@ 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) !== ''),
     };
 }

package/dist/commands/set.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `agents set` — ergonomic top-level setter for per-agent/version run defaults.
+ *
+ * `agents set claude@2.1.220 --model opus-5` pins the default model (and/or
+ * mode) that `agents run` uses for that agent version. It reads and writes the
+ * same store as `agents defaults run set` (agents.yaml -> run.defaults), so the
+ * two stay consistent — `set` is just the short front door.
+ *
+ *   agents set                          # list every configured default
+ *   agents set claude@2.1.220           # show the default for one version
+ *   agents set claude@2.1.220 --model opus-5
+ *   agents set 'claude:*' --mode auto --model opus
+ */
+import type { Command } from 'commander';
+export declare function registerSetCommand(program: Command): void;