@phnx-labs/agents-cli 1.20.86 → 1.20.88

package/dist/lib/session/discover.js

@@ -23,7 +23,7 @@ import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
 import { extractSessionTopic } from './prompt.js';
-import { parseAntigravity } from './parse.js';
+import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
 import { machineForSessionFile } from './origin-machine.js';
@@ -221,6 +221,7 @@ function dispatchAgentScan(agent, onProgress) {
         case 'kimi': return scanKimiIncremental(onProgress);
         case 'droid': return scanDroidIncremental(onProgress);
         case 'grok': return scanGrokIncremental(onProgress);
+        case 'cursor': return scanCursorIncremental(onProgress);
         default: return Promise.resolve();
     }
 }
@@ -660,6 +661,7 @@ const SESSION_ROOT_SPECS = [
     { agent: 'droid', subdir: 'sessions' },
     { agent: 'kimi', subdir: 'sessions' },
     { agent: 'grok', subdir: 'sessions' },
+    { agent: 'cursor', subdir: 'projects' },
 ];
 function sessionRootSubdir(agent) {
     return SESSION_ROOT_SPECS.find((spec) => spec.agent === agent)?.subdir ?? null;
@@ -752,6 +754,13 @@ async function readRoutineArchiveMeta(agent, filePath) {
         const result = await readCodexMeta(filePath);
         return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
     }
+    if (agent === 'cursor') {
+        // PR #1723 archives Cursor routine transcripts; preserve version resolution
+        // when this reader consumes those archives.
+        const currentVersion = await getCurrentAgentVersion('cursor');
+        const result = readCursorMeta(filePath, currentVersion);
+        return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
+    }
     return null;
 }
 async function scanRoutineArchivesIncremental(agent, onProgress) {
@@ -3601,6 +3610,133 @@ function sumKnownNumbers(values) {
 // Time range parsing
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
+// Cursor
+// ---------------------------------------------------------------------------
+// Cursor writes the conversation to
+// projects/<encoded-cwd>/agent-transcripts/<uuid>/<uuid>.jsonl and metadata to
+// chats/<workspace-hash>/<uuid>/meta.json. Discovery deliberately starts from
+// transcripts, then joins metadata by UUID: chat directories with no transcript
+// are empty or abandoned sessions and must not become broken zero-event rows.
+// Routine archives may contain only the transcript; those remain browsable with
+// file timestamps and without guessed cwd/title metadata.
+/** Incrementally re-scan changed Cursor transcript files and upsert into the DB. */
+async function scanCursorIncremental(onProgress) {
+    const currentVersion = await getCurrentAgentVersion('cursor');
+    const prestat = [];
+    for (const projectsDir of getAgentSessionDirs('cursor', 'projects')) {
+        collectCursorTranscripts(projectsDir, prestat);
+    }
+    const changed = filterChangedEntries(prestat);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'cursor', parsed: 0, total: changed.length });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = readCursorMeta(filePath, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'cursor', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(entries);
+    recordScans(touched);
+}
+function collectCursorTranscripts(projectsDir, out) {
+    let projectNames;
+    try {
+        projectNames = fs.readdirSync(projectsDir);
+    }
+    catch {
+        return;
+    }
+    for (const projectName of projectNames) {
+        const transcriptsDir = path.join(projectsDir, projectName, 'agent-transcripts');
+        for (const f of walkForFilesWithStat(transcriptsDir, '.jsonl', 100_000)) {
+            const sessionId = path.basename(path.dirname(f.path));
+            if (path.basename(f.path) !== `${sessionId}.jsonl`)
+                continue;
+            out.push({ filePath: f.path, fileMtimeMs: f.mtimeMs, fileSize: f.size });
+        }
+    }
+}
+function readCursorChatMeta(filePath, sessionId) {
+    const projectDir = path.dirname(path.dirname(path.dirname(filePath)));
+    const projectsDir = path.dirname(projectDir);
+    const chatsDir = path.join(path.dirname(projectsDir), 'chats');
+    let workspaceHashes;
+    try {
+        workspaceHashes = fs.readdirSync(chatsDir);
+    }
+    catch {
+        return undefined;
+    }
+    for (const workspaceHash of workspaceHashes) {
+        const metaPath = path.join(chatsDir, workspaceHash, sessionId, 'meta.json');
+        try {
+            return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        }
+        catch {
+            // This workspace hash does not own the session, or its metadata is unreadable.
+        }
+    }
+    return undefined;
+}
+/** Parse one Cursor transcript and enrich it with the matching chat meta.json. */
+export function readCursorMeta(filePath, currentVersion) {
+    const sessionId = path.basename(filePath).replace(/\.jsonl$/, '');
+    if (!sessionId || path.basename(path.dirname(filePath)) !== sessionId)
+        return null;
+    const events = parseCursor(filePath);
+    if (events.length === 0)
+        return null;
+    const chatMeta = readCursorChatMeta(filePath, sessionId);
+    const stat = safeStatSync(filePath);
+    const createdAtMs = typeof chatMeta?.createdAtMs === 'number' ? chatMeta.createdAtMs : undefined;
+    const updatedAtMs = typeof chatMeta?.updatedAtMs === 'number' ? chatMeta.updatedAtMs : undefined;
+    const timestamp = createdAtMs !== undefined
+        ? new Date(createdAtMs).toISOString()
+        : stat ? stat.mtime.toISOString() : new Date().toISOString();
+    const lastActivity = updatedAtMs !== undefined
+        ? new Date(updatedAtMs).toISOString()
+        : stat ? stat.mtime.toISOString() : timestamp;
+    const cwd = normalizeCwd(typeof chatMeta?.cwd === 'string' ? chatMeta.cwd : '');
+    const userTexts = events
+        .filter((event) => event.type === 'message' && event.role === 'user' && event.content)
+        .map((event) => event.content);
+    const firstUserText = userTexts[0];
+    const title = typeof chatMeta?.title === 'string' && chatMeta.title.trim()
+        ? chatMeta.title.trim()
+        : undefined;
+    const meta = {
+        id: sessionId,
+        shortId: deriveShortId(sessionId),
+        agent: 'cursor',
+        timestamp,
+        lastActivity,
+        project: cwd ? path.basename(cwd) : undefined,
+        cwd,
+        filePath,
+        version: resolveSessionVersion('cursor', filePath, undefined, currentVersion),
+        topic: firstUserText ? extractSessionTopic(firstUserText) : undefined,
+        label: title,
+        messageCount: events.filter((event) => event.type === 'message').length,
+    };
+    return { meta, content: userTexts.join('\n') };
+}
+// ---------------------------------------------------------------------------
 // Kimi
 // ---------------------------------------------------------------------------
 // Kimi stores sessions under ~/.kimi-code/sessions/<workdir_hash>/session_<uuid>/.

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

@@ -109,6 +109,8 @@ export declare function parseRush(filePath: string): SessionEvent[];
 export declare function parseHermes(filePath: string): SessionEvent[];
 /** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */
 export declare function parseKimi(filePath: string): SessionEvent[];
+/** Parse Cursor's Anthropic-shaped message JSONL transcript. */
+export declare function parseCursor(filePath: string): SessionEvent[];
 /**
  * Parse a Droid (Factory) JSONL session file into normalized events. Droid
  * wraps each turn in a `{type:'message', message:{role, content, modelId}}`

package/dist/lib/session/parse.js

@@ -154,6 +154,9 @@ export function parseSession(filePath, agent) {
         case 'droid':
             events = parseDroid(filePath);
             break;
+        case 'cursor':
+            events = parseCursor(filePath);
+            break;
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
@@ -194,6 +197,8 @@ export function detectAgent(filePath) {
         return 'kimi';
     if (filePath.includes('/.factory/') || filePath.includes('\\.factory\\'))
         return 'droid';
+    if (filePath.includes('/.cursor/') || filePath.includes('\\.cursor\\'))
+        return 'cursor';
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
     const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
@@ -1617,20 +1622,45 @@ export function parseKimi(filePath) {
     return events;
 }
 // ---------------------------------------------------------------------------
-// Droid (Factory) parser
+// Cursor and Droid (Factory) parsers
 // ---------------------------------------------------------------------------
+/** Parse Cursor's Anthropic-shaped message JSONL transcript. */
+export function parseCursor(filePath) {
+    return parseAnthropicMessageJsonl(filePath, 'cursor');
+}
 /**
- * Parse a Droid (Factory) JSONL session file into normalized events. Droid
- * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
- * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
- * tool_result), so block handling mirrors the Claude parser.
+ * Cursor stamps the first user turn as
+ * `<timestamp>Sunday, Aug 2, 2026, 3:51 AM (UTC-7)</timestamp>` followed by the
+ * real question in `<user_query>`. `Date.parse` silently DISCARDS the `(UTC-7)`
+ * parenthetical and reads the rest as local time, so the offset has to be applied
+ * by hand — otherwise the recovered instant is wrong on every machine whose zone
+ * differs from the one that wrote the transcript.
  */
-export function parseDroid(filePath) {
+function parseCursorUserText(text) {
+    const query = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
+    const stamp = text.match(/<timestamp>\s*([\s\S]*?)\s*<\/timestamp>/)?.[1]?.trim();
+    return { text: (query?.[1] ?? text).trim(), timestamp: parseCursorTimestamp(stamp) };
+}
+function parseCursorTimestamp(stamp) {
+    if (!stamp)
+        return undefined;
+    const offset = stamp.match(/\(UTC([+-])(\d{1,2})(?::(\d{2}))?\)/);
+    // Without a declared offset there is no instant to recover -- guessing the
+    // local zone would be worse than falling back to the file mtime.
+    if (!offset)
+        return undefined;
+    const wall = Date.parse(`${stamp.replace(/\s*\(UTC[^)]*\)\s*/, " ").trim()} UTC`);
+    if (Number.isNaN(wall))
+        return undefined;
+    const offsetMs = (Number(offset[2]) * 60 + Number(offset[3] ?? 0)) * 60_000;
+    return new Date(offset[1] === "-" ? wall + offsetMs : wall - offsetMs).toISOString();
+}
+function parseAnthropicMessageJsonl(filePath, agent) {
     const content = safeReadSessionFile(filePath);
     const lines = content.split('\n').filter(l => l.trim());
     const events = [];
-    // Map tool_use id -> {tool, args} for correlating with tool_result.
     const toolUseMap = new Map();
+    const fallbackTimestamp = fs.statSync(filePath).mtime.toISOString();
     for (const line of lines) {
         let raw;
         try {
@@ -1639,33 +1669,42 @@ export function parseDroid(filePath) {
         catch {
             continue;
         }
-        if (raw.type !== 'message')
+        if (raw.type === 'turn_ended' || (agent === 'droid' && raw.type !== 'message'))
             continue;
-        const message = raw.message || {};
-        const role = message.role === 'user' ? 'user' : 'assistant';
-        const timestamp = raw.timestamp || new Date().toISOString();
+        const message = raw.message;
+        const wireRole = agent === 'cursor' ? raw.role : message?.role;
+        if (!message || (agent === 'cursor' && !['user', 'assistant'].includes(wireRole)))
+            continue;
+        const role = wireRole === 'user' ? 'user' : 'assistant';
+        let timestamp = raw.timestamp || fallbackTimestamp;
         const blocks = message.content;
-        // Plain-string content (rare) renders as a single message.
         if (typeof blocks === 'string') {
-            const text = blocks.trim();
+            const parsed = agent === 'cursor' && role === 'user'
+                ? parseCursorUserText(blocks)
+                : { text: blocks.trim(), timestamp: undefined };
+            const text = parsed.text;
+            timestamp = parsed.timestamp || timestamp;
             if (text)
-                events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                events.push({ type: 'message', agent, timestamp, role, content: text });
             continue;
         }
         if (!Array.isArray(blocks))
             continue;
         for (const block of blocks) {
             if (block.type === 'text') {
-                const text = (block.text || '').trim();
-                // Skip injected context blocks (date, skills list) on the first user turn.
+                const parsed = agent === 'cursor' && role === 'user'
+                    ? parseCursorUserText(block.text || '')
+                    : { text: (block.text || '').trim(), timestamp: undefined };
+                const text = parsed.text;
+                timestamp = parsed.timestamp || timestamp;
                 if (text && !(role === 'user' && text.startsWith('<system-reminder>'))) {
-                    events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                    events.push({ type: 'message', agent, timestamp, role, content: text });
                 }
             }
             else if (block.type === 'thinking') {
                 const thinkingText = (block.thinking || '').trim();
                 if (thinkingText)
-                    events.push({ type: 'thinking', agent: 'droid', timestamp, content: thinkingText });
+                    events.push({ type: 'thinking', agent, timestamp, content: thinkingText });
             }
             else if (block.type === 'tool_use') {
                 const toolName = block.name || 'unknown';
@@ -1674,38 +1713,29 @@ export function parseDroid(filePath) {
                     toolUseMap.set(block.id, { tool: toolName, args: toolInput });
                 events.push({
                     type: 'tool_use',
-                    agent: 'droid',
+                    agent,
                     timestamp,
                     tool: toolName,
                     args: toolInput,
                     path: toolInput.file_path || toolInput.path || undefined,
-                    command: (toolName === 'Bash' || toolName === 'Execute') ? toolInput.command : undefined,
+                    command: (toolName === 'Bash' || toolName === 'Execute' || toolName === 'Shell') ? toolInput.command : undefined,
                 });
             }
             else if (block.type === 'tool_result') {
                 const toolId = block.tool_use_id;
                 const toolInfo = toolId ? toolUseMap.get(toolId) : undefined;
                 const isError = block.is_error === true;
-                let output = '';
-                if (typeof block.content === 'string') {
-                    output = block.content;
-                }
-                else if (Array.isArray(block.content)) {
-                    output = block.content
-                        .filter((c) => c.type === 'text')
-                        .map((c) => c.text || '')
-                        .join('\n');
-                }
+                const output = typeof block.content === 'string'
+                    ? block.content
+                    : Array.isArray(block.content)
+                        ? block.content.filter((c) => c.type === 'text').map((c) => c.text || '').join('\n')
+                        : '';
                 if (isError) {
-                    events.push({ type: 'error', agent: 'droid', timestamp, tool: toolInfo?.tool, content: output || 'Tool execution failed' });
+                    events.push({ type: 'error', agent, timestamp, tool: toolInfo?.tool, content: output || 'Tool execution failed' });
                 }
                 else {
                     events.push({
-                        type: 'tool_result',
-                        agent: 'droid',
-                        timestamp,
-                        tool: toolInfo?.tool,
-                        success: true,
+                        type: 'tool_result', agent, timestamp, tool: toolInfo?.tool, success: true,
                         output: output.length > 500 ? output.slice(0, 497) + '...' : output,
                     });
                 }
@@ -1715,9 +1745,18 @@ export function parseDroid(filePath) {
             else if (block.type === 'image') {
                 const source = block.source || {};
                 const sizeBytes = source.type === 'base64' ? Math.ceil((source.data?.length || 0) * 0.75) : 0;
-                events.push(normalizedAttachmentEvent('droid', timestamp, block, source, 'image/png', sizeBytes));
+                events.push(normalizedAttachmentEvent(agent, timestamp, block, source, 'image/png', sizeBytes));
             }
         }
     }
     return events;
 }
+/**
+ * Parse a Droid (Factory) JSONL session file into normalized events. Droid
+ * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
+ * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
+ * tool_result), so block handling mirrors the Claude parser.
+ */
+export function parseDroid(filePath) {
+    return parseAnthropicMessageJsonl(filePath, 'droid');
+}

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.js

@@ -201,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();
@@ -259,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[];