@tintinweb/pi-subagents 0.4.0 → 0.4.3

package/dist/model-resolver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
+ */
+export interface ModelEntry {
+    id: string;
+    name: string;
+    provider: string;
+}
+export interface ModelRegistry {
+    find(provider: string, modelId: string): any;
+    getAll(): any[];
+    getAvailable?(): any[];
+}
+/**
+ * Resolve a model string to a Model instance.
+ * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.
+ * Returns the Model on success, or an error message string on failure.
+ */
+export declare function resolveModel(input: string, registry: ModelRegistry): any | string;

package/dist/model-resolver.js

@@ -0,0 +1,62 @@
+/**
+ * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
+ */
+/**
+ * Resolve a model string to a Model instance.
+ * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.
+ * Returns the Model on success, or an error message string on failure.
+ */
+export function resolveModel(input, registry) {
+    // Available models (those with auth configured)
+    const all = (registry.getAvailable?.() ?? registry.getAll());
+    const availableSet = new Set(all.map(m => `${m.provider}/${m.id}`.toLowerCase()));
+    // 1. Exact match: "provider/modelId" — only if available (has auth)
+    const slashIdx = input.indexOf("/");
+    if (slashIdx !== -1) {
+        const provider = input.slice(0, slashIdx);
+        const modelId = input.slice(slashIdx + 1);
+        if (availableSet.has(input.toLowerCase())) {
+            const found = registry.find(provider, modelId);
+            if (found)
+                return found;
+        }
+    }
+    // 2. Fuzzy match against available models
+    const query = input.toLowerCase();
+    // Score each model: prefer exact id match > id contains > name contains > provider+id contains
+    let bestMatch;
+    let bestScore = 0;
+    for (const m of all) {
+        const id = m.id.toLowerCase();
+        const name = m.name.toLowerCase();
+        const full = `${m.provider}/${m.id}`.toLowerCase();
+        let score = 0;
+        if (id === query || full === query) {
+            score = 100; // exact
+        }
+        else if (id.includes(query) || full.includes(query)) {
+            score = 60 + (query.length / id.length) * 30; // substring, prefer tighter matches
+        }
+        else if (name.includes(query)) {
+            score = 40 + (query.length / name.length) * 20;
+        }
+        else if (query.split(/[\s\-/]+/).every(part => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))) {
+            score = 20; // all parts present somewhere
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestMatch = m;
+        }
+    }
+    if (bestMatch && bestScore >= 20) {
+        const found = registry.find(bestMatch.provider, bestMatch.id);
+        if (found)
+            return found;
+    }
+    // 3. No match — list available models
+    const modelList = all
+        .map(m => `  ${m.provider}/${m.id}`)
+        .sort()
+        .join("\n");
+    return `Model not found: "${input}".\n\nAvailable models:\n${modelList}`;
+}

package/dist/prompts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * prompts.ts — System prompt builder for agents.
+ */
+import type { AgentConfig, EnvInfo } from "./types.js";
+/**
+ * Build the system prompt for an agent from its config.
+ *
+ * - "replace" mode: env header + config.systemPrompt (full control, no parent identity)
+ * - "append" mode: env header + parent system prompt + sub-agent context + config.systemPrompt
+ * - "append" with empty systemPrompt: pure parent clone
+ *
+ * @param parentSystemPrompt  The parent agent's effective system prompt (for append mode).
+ */
+export declare function buildAgentPrompt(config: AgentConfig, cwd: string, env: EnvInfo, parentSystemPrompt?: string): string;

package/dist/prompts.js

@@ -0,0 +1,48 @@
+/**
+ * prompts.ts — System prompt builder for agents.
+ */
+/**
+ * Build the system prompt for an agent from its config.
+ *
+ * - "replace" mode: env header + config.systemPrompt (full control, no parent identity)
+ * - "append" mode: env header + parent system prompt + sub-agent context + config.systemPrompt
+ * - "append" with empty systemPrompt: pure parent clone
+ *
+ * @param parentSystemPrompt  The parent agent's effective system prompt (for append mode).
+ */
+export function buildAgentPrompt(config, cwd, env, parentSystemPrompt) {
+    const envBlock = `# Environment
+Working directory: ${cwd}
+${env.isGitRepo ? `Git repository: yes\nBranch: ${env.branch}` : "Not a git repository"}
+Platform: ${env.platform}`;
+    if (config.promptMode === "append") {
+        const identity = parentSystemPrompt || genericBase;
+        const bridge = `<sub_agent_context>
+You are operating as a sub-agent invoked to handle a specific task.
+- Use the read tool instead of cat/head/tail
+- Use the edit tool instead of sed/awk
+- Use the write tool instead of echo/heredoc
+- Use the find tool instead of bash find/ls for file search
+- Use the grep tool instead of bash grep/rg for content search
+- Make independent tool calls in parallel
+- Use absolute file paths
+- Do not use emojis
+- Be concise but complete
+</sub_agent_context>`;
+        const customSection = config.systemPrompt?.trim()
+            ? `\n\n<agent_instructions>\n${config.systemPrompt}\n</agent_instructions>`
+            : "";
+        return envBlock + "\n\n<inherited_system_prompt>\n" + identity + "\n</inherited_system_prompt>\n\n" + bridge + customSection;
+    }
+    // "replace" mode — env header + the config's full system prompt
+    const replaceHeader = `You are a pi coding agent sub-agent.
+You have been invoked to handle a specific task autonomously.
+
+${envBlock}`;
+    return replaceHeader + "\n\n" + config.systemPrompt;
+}
+/** Fallback base prompt when parent system prompt is unavailable in append mode. */
+const genericBase = `# Role
+You are a general-purpose coding agent for complex, multi-step tasks.
+You have full access to read, write, edit files, and execute commands.
+Do what has been asked; nothing more, nothing less.`;

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * types.ts — Type definitions for the subagent system.
+ */
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
+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"];
+/** Unified agent configuration — used for both default and user-defined agents. */
+export interface AgentConfig {
+    name: string;
+    displayName?: string;
+    description: string;
+    builtinToolNames?: string[];
+    /** true = inherit all, string[] = only listed, false = none */
+    extensions: true | string[] | false;
+    /** 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 */
+    inheritContext: boolean;
+    /** Default for spawn: run in background */
+    runInBackground: boolean;
+    /** Default for spawn: no extension tools */
+    isolated: boolean;
+    /** 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;
+}
+export interface EnvInfo {
+    isGitRepo: boolean;
+    branch: string;
+    platform: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * types.ts — Type definitions for the subagent system.
+ */
+/** Names of the three embedded default agents. */
+export const DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"];

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

@@ -0,0 +1,101 @@
+/**
+ * agent-widget.ts — Persistent widget showing running/completed agents above the editor.
+ *
+ * Displays a tree of agents with animated spinners, live stats, and activity descriptions.
+ * Uses the callback form of setWidget for themed rendering.
+ */
+import type { AgentManager } from "../agent-manager.js";
+import type { SubagentType } from "../types.js";
+/** Braille spinner frames for animated running indicator. */
+export declare const SPINNER: string[];
+/** Statuses that indicate an error/non-success outcome (used for linger behavior and icon rendering). */
+export declare const ERROR_STATUSES: Set<string>;
+export type Theme = {
+    fg(color: string, text: string): string;
+    bold(text: string): string;
+};
+export type UICtx = {
+    setStatus(key: string, text: string | undefined): void;
+    setWidget(key: string, content: undefined | ((tui: any, theme: Theme) => {
+        render(): string[];
+        invalidate(): void;
+    }), options?: {
+        placement?: "aboveEditor" | "belowEditor";
+    }): void;
+};
+/** Per-agent live activity state. */
+export interface AgentActivity {
+    activeTools: Map<string, string>;
+    toolUses: number;
+    tokens: string;
+    responseText: string;
+    session?: {
+        getSessionStats(): {
+            tokens: {
+                total: number;
+            };
+        };
+    };
+}
+/** Metadata attached to Agent tool results for custom rendering. */
+export interface AgentDetails {
+    displayName: string;
+    description: string;
+    subagentType: string;
+    toolUses: number;
+    tokens: string;
+    durationMs: number;
+    status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error" | "background";
+    /** Human-readable description of what the agent is currently doing. */
+    activity?: string;
+    /** Current spinner frame index (for animated running indicator). */
+    spinnerFrame?: number;
+    /** Short model name if different from parent (e.g. "haiku", "sonnet"). */
+    modelName?: string;
+    /** Notable config tags (e.g. ["thinking: high", "isolated"]). */
+    tags?: string[];
+    agentId?: string;
+    error?: string;
+}
+/** Format a token count compactly: "33.8k token", "1.2M token". */
+export declare function formatTokens(count: number): string;
+/** Format milliseconds as human-readable duration. */
+export declare function formatMs(ms: number): string;
+/** Format duration from start/completed timestamps. */
+export declare function formatDuration(startedAt: number, completedAt?: number): string;
+/** Get display name for any agent type (built-in or custom). */
+export declare function getDisplayName(type: SubagentType): string;
+/** Short label for prompt mode: "twin" for append, nothing for replace (the default). */
+export declare function getPromptModeLabel(type: SubagentType): string | undefined;
+/** Build a human-readable activity string from currently-running tools or response text. */
+export declare function describeActivity(activeTools: Map<string, string>, responseText?: string): string;
+export declare class AgentWidget {
+    private manager;
+    private agentActivity;
+    private uiCtx;
+    private widgetFrame;
+    private widgetInterval;
+    /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
+    private finishedTurnAge;
+    /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
+    private static readonly ERROR_LINGER_TURNS;
+    constructor(manager: AgentManager, agentActivity: Map<string, AgentActivity>);
+    /** Set the UI context (grabbed from first tool execution). */
+    setUICtx(ctx: UICtx): void;
+    /**
+     * Called on each new turn (tool_execution_start).
+     * Ages finished agents and clears those that have lingered long enough.
+     */
+    onTurnStart(): void;
+    /** Ensure the widget update timer is running. */
+    ensureTimer(): void;
+    /** Check if a finished agent should still be shown in the widget. */
+    private shouldShowFinished;
+    /** Record an agent as finished (call when agent completes). */
+    markFinished(agentId: string): void;
+    /** Render a finished agent line. */
+    private renderFinishedLine;
+    /** Force an immediate widget update. */
+    update(): void;
+    dispose(): void;
+}

package/dist/ui/agent-widget.js

@@ -0,0 +1,333 @@
+/**
+ * agent-widget.ts — Persistent widget showing running/completed agents above the editor.
+ *
+ * Displays a tree of agents with animated spinners, live stats, and activity descriptions.
+ * Uses the callback form of setWidget for themed rendering.
+ */
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import { getConfig } from "../agent-types.js";
+// ---- Constants ----
+/** Maximum number of rendered lines before overflow collapse kicks in. */
+const MAX_WIDGET_LINES = 12;
+/** Braille spinner frames for animated running indicator. */
+export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Statuses that indicate an error/non-success outcome (used for linger behavior and icon rendering). */
+export const ERROR_STATUSES = new Set(["error", "aborted", "steered", "stopped"]);
+/** Tool name → human-readable action for activity descriptions. */
+const TOOL_DISPLAY = {
+    read: "reading",
+    bash: "running command",
+    edit: "editing",
+    write: "writing",
+    grep: "searching",
+    find: "finding files",
+    ls: "listing",
+};
+// ---- Formatting helpers ----
+/** Format a token count compactly: "33.8k token", "1.2M token". */
+export function formatTokens(count) {
+    if (count >= 1_000_000)
+        return `${(count / 1_000_000).toFixed(1)}M token`;
+    if (count >= 1_000)
+        return `${(count / 1_000).toFixed(1)}k token`;
+    return `${count} token`;
+}
+/** Format milliseconds as human-readable duration. */
+export function formatMs(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+/** Format duration from start/completed timestamps. */
+export function formatDuration(startedAt, completedAt) {
+    if (completedAt)
+        return formatMs(completedAt - startedAt);
+    return `${formatMs(Date.now() - startedAt)} (running)`;
+}
+/** Get display name for any agent type (built-in or custom). */
+export function getDisplayName(type) {
+    return getConfig(type).displayName;
+}
+/** Short label for prompt mode: "twin" for append, nothing for replace (the default). */
+export function getPromptModeLabel(type) {
+    const config = getConfig(type);
+    return config.promptMode === "append" ? "twin" : undefined;
+}
+/** Truncate text to a single line, max `len` chars. */
+function truncateLine(text, len = 60) {
+    const line = text.split("\n").find(l => l.trim())?.trim() ?? "";
+    if (line.length <= len)
+        return line;
+    return line.slice(0, len) + "…";
+}
+/** Build a human-readable activity string from currently-running tools or response text. */
+export function describeActivity(activeTools, responseText) {
+    if (activeTools.size > 0) {
+        const groups = new Map();
+        for (const toolName of activeTools.values()) {
+            const action = TOOL_DISPLAY[toolName] ?? toolName;
+            groups.set(action, (groups.get(action) ?? 0) + 1);
+        }
+        const parts = [];
+        for (const [action, count] of groups) {
+            if (count > 1) {
+                parts.push(`${action} ${count} ${action === "searching" ? "patterns" : "files"}`);
+            }
+            else {
+                parts.push(action);
+            }
+        }
+        return parts.join(", ") + "…";
+    }
+    // No tools active — show truncated response text if available
+    if (responseText && responseText.trim().length > 0) {
+        return truncateLine(responseText);
+    }
+    return "thinking…";
+}
+// ---- Widget manager ----
+export class AgentWidget {
+    manager;
+    agentActivity;
+    uiCtx;
+    widgetFrame = 0;
+    widgetInterval;
+    /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
+    finishedTurnAge = new Map();
+    /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
+    static ERROR_LINGER_TURNS = 2;
+    constructor(manager, agentActivity) {
+        this.manager = manager;
+        this.agentActivity = agentActivity;
+    }
+    /** Set the UI context (grabbed from first tool execution). */
+    setUICtx(ctx) {
+        this.uiCtx = ctx;
+    }
+    /**
+     * Called on each new turn (tool_execution_start).
+     * Ages finished agents and clears those that have lingered long enough.
+     */
+    onTurnStart() {
+        // Age all finished agents
+        for (const [id, age] of this.finishedTurnAge) {
+            this.finishedTurnAge.set(id, age + 1);
+        }
+        // Trigger a widget refresh (will filter out expired agents)
+        this.update();
+    }
+    /** Ensure the widget update timer is running. */
+    ensureTimer() {
+        if (!this.widgetInterval) {
+            this.widgetInterval = setInterval(() => this.update(), 80);
+        }
+    }
+    /** Check if a finished agent should still be shown in the widget. */
+    shouldShowFinished(agentId, status) {
+        const age = this.finishedTurnAge.get(agentId) ?? 0;
+        const maxAge = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_TURNS : 1;
+        return age < maxAge;
+    }
+    /** Record an agent as finished (call when agent completes). */
+    markFinished(agentId) {
+        if (!this.finishedTurnAge.has(agentId)) {
+            this.finishedTurnAge.set(agentId, 0);
+        }
+    }
+    /** Render a finished agent line. */
+    renderFinishedLine(a, theme) {
+        const name = getDisplayName(a.type);
+        const modeLabel = getPromptModeLabel(a.type);
+        const duration = formatMs((a.completedAt ?? Date.now()) - a.startedAt);
+        let icon;
+        let statusText;
+        if (a.status === "completed") {
+            icon = theme.fg("success", "✓");
+            statusText = "";
+        }
+        else if (a.status === "steered") {
+            icon = theme.fg("warning", "✓");
+            statusText = theme.fg("warning", " (turn limit)");
+        }
+        else if (a.status === "stopped") {
+            icon = theme.fg("dim", "■");
+            statusText = theme.fg("dim", " stopped");
+        }
+        else if (a.status === "error") {
+            icon = theme.fg("error", "✗");
+            const errMsg = a.error ? `: ${a.error.slice(0, 60)}` : "";
+            statusText = theme.fg("error", ` error${errMsg}`);
+        }
+        else {
+            // aborted
+            icon = theme.fg("error", "✗");
+            statusText = theme.fg("warning", " aborted");
+        }
+        const parts = [];
+        if (a.toolUses > 0)
+            parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
+        parts.push(duration);
+        const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
+        return `${icon} ${theme.fg("dim", name)}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
+    }
+    /** Force an immediate widget update. */
+    update() {
+        if (!this.uiCtx)
+            return;
+        const allAgents = this.manager.listAgents();
+        const running = allAgents.filter(a => a.status === "running");
+        const queued = allAgents.filter(a => a.status === "queued");
+        const finished = allAgents.filter(a => a.status !== "running" && a.status !== "queued" && a.completedAt
+            && this.shouldShowFinished(a.id, a.status));
+        const hasActive = running.length > 0 || queued.length > 0;
+        const hasFinished = finished.length > 0;
+        // Nothing to show — clear widget
+        if (!hasActive && !hasFinished) {
+            this.uiCtx.setWidget("agents", undefined);
+            this.uiCtx.setStatus("subagents", undefined);
+            if (this.widgetInterval) {
+                clearInterval(this.widgetInterval);
+                this.widgetInterval = undefined;
+            }
+            // Clean up stale entries
+            for (const [id] of this.finishedTurnAge) {
+                if (!allAgents.some(a => a.id === id))
+                    this.finishedTurnAge.delete(id);
+            }
+            return;
+        }
+        // Status bar
+        if (hasActive) {
+            const statusParts = [];
+            if (running.length > 0)
+                statusParts.push(`${running.length} running`);
+            if (queued.length > 0)
+                statusParts.push(`${queued.length} queued`);
+            const total = running.length + queued.length;
+            this.uiCtx.setStatus("subagents", `${statusParts.join(", ")} agent${total === 1 ? "" : "s"}`);
+        }
+        else {
+            this.uiCtx.setStatus("subagents", undefined);
+        }
+        this.widgetFrame++;
+        const frame = SPINNER[this.widgetFrame % SPINNER.length];
+        this.uiCtx.setWidget("agents", (tui, theme) => {
+            const w = tui.terminal.columns;
+            const truncate = (line) => truncateToWidth(line, w);
+            const headingColor = hasActive ? "accent" : "dim";
+            const headingIcon = hasActive ? "●" : "○";
+            // Build sections separately for overflow-aware assembly.
+            // Each running agent = 2 lines (header + activity), finished = 1 line, queued = 1 line.
+            const finishedLines = [];
+            for (const a of finished) {
+                finishedLines.push(truncate(theme.fg("dim", "├─") + " " + this.renderFinishedLine(a, theme)));
+            }
+            const runningLines = []; // each entry is [header, activity]
+            for (const a of running) {
+                const name = getDisplayName(a.type);
+                const modeLabel = getPromptModeLabel(a.type);
+                const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
+                const elapsed = formatMs(Date.now() - a.startedAt);
+                const bg = this.agentActivity.get(a.id);
+                const toolUses = bg?.toolUses ?? a.toolUses;
+                let tokenText = "";
+                if (bg?.session) {
+                    try {
+                        tokenText = formatTokens(bg.session.getSessionStats().tokens.total);
+                    }
+                    catch { /* */ }
+                }
+                const parts = [];
+                if (toolUses > 0)
+                    parts.push(`${toolUses} tool use${toolUses === 1 ? "" : "s"}`);
+                if (tokenText)
+                    parts.push(tokenText);
+                parts.push(elapsed);
+                const statsText = parts.join(" · ");
+                const activity = bg ? describeActivity(bg.activeTools, bg.responseText) : "thinking…";
+                runningLines.push([
+                    truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${theme.bold(name)}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`),
+                    truncate(theme.fg("dim", "│  ") + theme.fg("dim", `  ⎿  ${activity}`)),
+                ]);
+            }
+            const queuedLine = queued.length > 0
+                ? truncate(theme.fg("dim", "├─") + ` ${theme.fg("muted", "◦")} ${theme.fg("dim", `${queued.length} queued`)}`)
+                : undefined;
+            // Assemble with overflow cap (heading + overflow indicator = 2 reserved lines).
+            const maxBody = MAX_WIDGET_LINES - 1; // heading takes 1 line
+            const totalBody = finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
+            const lines = [truncate(theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents"))];
+            if (totalBody <= maxBody) {
+                // Everything fits — add all lines and fix up connectors for the last item.
+                lines.push(...finishedLines);
+                for (const pair of runningLines)
+                    lines.push(...pair);
+                if (queuedLine)
+                    lines.push(queuedLine);
+                // Fix last connector: swap ├─ → └─ and │ → space for activity lines.
+                if (lines.length > 1) {
+                    const last = lines.length - 1;
+                    lines[last] = lines[last].replace("├─", "└─");
+                    // If last item is a running agent activity line, fix indent of that line
+                    // and fix the header line above it.
+                    if (runningLines.length > 0 && !queuedLine) {
+                        // The last two lines are the last running agent's header + activity.
+                        if (last >= 2) {
+                            lines[last - 1] = lines[last - 1].replace("├─", "└─");
+                            lines[last] = lines[last].replace("│  ", "   ");
+                        }
+                    }
+                }
+            }
+            else {
+                // Overflow — prioritize: running > queued > finished.
+                // Reserve 1 line for overflow indicator.
+                let budget = maxBody - 1;
+                let hiddenRunning = 0;
+                let hiddenFinished = 0;
+                // 1. Running agents (2 lines each)
+                for (const pair of runningLines) {
+                    if (budget >= 2) {
+                        lines.push(...pair);
+                        budget -= 2;
+                    }
+                    else {
+                        hiddenRunning++;
+                    }
+                }
+                // 2. Queued line
+                if (queuedLine && budget >= 1) {
+                    lines.push(queuedLine);
+                    budget--;
+                }
+                // 3. Finished agents
+                for (const fl of finishedLines) {
+                    if (budget >= 1) {
+                        lines.push(fl);
+                        budget--;
+                    }
+                    else {
+                        hiddenFinished++;
+                    }
+                }
+                // Overflow summary
+                const overflowParts = [];
+                if (hiddenRunning > 0)
+                    overflowParts.push(`${hiddenRunning} running`);
+                if (hiddenFinished > 0)
+                    overflowParts.push(`${hiddenFinished} finished`);
+                const overflowText = overflowParts.join(", ");
+                lines.push(truncate(theme.fg("dim", "└─") + ` ${theme.fg("dim", `+${hiddenRunning + hiddenFinished} more (${overflowText})`)}`));
+            }
+            return { render: () => lines, invalidate: () => { } };
+        }, { placement: "aboveEditor" });
+    }
+    dispose() {
+        if (this.widgetInterval) {
+            clearInterval(this.widgetInterval);
+            this.widgetInterval = undefined;
+        }
+        if (this.uiCtx) {
+            this.uiCtx.setWidget("agents", undefined);
+            this.uiCtx.setStatus("subagents", undefined);
+        }
+    }
+}