@phnx-labs/agents-cli 1.20.86 → 1.20.87

package/dist/commands/sessions.js

@@ -28,7 +28,7 @@ import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/
 import { inferSessionState } from '../lib/session/state.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 { filterTeamSessions, safeTeamText } 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';
@@ -113,7 +113,15 @@ function createScanProgressTracker(verbs, suffix, spinner) {
     };
 }
 const PICKER_RECENT_COUNT = 15;
-const PICKER_POOL_LIMIT = 200;
+/**
+ * The `--limit` default, shared with its `.option()` registration. Commander fills
+ * the default in, so `options.limit` is never falsy — code that wants to know
+ * whether the USER set a limit has to compare against this rather than test
+ * truthiness.
+ */
+const DEFAULT_LIMIT = '50';
+/** Pool size for `--in-team`: one team's rows can sit anywhere in the history. */
+const WHOLE_TEAM_POOL_LIMIT = 5000;
 // The grouped default view ("overview"): fetch a generous recency-ordered pool
 // for accurate per-project totals, show each project's most-recent rows grouped
 // by project, newest-active project first.
@@ -1016,7 +1024,12 @@ function useInteractiveBrowser(options) {
  * browser (preview-rich, selectable) instead of the legacy per-host raw stream.
  */
 export function isBareBrowserListing(options, query) {
-    return useInteractiveBrowser(options) && hasNoBrowserDisqualifyingFlags(options, query);
+    return (useInteractiveBrowser(options) &&
+        // A peer answering a fan-out must never open a TUI. It has no TTY either, so
+        // this is the explicit half of a guard that otherwise rests on the implicit
+        // invariant that peers are always dialed with --json (see remote-list.ts).
+        process.env.AGENTS_SESSIONS_LOCAL !== '1' &&
+        hasNoBrowserDisqualifyingFlags(options, query));
 }
 /**
  * Pure flag-gate half of {@link isBareBrowserListing} (TTY-independent, so it is
@@ -1033,7 +1046,15 @@ export function hasNoBrowserDisqualifyingFlags(options, query) {
         !options.project &&
         !options.sort &&
         !options.artifacts &&
-        options.artifact === undefined);
+        options.artifact === undefined &&
+        // --cloud lists a provider's tasks, not the transcript index, and
+        // runCloudSessions has no host scope — letting a `--device X --cloud` fall
+        // through to the browser gate would silently drop the X the user asked for.
+        !options.cloud &&
+        // The browser carries ONE device in its filter and `y` copies back exactly
+        // one --device, so a multi-host scope can't round-trip. Those stay on the
+        // legacy per-host stream, which prints each peer under its own banner.
+        (options.host?.length ?? 0) <= 1);
 }
 /** 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. */
@@ -1043,6 +1064,8 @@ function canonicalSessionsCommand(query, options) {
         a.push('--active');
     if (options.teams)
         a.push('--teams');
+    if (options.inTeam)
+        a.push('--in-team', options.inTeam);
     if (options.routine)
         a.push('--routine');
     if (options.agent)
@@ -1100,7 +1123,13 @@ async function renderSessionPreview(query, scope) {
     console.log(buildPreview(session));
 }
 /** Main action handler for `agents sessions`. Routes to picker, table, or single-session render. */
-async function sessionsAction(query, options) {
+async function sessionsAction(query, options, 
+/**
+ * Where commander got `--limit` from: 'cli'/'env' when the user supplied it,
+ * 'default' when it filled in its own. Truthiness can't tell those apart,
+ * because the default arrives as a string like any typed value.
+ */
+limitSource) {
     // Explicit --query is interchangeable with the positional; it's how you search
     // for text that collides with a subcommand name (e.g. `sessions --query go`).
     query = query ?? options.query;
@@ -1133,6 +1162,14 @@ async function sessionsAction(query, options) {
     // `── host ──` banner). With --active, the hosts are folded into the merged
     // machine-grouped view instead (handled below).
     if (options.host && options.host.length > 0 && !options.active) {
+        // --local means "skip the SSH fan-out"; --host means "look only over there".
+        // Together they ask for a peer's sessions without dialing the peer, which can
+        // only ever be empty — so say that instead of rendering a blank list.
+        if (options.local === true && !shouldIncludeLocal(options.host, machineId())) {
+            console.error(chalk.red('--local and --device name opposite scopes: --local skips the SSH fan-out that --device needs.'));
+            console.error(chalk.gray('Drop one — `--device <box>` to read that machine, `--local` to stay on this one.'));
+            process.exit(1);
+        }
         if (options.json) {
             await runRemoteSessionsJson(options.host);
             return;
@@ -1165,6 +1202,14 @@ async function sessionsAction(query, options) {
         return;
     }
     if (options.active) {
+        // The running view is built from the live scan, which carries no team lineage
+        // (that comes off the transcript index and the teams meta dir), so --in-team
+        // has nothing to match on here. Say so rather than ignoring the flag.
+        if (options.inTeam) {
+            console.error(chalk.red('--in-team does not apply to --active: the running view carries no team lineage.'));
+            console.error(chalk.gray('Drop --active to filter by team, or use `agents teams status <name>` for a live team.'));
+            process.exit(1);
+        }
         // On a TTY (and not a scripting path), open the interactive browser seeded to
         // running-only. --json / --waiting / --no-interactive / a peer fan-out keep the
         // static dump untouched, so scripts and agents are unaffected. An explicit
@@ -1212,6 +1257,8 @@ async function sessionsAction(query, options) {
             agent: options.agent,
             all: options.all,
             since: options.since,
+            host: options.host,
+            inTeam: options.inTeam,
         }), { local: options.local === true, hosts: options.host });
         return;
     }
@@ -1265,14 +1312,25 @@ async function sessionsAction(query, options) {
     // no query, no path drill-in, not explicitly --flat/--tree. It drops the silent
     // cwd-scope + 50-cap + 30-day window that hide most of a large index.
     const wantsOverview = isInteractive && !searchQuery && !pathFilter && !options.flat && !options.tree;
+    // --in-team asks for ONE team's whole lineage, which is a handful of rows that
+    // can sit anywhere in history. Bounding it by the default top-50 / 30-day window
+    // silently returns nothing for any team older than that — so the flag widens its
+    // own scope, the way --all does, unless the caller set an explicit --limit.
+    const wantsWholeTeam = !!options.inTeam;
+    // `--limit` has a commander default, so an untouched flag still arrives as a
+    // string and truthiness can't tell it from a typed one. Commander records where
+    // each value came from, which is the only signal that distinguishes an explicit
+    // `--limit 50` from no flag at all — a script asking for 50 must get 50, not the
+    // whole-team pool.
+    const userSetLimit = limitSource === 'cli' || limitSource === 'env';
     const limit = wantsOverview
         ? OVERVIEW_POOL_LIMIT
-        : parseInt(options.limit || (isInteractive ? String(PICKER_POOL_LIMIT) : '50'), 10);
+        : parseInt(userSetLimit ? options.limit : wantsWholeTeam ? String(WHOLE_TEAM_POOL_LIMIT) : DEFAULT_LIMIT, 10);
     // Overview: recency order across the whole index, no default window; an explicit
     // --since still narrows. Non-overview keeps the prior interactive-30d default.
     const since = wantsOverview
         ? options.since
-        : (options.since ?? (isInteractive && !options.all ? '30d' : undefined));
+        : (options.since ?? (isInteractive && !options.all && !wantsWholeTeam ? '30d' : undefined));
     const spinner = options.json ? null : ora().start();
     const tracker = createScanProgressTracker(LOAD_VERBS, 'sessions', spinner);
     try {
@@ -1285,12 +1343,15 @@ async function sessionsAction(query, options) {
         const scope = {
             agent,
             version,
-            all: pathFilter ? undefined : options.all,
+            // --in-team spans directories by construction: a team's teammates run in
+            // their own worktrees, so scoping to the current cwd hides most of the
+            // lineage the flag exists to show.
+            all: pathFilter ? undefined : options.all || wantsWholeTeam,
             cwd: process.cwd(),
             // Default overview scopes to the current repo SUBTREE (prefix match), so a
             // monorepo shows its sub-projects grouped instead of collapsing to the one
             // exact-cwd project. `--all` clears the prefix and spans the whole index.
-            cwdPrefix: pathFilter ?? (wantsOverview && !options.all ? process.cwd() : undefined),
+            cwdPrefix: pathFilter ?? (wantsOverview && !options.all && !wantsWholeTeam ? process.cwd() : undefined),
             project: options.project,
             since,
             until: options.until,
@@ -1316,7 +1377,15 @@ async function sessionsAction(query, options) {
         // enriched/hidden.
         const { visible: visibleSessions } = filterTeamSessions(sessions, !!options.teams);
         sessions = visibleSessions;
-        const hiddenCount = options.teams
+        // --in-team spans both ends of the lineage, so it can't be one SQL predicate:
+        // the orchestrator matches on the scan-derived `spawnedTeam` column, while a
+        // teammate only knows its team from the meta.json filterTeamSessions just
+        // read. Match either, after that pass has populated `teamOrigin`.
+        if (options.inTeam)
+            sessions = sessions.filter((s) => matchesTeam(s, options.inTeam));
+        // Under --in-team the visible list is one team, so the whole-index team-origin
+        // count would be a non-sequitur next to it.
+        const hiddenCount = options.teams || options.inTeam
             ? 0
             : countSessionsInScope({ ...scope, onlyTeamOrigin: true });
         // Smart ID routing: a bare query that resolves to one session renders
@@ -1437,12 +1506,55 @@ async function sessionsAction(query, options) {
         process.exit(1);
     }
 }
+/**
+ * Prefix marking a row as somebody's teammate: `[<team>/<handle>] `, falling back
+ * to the handle alone when the record predates team-name capture. The mode is
+ * deliberately dropped here (it survives in the preview pane) — this tag is
+ * folded into the topic cell, whose floor is 16 columns, so every character it
+ * takes is one the actual prompt loses.
+ */
 function teamTag(session) {
     const origin = session.teamOrigin;
     if (!origin)
         return '';
-    const parts = [origin.handle, origin.mode].filter(Boolean).join(' · ');
-    return parts ? `[${parts}] ` : '[team] ';
+    const handle = safeTeamText(origin.handle);
+    const team = safeTeamText(origin.team);
+    if (team)
+        return `[${team}${handle ? `/${handle}` : ''}] `;
+    return handle ? `[${handle}] ` : '[team] ';
+}
+/**
+ * Whether a session belongs to `team`, from either end: it spawned the team, or
+ * it is one of the team's teammates. Case-insensitive, matching the SQL
+ * predicate behind `querySessions({ spawnedTeam })`.
+ */
+export function matchesTeam(session, team) {
+    // The needle is peer-derived in the browser: `f.team` comes off the team cycle,
+    // which is built from rows another machine sent. Guard it the same way as the
+    // fields it is compared against, so a non-string can't throw out of a filter
+    // that runs over every row.
+    const want = safeTeamText(team)?.trim().toLowerCase();
+    if (!want)
+        return true;
+    return (safeTeamText(session.spawnedTeam)?.toLowerCase() === want ||
+        safeTeamText(session.teamOrigin?.team)?.toLowerCase() === want);
+}
+/** Longest team name rendered in the `team:` row badge before truncation. */
+const TEAM_BADGE_MAX = 10;
+/**
+ * The `team:<name>` badge for a session that SPAWNED a team — the orchestrator
+ * end of the lineage, from the scan-derived `spawnedTeam`. Returned as a plain
+ * (uncolored) string plus its display width so callers can reserve the width
+ * from the topic budget and color it as their own segment: folding it into the
+ * topic string would lose the color, since renderTopicCell strips ANSI and
+ * re-whitens every slice.
+ */
+export function teamBadge(session) {
+    const team = safeTeamText(session.spawnedTeam);
+    if (!team)
+        return { plain: '', width: 0 };
+    const plain = `team:${truncate(team, TEAM_BADGE_MAX)} `;
+    return { plain, width: stringWidth(plain) };
 }
 function originTag(session) {
     if (session.origin !== 'routine')
@@ -1477,6 +1589,8 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}) {
     const topicBase = tag ? `${tag}${session.topic ?? ''}` : session.topic;
     const doing = [restingTodo, preview || topicBase].filter(Boolean).join(' · ') || undefined;
     const wt = session.worktreeSlug ? chalk.magenta(`wt:${session.worktreeSlug}`) : '';
+    const team = teamBadge(session);
+    const teamSeg = team.plain ? chalk.green(team.plain) : '';
     // The machine column only earns its width when the listing spans more than one
     // box (i.e. the cross-machine fan-out folded remotes in) — same rule and
     // pool-derived width as the picker.
@@ -1497,7 +1611,7 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}) {
     const wtW = wt ? stringWidth(wt) + 1 : 0;
     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 fixedW = (10 + 9 + 8 + 16) + glyphW + statusW + machineW + ticketW + wtW + team.width + stringWidth(when) + 1;
     const modelSlack = width - fixedW - 16;
     const modelW = requestedModelW <= modelSlack
         ? requestedModelW
@@ -1511,6 +1625,7 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}) {
         chalk.cyan(linkCwdCell(session, padToWidth(truncateToWidth(project, 14), 16))) +
         (glyph ? glyph + ' ' : '') +
         statusCell +
+        teamSeg +
         renderTopicCell(label, doing, '', topicW, topicW) +
         ticketCell +
         (wt ? wt + ' ' : '') +
@@ -1530,16 +1645,19 @@ function treeSessionRow(session, live) {
     const topic = [restingTodo, topicBase].filter(Boolean).join(' · ') || '-';
     const badges = signalBadges(metaSignals(session));
     const badgeW = badges ? stringWidth(badges) + 1 : 0;
+    const team = teamBadge(session);
+    const teamSeg = team.plain ? chalk.green(team.plain) : '';
     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 - statusW - badgeW - stringWidth(when) - 1);
+    const topicW = Math.max(12, terminalWidth() - (2 + 9 + 8) - glyphW - statusW - badgeW - team.width - stringWidth(when) - 1);
     return ('  ' +
         chalk.dim(padToWidth(session.shortId, 9)) +
         agentColor(padToWidth(truncateToWidth(session.agent, 7), 8)) +
         (badges ? badges + ' ' : '') +
         (glyph ? glyph + ' ' : '') +
         statusCell +
+        teamSeg +
         padToWidth(chalk.white(truncateToWidth(head, topicW)), topicW) +
         ' ' + chalk.gray(when));
 }
@@ -1934,6 +2052,10 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '') {
     const sshPlain = ssh ? (ssh.device ? `ssh←${ssh.device} ` : 'ssh ') : '';
     const sshSeg = sshPlain ? chalk.red(sshPlain) : '';
     const sshW = sshPlain ? stringWidth(sshPlain) : 0;
+    // Orchestrator badge — same own-segment treatment as `ssh` above, for the same
+    // reason: renderTopicCell would strip its colour if it rode inside the topic.
+    const team = teamBadge(s);
+    const teamSeg = team.plain ? chalk.green(team.plain) : '';
     const tag = originTag(s) || teamTag(s);
     const label = s.label;
     const topic = tag ? `${tag}${s.topic ?? ''}` : s.topic;
@@ -1960,7 +2082,7 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '') {
     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 - hostW - ticketW - wtW - sshW - stringWidth(when) - 1);
+    const topicW = Math.max(16, terminalWidth() - gutter - (10 + 9 + 8 + 16) - machineColW - hostW - ticketW - wtW - sshW - team.width - 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
@@ -1972,6 +2094,7 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '') {
         hostCell +
         chalk.cyan(padRight(truncate(project, 14), 16)) +
         sshSeg +
+        teamSeg +
         renderTopicCell(label, topic, query, topicW, topicW) +
         ticketCell +
         (wt ? wt + ' ' : '') +
@@ -2816,11 +2939,12 @@ export function registerSessionsCommands(program) {
         .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('--in-team <name>', "Only this team: the session that spawned it plus (with --teams) its teammates. Spans every directory and all time, since a team's worktrees and history sit outside the default window.")
         .option('--routine', 'Show only sessions archived from routine runs')
         .option('-p, --project <name>', 'Filter by project name (searches across all directories)')
         .option('--since <time>', 'Only sessions newer than this (e.g., 2h, 7d, 4w, or ISO date)')
         .option('--until <time>', 'Only sessions older than this (ISO timestamp)')
-        .option('-n, --limit <n>', 'Maximum number of sessions to return', '50')
+        .option('-n, --limit <n>', 'Maximum number of sessions to return', DEFAULT_LIMIT)
         .option('--sort <field>', 'Sort the list by: recent (default), cost, or duration')
         .option('--markdown', 'Render the session as markdown (user, assistant, thinking, tool calls)')
         .option('--no-redact', 'Disable default secret redaction in rendered session output (--markdown and --json)')
@@ -2866,6 +2990,10 @@ export function registerSessionsCommands(program) {
       # Search across every directory, not just this project
       agents sessions "topic" --all
 
+      # Who spawned which team: an orchestrator row carries team:<name>, and a
+      # teammate row [<team>/<handle>]. --in-team narrows to one team's lineage.
+      agents sessions --in-team redesign --teams
+
       # Show routine-run sessions and open one by routine run id
       agents sessions --routine --all
       agents sessions 2026-07-21T10-30-00-000Z
@@ -2882,6 +3010,7 @@ export function registerSessionsCommands(program) {
         notes: `
       - The interactive listing folds in your other online machines automatically (live over SSH, no sync) — each row is labelled by host, this machine first. Use --local to skip the fan-out; --json and single-id lookups stay local.
       - --host runs the query on the remote's own index over SSH (host alias or user@host); repeat or pass several to fan out. SSH access is the only auth.
+      - --in-team matches both ends of the lineage: the session that ran 'agents teams create/add', and (with --teams) that team's teammates. In the interactive list, 't' cycles the same filter over the teams in view.
       - --include and --exclude are mutually exclusive.
       - --first and --last are mutually exclusive.
       - A filter flag (--include/--exclude/--first/--last) without --markdown/--json defaults to --markdown output.
@@ -2890,13 +3019,13 @@ export function registerSessionsCommands(program) {
       - Without --teams, team-spawned sessions are hidden by default.
     `,
     });
-    sessionsCmd.action(async (query, options) => {
+    sessionsCmd.action(async (query, options, command) => {
         if (options.browser) {
             // Alias for `agents browser sessions`: a profile positional narrows to one profile.
             runBrowserSessions({ profile: query, json: options.json });
             return;
         }
-        await sessionsAction(query, options);
+        await sessionsAction(query, options, command.getOptionValueSource('limit'));
     });
     registerSessionsTailCommand(sessionsCmd);
     registerSessionsSyncCommand(sessionsCmd);

package/dist/commands/ssh.js

@@ -20,7 +20,7 @@ import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secret
 import { machineId } from '../lib/session/sync/config.js';
 import { registerFleetCaptureCommand } from './fleet-capture.js';
 import { registerFleetApplyAlias } from './apply.js';
-import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
+import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, setAutoLaunchEnabled, setAutoLaunchPreferred, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
 import { collectReachabilityWriteBacks, deviceOnlineState } from '../lib/devices/reachability.js';
 import { addControlToken } from '../lib/serve/token.js';
 import { DEFAULT_SERVE_PORT } from '../lib/serve/server.js';
@@ -687,6 +687,8 @@ Typical workflow:
   agents devices sync --yes      # non-interactive: register all non-ignored nodes
   agents devices list            # see what's registered
   agents devices ignore ipad165  # dismiss a node so it's never re-suggested
+  agents devices disable zion    # exclude a device from Factory auto-launch
+  agents devices prefer mac-mini # boost a device in Factory auto-launch ranking
   agents devices set win-mini --auth password --bundle muqsit
   agents devices render --write  # write ~/.ssh/config.d/agents include
   agents fleet update            # roll out latest agents-cli to every online device
@@ -766,6 +768,62 @@ Typical workflow:
         }
         console.log(chalk.green(`No longer ignoring '${name}'`) + chalk.gray(' — run `agents devices sync` to register it.'));
     });
+    devicesCmd
+        .command('enable <name>')
+        .description('Allow a registered device to be auto-picked by Factory agent launches.')
+        .action(async (name) => {
+        try {
+            await mustGetDevice(name);
+            await setAutoLaunchEnabled(name, true);
+            console.log(chalk.green(`Enabled '${name}'`) + chalk.gray(' for Factory auto-launch.'));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    devicesCmd
+        .command('disable <name>')
+        .description('Exclude a registered device from Factory auto-launch. It can still be picked manually via (Pick Host).')
+        .action(async (name) => {
+        try {
+            await mustGetDevice(name);
+            await setAutoLaunchEnabled(name, false);
+            console.log(chalk.green(`Disabled '${name}'`) + chalk.gray(' for Factory auto-launch.'));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    devicesCmd
+        .command('prefer <name>')
+        .description('Boost a registered device in Factory auto-launch ranking.')
+        .action(async (name) => {
+        try {
+            await mustGetDevice(name);
+            await setAutoLaunchPreferred(name, true);
+            console.log(chalk.green(`Preferred '${name}'`) + chalk.gray(' for Factory auto-launch.'));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    devicesCmd
+        .command('unprefer <name>')
+        .description('Remove the auto-launch preference boost from a device.')
+        .action(async (name) => {
+        try {
+            await mustGetDevice(name);
+            await setAutoLaunchPreferred(name, false);
+            console.log(chalk.green(`No longer preferring '${name}'`) + chalk.gray(' for Factory auto-launch.'));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
     const runList = async (opts = {}) => {
         const reg = await loadDevices();
         const names = Object.keys(reg).sort();

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

@@ -3,6 +3,8 @@ export interface TeamRow {
     team: TaskInfo;
     agents: AgentStatusDetail[];
     description?: string;
+    /** Short id of the session that spawned this team, when the index knows it. */
+    spawnedBy?: string;
 }
 export interface PickedTeam {
     team: string;

package/dist/commands/teams-picker.js

@@ -132,7 +132,8 @@ export function formatTeamRow(row, nameWidth, compositionWidth) {
     const work = workCell(row.agents);
     const runtime = runtimeSpan(t);
     const age = chalk.gray(relTime(t.modified_at));
-    const middleParts = [status, work, runtime].filter(Boolean);
+    const spawnedBy = row.spawnedBy ? chalk.green(`by ${row.spawnedBy}`) : '';
+    const middleParts = [status, work, runtime, spawnedBy].filter(Boolean);
     const middle = middleParts.join(chalk.gray(' · '));
     return `${name}  ${composition}  ${middle}${middle ? chalk.gray(' · ') : ''}${age}`;
 }

package/dist/commands/teams.d.ts

@@ -9,6 +9,7 @@ import type { Command } from 'commander';
 import { AgentManager, AgentStatus, type TaskType } from '../lib/teams/agents.js';
 import { type TaskInfo } from '../lib/teams/api.js';
 import { type TeamRow } from './teams-picker.js';
+import { type TeamSpawner } from '../lib/session/db.js';
 type TeamRegistry = Record<string, {
     created_at: string;
     description?: string;
@@ -58,7 +59,9 @@ export declare function decideTeamMessageRoute(status: AgentStatus, hasMessage:
  * the teammate itself so we don't need the original --cloud CLI args.
  */
 export declare function wireCloudDispatcher(mgr: AgentManager): void;
-export declare function buildTeamRowsFromSnapshots(registry: TeamRegistry, agents: TeamListAgentSnapshot[]): {
+export declare function buildTeamRowsFromSnapshots(registry: TeamRegistry, agents: TeamListAgentSnapshot[], 
+/** team name -> the session that spawned it (see teamSpawners). */
+spawners?: Map<string, TeamSpawner>): {
     rows: TeamRow[];
     teams: TaskInfo[];
     names: string[];