@clanker-code/pi-subagents 0.10.5

package/dist/skill-loader.js

@@ -0,0 +1,93 @@
+/**
+ * skill-loader.ts — Preload named skills.
+ *
+ * Roots, in precedence order:
+ *   - <cwd>/.pi/skills           (project, Pi's standard)
+ *   - <cwd>/.agents/skills       (project, cross-tool Agent Skills spec — https://agentskills.io)
+ *   - getAgentDir()/skills       (user, default ~/.pi/agent/skills — Pi's standard)
+ *   - ~/.agents/skills           (user, cross-tool Agent Skills spec)
+ *   - ~/.pi/skills               (legacy global, pre-Pi)
+ *
+ * Layout per root:
+ *   - <root>/<name>.md            (flat file at the top level)
+ *   - <root>/.../<name>/SKILL.md  (directory skill, may be nested — Pi's standard)
+ *
+ * Recursion skips dotfile entries and node_modules. A directory that itself contains
+ * SKILL.md is a skill — we don't descend into it (Pi: skills don't nest).
+ *
+ * Symlinks are rejected for security (deviation from Pi, which follows them).
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { isSymlink, isUnsafeName, safeReadFile } from "./memory.js";
+export function preloadSkills(skillNames, cwd) {
+    return skillNames.map((name) => ({ name, content: loadSkillContent(name, cwd) }));
+}
+function loadSkillContent(name, cwd) {
+    if (isUnsafeName(name)) {
+        return `(Skill "${name}" skipped: name contains path traversal characters)`;
+    }
+    const roots = [
+        join(cwd, ".pi", "skills"), // project — Pi standard
+        join(cwd, ".agents", "skills"), // project — Agent Skills spec
+        join(getAgentDir(), "skills"), // user — Pi standard
+        join(homedir(), ".agents", "skills"), // user — Agent Skills spec
+        join(homedir(), ".pi", "skills"), // legacy global, pre-Pi
+    ];
+    for (const root of roots) {
+        const content = findInRoot(root, name);
+        if (content !== undefined)
+            return content;
+    }
+    return `(Skill "${name}" not found in .pi/skills/, .agents/skills/, or global skill locations)`;
+}
+function findInRoot(root, name) {
+    if (isSymlink(root))
+        return undefined; // reject symlinked roots entirely
+    const flat = safeReadFile(join(root, `${name}.md`))?.trim();
+    if (flat !== undefined)
+        return flat;
+    return findSkillDirectory(root, name);
+}
+/** BFS under `root` for a directory named `name` containing `SKILL.md`. Pi-conforming filters. */
+function findSkillDirectory(root, name) {
+    if (!existsSync(root))
+        return undefined;
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        // Deterministic byte-order traversal — locale-independent.
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || entry.name === "node_modules")
+                continue;
+            // Symlinked dirs already filtered by entry.isDirectory() — Dirent uses lstat semantics.
+            const path = join(current, entry.name);
+            const skillMd = join(path, "SKILL.md");
+            const isSkillDir = existsSync(skillMd);
+            if (isSkillDir) {
+                if (entry.name === name) {
+                    const content = safeReadFile(skillMd)?.trim();
+                    if (content !== undefined)
+                        return content;
+                }
+                continue; // Pi rule: skills don't nest — don't descend into a skill dir
+            }
+            queue.push(path);
+        }
+    }
+    return undefined;
+}

package/dist/status-note.d.ts

@@ -0,0 +1,13 @@
+/**
+ * status-note.ts — Parenthetical status note appended to agent result text.
+ */
+/**
+ * Explicit parenthetical note for a non-normal terminal outcome, so the parent
+ * agent can't mistake partial output for a completed result. Empty string for a
+ * clean completion (and any unknown/non-terminal status).
+ *
+ * `stopped` (a human aborted it) is deliberately distinct from `aborted` (the
+ * turn limit was hit) — the parent should treat human intervention differently
+ * from a budget cutoff.
+ */
+export declare function getStatusNote(status: string): string;

package/dist/status-note.js

@@ -0,0 +1,24 @@
+/**
+ * status-note.ts — Parenthetical status note appended to agent result text.
+ */
+/**
+ * Explicit parenthetical note for a non-normal terminal outcome, so the parent
+ * agent can't mistake partial output for a completed result. Empty string for a
+ * clean completion (and any unknown/non-terminal status).
+ *
+ * `stopped` (a human aborted it) is deliberately distinct from `aborted` (the
+ * turn limit was hit) — the parent should treat human intervention differently
+ * from a budget cutoff.
+ */
+export function getStatusNote(status) {
+    switch (status) {
+        case "stopped":
+            return " (STOPPED BY THE USER before completion — output is partial; the task was NOT finished)";
+        case "aborted":
+            return " (aborted — hit the turn limit before completion; output may be incomplete)";
+        case "steered":
+            return " (wrapped up at the turn limit — output may be partial)";
+        default:
+            return "";
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,184 @@
+/**
+ * types.ts — Type definitions for the subagent system.
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { LifetimeUsage } from "./usage.js";
+export type { ThinkingLevel };
+/** Agent type: any string name (built-in defaults or user-defined). */
+export type SubagentType = string;
+/** Names of the three embedded default agents. */
+export declare const DEFAULT_AGENT_NAMES: readonly ["general-purpose", "Explore", "Plan"];
+/** Maximum recursive subagent depth. Parent/orchestrator is depth 0; agents may run at depths 1..4. */
+export declare const MAX_RECURSIVE_DEPTH = 4;
+/** Memory scope for persistent agent memory. */
+export type MemoryScope = "user" | "project" | "local";
+/** Isolation mode for agent execution. */
+export type IsolationMode = "worktree";
+/** Unified agent configuration — used for both default and user-defined agents. */
+export interface AgentConfig {
+    name: string;
+    displayName?: string;
+    description: string;
+    builtinToolNames?: string[];
+    /** Raw `ext:` selector entries from the `tools:` CSV, e.g. ["ext:foo", "ext:bar/x"].
+     * Presence of any entry flips extension tools to an explicit allowlist. */
+    extSelectors?: string[];
+    /** Tool denylist — these tools are removed even if `builtinToolNames` or extensions include them. */
+    disallowedTools?: string[];
+    /** true = inherit all, string[] = only listed, false = none */
+    extensions: true | string[] | false;
+    /** Extension-name denylist applied after the `extensions:` include set. Exclude wins.
+     * Plain canonical names only (case-insensitive); no paths, no wildcard. */
+    excludeExtensions?: string[];
+    /** true = inherit all, string[] = only listed, false = none */
+    skills: true | string[] | false;
+    model?: string;
+    thinking?: ThinkingLevel;
+    maxTurns?: number;
+    systemPrompt: string;
+    promptMode: "replace" | "append";
+    /** Default for spawn: fork parent conversation. undefined = caller decides. */
+    inheritContext?: boolean;
+    /** Default for spawn: run in background. undefined = caller decides.
+     *  NOTE: this fork always runs agents in the background, so a configured value
+     *  here is accepted (frontmatter/RPC) but ignored at spawn time. Kept on the
+     *  type for upstream/fixture compatibility. */
+    runInBackground?: boolean;
+    /** Default for spawn: no extension tools. undefined = caller decides. */
+    isolated?: boolean;
+    /** Persistent memory scope — agents with memory get a persistent directory and MEMORY.md */
+    memory?: MemoryScope;
+    /** Isolation mode — "worktree" runs the agent in a temporary git worktree */
+    isolation?: IsolationMode;
+    /** true = this is an embedded default agent (informational) */
+    isDefault?: boolean;
+    /** false = agent is hidden from the registry */
+    enabled?: boolean;
+    /** Where this agent was loaded from */
+    source?: "default" | "project" | "global";
+}
+export type JoinMode = 'async' | 'group' | 'smart';
+export interface AgentRecord {
+    id: string;
+    type: SubagentType;
+    description: string;
+    status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error";
+    result?: string;
+    error?: string;
+    toolUses: number;
+    startedAt: number;
+    completedAt?: number;
+    session?: AgentSession;
+    abortController?: AbortController;
+    promise?: Promise<string>;
+    groupId?: string;
+    joinMode?: JoinMode;
+    /** Set when result was already consumed via get_subagent_result — suppresses completion notification. */
+    resultConsumed?: boolean;
+    /** Steering messages queued before the session was ready. */
+    pendingSteers?: string[];
+    /** Worktree info if the agent is running in an isolated worktree. */
+    worktree?: {
+        path: string;
+        branch: string;
+        baseSha: string;
+        workPath: string;
+    };
+    /** Worktree cleanup result after agent completion. */
+    worktreeResult?: {
+        hasChanges: boolean;
+        branch?: string;
+    };
+    /** The tool_use_id from the original Agent tool call. */
+    toolCallId?: string;
+    /** Recursive subagent depth. Parent/orchestrator is 0; spawned agents are 1..4. */
+    depth: number;
+    /** Parent subagent id when spawned recursively from another subagent. */
+    parentAgentId?: string;
+    /** Path to the streaming output transcript file. */
+    outputFile?: string;
+    /** Cleanup function for the output file stream subscription. */
+    outputCleanup?: () => void;
+    /**
+     * Lifetime usage breakdown, accumulated via `message_end` events. Survives
+     * compaction. Total = input + output + cacheWrite (cacheRead deliberately
+     * excluded — see issue #38). Initialized to zeros at spawn.
+     */
+    lifetimeUsage: LifetimeUsage;
+    /** Number of times this agent's session has compacted. Initialized to 0 at spawn. */
+    compactionCount: number;
+    /** Resolved spawn params, captured for UI display. Fixed at spawn time. */
+    invocation?: AgentInvocation;
+}
+export interface AgentInvocation {
+    /** Short display name, e.g. "haiku" — only set when different from parent. */
+    modelName?: string;
+    thinking?: ThinkingLevel;
+    maxTurns?: number;
+    isolated?: boolean;
+    inheritContext?: boolean;
+    runInBackground?: boolean;
+    isolation?: IsolationMode;
+    depth?: number;
+    parentAgentId?: string;
+    maxDepth?: number;
+}
+/** Details attached to custom notification messages for visual rendering. */
+export interface NotificationDetails {
+    id: string;
+    description: string;
+    status: string;
+    toolUses: number;
+    turnCount: number;
+    maxTurns?: number;
+    totalTokens: number;
+    durationMs: number;
+    outputFile?: string;
+    error?: string;
+    resultPreview: string;
+    /** Additional agents in a group notification. */
+    others?: NotificationDetails[];
+}
+export interface EnvInfo {
+    isGitRepo: boolean;
+    branch: string;
+    platform: string;
+}
+/**
+ * A subagent spawn registered to fire on a schedule.
+ *
+ * Stored at `<cwd>/.pi/subagent-schedules/<sessionId>.json`. Session-scoped:
+ * survives `/resume` but resets on `/new`, mirroring pi-chonky-tasks.
+ */
+export interface ScheduledSubagent {
+    id: string;
+    /** Unique within store. Defaults to `description`. */
+    name: string;
+    description: string;
+    /** Raw user input — cron expr | "+10m" | ISO | "5m". */
+    schedule: string;
+    scheduleType: "cron" | "once" | "interval";
+    /** Computed at create time for interval/once. */
+    intervalMs?: number;
+    subagent_type: SubagentType;
+    prompt: string;
+    model?: string;
+    thinking?: ThinkingLevel;
+    max_turns?: number;
+    isolated?: boolean;
+    isolation?: IsolationMode;
+    enabled: boolean;
+    /** ISO timestamp. */
+    createdAt: string;
+    lastRun?: string;
+    lastStatus?: "success" | "error" | "running";
+    /** Refreshed on every fire and on store load. */
+    nextRun?: string;
+    runCount: number;
+}
+export interface ScheduleStoreData {
+    /** For future migrations. */
+    version: 1;
+    jobs: ScheduledSubagent[];
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * types.ts — Type definitions for the subagent system.
+ */
+/** Names of the three embedded default agents. */
+export const DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"];
+/** Maximum recursive subagent depth. Parent/orchestrator is depth 0; agents may run at depths 1..4. */
+export const MAX_RECURSIVE_DEPTH = 4;

package/dist/ui/agent-tool-rendering.d.ts

@@ -0,0 +1,34 @@
+import { Text } from "@earendil-works/pi-tui";
+export declare function compactPreview(text: string, maxLen?: number): string;
+export declare function tailPreview(text: string, maxLen?: number): string;
+export declare function snipMiddleLines(text: string, edgeLines?: number): string[];
+/**
+ * Shape of the args passed to the Agent tool's `renderCall`. Mirrors the tool
+ * parameter schema — only the fields whose presence changes the call-time
+ * header are listed. Anything we can't decide at call time (e.g. an agent that
+ * inherits its model from the parent) is intentionally omitted here and is
+ * surfaced later by `renderResult`.
+ */
+export interface AgentCallArgs {
+    subagent_type?: string;
+    description?: string;
+    /** Explicit per-call model override (`provider/modelId` or fuzzy name). */
+    model?: string;
+    /** Agent ID being resumed; only set on resume calls. */
+    resume?: string;
+    /** Schedule expression; only set on schedule calls. */
+    schedule?: string;
+    /** Drop parent extension tools for this run. */
+    isolated?: boolean;
+    /** Isolation mode — currently only "worktree". */
+    isolation?: "worktree";
+}
+export declare function renderAgentCall(args: any, theme: any): Text;
+export declare function renderAgentResult(result: any, { expanded, isPartial }: {
+    expanded: boolean;
+    isPartial: boolean;
+}, theme: any): Text;
+export declare function renderSteerCall(args: {
+    agent_id?: string;
+    message?: string;
+}, theme: any): Text;

package/dist/ui/agent-tool-rendering.js

@@ -0,0 +1,154 @@
+import { Text } from "@earendil-works/pi-tui";
+import { getModelLabelFromConfig } from "../agent-tool-description.js";
+import { getAgentConfig } from "../agent-types.js";
+import { extractText } from "../context.js";
+import { formatMs, formatTurns, getDisplayName, SPINNER } from "./agent-widget.js";
+export function compactPreview(text, maxLen = 80) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= maxLen)
+        return oneLine;
+    return oneLine.slice(0, maxLen - 1).trimEnd() + "…";
+}
+export function tailPreview(text, maxLen = 100) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= maxLen)
+        return oneLine;
+    return "…" + oneLine.slice(oneLine.length - (maxLen - 1));
+}
+export function snipMiddleLines(text, edgeLines = 20) {
+    const lines = text.split("\n");
+    const maxLines = edgeLines * 2;
+    if (lines.length <= maxLines)
+        return lines;
+    const omitted = lines.length - maxLines;
+    return [
+        ...lines.slice(0, edgeLines),
+        `... ${omitted} lines omitted; expand for full output ...`,
+        ...lines.slice(-edgeLines),
+    ];
+}
+/**
+ * Resolve the model that this call will use, if it's knowable before execute().
+ * Resolution order: explicit `args.model` > agent config frontmatter > none.
+ * Inheritance from the parent session is decided inside execute() and surfaced
+ * by `renderResult` once the resolved model is available.
+ */
+function resolveCallModel(args) {
+    if (typeof args.model === "string" && args.model)
+        return args.model;
+    if (typeof args.subagent_type === "string")
+        return getAgentConfig(args.subagent_type)?.model;
+    return undefined;
+}
+/** Build the dimmed badge list shown between the agent name and the description. */
+function buildCallBadges(args, theme) {
+    const badges = [];
+    const callModel = resolveCallModel(args);
+    if (callModel)
+        badges.push(getModelLabelFromConfig(callModel));
+    if (typeof args.resume === "string" && args.resume) {
+        badges.push(`resume: ${compactPreview(args.resume, 12)}`);
+    }
+    if (typeof args.schedule === "string" && args.schedule) {
+        badges.push(`schedule: ${compactPreview(args.schedule, 20)}`);
+    }
+    if (args.isolation === "worktree")
+        badges.push("worktree");
+    if (args.isolated)
+        badges.push("isolated");
+    if (badges.length === 0)
+        return "";
+    const sep = " " + theme.fg("dim", "·") + " ";
+    return "  " + badges.map((b) => theme.fg("dim", b)).join(sep);
+}
+export function renderAgentCall(args, theme) {
+    const displayName = args.subagent_type ? getDisplayName(args.subagent_type) : "Agent";
+    const desc = args.description ?? "";
+    const badges = buildCallBadges(args, theme);
+    const descPart = desc ? "  " + theme.fg("muted", desc) : "";
+    return new Text("▸ " + theme.fg("toolTitle", theme.bold(displayName)) + badges + descPart, 0, 0);
+}
+function getResultText(content) {
+    if (!Array.isArray(content))
+        return typeof content === "string" ? content : "";
+    return extractText(content);
+}
+export function renderAgentResult(result, { expanded, isPartial }, theme) {
+    const details = result.details;
+    if (!details) {
+        return new Text(getResultText(result.content), 0, 0);
+    }
+    const stats = (d) => {
+        const parts = [];
+        if (d.modelName)
+            parts.push(d.modelName);
+        if (d.tags)
+            parts.push(...d.tags);
+        if (d.turnCount != null && d.turnCount > 0) {
+            parts.push(formatTurns(d.turnCount, d.maxTurns));
+        }
+        if (d.toolUses > 0)
+            parts.push(`${d.toolUses} tool use${d.toolUses === 1 ? "" : "s"}`);
+        if (d.tokens)
+            parts.push(d.tokens);
+        return parts.map(p => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
+    };
+    if (isPartial || details.status === "running") {
+        const frame = SPINNER[details.spinnerFrame ?? 0];
+        const s = stats(details);
+        let line = theme.fg("accent", frame) + (s ? " " + s : "");
+        line += "\n" + theme.fg("dim", `  ⎿  ${details.activity ?? "thinking…"}`);
+        return new Text(line, 0, 0);
+    }
+    if (details.status === "background") {
+        return new Text(theme.fg("dim", `  ⎿  Running in background (ID: ${details.agentId})`), 0, 0);
+    }
+    if (details.status === "completed" || details.status === "steered") {
+        const duration = formatMs(details.durationMs);
+        const isSteered = details.status === "steered";
+        const icon = isSteered ? theme.fg("warning", "✓") : theme.fg("success", "✓");
+        const s = stats(details);
+        let line = icon + (s ? " " + s : "");
+        line += " " + theme.fg("dim", "·") + " " + theme.fg("dim", duration);
+        const resultText = getResultText(result.content).trim();
+        if (expanded) {
+            if (resultText) {
+                for (const lineText of resultText.split("\n")) {
+                    line += "\n" + theme.fg("dim", `  ${lineText}`);
+                }
+            }
+        }
+        else {
+            const doneText = isSteered ? "Wrapped up (turn limit)" : "Done";
+            if (resultText) {
+                for (const lineText of snipMiddleLines(resultText)) {
+                    line += "\n" + theme.fg("dim", `  ${lineText}`);
+                }
+            }
+            else {
+                line += "\n" + theme.fg("dim", `  ⎿  ${doneText}`);
+            }
+        }
+        return new Text(line, 0, 0);
+    }
+    if (details.status === "stopped") {
+        const s = stats(details);
+        let line = theme.fg("dim", "■") + (s ? " " + s : "");
+        line += "\n" + theme.fg("dim", "  ⎿  Stopped");
+        return new Text(line, 0, 0);
+    }
+    const s = stats(details);
+    let line = theme.fg("error", "✗") + (s ? " " + s : "");
+    if (details.status === "error") {
+        line += "\n" + theme.fg("error", `  ⎿  Error: ${details.error ?? "unknown"}`);
+    }
+    else {
+        line += "\n" + theme.fg("warning", "  ⎿  Aborted (max turns exceeded)");
+    }
+    return new Text(line, 0, 0);
+}
+export function renderSteerCall(args, theme) {
+    const agentId = args.agent_id ? ` ${theme.fg("muted", args.agent_id)}` : "";
+    const preview = args.message ? `  ${theme.fg("dim", `“${compactPreview(args.message)}”`)}` : "";
+    return new Text(`▸ ${theme.fg("toolTitle", theme.bold("Steer Agent"))}${agentId}${preview}`, 0, 0);
+}

package/dist/ui/agent-widget-tree.d.ts

@@ -0,0 +1,33 @@
+import type { AgentInvocation, SubagentType } from "../types.js";
+import type { AgentActivity, Theme } from "./agent-widget.js";
+export type WidgetDisplayMode = "auto" | "rich" | "compact";
+export interface WidgetAgentSnapshot {
+    id: string;
+    parentAgentId?: string;
+    depth?: number;
+    type: SubagentType;
+    description: string;
+    status: string;
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+    toolUses: number;
+    invocation?: AgentInvocation;
+    activity?: AgentActivity;
+}
+export interface WidgetTreeNode {
+    snapshot: WidgetAgentSnapshot;
+    children: WidgetTreeNode[];
+    orphaned?: boolean;
+}
+export interface RenderTreeOptions {
+    mode: WidgetDisplayMode;
+    width: number;
+    maxLines: number;
+    theme: Theme;
+    frame: string;
+    now?: number;
+}
+export declare function buildAgentTree(records: WidgetAgentSnapshot[]): WidgetTreeNode[];
+export declare function chooseEffectiveMode(mode: WidgetDisplayMode, width: number, richLineCount: number, maxLines: number): "rich" | "compact";
+export declare function renderAgentTree(records: WidgetAgentSnapshot[], options: RenderTreeOptions): string[];

package/dist/ui/agent-widget-tree.js

@@ -0,0 +1,130 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { getConfig } from "../agent-types.js";
+function statusRank(status) {
+    if (status === "running")
+        return 0;
+    if (status === "queued")
+        return 1;
+    return 2;
+}
+function sortNodes(a, b) {
+    const status = statusRank(a.snapshot.status) - statusRank(b.snapshot.status);
+    if (status !== 0)
+        return status;
+    return a.snapshot.startedAt - b.snapshot.startedAt;
+}
+export function buildAgentTree(records) {
+    const nodes = new Map();
+    for (const record of records)
+        nodes.set(record.id, { snapshot: record, children: [] });
+    const roots = [];
+    for (const node of nodes.values()) {
+        const parentId = node.snapshot.parentAgentId;
+        const parent = parentId ? nodes.get(parentId) : undefined;
+        if (parent) {
+            parent.children.push(node);
+        }
+        else {
+            if (parentId)
+                node.orphaned = true;
+            roots.push(node);
+        }
+    }
+    function sortDeep(items) {
+        items.sort(sortNodes);
+        for (const item of items)
+            sortDeep(item.children);
+    }
+    sortDeep(roots);
+    return roots;
+}
+export function chooseEffectiveMode(mode, width, richLineCount, maxLines) {
+    if (mode === "rich" || mode === "compact")
+        return mode;
+    if (width < 88)
+        return "compact";
+    if (richLineCount > maxLines)
+        return "compact";
+    return "rich";
+}
+function formatElapsed(startedAt, now) {
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return rest > 0 ? `${minutes}m ${rest}s` : `${minutes}m`;
+}
+function statusIcon(snapshot, frame, theme) {
+    if (snapshot.status === "running")
+        return theme.fg("accent", frame);
+    if (snapshot.status === "queued")
+        return theme.fg("muted", "◦");
+    if (snapshot.status === "completed")
+        return theme.fg("success", "✓");
+    if (snapshot.status === "stopped")
+        return theme.fg("dim", "■");
+    return theme.fg("error", "✗");
+}
+function displayName(type) {
+    return getConfig(type).displayName;
+}
+function collectRows(nodes, options, mode, prefix = "") {
+    const rows = [];
+    nodes.forEach((node, index) => {
+        const isLast = index === nodes.length - 1;
+        const connector = isLast ? "└─" : "├─";
+        const childPrefix = prefix + (isLast ? "   " : "│  ");
+        const s = node.snapshot;
+        const name = displayName(s.type);
+        const elapsed = formatElapsed(s.startedAt, options.now ?? Date.now());
+        const stats = [];
+        if (s.activity?.turnCount)
+            stats.push(`↻${s.activity.turnCount}`);
+        if (s.toolUses > 0)
+            stats.push(`${s.toolUses} tool${s.toolUses === 1 ? "" : "s"}`);
+        stats.push(elapsed);
+        const orphan = node.orphaned ? " ⚠ orphan" : "";
+        const error = s.error ? ` error: ${s.error}` : "";
+        rows.push(`${prefix}${connector} ${statusIcon(s, options.frame, options.theme)} ${options.theme.bold(name)}  ${options.theme.fg("muted", s.description)} ${options.theme.fg("dim", `· ${stats.join(" · ")}${orphan}${error}`)}`);
+        if (mode === "rich" && s.status === "running") {
+            const activity = s.activity?.activityDescription ?? "thinking…";
+            rows.push(`${childPrefix}${options.theme.fg("dim", `⎿ ${activity}`)}`);
+        }
+        rows.push(...collectRows(node.children, options, mode, childPrefix));
+    });
+    return rows;
+}
+function applyOverflow(lines, maxLines, width, hiddenLabel = "agents") {
+    if (lines.length <= maxLines)
+        return lines.map(line => truncateToWidth(line, width));
+    if (maxLines <= 1)
+        return [truncateToWidth(`+${lines.length} more ${hiddenLabel} hidden`, width)];
+    const visible = lines.slice(0, maxLines - 1);
+    const hidden = lines.length - visible.length;
+    visible.push(`└─ +${hidden} more ${hiddenLabel} hidden`);
+    return visible.map(line => truncateToWidth(line, width));
+}
+export function renderAgentTree(records, options) {
+    const tree = buildAgentTree(records);
+    const now = options.now ?? Date.now();
+    const active = records.filter(r => r.status === "running").length;
+    const queued = records.filter(r => r.status === "queued").length;
+    const maxDepth = records.reduce((max, r) => Math.max(max, r.depth ?? 0), 0);
+    let mode;
+    let rows;
+    if (options.mode === "rich" || options.mode === "compact") {
+        mode = options.mode;
+        rows = collectRows(tree, { ...options, now }, mode);
+    }
+    else {
+        const richRows = collectRows(tree, { ...options, now }, "rich");
+        mode = chooseEffectiveMode(options.mode, options.width, richRows.length + 1, options.maxLines);
+        rows = mode === "rich" ? richRows : collectRows(tree, { ...options, now }, "compact");
+    }
+    const suffix = mode === "rich" && records.length > 0
+        ? options.theme.fg("dim", ` ${active} running · ${queued} queued · depth ${maxDepth}/4`)
+        : "";
+    const heading = `${active > 0 ? options.theme.fg("accent", "●") : options.theme.fg("dim", "○")} ${options.theme.fg(active > 0 ? "accent" : "dim", "Agents")}${suffix}`;
+    return applyOverflow([heading, ...rows], options.maxLines, options.width);
+}