@phnx-labs/agents-cli 1.20.85 → 1.20.87

package/dist/lib/session/db.js

@@ -16,8 +16,10 @@ import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
-/** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 20;
+/** Current schema version; bumped when migrations are added. Exported so tests
+ * assert against the constant instead of hardcoding a number that every bump
+ * then has to chase (docs/05-sessions.md calls the constant the source of truth). */
+export const SCHEMA_VERSION = 21;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -74,6 +76,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   pr_number INTEGER,
   worktree_slug TEXT,
   ticket_id TEXT,
+  spawned_team TEXT,
   plan TEXT,
   machine TEXT,
   todos TEXT,
@@ -383,6 +386,19 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN model TEXT`);
         db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
     }
+    if (fromVersion < 21) {
+        // v20 → v21: persist the team a session SPAWNED (`agents teams create/add`).
+        // The value was already derived at scan time (discover.ts detectSpawnedTeam)
+        // and set on SessionMeta, but had no column — so it was dropped at the write
+        // and no consumer ever saw it. Wipe BOTH ledgers, not just scan_ledger: with
+        // dir_ledger intact, collectChangedFilesInLeafDirs treats every non-live-root
+        // dir as unchanged and derives its hot set from the scan stamps just deleted,
+        // so archived dirs would never be re-parsed and would stay NULL forever.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'spawned_team'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN spawned_team TEXT`);
+        db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -744,7 +760,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     project, cwd, git_branch, topic, label, message_count, token_count,
     output_tokens, cost_usd, duration_ms, model,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
-    pr_url, pr_number, worktree_slug, ticket_id, plan, todos,
+    pr_url, pr_number, worktree_slug, ticket_id, spawned_team, plan, todos,
     recent_directories_touched, linear_project, linear_project_url, machine,
     actor, initiated_by
   ) VALUES (
@@ -753,7 +769,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @output_tokens, @cost_usd, @duration_ms, @model,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
-    @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan, @todos,
+    @pr_url, @pr_number, @worktree_slug, @ticket_id, @spawned_team, @plan, @todos,
     @recent_directories_touched, @linear_project, @linear_project_url, @machine,
     @actor, @initiated_by
   )
@@ -795,6 +811,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     pr_number = excluded.pr_number,
     worktree_slug = excluded.worktree_slug,
     ticket_id = excluded.ticket_id,
+    spawned_team = excluded.spawned_team,
     plan = excluded.plan,
     todos = excluded.todos,
     recent_directories_touched = excluded.recent_directories_touched,
@@ -911,6 +928,7 @@ export function upsertSession(meta, content, scan) {
         pr_number: meta.prNumber ?? null,
         worktree_slug: meta.worktreeSlug ?? null,
         ticket_id: meta.ticketId ?? null,
+        spawned_team: meta.spawnedTeam ?? null,
         plan: meta.plan ?? null,
         todos: meta.todos ? JSON.stringify(meta.todos) : null,
         recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
@@ -1031,6 +1049,7 @@ export function upsertSessionsBatch(entries) {
                     pr_number: meta.prNumber ?? null,
                     worktree_slug: meta.worktreeSlug ?? null,
                     ticket_id: meta.ticketId ?? null,
+                    spawned_team: meta.spawnedTeam ?? null,
                     plan: meta.plan ?? null,
                     todos: meta.todos ? JSON.stringify(meta.todos) : null,
                     recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
@@ -1219,6 +1238,7 @@ function rowToMeta(row) {
         prNumber: row.pr_number ?? undefined,
         worktreeSlug: row.worktree_slug ?? undefined,
         ticketId: row.ticket_id ?? undefined,
+        spawnedTeam: row.spawned_team ?? undefined,
         plan: row.plan ?? undefined,
         todos: parseJsonColumn(row.todos),
         recentDirectoriesTouched: parseJsonColumn(row.recent_directories_touched),
@@ -1483,6 +1503,27 @@ export function queryUsageRollup(options) {
   `;
     return db.prepare(sql).all(...params);
 }
+/**
+ * Map every team name to the session that ran `agents teams create/add` for it.
+ *
+ * One scan over the rows that carry a `spawned_team`, rather than a query per
+ * team — `agents teams list` needs the whole map at once, and the column has no
+ * index. When two sessions spawned the same team name (a team re-created after a
+ * disband), the most recent wins, which is the one whose work the name refers to.
+ */
+export function teamSpawners() {
+    const db = getDB();
+    const rows = db
+        .prepare(`SELECT spawned_team, id, short_id, actor FROM sessions
+       WHERE spawned_team IS NOT NULL AND spawned_team != ''
+       ORDER BY timestamp ASC`)
+        .all();
+    const out = new Map();
+    for (const r of rows) {
+        out.set(r.spawned_team, { sessionId: r.id, shortId: r.short_id, actor: r.actor ?? undefined });
+    }
+    return out;
+}
 /**
  * Return the N most expensive sessions (cost_usd DESC, NULLs excluded),
  * honoring the same filter shape as querySessions. Drops rows whose JSONL

package/dist/lib/session/parse.d.ts

@@ -27,6 +27,17 @@ export declare function safeReadSessionFile(filePath: string, maxBytes?: number)
 export declare function parseSession(filePath: string, agent?: SessionAgentId): SessionEvent[];
 /** Infer the agent type from a session file path using known directory conventions. */
 export declare function detectAgent(filePath: string): SessionAgentId | null;
+/**
+ * Checklist-snapshot tool names across harnesses — each sends the WHOLE list on
+ * every write, so the last call is the current checklist. Claude `TodoWrite`,
+ * Kimi `TodoList`, Droid/OpenCode `todo_write`, Codex `update_plan`.
+ */
+export declare const SNAPSHOT_TODO_TOOLS: Set<string>;
+/**
+ * Whether a harness's checklist status means "finished". Claude/Codex write
+ * `completed`; Kimi writes `done`.
+ */
+export declare function isCompletedTodoStatus(status: unknown): boolean;
 /**
  * Summarize a tool_use into a one-liner string.
  */

package/dist/lib/session/parse.js

@@ -205,6 +205,19 @@ export function detectAgent(filePath) {
         return 'gemini';
     return null;
 }
+/**
+ * Checklist-snapshot tool names across harnesses — each sends the WHOLE list on
+ * every write, so the last call is the current checklist. Claude `TodoWrite`,
+ * Kimi `TodoList`, Droid/OpenCode `todo_write`, Codex `update_plan`.
+ */
+export const SNAPSHOT_TODO_TOOLS = new Set(['TodoWrite', 'TodoList', 'todo_write', 'update_plan']);
+/**
+ * Whether a harness's checklist status means "finished". Claude/Codex write
+ * `completed`; Kimi writes `done`.
+ */
+export function isCompletedTodoStatus(status) {
+    return status === 'completed' || status === 'done';
+}
 /**
  * Summarize a tool_use into a one-liner string.
  */
@@ -214,12 +227,13 @@ export function summarizeToolUse(tool, args) {
     switch (tool) {
         case 'Bash':
             return `Bash: ${truncate(String(args.command || '').replace(/\n/g, ' ').trim(), 120)}`;
+        // `path` is the Kimi spelling of Claude's `file_path` for the same tools.
         case 'Read':
-            return `Read ${shortenPath(args.file_path || '')}`;
+            return `Read ${shortenPath(args.file_path || args.path || '')}`;
         case 'Write':
-            return `Write ${shortenPath(args.file_path || '')}`;
+            return `Write ${shortenPath(args.file_path || args.path || '')}`;
         case 'Edit':
-            return `Edit ${shortenPath(args.file_path || '')}`;
+            return `Edit ${shortenPath(args.file_path || args.path || '')}`;
         case 'Glob':
             return `Glob ${args.pattern || ''}`;
         case 'Grep':
@@ -234,14 +248,17 @@ export function summarizeToolUse(tool, args) {
             const steps = Array.isArray(args.plan) ? args.plan.length : 0;
             return `Plan: ${steps} step${steps === 1 ? '' : 's'}`;
         }
-        // Claude's live checklist: show progress + the current step, not a bare "TodoWrite".
-        case 'TodoWrite': {
+        // Live checklist: show progress + the current step, not a bare "TodoWrite".
+        // Claude writes `TodoWrite`, Kimi writes `TodoList`; both carry the whole list
+        // under `todos`, with Kimi spelling the item text `title` and "done" `done`.
+        case 'TodoWrite':
+        case 'TodoList': {
             const todos = Array.isArray(args.todos) ? args.todos : [];
             if (todos.length === 0)
                 return 'Plan: 0 steps';
-            const done = todos.filter((t) => t?.status === 'completed').length;
+            const done = todos.filter((t) => isCompletedTodoStatus(t?.status)).length;
             const active = todos.find((t) => t?.status === 'in_progress');
-            const step = active?.activeForm || active?.content;
+            const step = active?.activeForm || active?.content || active?.title;
             return step
                 ? `Plan ${done}/${todos.length}: ${truncate(String(step), 80)}`
                 : `Plan: ${done}/${todos.length} done`;

package/dist/lib/session/remote-list.d.ts

@@ -20,6 +20,13 @@ export interface RemoteListResult {
     sessions: SessionMeta[];
     /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
     deviceCount: number;
+    /**
+     * Peers that failed to answer, by display name. The stderr note above is
+     * enough for a printed listing, but the interactive browser repaints over it —
+     * so callers rendering a full-screen UI need the outcome as data to tell
+     * "that box is asleep" apart from "that box has no matching sessions".
+     */
+    unreachable: string[];
 }
 /**
  * Gather listing sessions from other machines. With an explicit `hosts` list

package/dist/lib/session/remote-list.js

@@ -97,9 +97,9 @@ async function fetchByTarget(target, machine, display, forwardedArgs, os) {
     const { code, stdout } = await sshCapture(target, remoteListCommand(forwardedArgs, os), REMOTE_TIMEOUT_MS);
     if (code !== 0) {
         process.stderr.write(chalk.gray(`  ${display}: unreachable or no agents CLI — skipped\n`));
-        return [];
+        return { sessions: [], unreachable: display };
     }
-    return parseRemoteList(stdout, machine);
+    return { sessions: parseRemoteList(stdout, machine) };
 }
 /**
  * Gather listing sessions from other machines. With an explicit `hosts` list
@@ -122,7 +122,7 @@ export async function gatherRemoteList(forwardedArgs, hosts) {
             reg = await loadDevices();
         }
         catch {
-            return { sessions: [], deviceCount: 0 };
+            return { sessions: [], deviceCount: 0, unreachable: [] };
         }
         for (const d of Object.values(reg)) {
             if (d.tailscale?.online !== true)
@@ -147,7 +147,11 @@ export async function gatherRemoteList(forwardedArgs, hosts) {
         }
     }
     const results = await Promise.all(targets.map((t) => fetchByTarget(t.target, t.machine, t.name, forwardedArgs, t.os)));
-    return { sessions: results.flat(), deviceCount: targets.length };
+    return {
+        sessions: results.flatMap((r) => r.sessions),
+        deviceCount: targets.length,
+        unreachable: results.map((r) => r.unreachable).filter((n) => !!n),
+    };
 }
 /** Resolve a peer's SSH target (and OS) from the device registry by its
  * normalized machine id — the same id the fan-out tags rows with. Returns

package/dist/lib/session/state.d.ts

@@ -119,11 +119,12 @@ export interface StateContext {
     activeWindowMs?: number;
 }
 /**
- * Derive live plan progress from a checklist tool call's args. Accepts both
- * Claude's `TodoWrite` (`todos: [{content,status,activeForm}]`) and Codex's
- * `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the single source
- * of checklist state for every agent. Returns undefined when there is no usable
- * list, so a session with no plan carries no `todos` field.
+ * Derive live plan progress from a checklist tool call's args. Accepts Claude's
+ * `TodoWrite` (`todos: [{content,status,activeForm}]`), Kimi's `TodoList`
+ * (`todos: [{title,status}]`, where finished is `done` rather than `completed`)
+ * and Codex's `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the
+ * single source of checklist state for every agent. Returns undefined when there
+ * is no usable list, so a session with no plan carries no `todos` field.
  */
 export declare function extractTodoProgress(args?: Record<string, any>): TodoProgress | undefined;
 /** Fold snapshot checklist tools and Claude TaskCreate/TaskUpdate event logs. */

package/dist/lib/session/state.js

@@ -15,7 +15,7 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import * as path from 'path';
-import { summarizeToolUse } from './parse.js';
+import { isCompletedTodoStatus, SNAPSHOT_TODO_TOOLS, summarizeToolUse } from './parse.js';
 /**
  * Detect per-session rate-limit / usage-limit signals in assistant or error
  * text (RUSH-1523). Matches the same shapes Factory's prewarm detectBlockingPrompt
@@ -48,15 +48,15 @@ const PROSE_QUESTION_FRESH_MS = 30 * 60_000;
 /** Claude tool names that structurally mean "the agent handed control back to you". */
 const PLAN_TOOL = 'ExitPlanMode';
 const ASK_TOOL = 'AskUserQuestion';
-const SNAPSHOT_TODO_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan']);
 const TASK_CREATE_TOOL = 'TaskCreate';
 const TASK_UPDATE_TOOL = 'TaskUpdate';
 /**
- * Derive live plan progress from a checklist tool call's args. Accepts both
- * Claude's `TodoWrite` (`todos: [{content,status,activeForm}]`) and Codex's
- * `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the single source
- * of checklist state for every agent. Returns undefined when there is no usable
- * list, so a session with no plan carries no `todos` field.
+ * Derive live plan progress from a checklist tool call's args. Accepts Claude's
+ * `TodoWrite` (`todos: [{content,status,activeForm}]`), Kimi's `TodoList`
+ * (`todos: [{title,status}]`, where finished is `done` rather than `completed`)
+ * and Codex's `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the
+ * single source of checklist state for every agent. Returns undefined when there
+ * is no usable list, so a session with no plan carries no `todos` field.
  */
 export function extractTodoProgress(args) {
     const input = args?.input && typeof args.input === 'object' ? args.input : args;
@@ -76,10 +76,16 @@ export function extractTodoProgress(args) {
                 ? t.text
                 : typeof t?.step === 'string' && t.step
                     ? t.step
-                    : activeForm ?? '';
+                    : typeof t?.title === 'string' && t.title
+                        ? t.title
+                        : activeForm ?? '';
         if (!content)
             continue;
-        const status = t?.status === 'completed' || t?.status === 'in_progress' ? t.status : 'pending';
+        const status = isCompletedTodoStatus(t?.status)
+            ? 'completed'
+            : t?.status === 'in_progress'
+                ? 'in_progress'
+                : 'pending';
         const description = typeof t?.description === 'string' && t.description ? t.description : undefined;
         items.push({ content, status, ...(description ? { description } : {}), ...(activeForm ? { activeForm } : {}) });
     }
@@ -195,12 +201,66 @@ const GH_PR_CREATE_RE = /\bgh\s+pr\s+(?:create|new)\b/;
 const GH_ISSUE_CREATE_RE = /\bgh\s+issue\s+create\b/;
 /** A created GitHub issue URL (…/issues/123) in tool-result output. */
 const GH_ISSUE_URL_RE = /https:\/\/github\.com\/[^\s"'()<>]+\/issues\/(\d+)/;
+/**
+ * Flags of `teams create` / `teams add` that take a value, so the value is not
+ * mistaken for the positional team name. Mirrors their value-taking flags in
+ * `commands/teams.ts` — most are `.option('… <x>')` registrations, but
+ * `--device`/`--host` come from `addHostOption`, so auditing this list against
+ * `.option(` alone would wrongly drop them. A flag missing here degrades to "no
+ * team detected", never to a wrong one.
+ */
+const TEAM_VALUE_FLAGS = [
+    '-d', '--description', '--use-worktree', '--devices', '--hosts', '--repo',
+    '-n', '--name', '-m', '--mode', '-e', '--effort', '--model', '--env',
+    '--cwd', '--worktree', '--after', '--task-type', '--cloud', '--branch',
+    '--device', '--host',
+];
+/**
+ * One flag value: a quoted string or a bare token. `-d "sessions lineage"` is the
+ * common shape — `--description` is usually a phrase — and a value pattern of
+ * `\S+` alone stops at the first space, leaving the rest of the phrase to be read
+ * as the positional team name (`… -d "sessions lineage" my-team` detected
+ * `lineage`). Quotes are matched as a unit so the whole value is consumed.
+ *
+ * A value containing an ESCAPED quote (`-d "say \"hi\" now"`) stops the quoted
+ * branch early and the match then fails outright — which is the intended failure
+ * direction: no team detected rather than a wrong one.
+ */
+const FLAG_VALUE = String.raw `(?:"[^"\n]*"|'[^'\n]*'|\S+)`;
 /**
  * `agents teams create <name>` / `agents teams add <team> …` (also the `ag` alias).
  * The team NAME is the first bareword after the sub-verb, skipping any flags. This
  * is the structural signal that a session SPAWNED a team (vs. was spawned by one).
+ *
+ * The separators are spaces/tabs, never `\s`: a command string routinely embeds
+ * documentation and quoted output, and `\s` let the flag-skip run across newlines
+ * to capture a word from a completely different line (a real scan produced
+ * `team:installed` from a heredoc). For the same reason the flag-skip is bounded
+ * rather than unlimited — a real invocation carries a handful of flags before the
+ * name, not dozens.
  */
-const TEAMS_SPAWN_RE = /\bag(?:ents)?\s+teams?\s+(?:create|add)\s+(?:--?[a-z][\w-]*(?:[= ]\S+)?\s+)*([A-Za-z0-9][\w-]*)/;
+const TEAMS_SPAWN_RE = new RegExp(
+// Start of an actually-executed command: string start, a newline, or a shell
+// separator. Without this, a backticked mention inside prose or tool output
+// ("… and `agents teams add --device auto`") reads as a spawn.
+String.raw `(?:^|[\n;&|(]|&&|\|\|)[ \t]*` +
+    String.raw `ag(?:ents)?[ \t]+teams?[ \t]+(?:create|add)[ \t]+` +
+    // Flags before the positional name. A value-taking flag must swallow its
+    // value, or `--device auto` leaves `auto` looking like the team name — and
+    // the generic branch must exclude those flags, or it swallows the flag alone
+    // and hands the value back as the name.
+    String.raw `(?:(?:${TEAM_VALUE_FLAGS.join('|')})[= \t]${FLAG_VALUE}[ \t]+` +
+    String.raw `|(?!(?:${TEAM_VALUE_FLAGS.join('|')})[= \t])--?[a-z][\w-]*(?:=\S+)?[ \t]+){0,6}` +
+    // A team name may start with a digit — `createTeam` validates nothing, and
+    // `2fa-migration` is a legal name — so the class stays [A-Za-z0-9]. The
+    // all-digits case is rejected in the guard below instead.
+    String.raw `([A-Za-z0-9][\w-]*)`);
+/**
+ * Sub-verbs that can follow `teams create|add` in prose ("teams add a teammate")
+ * but are never a team name. Guards the common case where the match came from a
+ * sentence rather than an executed command.
+ */
+const NON_TEAM_WORDS = new Set(['a', 'an', 'the', 'to', 'for', 'with', 'and', 'this', 'your', 'my', 'it']);
 /** Collapse to a single trimmed line for a one-row preview cell. */
 function oneLine(s) {
     return s.replace(/\s+/g, ' ').trim();
@@ -253,7 +313,20 @@ export function detectSpawnedTeam(command) {
     if (!command)
         return undefined;
     const m = command.match(TEAMS_SPAWN_RE);
-    return m ? m[1] : undefined;
+    if (!m)
+        return undefined;
+    const name = m[1];
+    // A single character is a doc placeholder (`agents teams create t --host <box>`)
+    // far more often than a real team, and an English article is prose. Both used to
+    // land in the index as a team name, and now that the name is rendered on the row
+    // a wrong one is worse than none.
+    // A single character is a doc placeholder (`agents teams create t --host <name>`)
+    // far more often than a real team; an all-digits token is a flag value or a list
+    // index that leaked through, never a name someone typed. Both had reached the
+    // index, and now that the name is rendered a wrong one is worse than none.
+    if (name.length < 2 || /^\d+$/.test(name) || NON_TEAM_WORDS.has(name.toLowerCase()))
+        return undefined;
+    return name;
 }
 /**
  * True when a tool_use call CREATES a tracker ticket — a Linear MCP `create_issue`

package/dist/lib/session/team-filter.d.ts

@@ -12,14 +12,33 @@ import type { SessionMeta, TeamOrigin } from './types.js';
  *
  * Primary signal is `session.isTeamOrigin`, captured at scan time from the
  * JSONL `entrypoint` field ('sdk-cli' for team spawns, 'cli' for real CLI).
- * When a team meta.json exists we additionally enrich with handle/mode — but
- * its absence no longer demotes a session: older team runs whose meta dir
- * was cleaned up still get recognized via the entrypoint flag.
+ * When a team meta.json exists we additionally enrich with handle/mode/team and
+ * the orchestrator that spawned it — but its absence no longer demotes a
+ * session: older team runs whose meta dir was cleaned up still get recognized
+ * via the entrypoint flag.
  *
  * Returns the TeamOrigin metadata when the session is team-origin, or null
  * when it is a normal interactive session.
  */
 export declare function classifyTeamSession(session: SessionMeta): TeamOrigin | null;
+/**
+ * A team name / handle as it is safe to render: a real string, terminal escapes
+ * stripped, or undefined.
+ *
+ * These values reach the row and the preview pane, and for a peer's row they are
+ * whatever JSON that machine sent — `parseRemoteList` copies the object through
+ * without inspecting its fields, so neither the type nor the content is ours to
+ * assume. A non-string `spawnedTeam` used to throw out of `teamBadge`, which runs
+ * on every row, taking down the whole listing rather than one entry.
+ */
+export declare function safeTeamText(value: unknown): string | undefined;
+/** Drop the cached teammate index — for tests that rewrite AGENTS_TEAMS_DIR. */
+export declare function _resetTeamOriginIndex(): void;
+/**
+ * Attach `teamOrigin` to every team-spawned row in `sessions`, from the shared
+ * teammate index rather than a stat per row.
+ */
+export declare function enrichTeamOrigins(sessions: SessionMeta[]): SessionMeta[];
 /** Result of splitting sessions into visible and hidden (team-origin) groups. */
 export interface FilterResult {
     visible: SessionMeta[];

package/dist/lib/session/team-filter.js

@@ -9,6 +9,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { sanitizeForTerminal } from './parse.js';
 import { getTeamsAgentsDir } from '../state.js';
 const HOME = os.homedir();
 // Default path; tests can override via AGENTS_TEAMS_DIR env var.
@@ -21,33 +22,121 @@ function teamsAgentsDir() {
  *
  * Primary signal is `session.isTeamOrigin`, captured at scan time from the
  * JSONL `entrypoint` field ('sdk-cli' for team spawns, 'cli' for real CLI).
- * When a team meta.json exists we additionally enrich with handle/mode — but
- * its absence no longer demotes a session: older team runs whose meta dir
- * was cleaned up still get recognized via the entrypoint flag.
+ * When a team meta.json exists we additionally enrich with handle/mode/team and
+ * the orchestrator that spawned it — but its absence no longer demotes a
+ * session: older team runs whose meta dir was cleaned up still get recognized
+ * via the entrypoint flag.
  *
  * Returns the TeamOrigin metadata when the session is team-origin, or null
  * when it is a normal interactive session.
  */
 export function classifyTeamSession(session) {
-    const metaPath = path.join(teamsAgentsDir(), session.id, 'meta.json');
-    if (fs.existsSync(metaPath)) {
-        try {
-            const raw = fs.readFileSync(metaPath, 'utf-8');
-            const meta = JSON.parse(raw);
-            const name = typeof meta.name === 'string' && meta.name ? meta.name : undefined;
-            const handle = name ?? session.id.slice(0, 8);
-            const mode = typeof meta.mode === 'string' ? meta.mode : undefined;
-            return { handle, mode };
-        }
-        catch {
-            return { handle: session.id.slice(0, 8) };
-        }
-    }
+    const origin = teamOriginIndex().get(session.id);
+    if (origin)
+        return origin;
     if (session.isTeamOrigin) {
         return { handle: session.id.slice(0, 8) };
     }
     return null;
 }
+/**
+ * Parse one teammate `meta.json` into a {@link TeamOrigin}. Degrades to a bare
+ * handle when the file is unreadable or malformed — a teammate whose record we
+ * can't parse is still a teammate.
+ */
+function readTeamOrigin(metaPath, agentId) {
+    try {
+        const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        const str = (v) => (typeof v === 'string' && v ? v : undefined);
+        return {
+            origin: {
+                handle: str(meta.name) ?? agentId.slice(0, 8),
+                mode: str(meta.mode),
+                team: str(meta.task_name),
+                parentSessionId: str(meta.parent_session_id),
+            },
+            sessionId: str(meta.remote_session_id),
+        };
+    }
+    catch {
+        return { origin: { handle: agentId.slice(0, 8) } };
+    }
+}
+/**
+ * A team name / handle as it is safe to render: a real string, terminal escapes
+ * stripped, or undefined.
+ *
+ * These values reach the row and the preview pane, and for a peer's row they are
+ * whatever JSON that machine sent — `parseRemoteList` copies the object through
+ * without inspecting its fields, so neither the type nor the content is ours to
+ * assume. A non-string `spawnedTeam` used to throw out of `teamBadge`, which runs
+ * on every row, taking down the whole listing rather than one entry.
+ */
+export function safeTeamText(value) {
+    if (typeof value !== 'string' || value === '')
+        return undefined;
+    return sanitizeForTerminal(value);
+}
+/** Cached teammate index; the directory is small (teams GC it after 7 days). */
+let originIndexCache = null;
+/** Drop the cached teammate index — for tests that rewrite AGENTS_TEAMS_DIR. */
+export function _resetTeamOriginIndex() {
+    originIndexCache = null;
+}
+/**
+ * Every teammate record, keyed by the session ids it can be reached under.
+ *
+ * A teammate's directory name is its **agent id**, which is only sometimes the
+ * id of the transcript it produced: the harness mints its own session id, and
+ * the spawn records it separately as `remote_session_id`. Keying the lookup on
+ * the directory name alone therefore missed most teammates — on a live box, 14
+ * of 16 records were reachable only by `remote_session_id` — so a teammate row
+ * could not name its team however good the record was. Both keys are registered.
+ *
+ * Read once per process rather than per row: the old per-session `existsSync` +
+ * `readFileSync` cost a pair of syscalls for every row in the pool, which the
+ * interactive browser re-pays on each hotkey.
+ */
+function teamOriginIndex() {
+    if (originIndexCache)
+        return originIndexCache;
+    const dir = teamsAgentsDir();
+    const index = new Map();
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        entries = [];
+    }
+    for (const agentId of entries) {
+        const metaPath = path.join(dir, agentId, 'meta.json');
+        if (!fs.existsSync(metaPath))
+            continue;
+        const { origin, sessionId } = readTeamOrigin(metaPath, agentId);
+        index.set(agentId, origin);
+        if (sessionId)
+            index.set(sessionId, origin);
+    }
+    originIndexCache = index;
+    return index;
+}
+/**
+ * Attach `teamOrigin` to every team-spawned row in `sessions`, from the shared
+ * teammate index rather than a stat per row.
+ */
+export function enrichTeamOrigins(sessions) {
+    const index = teamOriginIndex();
+    return sessions.map((session) => {
+        // A peer's rows are classified on the peer (its meta.json is on its disk, not
+        // ours) and ride across in the --json fan-out already populated. Re-deriving
+        // here would find no local record and downgrade a named teammate to a bare id.
+        if (session.teamOrigin)
+            return session;
+        const origin = index.get(session.id) ?? (session.isTeamOrigin ? { handle: session.id.slice(0, 8) } : null);
+        return origin ? { ...session, teamOrigin: origin } : session;
+    });
+}
 /**
  * Split `sessions` into visible and hidden (team-origin) groups.
  * When `showTeams` is true every session is visible and `teamOrigin` is

package/dist/lib/session/types.d.ts

@@ -88,6 +88,14 @@ export interface TeamOrigin {
     handle?: string;
     /** Agent mode: 'plan', 'edit', 'auto', or 'skip' ('full' accepted as legacy alias for 'skip'). */
     mode?: string;
+    /** The team this teammate belongs to (`task_name` in its meta.json). */
+    team?: string;
+    /**
+     * The orchestrator session that spawned this teammate (`parent_session_id`).
+     * Absent for a team started outside any agent session, and for teammates whose
+     * meta dir has aged past the teams cleanup window.
+     */
+    parentSessionId?: string;
 }
 /** Lightweight metadata for a discovered session, used in listings and pickers. */
 export interface SessionMeta {

package/dist/lib/signin-badge.d.ts

@@ -23,6 +23,23 @@ export declare function loginHint(agentId: AgentId): string;
  * agents (the ones the feature is for), so the resume's `forceInteractive` flag is
  * consulted directly.
  */
+/**
+ * Is a Claude run on this box going to authenticate from an ambient
+ * `CLAUDE_CODE_OAUTH_TOKEN` rather than a per-version login?
+ *
+ * `AccountInfo.signedIn` is `!!email` read from a version home's `.claude.json`
+ * (agents.ts), so a version with no account written there reports signed-out —
+ * even though Claude Code authenticates fine from the env token and the run
+ * succeeds. Rendering that as "logged out" sends people hunting a login that is
+ * not missing (a real fleet incident: every version on a box read as locked out
+ * while all of them answered a live prompt).
+ *
+ * It is also the more useful warning: an ambient token is ONE account, so every
+ * version on the box resolves to it and balanced rotation across them rotates
+ * nothing. `env` is a parameter so the branch is testable without mutating the
+ * process environment.
+ */
+export declare function ambientClaudeToken(agentId: AgentId | string, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldCheckLoginBeforeLaunch(o: {
     interactive?: boolean;
     forceInteractive?: boolean;

package/dist/lib/signin-badge.js

@@ -46,6 +46,25 @@ export function loginHint(agentId) {
  * agents (the ones the feature is for), so the resume's `forceInteractive` flag is
  * consulted directly.
  */
+/**
+ * Is a Claude run on this box going to authenticate from an ambient
+ * `CLAUDE_CODE_OAUTH_TOKEN` rather than a per-version login?
+ *
+ * `AccountInfo.signedIn` is `!!email` read from a version home's `.claude.json`
+ * (agents.ts), so a version with no account written there reports signed-out —
+ * even though Claude Code authenticates fine from the env token and the run
+ * succeeds. Rendering that as "logged out" sends people hunting a login that is
+ * not missing (a real fleet incident: every version on a box read as locked out
+ * while all of them answered a live prompt).
+ *
+ * It is also the more useful warning: an ambient token is ONE account, so every
+ * version on the box resolves to it and balanced rotation across them rotates
+ * nothing. `env` is a parameter so the branch is testable without mutating the
+ * process environment.
+ */
+export function ambientClaudeToken(agentId, env = process.env) {
+    return agentId === 'claude' && (env.CLAUDE_CODE_OAUTH_TOKEN ?? '').trim().length > 0;
+}
 export function shouldCheckLoginBeforeLaunch(o) {
     if (o.json || o.quiet || o.authCheckDisabled || o.rotated)
         return false;