@clanker-code/pi-subagents 0.10.8 → 0.11.0

package/dist/default-agents.js

@@ -30,7 +30,6 @@ export const DEFAULT_AGENTS = new Map([
             builtinToolNames: READ_ONLY_TOOLS,
             extensions: true,
             skills: true,
-            model: "anthropic/claude-haiku-4-5-20251001",
             systemPrompt: `# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
 You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools.

package/dist/index.js

@@ -23,8 +23,10 @@ import { getAgentConversation, getCurrentExtensionAgentId, getCurrentExtensionDe
 import { buildAgentToolDescription, getModelLabelFromConfig } from "./agent-tool-description.js";
 import { BUILTIN_TOOL_NAMES, getAgentConfig, getAllTypes, getAvailableTypes, isDefaultsDisabled, registerAgents, resolveType, setDefaultsDisabled } from "./agent-types.js";
 import { formatOutputFileHint, limitText, MAX_RESULT_CHARS, MAX_VERBOSE_CHARS } from "./bounded-output.js";
+import { extractText } from "./context.js";
 import { registerRpcHandlers } from "./cross-extension-rpc.js";
 import { loadCustomAgents } from "./custom-agents.js";
+import { registerDashboardModules } from "./dashboard-ui.js";
 import { isModelInScope, readEnabledModels, resolveEnabledModels } from "./enabled-models.js";
 import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
@@ -36,8 +38,9 @@ import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
 import { applyAndEmitLoaded, DEFAULT_WAIT_TIMEOUT_SECONDS, saveAndEmitChanged } from "./settings.js";
 import { getStatusNote } from "./status-note.js";
+import { registerSubagentListClearTools } from "./subagent-list-clear.js";
 import { MAX_RECURSIVE_DEPTH } from "./types.js";
-import { renderAgentCall, renderAgentResult, renderSteerCall, tailPreview } from "./ui/agent-tool-rendering.js";
+import { renderAgentCall, renderAgentResult, renderSteerCall, snipMiddleLines, tailPreview } from "./ui/agent-tool-rendering.js";
 import { AgentWidget, buildInvocationTags, describeActivity, formatContextWindow, formatDuration, getDisplayName, getPromptModeLabel, } from "./ui/agent-widget.js";
 import { menuSelect } from "./ui/menu-select.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
@@ -388,6 +391,8 @@ export default function (pi) {
     // Capture ctx from session_start for RPC spawn handler + start the scheduler.
     pi.on("session_start", async (_event, ctx) => {
         currentCtx = ctx;
+        clearBatchState();
+        groupJoin.dispose();
         manager.clearCompleted();
         widget.clearSnapshots();
         retryStash.clear();
@@ -395,8 +400,10 @@ export default function (pi) {
             startScheduler(ctx);
     });
     pi.on("session_before_switch", () => {
+        clearBatchState();
+        groupJoin.dispose();
         manager.clearCompleted();
-        widget.clearSnapshots();
+        widget.dispose();
         retryStash.clear();
         scheduler.stop();
     });
@@ -414,13 +421,17 @@ export default function (pi) {
         unsubSpawnRpc();
         unsubStopRpc();
         unsubPingRpc();
+        unsubWidgetCreated?.();
         unsubWidgetStarted?.();
         unsubWidgetCompleted?.();
         unsubWidgetFailed?.();
         currentCtx = undefined;
         delete globalThis[MANAGER_KEY];
         scheduler.stop();
+        clearBatchState();
+        groupJoin.dispose();
         manager.abortAll();
+        widget.dispose();
         for (const timer of pendingNudges.values())
             clearTimeout(timer);
         pendingNudges.clear();
@@ -434,6 +445,7 @@ export default function (pi) {
         if (snapshot)
             widget.upsertSnapshot(snapshot);
     };
+    const unsubWidgetCreated = pi.events.on("subagents:created", upsertWidgetEventSnapshot);
     const unsubWidgetStarted = pi.events.on("subagents:started", upsertWidgetEventSnapshot);
     const unsubWidgetCompleted = pi.events.on("subagents:completed", upsertWidgetEventSnapshot);
     const unsubWidgetFailed = pi.events.on("subagents:failed", upsertWidgetEventSnapshot);
@@ -501,6 +513,13 @@ export default function (pi) {
     let currentBatchAgents = [];
     let batchFinalizeTimer;
     let batchCounter = 0;
+    function clearBatchState() {
+        if (batchFinalizeTimer) {
+            clearTimeout(batchFinalizeTimer);
+            batchFinalizeTimer = undefined;
+        }
+        currentBatchAgents = [];
+    }
     /** Finalize the current batch: if 2+ smart-mode agents, register as a group. */
     function finalizeBatch() {
         batchFinalizeTimer = undefined;
@@ -597,7 +616,7 @@ export default function (pi) {
                 description: "A short (3-5 word) description of the task (shown in UI).",
             }),
             subagent_type: Type.Optional(Type.String({
-                description: `The type of specialized agent to use. Available types: ${getAvailableTypes().join(", ")}. Custom agents from .pi/agents/*.md (project) or ${getAgentDir()}/agents/*.md (global) are also available. OMIT when retrying (preserved by the handle) unless you want to override it.`,
+                description: `The type of specialized agent to use. Defaults to general-purpose when omitted. Available types: ${getAvailableTypes().join(", ")}. Custom agents from .pi/agents/*.md (project) or ${getAgentDir()}/agents/*.md (global) are also available. OMIT when retrying (preserved by the handle) unless you want to override it.`,
             })),
             model: Type.Optional(Type.String({
                 description: 'Optional model override. Accepts "provider/modelId" or fuzzy name (e.g. "haiku", "sonnet"). Omit to use the agent type\'s default.',
@@ -673,14 +692,14 @@ export default function (pi) {
                 const { retry: _omit, ...overrides } = params;
                 P = { ...stashed.params, ...overrides };
             }
-            emitPromptPreview(P.prompt, P.description, P.subagent_type);
-            // Retry supplied the prompt/type from the stash; otherwise both are required.
-            if (!retryHandle && (!P.prompt || !P.subagent_type)) {
-                return textResult(`Missing required argument${!P.prompt && !P.subagent_type ? "s" : ""}: ` +
-                    [!P.prompt && "prompt", !P.subagent_type && "subagent_type"].filter(Boolean).join(", ") +
-                    ".");
+            const requestedSubagentType = (P.subagent_type ?? "general-purpose");
+            emitPromptPreview(P.prompt, P.description, requestedSubagentType);
+            // Retry supplied the prompt from the stash; otherwise prompt is required.
+            // subagent_type defaults to general-purpose when omitted.
+            if (!retryHandle && !P.prompt) {
+                return textResult("Missing required argument: prompt.");
             }
-            const rawType = P.subagent_type;
+            const rawType = requestedSubagentType;
             const resolved = resolveType(rawType);
             if (!resolved) {
                 // Unknown agent type — recoverable. List valid types so the orchestrator
@@ -896,6 +915,10 @@ export default function (pi) {
                 isBackground: true,
                 depth: record?.depth ?? nextSubagentDepth,
                 parentAgentId: extensionAgentId,
+                status: record?.status ?? "running",
+                startedAt: record?.startedAt,
+                toolUses: record?.toolUses ?? 0,
+                invocation: record?.invocation,
             });
             const isQueued = record?.status === "queued";
             return textResult(`Agent ${isQueued ? "queued" : "started"} in background.\nAgent ID: ${id}\nType: ${displayName}\nDescription: ${P.description}\n` +
@@ -928,6 +951,56 @@ export default function (pi) {
                 description: "Return a lightweight tail/filter view of the agent's result or live output file, with line numbers. Ignored when verbose is true.",
             })),
         }),
+        renderResult(result, { expanded }, theme) {
+            const details = result.details;
+            const text = extractText(result.content);
+            // Header: status + stats + description
+            let line = "";
+            if (details) {
+                const icon = details.status === "error" || details.status === "stopped" || details.status === "aborted"
+                    ? theme.fg("error", "✗")
+                    : details.status === "running" || details.status === "queued"
+                        ? theme.fg("accent", "◌")
+                        : theme.fg("success", "✓");
+                const parts = [];
+                if (details.toolUses > 0)
+                    parts.push(`${details.toolUses} tool use${details.toolUses === 1 ? "" : "s"}`);
+                if (details.tokens)
+                    parts.push(details.tokens);
+                if (details.contextPercent !== null)
+                    parts.push(`ctx ${Math.round(details.contextPercent)}%`);
+                if (details.duration)
+                    parts.push(details.duration);
+                const stats = parts.map(p => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
+                line = `${icon} ${theme.bold(details.description)} ${theme.fg("dim", details.status)}`;
+                if (stats)
+                    line += "\n  " + stats;
+            }
+            // Body: snip when collapsed, full when expanded
+            // Extract the body portion (after the first blank line) to keep the
+            // tool-output header always visible and only snip the actual result.
+            if (text.trim()) {
+                const firstBlank = text.indexOf("\n\n");
+                const body = firstBlank >= 0 ? text.slice(firstBlank + 2) : text;
+                if (expanded) {
+                    for (const l of text.split("\n")) {
+                        line += "\n" + theme.fg("dim", `  ${l}`);
+                    }
+                }
+                else {
+                    // Show the tool-output header verbatim, then snip only the body
+                    if (firstBlank >= 0) {
+                        for (const l of text.slice(0, firstBlank).split("\n")) {
+                            line += "\n" + theme.fg("dim", `  ${l}`);
+                        }
+                    }
+                    for (const l of snipMiddleLines(body, 20)) {
+                        line += "\n" + theme.fg("dim", `  ${l}`);
+                    }
+                }
+            }
+            return new Text(line, 0, 0);
+        },
         execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
             const record = manager.getRecord(params.agent_id);
             if (!record) {
@@ -974,6 +1047,15 @@ export default function (pi) {
             if (record.compactionCount)
                 statsParts.push(`Compactions: ${record.compactionCount}`);
             statsParts.push(`Duration: ${duration}`);
+            const details = {
+                status: record.status,
+                description: record.description,
+                toolUses: record.toolUses,
+                tokens: tokens || null,
+                contextPercent,
+                duration,
+                outputFile: record.outputFile,
+            };
             let output = `Agent: ${record.id}\n` +
                 `Type: ${displayName} | Status: ${record.status}${getStatusNote(record.status)} | ${statsParts.join(" | ")}\n` +
                 `Description: ${record.description}\n` +
@@ -1014,7 +1096,7 @@ export default function (pi) {
                     }
                 }
             }
-            return textResult(output);
+            return textResult(output, details);
         },
     }));
     // ---- steer_subagent tool ----
@@ -1072,6 +1154,9 @@ export default function (pi) {
             }
         },
     }));
+    // ---- list_subagents / clear_subagents tools ----
+    registerSubagentListClearTools(pi, manager);
+    registerDashboardModules(pi, manager);
     // ---- list_models tool ----
     pi.registerTool(defineTool({
         name: SUBAGENT_TOOL_NAMES.LIST_MODELS,

package/dist/peek.js

@@ -81,6 +81,12 @@ function parseOutputFileLines(path) {
         return [];
     }
     const out = [];
+    const pushRenderedLines = (text) => {
+        for (const renderedLine of text.trimEnd().split("\n")) {
+            if (renderedLine.trim())
+                out.push(renderedLine);
+        }
+    };
     for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -96,12 +102,12 @@ function parseOutputFileLines(path) {
         if (!Array.isArray(content)) {
             // Some entries may carry a plain string content.
             if (typeof content === "string" && content.trim())
-                out.push(content.trim());
+                pushRenderedLines(content);
             continue;
         }
         for (const block of content) {
             if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) {
-                out.push(block.text.trimEnd());
+                pushRenderedLines(block.text);
             }
         }
     }

package/dist/subagent-list-clear.d.ts

@@ -0,0 +1,57 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import type { AgentManager } from "./agent-manager.js";
+import type { AgentRecord } from "./types.js";
+export interface ListSubagentsOptions {
+    all?: boolean;
+    now?: number;
+    recentSuccessLimit?: number;
+}
+export interface ListSubagentsAgentDetails {
+    id: string;
+    type: AgentRecord["type"];
+    description: string;
+    status: AgentRecord["status"];
+    startedAt: number;
+    completedAt?: number;
+}
+export interface ListSubagentsDetails {
+    total: number;
+    all: boolean;
+    visible: ListSubagentsAgentDetails[];
+    hiddenDoneCount: number;
+    activeCount: number;
+    problemCount: number;
+    recentDoneCount: number;
+    now: number;
+}
+export interface ClearSubagentsOptions {
+    agentIds?: string[];
+    now?: number;
+    olderThanMs?: number;
+    includeErrors?: boolean;
+}
+export interface ClearSelectionResult {
+    clearIds: string[];
+    errors: string[];
+    requestedCount: number;
+    keptActiveCount: number;
+    keptFailedCount: number;
+    keptYoungSuccessCount: number;
+}
+export interface ClearSubagentsDetails extends ClearSelectionResult {
+    clearedCount: number;
+}
+export type RenderTheme = {
+    fg(color: string, text: string): string;
+    bold(text: string): string;
+};
+export declare function buildListSubagentsDetails(records: AgentRecord[], options?: ListSubagentsOptions): ListSubagentsDetails;
+export declare function clearSubagentRecords(records: AgentRecord[], options?: ClearSubagentsOptions): ClearSelectionResult;
+export declare function buildClearSubagentsDetails(result: ClearSelectionResult): ClearSubagentsDetails;
+export declare function renderListSubagentsDetails(details: ListSubagentsDetails, theme: RenderTheme): Component;
+export declare function renderClearSubagentsDetails(details: ClearSubagentsDetails, theme: RenderTheme): Component;
+export declare function renderEmptyCall(): Component;
+export declare function formatListSubagentsText(details: ListSubagentsDetails): string;
+export declare function formatClearSubagentsText(details: ClearSubagentsDetails): string;
+export declare function registerSubagentListClearTools(pi: ExtensionAPI, manager: AgentManager): void;

package/dist/subagent-list-clear.js

@@ -0,0 +1,331 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { SUBAGENT_TOOL_NAMES } from "./agent-runner.js";
+const DEFAULT_RECENT_SUCCESS_LIMIT = 2;
+const DEFAULT_CLEAR_AGE_MS = 5 * 60_000;
+const INDENT = " ";
+const HEADER_GLYPH = "⏣";
+const TREE_MID = "├─";
+const TREE_END = "└─";
+const TREE_GAP = " ";
+const TREE_PREFIX_LEN = INDENT.length + TREE_MID.length + TREE_GAP.length;
+const SUCCESS_STATUSES = new Set(["completed", "steered"]);
+const ACTIVE_STATUSES = new Set(["running", "queued"]);
+const PROBLEM_STATUSES = new Set(["error", "aborted", "stopped"]);
+class LineListComponent {
+    getLines;
+    constructor(getLines) {
+        this.getLines = getLines;
+    }
+    render(width) { return this.getLines(width); }
+    invalidate() { }
+}
+function isActive(record) {
+    return ACTIVE_STATUSES.has(record.status);
+}
+function isSuccess(record) {
+    return SUCCESS_STATUSES.has(record.status);
+}
+function isProblem(record) {
+    return PROBLEM_STATUSES.has(record.status);
+}
+function recency(record) {
+    return record.completedAt ?? record.startedAt;
+}
+function newestFirst(a, b) {
+    return recency(b) - recency(a);
+}
+function plural(n, one, many = `${one}s`) {
+    return `${n} ${n === 1 ? one : many}`;
+}
+function toListSubagentsAgentDetails(record) {
+    const details = {
+        id: record.id,
+        type: record.type,
+        description: record.description,
+        status: record.status,
+        startedAt: record.startedAt,
+    };
+    if (record.completedAt !== undefined)
+        details.completedAt = record.completedAt;
+    return details;
+}
+function formatAge(record, now) {
+    const start = record.completedAt ?? record.startedAt;
+    const elapsed = Math.max(0, now - start);
+    if (elapsed < 1_000)
+        return "0s";
+    const seconds = Math.floor(elapsed / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function pad(text, width) {
+    return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+function shortId(id) {
+    return id.slice(0, 8);
+}
+function displayType(type) {
+    return type === "general-purpose" ? "general" : type;
+}
+function statusLabel(status) {
+    if (status === "completed")
+        return "done";
+    if (status === "steered")
+        return "done";
+    return status;
+}
+function statusIcon(status) {
+    switch (status) {
+        case "running": return "⠋";
+        case "queued": return "◼";
+        case "completed":
+        case "steered": return "✓";
+        case "error":
+        case "aborted": return "✗";
+        case "stopped": return "■";
+        default: return "•";
+    }
+}
+function statusColor(status) {
+    switch (status) {
+        case "running":
+        case "queued": return "accent";
+        case "completed":
+        case "steered": return "success";
+        case "stopped": return "dim";
+        default: return "error";
+    }
+}
+function labeledPrefix(label, theme) {
+    return `${INDENT}${theme.fg("accent", HEADER_GLYPH)} ${theme.fg("accent", label)}${theme.fg("dim", " · ")}`;
+}
+function normalizeIds(agentIds) {
+    return [...new Set((agentIds ?? []).map((id) => id.trim()).filter(Boolean))];
+}
+function resolveId(records, query) {
+    const exact = records.find((record) => record.id === query);
+    if (exact)
+        return { id: exact.id };
+    const matches = records.filter((record) => record.id.startsWith(query));
+    if (matches.length === 0)
+        return { error: `${query} not found` };
+    if (matches.length > 1)
+        return { error: `${query} matched multiple agents: ${matches.map((r) => shortId(r.id)).join(", ")}` };
+    return { id: matches[0].id };
+}
+export function buildListSubagentsDetails(records, options = {}) {
+    const now = options.now ?? Date.now();
+    const all = options.all === true;
+    const sorted = [...records].sort(newestFirst);
+    const active = sorted.filter(isActive);
+    const problems = sorted.filter(isProblem);
+    const successes = sorted.filter(isSuccess);
+    const recentSuccessLimit = options.recentSuccessLimit ?? DEFAULT_RECENT_SUCCESS_LIMIT;
+    const recentSuccesses = successes.slice(0, recentSuccessLimit);
+    const visible = all ? sorted : [...active, ...problems, ...recentSuccesses];
+    return {
+        total: records.length,
+        all,
+        visible: visible.map(toListSubagentsAgentDetails),
+        hiddenDoneCount: all ? 0 : Math.max(0, successes.length - recentSuccesses.length),
+        activeCount: active.length,
+        problemCount: problems.length,
+        recentDoneCount: all ? successes.length : recentSuccesses.length,
+        now,
+    };
+}
+export function clearSubagentRecords(records, options = {}) {
+    const now = options.now ?? Date.now();
+    const olderThanMs = options.olderThanMs ?? DEFAULT_CLEAR_AGE_MS;
+    const requestedIds = normalizeIds(options.agentIds);
+    const errors = [];
+    const clearIds = [];
+    if (requestedIds.length > 0) {
+        for (const query of requestedIds) {
+            const resolved = resolveId(records, query);
+            if (resolved.error || !resolved.id) {
+                errors.push(resolved.error ?? `${query} not found`);
+                continue;
+            }
+            const record = records.find((r) => r.id === resolved.id);
+            if (isActive(record)) {
+                errors.push(`${query} matched ${record.status} agent ${record.id}`);
+                continue;
+            }
+            clearIds.push(record.id);
+        }
+    }
+    else {
+        for (const record of records) {
+            const age = now - (record.completedAt ?? record.startedAt);
+            if (age < olderThanMs)
+                continue;
+            if (isSuccess(record) || (options.includeErrors && isProblem(record))) {
+                clearIds.push(record.id);
+            }
+        }
+    }
+    const clearIdSet = new Set(clearIds);
+    const remaining = records.filter((record) => !clearIdSet.has(record.id));
+    const keptActiveCount = remaining.filter(isActive).length;
+    const keptFailedCount = remaining.filter(isProblem).length;
+    const keptYoungSuccessCount = remaining.filter((record) => isSuccess(record) && now - (record.completedAt ?? record.startedAt) < olderThanMs).length;
+    return { clearIds, errors, requestedCount: requestedIds.length, keptActiveCount, keptFailedCount, keptYoungSuccessCount };
+}
+export function buildClearSubagentsDetails(result) {
+    return { ...result, clearedCount: result.clearIds.length };
+}
+function renderAgentLine(record, theme, now) {
+    const icon = theme.fg(statusColor(record.status), statusIcon(record.status));
+    const id = theme.fg("muted", shortId(record.id));
+    const type = theme.fg("text", pad(displayType(record.type), 8));
+    const status = theme.fg(statusColor(record.status), pad(statusLabel(record.status), 8));
+    const age = theme.fg("dim", pad(formatAge(record, now), 4));
+    return `${icon} ${id} ${type} ${status} ${age} ${theme.fg("muted", record.description)}`;
+}
+function listSummary(details, theme) {
+    if (details.total === 0)
+        return `${theme.fg("text", "0 visible")} ${theme.fg("dim", "(empty)")}`;
+    if (details.all)
+        return `${theme.fg("text", plural(details.visible.length, "agent"))} ${theme.fg("dim", "(full list)")}`;
+    const parts = [
+        plural(details.activeCount, "active"),
+        plural(details.problemCount, "problem"),
+        `${plural(details.recentDoneCount, "recent done", "recent done")}`,
+    ];
+    const hidden = details.hiddenDoneCount > 0 ? `; ${plural(details.hiddenDoneCount, "hidden done", "hidden done")}` : "";
+    return `${theme.fg("text", `${details.visible.length} visible`)} ${theme.fg("dim", `(${parts.join(", ")}${hidden})`)}`;
+}
+export function renderListSubagentsDetails(details, theme) {
+    return new LineListComponent((width) => {
+        const header = `${labeledPrefix("List Agents", theme)}${listSummary(details, theme)}`;
+        if (details.visible.length === 0)
+            return [truncateToWidth(header, width)];
+        const lines = [truncateToWidth(header, width)];
+        const avail = Math.max(1, width - TREE_PREFIX_LEN);
+        details.visible.forEach((record, i) => {
+            const connector = i === details.visible.length - 1 ? TREE_END : TREE_MID;
+            const line = truncateToWidth(renderAgentLine(record, theme, details.now), avail);
+            lines.push(`${INDENT}${connector}${TREE_GAP}${line}`);
+        });
+        return lines;
+    });
+}
+function clearSummary(details, theme) {
+    const primary = theme.fg("text", `cleared ${plural(details.clearedCount, "record")}`);
+    const extra = [];
+    if (details.keptYoungSuccessCount)
+        extra.push(`${plural(details.keptYoungSuccessCount, "new done", "new done")} kept`);
+    if (details.keptFailedCount)
+        extra.push(`${plural(details.keptFailedCount, "failed", "failed")} kept`);
+    if (details.keptActiveCount)
+        extra.push(`${plural(details.keptActiveCount, "active", "active")} kept`);
+    if (details.errors.length)
+        extra.push(theme.fg("error", `${plural(details.errors.length, "error")}`));
+    if (extra.length === 0)
+        return primary;
+    return `${primary}${theme.fg("dim", " (")}${extra.join(theme.fg("dim", ", "))}${theme.fg("dim", ")")}`;
+}
+export function renderClearSubagentsDetails(details, theme) {
+    return new LineListComponent((width) => [truncateToWidth(`${labeledPrefix("Clear Agents", theme)}${clearSummary(details, theme)}`, width)]);
+}
+export function renderEmptyCall() {
+    return new LineListComponent(() => []);
+}
+export function formatListSubagentsText(details) {
+    const lines = [`${details.visible.length} visible of ${details.total} retained subagents.`];
+    for (const record of details.visible) {
+        lines.push(`${record.id} | ${displayType(record.type)} | ${record.status} | ${record.description}`);
+    }
+    if (details.hiddenDoneCount > 0) {
+        lines.push(`${details.hiddenDoneCount} successful completed subagent(s) hidden. Pass all: true for the full retained list.`);
+    }
+    return lines.join("\n");
+}
+export function formatClearSubagentsText(details) {
+    const lines = [`Cleared ${details.clearedCount} subagent record(s).`];
+    if (details.clearIds.length)
+        lines.push(`Cleared IDs: ${details.clearIds.join(", ")}`);
+    if (details.keptYoungSuccessCount)
+        lines.push(`Kept ${details.keptYoungSuccessCount} successful subagent(s) newer than the age threshold.`);
+    if (details.keptFailedCount)
+        lines.push(`Kept ${details.keptFailedCount} failed/stopped/aborted subagent(s).`);
+    if (details.keptActiveCount)
+        lines.push(`Kept ${details.keptActiveCount} active subagent(s).`);
+    if (details.errors.length)
+        lines.push(`Errors: ${details.errors.join("; ")}`);
+    return lines.join("\n");
+}
+function textResult(msg, details) {
+    return { content: [{ type: "text", text: msg }], details: details };
+}
+export function registerSubagentListClearTools(pi, manager) {
+    pi.registerTool(defineTool({
+        name: SUBAGENT_TOOL_NAMES.LIST_SUBAGENTS,
+        label: "List Agents",
+        description: "List retained subagent records. By default shows queued/running agents, failed/stopped/aborted agents, " +
+            "and the most recent 2 successful agents that have not been cleaned up. Also reports how many successful " +
+            "completed agents are hidden. Pass all: true to show the full retained list.",
+        promptSnippet: "List retained subagents and their current status",
+        parameters: Type.Object({
+            all: Type.Optional(Type.Boolean({
+                description: "If true, show every retained subagent record instead of the default compact view.",
+            })),
+        }),
+        renderShell: "self",
+        renderCall: () => renderEmptyCall(),
+        renderResult: (result, _options, theme) => {
+            const details = result?.details;
+            return details ? renderListSubagentsDetails(details, theme) : renderEmptyCall();
+        },
+        execute: async (_toolCallId, params) => {
+            const details = buildListSubagentsDetails(manager.listAgents(), { all: params.all === true });
+            return textResult(formatListSubagentsText(details), details);
+        },
+    }));
+    pi.registerTool(defineTool({
+        name: SUBAGENT_TOOL_NAMES.CLEAR_SUBAGENTS,
+        label: "Clear Agents",
+        description: "Clear retained terminal subagent records. By default clears successful completed/steered subagents older than 5 minutes. " +
+            "Provide agent_ids to clear specific terminal subagents by exact ID or unique prefix. Running and queued subagents are never cleared; " +
+            "specific attempts to clear them are reported as errors.",
+        promptSnippet: "Clear completed subagent records that are still retained",
+        parameters: Type.Object({
+            agent_ids: Type.Optional(Type.Array(Type.String(), {
+                description: "Optional exact IDs or unique prefixes to clear. When provided, the age threshold is ignored for those IDs.",
+            })),
+            older_than_minutes: Type.Optional(Type.Number({
+                description: "Default-mode age threshold in minutes. Defaults to 5. Ignored when agent_ids is provided.",
+                minimum: 0,
+            })),
+            include_errors: Type.Optional(Type.Boolean({
+                description: "In default mode, also clear failed/stopped/aborted terminal records older than the age threshold. Default false.",
+            })),
+        }),
+        renderShell: "self",
+        renderCall: () => renderEmptyCall(),
+        renderResult: (result, _options, theme) => {
+            const details = result?.details;
+            return details ? renderClearSubagentsDetails(details, theme) : renderEmptyCall();
+        },
+        execute: async (_toolCallId, params) => {
+            const selection = clearSubagentRecords(manager.listAgents(), {
+                agentIds: params.agent_ids,
+                olderThanMs: (params.older_than_minutes ?? 5) * 60_000,
+                includeErrors: params.include_errors === true,
+            });
+            const removed = manager.clearRecords(selection.clearIds);
+            const details = buildClearSubagentsDetails({ ...selection, clearIds: removed });
+            return textResult(formatClearSubagentsText(details), details);
+        },
+    }));
+}

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

@@ -23,7 +23,7 @@ export function snipMiddleLines(text, edgeLines = 20) {
     const omitted = lines.length - maxLines;
     return [
         ...lines.slice(0, edgeLines),
-        `... ${omitted} lines omitted; expand for full output ...`,
+        `─────── ⋐ ${omitted} lines hidden from preview ⋑ ───────`,
         ...lines.slice(-edgeLines),
     ];
 }