@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/session/stream-render.d.ts

@@ -1,4 +0,0 @@
-import type { SessionAgentId } from './types.js';
-type StreamLineRenderer = (line: string) => string | null;
-export declare function makeStreamRenderer(agent: SessionAgentId, cwd?: string): StreamLineRenderer;
-export {};

package/dist/lib/session/stream-render.js

@@ -1,131 +0,0 @@
-import chalk from 'chalk';
-import { truncate } from '../format.js';
-import { parseClaudeContent, parseCodexContent, sanitizeEvents, summarizeToolUse } from './parse.js';
-import { linkPath, relativeToCwd } from './render.js';
-import { isShellExecTool } from './shell-programs.js';
-const LINE_MAX = 120;
-function timeOf(event) {
-    const d = new Date(event.timestamp);
-    if (Number.isNaN(d.getTime()))
-        return '00:00:00';
-    return d.toTimeString().slice(0, 8);
-}
-function paintTool(tool) {
-    const label = tool.padEnd(10);
-    if (isShellExecTool(tool))
-        return chalk.yellow(label);
-    if (tool === 'Edit' || tool === 'Write' || tool === 'Read')
-        return chalk.cyan(label);
-    if (tool === 'Agent')
-        return chalk.magenta(label);
-    return chalk.cyan(label);
-}
-function formatPath(absPath, cwd) {
-    const label = relativeToCwd(absPath, cwd);
-    return absPath.startsWith('/') ? linkPath(absPath, label) : label;
-}
-function splitToolSummary(tool, summary, event, cwd) {
-    if (event.path)
-        return formatPath(event.path, cwd);
-    const prefix = `${tool}: `;
-    if (summary.startsWith(prefix))
-        return summary.slice(prefix.length);
-    const spacedPrefix = `${tool} `;
-    if (summary.startsWith(spacedPrefix))
-        return summary.slice(spacedPrefix.length);
-    return summary === tool ? '' : summary;
-}
-function lineCount(text) {
-    if (!text)
-        return 0;
-    return text.split(/\r?\n/).length;
-}
-function plural(n, word) {
-    return `${n} ${word}${n === 1 ? '' : 's'}`;
-}
-function claudeToolResultLines(raw) {
-    if (raw?.type !== 'user' || !Array.isArray(raw?.message?.content))
-        return undefined;
-    const block = raw.message.content.find((b) => b?.type === 'tool_result');
-    if (!block)
-        return undefined;
-    if (typeof block.content === 'string')
-        return lineCount(block.content);
-    if (Array.isArray(block.content)) {
-        const text = block.content
-            .filter((c) => c?.type === 'text')
-            .map((c) => c.text || '')
-            .join('\n');
-        return lineCount(text);
-    }
-    return 0;
-}
-function codexToolResultLines(raw) {
-    if (raw?.type !== 'response_item')
-        return undefined;
-    const ptype = raw?.payload?.type;
-    if (ptype !== 'function_call_output' && ptype !== 'custom_tool_call_output')
-        return undefined;
-    return lineCount(String(raw.payload.output || ''));
-}
-function rawToolResultLines(line, agent) {
-    try {
-        const raw = JSON.parse(line);
-        return agent === 'codex' ? codexToolResultLines(raw) : claudeToolResultLines(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
-function renderEvent(event, cwd, lastTool, resultLines) {
-    const prefix = chalk.dim(`${timeOf(event)}  `);
-    switch (event.type) {
-        case 'message': {
-            const marker = event.role === 'user' ? chalk.blue('» you       ') : chalk.green(`· ${event.agent.padEnd(9)}`);
-            return prefix + marker + truncate((event.content || '').replace(/\s+/g, ' ').trim(), LINE_MAX);
-        }
-        case 'tool_use': {
-            const tool = event.tool || 'unknown';
-            const summary = summarizeToolUse(tool, event.args);
-            const detail = splitToolSummary(tool, summary, event, cwd);
-            return prefix + chalk.yellow('→ ') + paintTool(tool) + chalk.gray(truncate(detail.replace(/\s+/g, ' ').trim(), LINE_MAX));
-        }
-        case 'tool_result': {
-            const tool = event.tool || lastTool || 'tool';
-            const count = resultLines ?? lineCount(event.output || '');
-            const status = event.success === false ? chalk.red('✗ ') : chalk.green('✓ ');
-            return prefix + status + paintTool(tool) + chalk.dim(`(result elided — ${plural(count, 'line')})`);
-        }
-        case 'error': {
-            const label = event.tool ? `${event.tool}: ` : '';
-            return prefix + chalk.red('✗ Error     ') + chalk.gray(truncate((label + (event.content || '')).replace(/\s+/g, ' ').trim(), LINE_MAX));
-        }
-        case 'thinking':
-        case 'usage':
-        case 'init':
-        case 'result':
-            return null;
-        default:
-            return null;
-    }
-}
-export function makeStreamRenderer(agent, cwd) {
-    const parse = agent === 'codex' ? parseCodexContent : parseClaudeContent;
-    let lastTool;
-    return (line) => {
-        const events = parse(line);
-        sanitizeEvents(events);
-        if (events.length === 0)
-            return null;
-        const resultLines = rawToolResultLines(line, agent);
-        const rendered = [];
-        for (const event of events) {
-            const out = renderEvent(event, cwd, lastTool, resultLines);
-            if (event.type === 'tool_use' && event.tool)
-                lastTool = event.tool;
-            if (out)
-                rendered.push(out);
-        }
-        return rendered.length ? rendered.join('\n') : null;
-    };
-}

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

@@ -1,88 +0,0 @@
-/**
- * Fast tail read of a session transcript.
- *
- * The live `--active` view needs the *last* few events of a possibly-huge JSONL
- * to infer state — parsing the whole file per row would make the view crawl. We
- * read only the final chunk from an fd (mirroring the bounded head-read in
- * active.ts's `quickExtractTopic`), drop a partial leading line, and hand the
- * chunk to the existing content parsers so there's zero duplicated parse logic.
- */
-import type { SessionAgentId, SessionEvent } from './types.js';
-/** A tail read: the last few normalized events plus the raw text they came from. */
-interface SessionTail {
-    events: SessionEvent[];
-    /** The raw JSONL chunk (leading partial line dropped), for content-level math. */
-    content: string;
-}
-/**
- * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
- * begins mid-file yields one malformed leading line, which is dropped here so
- * downstream per-line parsers only see whole lines. Returns '' on any error or
- * empty file.
- */
-export declare function readSessionTailContent(filePath: string, maxBytes?: number): string;
-/**
- * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events *and* the raw text they were parsed from — the
- * raw text feeds content-level readouts (e.g. token throughput) that need the
- * lines the event model discards (Codex `token_count`). Only Claude and Codex
- * are supported (the prioritized harnesses for live state); other agents return
- * an empty tail.
- */
-export declare function readSessionTailWithRaw(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionTail;
-/**
- * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
- * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
- */
-export declare function readSessionTail(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionEvent[];
-/**
- * Read the FIRST `maxBytes` of a JSONL transcript as cleaned text — the mirror
- * of {@link readSessionTailContent}, for recovering the session's ACTUAL
- * original request boundedly when it isn't already indexed
- * (`SessionMeta.firstUserMessage`). Returns '' on any error, an empty file, or
- * a first record too large to fit `maxBytes` (bare — no elision fallback; see
- * {@link readSessionHeadContentBounded} for that).
- */
-export declare function readSessionHeadContent(filePath: string, maxBytes?: number): string;
-/**
- * Recover the transcript's opening JSONL record even when it doesn't fit the
- * plain {@link DEFAULT_HEAD_MAX_BYTES} chunk — the case a first turn carrying
- * a multi-megabyte inline image produces, where the record's own closing
- * newline sits past whatever small chunk was read, so the old bare head
- * reader dropped the WHOLE record (and with it, the real original request)
- * rather than the oversized value inside it.
- *
- * Only invoked when the cheap path already failed to find a complete line
- * (bounded — see {@link readSessionHeadChunk}'s `sawEof`), so an ordinary
- * transcript never pays this cost. Reads up to {@link HEAD_ELISION_MAX_READ_BYTES}
- * from byte 0, runs it through {@link elideOversizedJsonStrings} (bounded by
- * {@link HEAD_ELISION_MAX_MS}), and returns the first complete elided line —
- * text before and after the oversized value is preserved verbatim (only the
- * oversized value itself is shortened), UTF-8 decoding and escape handling
- * both go through the exact same path an unelided record would. Returns ''
- * (a partial result, not a guess) when the scan is cut off by either budget
- * before a complete line was ever produced — never a followup/tail turn
- * substituted for it.
- */
-export declare function readSessionHeadContentBounded(filePath: string, maxReadBytes?: number): string;
-/**
- * Read the FIRST `maxEvents` normalized events from a JSONL transcript's
- * head — the session's actual opening turns, bounded and cheap (one small
- * read from byte 0, the same shared Claude/Codex content parsers `readSessionTail`
- * uses, zero duplicated parse logic). Only Claude and Codex are supported,
- * matching {@link readSessionTailWithRaw}; other agents return no events.
- *
- * When the plain bounded chunk holds no complete first line at all — an
- * opening user turn embedding a multi-megabyte inline image is the real case
- * this covers — falls back to {@link readSessionHeadContentBounded}'s
- * JSON-aware elision scan rather than returning nothing: the same content
- * parsers then see a syntactically valid record with the oversized value
- * shortened, so a text block before or after an elided image block is
- * recovered exactly as if the image had never been oversized (the parser's
- * own image-handling path, e.g. Claude's `normalizedAttachmentEvent`, still
- * runs — it just sees a short placeholder `source.data` instead of the real
- * payload, so an attachment's derived byte size is not meaningful when this
- * fallback fired, only the surrounding TEXT is trustworthy).
- */
-export declare function readSessionHead(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionEvent[];
-export {};

package/dist/lib/session/tail.js

@@ -1,294 +0,0 @@
-/**
- * Fast tail read of a session transcript.
- *
- * The live `--active` view needs the *last* few events of a possibly-huge JSONL
- * to infer state — parsing the whole file per row would make the view crawl. We
- * read only the final chunk from an fd (mirroring the bounded head-read in
- * active.ts's `quickExtractTopic`), drop a partial leading line, and hand the
- * chunk to the existing content parsers so there's zero duplicated parse logic.
- */
-import * as fs from 'fs';
-import { parseClaudeContent, parseCodexContent, sanitizeEvents } from './parse.js';
-const DEFAULT_MAX_BYTES = 128 * 1024;
-const DEFAULT_MAX_EVENTS = 60;
-/**
- * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
- * begins mid-file yields one malformed leading line, which is dropped here so
- * downstream per-line parsers only see whole lines. Returns '' on any error or
- * empty file.
- */
-export function readSessionTailContent(filePath, maxBytes = DEFAULT_MAX_BYTES) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, 'r');
-    }
-    catch {
-        return '';
-    }
-    try {
-        const size = fs.fstatSync(fd).size;
-        if (size === 0)
-            return '';
-        const start = Math.max(0, size - maxBytes);
-        const len = size - start;
-        const buf = Buffer.alloc(len);
-        fs.readSync(fd, buf, 0, len, start);
-        let content = buf.toString('utf8');
-        // If we started mid-file, the first line is almost certainly partial — drop it.
-        if (start > 0) {
-            const nl = content.indexOf('\n');
-            content = nl >= 0 ? content.slice(nl + 1) : '';
-        }
-        return content;
-    }
-    catch {
-        return '';
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-/**
- * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events *and* the raw text they were parsed from — the
- * raw text feeds content-level readouts (e.g. token throughput) that need the
- * lines the event model discards (Codex `token_count`). Only Claude and Codex
- * are supported (the prioritized harnesses for live state); other agents return
- * an empty tail.
- */
-export function readSessionTailWithRaw(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
-    if (agent !== 'claude' && agent !== 'codex')
-        return { events: [], content: '' };
-    const content = readSessionTailContent(filePath, maxBytes);
-    if (!content.trim())
-        return { events: [], content: '' };
-    const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
-    sanitizeEvents(events);
-    return { events: events.length > maxEvents ? events.slice(-maxEvents) : events, content };
-}
-/**
- * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
- * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
- */
-export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
-    return readSessionTailWithRaw(filePath, agent, maxBytes, maxEvents).events;
-}
-/** A session's original first turn is typically within the first few KiB —
- * far smaller than the tail window, since it's exactly one line near the
- * start of the file, not a rolling window of recent activity. */
-const DEFAULT_HEAD_MAX_BYTES = 32 * 1024;
-/**
- * Read exactly the first `maxBytes` of the file and, if that chunk doesn't
- * reach EOF, drop a trailing partial line so downstream per-line parsers only
- * see whole lines. This is the plain, cheap path — correct and unchanged for
- * the overwhelming majority of transcripts, where the opening JSONL record is
- * a few hundred bytes. Returns '' on any error, an empty file, or a chunk that
- * turned out to hold no complete line at all (the record is bigger than
- * `maxBytes`) — callers needing to recover from THAT case use
- * {@link readSessionHeadContentBounded}, not this.
- */
-function readSessionHeadChunk(filePath, maxBytes) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, 'r');
-    }
-    catch {
-        return undefined;
-    }
-    try {
-        const size = fs.fstatSync(fd).size;
-        if (size === 0)
-            return { content: '', sawEof: true };
-        const len = Math.min(size, maxBytes);
-        const buf = Buffer.alloc(len);
-        fs.readSync(fd, buf, 0, len, 0);
-        return { content: buf.toString('utf8'), sawEof: len >= size };
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-/**
- * Read the FIRST `maxBytes` of a JSONL transcript as cleaned text — the mirror
- * of {@link readSessionTailContent}, for recovering the session's ACTUAL
- * original request boundedly when it isn't already indexed
- * (`SessionMeta.firstUserMessage`). Returns '' on any error, an empty file, or
- * a first record too large to fit `maxBytes` (bare — no elision fallback; see
- * {@link readSessionHeadContentBounded} for that).
- */
-export function readSessionHeadContent(filePath, maxBytes = DEFAULT_HEAD_MAX_BYTES) {
-    const chunk = readSessionHeadChunk(filePath, maxBytes);
-    if (!chunk)
-        return '';
-    let content = chunk.content;
-    if (!chunk.sawEof) {
-        // Didn't reach EOF: the last line in this chunk may be a partial write
-        // of a longer record. Keep only whole lines.
-        const lastNl = content.lastIndexOf('\n');
-        content = lastNl >= 0 ? content.slice(0, lastNl) : '';
-    }
-    return content;
-}
-/**
- * Hard ceiling on how far {@link readSessionHeadContentBounded} will read
- * looking for the opening record's closing newline. A JSONL record is one
- * line, so a user turn that embeds a multi-megabyte image (base64, inline in
- * the same `"data": "..."` string) can push that line's own terminator
- * arbitrarily far past the plain {@link DEFAULT_HEAD_MAX_BYTES} chunk — this
- * is the point past which the record is treated as unrecoverable (`partial`),
- * never guessed at from a truncated fragment.
- */
-const HEAD_ELISION_MAX_READ_BYTES = 4 * 1024 * 1024;
-/** Keep at most this many UTF-16 units of any single JSON string value
- * verbatim; the remainder is replaced with a short marker. Bounds the ELIDED
- * OUTPUT size independent of how large the source string (an image's base64
- * payload can be tens of megabytes) actually is, while staying far larger
- * than any real first-turn text block ever needs to be. */
-const HEAD_ELISION_STRING_KEEP_UNITS = 2048;
-/** Wall-clock ceiling on the elision scan itself. The scan runs over data
- * already bounded by {@link HEAD_ELISION_MAX_READ_BYTES} and does O(1) work
- * per character, so this should never trip in practice — it exists as a
- * defense-in-depth budget, not the primary bound. */
-const HEAD_ELISION_MAX_MS = 200;
-/** How many characters the elision scan advances between wall-clock checks —
- * frequent enough that the time budget above is actually honored, infrequent
- * enough that `Date.now()` isn't on the hot path of every character. */
-const HEAD_ELISION_TIME_CHECK_MASK = 0x3ffff; // every ~262k chars
-/**
- * A single-pass, JSON-string-aware elision scan: copies `input` verbatim
- * except inside a string literal whose content exceeds
- * {@link HEAD_ELISION_STRING_KEEP_UNITS}, where it keeps a short prefix and
- * splices in a `…[elided N chars]` marker for the rest — but still tracks
- * escape/quote state through to that string's real closing quote, so
- * surrounding JSON structure (a text block that follows an oversized image
- * block in the same content array) stays syntactically valid. This is a
- * generic JSON-string eliser, not an image-specific one: it does not care
- * WHAT is inside the oversized string, only that it is too large to keep.
- *
- * `deadlineMs` is an absolute `Date.now()` value. `truncatedByBudget: true`
- * means the scan did not finish (ran out of time) — critically, the output
- * up to that point NEVER includes the unflushed tail of a string that had
- * already crossed the elision threshold (the flush happens once, the moment
- * the threshold is crossed, not at the closing quote), so a cutoff mid-scan
- * can never smuggle megabytes of un-elided content into the result.
- */
-function elideOversizedJsonStrings(input, deadlineMs) {
-    const outParts = [];
-    let spanStart = 0;
-    let inString = false;
-    let escaped = false;
-    let stringStart = 0;
-    let skipping = false; // current string already crossed the keep threshold
-    const n = input.length;
-    for (let i = 0; i < n; i++) {
-        if ((i & HEAD_ELISION_TIME_CHECK_MASK) === 0 && Date.now() > deadlineMs) {
-            if (!skipping)
-                outParts.push(input.slice(spanStart, i));
-            return { text: outParts.join(''), truncatedByBudget: true };
-        }
-        const ch = input.charCodeAt(i);
-        if (!inString) {
-            if (ch === 0x22 /* '"' */) {
-                inString = true;
-                stringStart = i + 1;
-                skipping = false;
-            }
-            continue;
-        }
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (ch === 0x5c /* '\\' */) {
-            escaped = true;
-            continue;
-        }
-        if (ch === 0x22 /* '"' */) {
-            inString = false;
-            if (skipping) {
-                const elidedUnits = i - stringStart - HEAD_ELISION_STRING_KEEP_UNITS;
-                outParts.push(`…[elided ${elidedUnits} chars]`);
-                spanStart = i; // resume normal copying AT the closing quote
-                skipping = false; // the string is closed; the final flush must still emit the record's own tail ("}\n) even when this was the last string literal
-            }
-            continue;
-        }
-        if (!skipping && (i - stringStart) === HEAD_ELISION_STRING_KEEP_UNITS) {
-            outParts.push(input.slice(spanStart, i)); // flush the kept prefix now
-            skipping = true;
-        }
-    }
-    if (!skipping)
-        outParts.push(input.slice(spanStart, n));
-    return { text: outParts.join(''), truncatedByBudget: false };
-}
-/**
- * Recover the transcript's opening JSONL record even when it doesn't fit the
- * plain {@link DEFAULT_HEAD_MAX_BYTES} chunk — the case a first turn carrying
- * a multi-megabyte inline image produces, where the record's own closing
- * newline sits past whatever small chunk was read, so the old bare head
- * reader dropped the WHOLE record (and with it, the real original request)
- * rather than the oversized value inside it.
- *
- * Only invoked when the cheap path already failed to find a complete line
- * (bounded — see {@link readSessionHeadChunk}'s `sawEof`), so an ordinary
- * transcript never pays this cost. Reads up to {@link HEAD_ELISION_MAX_READ_BYTES}
- * from byte 0, runs it through {@link elideOversizedJsonStrings} (bounded by
- * {@link HEAD_ELISION_MAX_MS}), and returns the first complete elided line —
- * text before and after the oversized value is preserved verbatim (only the
- * oversized value itself is shortened), UTF-8 decoding and escape handling
- * both go through the exact same path an unelided record would. Returns ''
- * (a partial result, not a guess) when the scan is cut off by either budget
- * before a complete line was ever produced — never a followup/tail turn
- * substituted for it.
- */
-export function readSessionHeadContentBounded(filePath, maxReadBytes = HEAD_ELISION_MAX_READ_BYTES) {
-    const chunk = readSessionHeadChunk(filePath, maxReadBytes);
-    if (!chunk || !chunk.content)
-        return '';
-    const { text, truncatedByBudget } = elideOversizedJsonStrings(chunk.content, Date.now() + HEAD_ELISION_MAX_MS);
-    const firstNl = text.indexOf('\n');
-    if (firstNl >= 0)
-        return text.slice(0, firstNl);
-    // No line terminator found anywhere in the elided text: either the record
-    // (minus its oversized values) is STILL bigger than the read budget, or the
-    // elision scan itself hit its time budget first, or we reached real EOF
-    // with no trailing newline at all (a truncated/interrupted write).
-    if (truncatedByBudget)
-        return '';
-    return chunk.sawEof ? text : '';
-}
-/**
- * Read the FIRST `maxEvents` normalized events from a JSONL transcript's
- * head — the session's actual opening turns, bounded and cheap (one small
- * read from byte 0, the same shared Claude/Codex content parsers `readSessionTail`
- * uses, zero duplicated parse logic). Only Claude and Codex are supported,
- * matching {@link readSessionTailWithRaw}; other agents return no events.
- *
- * When the plain bounded chunk holds no complete first line at all — an
- * opening user turn embedding a multi-megabyte inline image is the real case
- * this covers — falls back to {@link readSessionHeadContentBounded}'s
- * JSON-aware elision scan rather than returning nothing: the same content
- * parsers then see a syntactically valid record with the oversized value
- * shortened, so a text block before or after an elided image block is
- * recovered exactly as if the image had never been oversized (the parser's
- * own image-handling path, e.g. Claude's `normalizedAttachmentEvent`, still
- * runs — it just sees a short placeholder `source.data` instead of the real
- * payload, so an attachment's derived byte size is not meaningful when this
- * fallback fired, only the surrounding TEXT is trustworthy).
- */
-export function readSessionHead(filePath, agent, maxBytes = DEFAULT_HEAD_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
-    if (agent !== 'claude' && agent !== 'codex')
-        return [];
-    let content = readSessionHeadContent(filePath, maxBytes);
-    if (!content.trim())
-        content = readSessionHeadContentBounded(filePath);
-    if (!content.trim())
-        return [];
-    const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
-    sanitizeEvents(events);
-    return events.length > maxEvents ? events.slice(0, maxEvents) : events;
-}

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

@@ -1,129 +0,0 @@
-/**
- * Classification and filtering of team-spawned sessions.
- *
- * Sessions launched by `agents teams` carry an 'sdk-cli' entrypoint and
- * optionally have a meta.json with handle/mode info. This module determines
- * whether a session is team-origin and splits session lists into visible
- * and hidden groups for the picker UI.
- */
-import type { SessionMeta, TeamOrigin } from './types.js';
-/**
- * Determine whether `session` was spawned by `agents teams`.
- *
- * 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/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. */
-interface FilterResult {
-    visible: SessionMeta[];
-    hiddenCount: number;
-}
-/**
- * Whether a listing scope must retain team-origin sessions.
- *
- * A routine owns every session produced during its run, including teammates and
- * SDK-launched children. Requiring callers to add `--teams` would make a routine
- * catalog incomplete and can make team-heavy routines appear to have no runs.
- */
-export declare function shouldShowTeamSessions(filters: {
-    teams?: boolean;
-    routine?: boolean | string;
-}): boolean;
-/**
- * Split `sessions` into visible and hidden (team-origin) groups.
- * When `showTeams` is true every session is visible and `teamOrigin` is
- * populated on team sessions for display. When false, team sessions are
- * excluded and counted in `hiddenCount`.
- */
-export declare function filterTeamSessions(sessions: SessionMeta[], showTeams: boolean): FilterResult;
-/**
- * Whether a team-origin session is a real `agents teams` teammate or a bare SDK
- * spawn with no teammate record. The two share the `sdk-cli` entrypoint that
- * sets `isTeamOrigin`, so they are told apart by whether a `meta.json` teammate
- * record backs the origin ({@link TeamOrigin.source} === `'meta'`).
- *
- * `source` is newer than the rest of {@link TeamOrigin}, so a row that arrived
- * from a pre-`source` peer over the `--device` fan-out carries none. There the
- * meta-only fields settle it: the entrypoint fallback is a bare `{ handle }`, so
- * any `team` / `mode` / `parentSessionId` / `startedAt` means a real teammate
- * record produced it — otherwise a genuine teammate from an unupgraded peer
- * would be misfiled into the no-team bucket, the exact conflation this splits.
- */
-export declare function teamRowKind(origin: TeamOrigin | undefined): 'teammate' | 'subagent';
-/** A team-origin session with its resolved {@link TeamOrigin} guaranteed present. */
-type TeamSession = SessionMeta & {
-    teamOrigin: TeamOrigin;
-};
-/**
- * Key/label for the residual bucket — sessions flagged `isTeamOrigin` (an SDK /
- * `sdk-cli` entrypoint) that carry no teammate `meta.json`. In practice this is
- * headless `agents run` spawns and teammates whose team record aged out; a true
- * `Task` sub-agent's transcript is never indexed, so it cannot land here. Named
- * "(no team)" rather than "(sub-agents)" so the label matches what it holds.
- */
-export declare const NO_TEAM_GROUP_KEY = "(no team)";
-/** Key/label for teammates whose record carries no team name (`task_name`). */
-export declare const UNNAMED_TEAM_KEY = "(unnamed team)";
-/** One team's sessions, grouped for the `agents sessions --teams` view. */
-export interface TeamSessionGroup {
-    /**
-     * The grouping key: the team name, {@link UNNAMED_TEAM_KEY} for teammates that
-     * carry no `task_name`, or {@link NO_TEAM_GROUP_KEY} for the residual bucket.
-     */
-    key: string;
-    /** A named team of `agents teams` teammates vs the catch-all no-team bucket. */
-    kind: 'team' | 'noTeam';
-    /** Team name when this is a named team, else undefined. */
-    team?: string;
-    /**
-     * The orchestrator session id that spawned this team (`parent_session_id`),
-     * when every teammate agrees on one. Undefined for the no-team bucket, an
-     * unparented team, or a group whose teammates disagree.
-     */
-    spawnerSessionId?: string;
-    /** The team's rows, newest-active first. */
-    sessions: TeamSession[];
-    /** Most-recent activity across the group, for ordering groups. */
-    maxTs: string;
-    /** Earliest spawn time across the group (`started_at`, else `timestamp`). */
-    firstSpawnTs: string;
-}
-/**
- * Group team-origin sessions for the `--teams` view: each named team becomes one
- * group of its teammates, and every bare SDK spawn with no teammate record falls
- * into a single trailing {@link NO_TEAM_GROUP_KEY} bucket, so a real teammate and
- * a bare spawn are never shown as the same thing.
- *
- * Only rows with a resolved {@link TeamOrigin} participate (the caller has
- * already run {@link filterTeamSessions}); any non-team session is ignored.
- * Groups are ordered newest-active first; sub-agents always sort last. Pure —
- * unit-tested.
- */
-export declare function groupSessionsByTeam(sessions: SessionMeta[]): TeamSessionGroup[];
-export {};