@clanker-code/pi-subagents 0.10.8 → 0.11.1

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),
     ];
 }

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

@@ -1,5 +1,6 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { getConfig } from "../agent-types.js";
+import { getSessionTokens } from "../usage.js";
 function statusRank(status) {
     if (status === "running")
         return 0;
@@ -55,6 +56,14 @@ function formatElapsed(startedAt, now) {
     const rest = seconds % 60;
     return rest > 0 ? `${minutes}m ${rest}s` : `${minutes}m`;
 }
+/** Compact token count for widget rows: "12.3k tok", "1.2M tok". */
+function formatCompactTokens(count) {
+    if (count >= 1_000_000)
+        return `${(count / 1_000_000).toFixed(1)}M tok`;
+    if (count >= 1_000)
+        return `${(count / 1_000).toFixed(1)}k tok`;
+    return `${count} tok`;
+}
 function statusIcon(snapshot, frame, theme) {
     if (snapshot.status === "running")
         return theme.fg("accent", frame);
@@ -62,6 +71,8 @@ function statusIcon(snapshot, frame, theme) {
         return theme.fg("muted", "◦");
     if (snapshot.status === "completed")
         return theme.fg("success", "✓");
+    if (snapshot.status === "steered")
+        return theme.fg("warning", "✓");
     if (snapshot.status === "stopped")
         return theme.fg("dim", "■");
     return theme.fg("error", "✗");
@@ -77,13 +88,19 @@ function collectRows(nodes, options, mode, prefix = "") {
         const childPrefix = prefix + (isLast ? "   " : "│  ");
         const s = node.snapshot;
         const name = displayName(s.type);
-        const elapsed = formatElapsed(s.startedAt, options.now ?? Date.now());
+        const elapsedUntil = s.status === "running" || s.status === "queued" ? (options.now ?? Date.now()) : (s.completedAt ?? options.now ?? Date.now());
+        const elapsed = formatElapsed(s.startedAt, elapsedUntil);
         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);
+        if (s.activity?.session) {
+            const tokens = getSessionTokens(s.activity.session);
+            if (tokens > 0)
+                stats.push(formatCompactTokens(tokens));
+        }
         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}`)}`);
@@ -126,5 +143,5 @@ export function renderAgentTree(records, options) {
         ? 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);
+    return applyOverflow([heading, ...rows], options.maxLines, options.width, mode === "rich" ? "lines" : "agents");
 }

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

@@ -113,8 +113,14 @@ export declare class AgentWidget {
     private widgetInterval;
     /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
     private finishedTurnAge;
+    /** Tracks wall-clock finish time so long-running turns cannot keep completed rows forever. */
+    private finishedAt;
     /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
     private static readonly ERROR_LINGER_TURNS;
+    /** Max wall-clock linger for successful completions when no new parent turn starts. */
+    private static readonly COMPLETED_LINGER_MS;
+    /** Max wall-clock linger for non-success outcomes when no new parent turn starts. */
+    private static readonly ERROR_LINGER_MS;
     /** Whether the widget callback is currently registered with the TUI. */
     private widgetRegistered;
     /** Cached TUI reference from widget factory callback, used for requestRender(). */
@@ -142,7 +148,7 @@ export declare class AgentWidget {
     /** 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;
+    markFinished(agentId: string, completedAt?: number): void;
     private recordToSnapshot;
     private visibleSnapshots;
     /**

package/dist/ui/agent-widget.js

@@ -14,7 +14,7 @@ const DEFAULT_STATUS_TEXT_WIDTH = 20;
 /** 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"]);
+export const ERROR_STATUSES = new Set(["error", "aborted", "stopped"]);
 /** Tool name → human-readable action for activity descriptions. */
 const TOOL_DISPLAY = {
     read: "reading",
@@ -193,8 +193,14 @@ export class AgentWidget {
     widgetInterval;
     /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
     finishedTurnAge = new Map();
+    /** Tracks wall-clock finish time so long-running turns cannot keep completed rows forever. */
+    finishedAt = new Map();
     /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
     static ERROR_LINGER_TURNS = 2;
+    /** Max wall-clock linger for successful completions when no new parent turn starts. */
+    static COMPLETED_LINGER_MS = 30_000;
+    /** Max wall-clock linger for non-success outcomes when no new parent turn starts. */
+    static ERROR_LINGER_MS = 120_000;
     /** Whether the widget callback is currently registered with the TUI. */
     widgetRegistered = false;
     /** Cached TUI reference from widget factory callback, used for requestRender(). */
@@ -215,17 +221,25 @@ export class AgentWidget {
     }
     upsertSnapshot(snapshot) {
         this.descendantSnapshots.set(snapshot.id, snapshot);
-        if (snapshot.status !== "running" && snapshot.status !== "queued") {
-            this.markFinished(snapshot.id);
+        if (snapshot.status === "running" || snapshot.status === "queued") {
+            this.finishedTurnAge.delete(snapshot.id);
+            this.finishedAt.delete(snapshot.id);
+        }
+        else {
+            this.markFinished(snapshot.id, snapshot.completedAt);
         }
         this.update();
     }
     removeSnapshot(id) {
         this.descendantSnapshots.delete(id);
+        this.finishedTurnAge.delete(id);
+        this.finishedAt.delete(id);
         this.update();
     }
     clearSnapshots() {
         this.descendantSnapshots.clear();
+        this.finishedTurnAge.clear();
+        this.finishedAt.clear();
         this.update();
     }
     /** Set the UI context (grabbed from first tool execution). */
@@ -258,16 +272,25 @@ export class AgentWidget {
         }
     }
     /** Check if a finished agent should still be shown in the widget. */
-    shouldShowFinished(agentId, status) {
+    shouldShowFinished(agentId, status, completedAt) {
         const age = this.finishedTurnAge.get(agentId) ?? 0;
         const maxAge = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_TURNS : 1;
-        return age < maxAge;
+        if (age >= maxAge)
+            return false;
+        const finishedAt = this.finishedAt.get(agentId) ?? completedAt;
+        if (finishedAt == null)
+            return true;
+        const maxMs = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_MS : AgentWidget.COMPLETED_LINGER_MS;
+        return Date.now() - finishedAt < maxMs;
     }
     /** Record an agent as finished (call when agent completes). */
-    markFinished(agentId) {
+    markFinished(agentId, completedAt = Date.now()) {
         if (!this.finishedTurnAge.has(agentId)) {
             this.finishedTurnAge.set(agentId, 0);
         }
+        if (!this.finishedAt.has(agentId)) {
+            this.finishedAt.set(agentId, completedAt);
+        }
     }
     recordToSnapshot(a) {
         const activity = this.agentActivity.get(a.id);
@@ -290,13 +313,25 @@ export class AgentWidget {
         const merged = new Map(this.descendantSnapshots);
         const allAgents = this.manager.listAgents();
         for (const a of allAgents) {
-            if (a.status === "running" || a.status === "queued" || (a.completedAt && this.shouldShowFinished(a.id, a.status))) {
+            if (a.status === "running" || a.status === "queued") {
+                this.finishedTurnAge.delete(a.id);
+                this.finishedAt.delete(a.id);
+                merged.set(a.id, this.recordToSnapshot(a));
+            }
+            else if (a.completedAt && this.shouldShowFinished(a.id, a.status, a.completedAt)) {
                 merged.set(a.id, this.recordToSnapshot(a));
             }
         }
+        const liveRecordIds = new Set(allAgents.map(a => a.id));
         for (const [id, snapshot] of merged) {
-            if (snapshot.status !== "running" && snapshot.status !== "queued" && snapshot.completedAt && !this.shouldShowFinished(id, snapshot.status)) {
+            if (snapshot.status !== "running" && snapshot.status !== "queued" && !this.shouldShowFinished(id, snapshot.status, snapshot.completedAt)) {
                 merged.delete(id);
+                if (this.descendantSnapshots.has(id))
+                    this.descendantSnapshots.delete(id);
+                if (!liveRecordIds.has(id)) {
+                    this.finishedTurnAge.delete(id);
+                    this.finishedAt.delete(id);
+                }
             }
         }
         return [...merged.values()];
@@ -334,7 +369,7 @@ export class AgentWidget {
             else if (a.status === "queued") {
                 queuedCount++;
             }
-            else if (a.completedAt && this.shouldShowFinished(a.id, a.status)) {
+            else if (this.shouldShowFinished(a.id, a.status, a.completedAt)) {
                 hasFinished = true;
             }
         }
@@ -356,11 +391,14 @@ export class AgentWidget {
             }
             // Clean up stale entries
             for (const [id] of this.finishedTurnAge) {
-                if (!allAgents.some(a => a.id === id))
+                if (!allAgents.some(a => a.id === id) && !this.descendantSnapshots.has(id)) {
                     this.finishedTurnAge.delete(id);
+                    this.finishedAt.delete(id);
+                }
             }
             return;
         }
+        this.ensureTimer();
         // Status bar — only call setStatus when the text actually changes
         const statusWidth = this.tui?.terminal.columns ?? DEFAULT_STATUS_TEXT_WIDTH;
         const newStatusText = hasActive
@@ -403,6 +441,10 @@ export class AgentWidget {
         }
         this.widgetRegistered = false;
         this.tui = undefined;
+        this.uiCtx = undefined;
         this.lastStatusText = undefined;
+        this.descendantSnapshots.clear();
+        this.finishedTurnAge.clear();
+        this.finishedAt.clear();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clanker-code/pi-subagents",
-  "version": "0.10.8",
+  "version": "0.11.1",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "clankercode",
   "license": "MIT",