@phnx-labs/agents-cli 1.20.85 → 1.20.87

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

@@ -31,18 +31,31 @@ 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[];
-};
+/**
+ * Body lines available from SessionMeta alone (no transcript parse) — used for
+ * remote / unindexed sessions so checklist progress still surfaces when the
+ * parser teammate (or a prior scan) has populated `session.todos`.
+ */
+/**
+ * The session's place in a team, from whichever end it sits at: the orchestrator
+ * that ran `agents teams create` (from the scan-derived `spawnedTeam`), or a
+ * teammate (from its `meta.json`, via `classifyTeamSession`). Empty for a session
+ * with no team involvement, which is the overwhelming majority.
+ *
+ * Deliberately no live teammate counts: tallying a team means reading every
+ * record under the teams-agents dir, which runs to thousands of files on a busy
+ * machine — far too much for a pane that repaints as the cursor moves. The line
+ * names the command that does report them instead.
+ */
+export declare function formatTeamLineage(session: SessionMeta): 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.
+ * Prefer `session.recentDirectoriesTouched` — the scan records it on the row, so
+ * it is present for remote rows whose transcript we can't parse here — otherwise
+ * derive from the file-change + tool paths already available.
  */
-export declare function directoriesTouched(session: SessionMetaWithDirs, events: SessionEvent[], changes: ReturnType<typeof classifyFileChanges>): string[];
+export declare function directoriesTouched(session: SessionMeta, 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

@@ -9,7 +9,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
-import { parseSession, sanitizeForTerminal } from '../lib/session/parse.js';
+import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
+import { safeTeamText } from '../lib/session/team-filter.js';
 import { cleanSessionPrompt, extractSessionTopic } from '../lib/session/prompt.js';
 import { linkPath, linkUrl, relativeToCwd, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
@@ -84,6 +85,12 @@ function sanitizeMeta(s) {
         label: clean(s.label),
         ticketId: clean(s.ticketId),
         prUrl: clean(s.prUrl),
+        // A remote row's meta is peer-supplied JSON that parseRemoteList hands over
+        // unsanitized, and both of these reach the preview pane — so an escape
+        // sequence in a peer's plan text or path list would otherwise hit our TTY.
+        plan: clean(s.plan),
+        spawnedTeam: clean(s.spawnedTeam),
+        recentDirectoriesTouched: s.recentDirectoriesTouched?.map(sanitizeForTerminal),
         todos,
     };
 }
@@ -205,15 +212,69 @@ function formatHeader(session, events) {
  * remote / unindexed sessions so checklist progress still surfaces when the
  * parser teammate (or a prior scan) has populated `session.todos`.
  */
+/**
+ * The session's place in a team, from whichever end it sits at: the orchestrator
+ * that ran `agents teams create` (from the scan-derived `spawnedTeam`), or a
+ * teammate (from its `meta.json`, via `classifyTeamSession`). Empty for a session
+ * with no team involvement, which is the overwhelming majority.
+ *
+ * Deliberately no live teammate counts: tallying a team means reading every
+ * record under the teams-agents dir, which runs to thousands of files on a busy
+ * machine — far too much for a pane that repaints as the cursor moves. The line
+ * names the command that does report them instead.
+ */
+export function formatTeamLineage(session) {
+    const origin = session.teamOrigin;
+    if (origin) {
+        const team = safeTeamText(origin.team);
+        const handleName = safeTeamText(origin.handle);
+        const mode = safeTeamText(origin.mode);
+        const parent = safeTeamText(origin.parentSessionId);
+        const parts = [chalk.white(team ?? 'team')];
+        const handle = handleName ? `teammate ${handleName}` : 'teammate';
+        parts.push(chalk.white(mode ? `${handle} (${mode})` : handle));
+        if (parent) {
+            parts.push(chalk.gray('spawned by ') + chalk.white(parent.slice(0, 8)));
+        }
+        return parts.join(chalk.gray(' · '));
+    }
+    const spawned = safeTeamText(session.spawnedTeam);
+    if (spawned) {
+        return (chalk.gray('spawned team ') +
+            chalk.white(spawned) +
+            chalk.gray(` · agents teams status ${spawned}`));
+    }
+    return '';
+}
 function formatMetaOnlyBody(session) {
     const lines = [];
     if (session.topic) {
         lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(session.topic.trim(), (process.stdout.columns || 80) - 12)));
     }
+    const teamLine = formatTeamLineage(session);
+    if (teamLine) {
+        lines.push(chalk.cyan('Team:   ') + teamLine);
+    }
     const compact = formatTodoCompact(session.todos);
     if (compact) {
         lines.push(chalk.cyan('Todos: ') + chalk.white(compact));
     }
+    const termWidth = process.stdout.columns || 80;
+    for (const l of session.todos?.items?.length ? renderTodos(session.todos.items, termWidth) : []) {
+        lines.push(l);
+    }
+    const dirs = session.recentDirectoriesTouched?.slice(0, DIRS_TOUCHED_MAX) ?? [];
+    if (dirs.length) {
+        lines.push(chalk.cyan('Dirs:   ') + chalk.white(dirs.join(chalk.gray(' · '))));
+    }
+    // `plan` is the whole ExitPlanMode markdown, not a path — summarize it. The
+    // pane is height-clamped anyway, so pasting the blob would just push every
+    // other line out of view.
+    const planLines = session.plan?.trim() ? session.plan.trim().split('\n') : [];
+    if (planLines.length) {
+        const head = truncate(planLines[0].replace(/^#+\s*/, ''), termWidth - 20);
+        lines.push(chalk.cyan('Plan:   ') + chalk.white(head) + chalk.gray(` · ${planLines.length} lines`));
+    }
     if (lines.length === 0)
         return '';
     return lines.map(l => '  ' + l).join('\n');
@@ -312,9 +373,10 @@ function formatCompactPreview(events, session) {
             if (!planFile && p && /\/plans\/[^/]+\.md$/.test(p)) {
                 planFile = p;
             }
-            // Claude TodoWrite (`todos`) and Codex update_plan (`plan`) — same source as
-            // extractTodoProgress in the state engine. Prefer the most recent write.
-            if (tool === 'TodoWrite' || tool === 'update_plan') {
+            // Every harness's checklist-snapshot tool (Claude TodoWrite, Kimi TodoList,
+            // Codex update_plan, …) — the same registry the state engine folds through
+            // extractTodoProgress. Prefer the most recent write.
+            if (SNAPSHOT_TODO_TOOLS.has(tool)) {
                 const progress = extractTodoProgress(event.args);
                 if (progress)
                     latestTodos = progress;
@@ -359,6 +421,10 @@ function formatCompactPreview(events, session) {
     if (dirs.length) {
         lines.push(chalk.cyan('Dirs:    ') + chalk.white(dirs.join(chalk.gray(' · '))));
     }
+    const teamLine = formatTeamLineage(session);
+    if (teamLine) {
+        lines.push(chalk.cyan('Team:    ') + teamLine);
+    }
     const activity = [];
     const changed = chg.created + chg.modified + chg.deleted;
     if (changed) {
@@ -434,16 +500,27 @@ function isSubAgentTool(tool, 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.
+ * Prefer `session.recentDirectoriesTouched` — the scan records it on the row, so
+ * it is present for remote rows whose transcript we can't parse here — otherwise
+ * derive from the file-change + tool paths already available.
  */
 export function directoriesTouched(session, events, changes) {
-    const fromMeta = session.dirsTouched;
+    const fromMeta = session.recentDirectoriesTouched;
     if (Array.isArray(fromMeta) && fromMeta.length > 0) {
-        return fromMeta
-            .map((d) => sanitizeForTerminal(String(d).trim()))
-            .filter(Boolean)
-            .slice(0, DIRS_TOUCHED_MAX);
+        // The scan stores ABSOLUTE paths, so they go through the same relativizer the
+        // derived branch below uses — otherwise adopting this field (which a remote row
+        // needs, having no transcript to derive from) would turn every local preview's
+        // `Dirs:` line from `src/lib · docs` into a column of full home-rooted paths.
+        const seen = new Set();
+        for (const raw of fromMeta) {
+            const dir = relativizeDir(sanitizeForTerminal(String(raw).trim()), session.cwd);
+            if (dir)
+                seen.add(dir);
+            if (seen.size >= DIRS_TOUCHED_MAX)
+                break;
+        }
+        if (seen.size > 0)
+            return [...seen];
     }
     const counts = new Map();
     const bump = (raw) => {

package/dist/commands/sessions.d.ts

@@ -8,6 +8,7 @@ interface SessionFilterOptions {
     project?: string;
     all?: boolean;
     teams?: boolean;
+    inTeam?: string;
     routine?: boolean;
     since?: string;
     until?: string;
@@ -274,6 +275,24 @@ export declare function isBareBrowserListing(options: SessionsOptions, query: st
  * `runSessionBrowser` picker cannot represent.
  */
 export declare function hasNoBrowserDisqualifyingFlags(options: SessionsOptions, query: string | undefined): boolean;
+/**
+ * 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 declare function matchesTeam(session: SessionMeta, team: string): boolean;
+/**
+ * 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 declare function teamBadge(session: SessionMeta): {
+    plain: string;
+    width: 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

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);