@hheei/pi-subagents 0.1.2 → 0.2.2

package/dist/tools.js

@@ -1,130 +1,269 @@
-import { getToolTui, registerToolTuiTrace } from "@hheei/pi-ext-core";
+import { getToolTui, isRecord, registerToolTuiTrace, textToolResult } from "@hheei/pi-ext-core";
 import { Type } from "typebox";
-import { sendReportToRunner } from "./connector.js";
-import { isRecord } from "./domain.js";
+import { discoverAgents } from "./agent-resolver.js";
+import { builtinAgents } from "./builtin-agents.js";
+import { isOperationError } from "./domain.js";
 const spawnSchema = Type.Object({
+    id: Type.Optional(Type.String({
+        description: "Optional subagent id (e.g. 'agent-1') to re-awaken an idle or completed subagent with a new task instead of creating a new one.",
+    })),
     task: Type.String({ minLength: 1 }),
-    agent: Type.String({ minLength: 1 }),
+    agent: Type.String({
+        minLength: 1,
+        description: "Name of an agent defined in .pi/agents/*.md or ~/.pi/agent/agents/*.md",
+    }),
     cwd: Type.Optional(Type.String()),
+    title: Type.Optional(Type.String({
+        maxLength: 60,
+        description: "Short session title for this child, e.g. 'OVITO properties editor'. It becomes the child's Pi session title, prefixed with a robot marker so delegated sessions stay recognizable; omit it — or leave it blank — to derive one from the agent name and child id.",
+    })),
+    forkFrom: Type.Optional(Type.String({
+        description: "Optional session or subagent id to reference context from: 'parent' (parent session), or a subagent id like 'agent-1' (including subagents that ended in 'error'). Does not inject past conversation into the prompt; provides the referenced session JSONL path in instructions so the subagent can inspect prior context on demand via read or grep. Cannot be 'current'.",
+    })),
 });
 const sendSchema = Type.Object({
-    id: Type.String({ minLength: 1 }),
+    id: Type.String({ minLength: 1, description: "Subagent id, e.g. agent-1" }),
     message: Type.String({ minLength: 1 }),
     mode: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("follow_up"), Type.Literal("auto")])),
 });
-const idSchema = Type.Object({ id: Type.String({ minLength: 1 }) });
+const idSchema = Type.Object({
+    id: Type.String({ minLength: 1, description: "Subagent id, e.g. agent-1" }),
+});
 const contactSchema = Type.Object({
-    reason: Type.Union([
-        Type.Literal("progress_update"),
-        Type.Literal("important_finding"),
-        Type.Literal("need_decision"),
-        Type.Literal("blocked"),
-    ]),
-    message: Type.String({ minLength: 1 }),
+    message: Type.String({
+        minLength: 1,
+        description: "Explanation of what is blocking progress or the error encountered.",
+    }),
+    reason: Type.Optional(Type.Union([Type.Literal("blocked"), Type.Literal("error")], {
+        description: "Reason: 'blocked' if waiting for input/guidance (can be resumed via send_agent), or 'error' if fatal unrecoverable failure (cannot continue). Defaults to 'blocked'.",
+    })),
 });
 const emptySchema = Type.Object({});
-function isOperationError(value) {
-    return (isRecord(value) &&
-        typeof value.operation === "string" &&
-        typeof value.reason === "string" &&
-        Array.isArray(value.sideEffects));
-}
 function result(value) {
     if (isOperationError(value))
         throw new Error(JSON.stringify(value));
-    return {
-        content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value) }],
-        details: value,
-    };
+    return textToolResult(typeof value === "string" ? value : JSON.stringify(value), value);
 }
-const SPAWN_DESCRIPTION = "Start an independent background RPC subagent. This call waits until the child runtime is ready, then returns the child id and initial state. Do NOT poll get_subagent or list_subagents to wait for the child's work. When the child reports via contact_parent, the harness delivers that report as a pi-subagent-report message and starts your next turn. After this tool returns, either end your turn or work on other independent tasks, including spawning more subagents in parallel. Do not fabricate or assume the child's results.";
-const SPAWN_SNIPPET = "Start a background RPC subagent. Returns when the runtime is ready. Results arrive later as pi-subagent-report; do not poll.";
+const SUBAGENTS_NAMESPACE = {
+    name: "subagents",
+    description: "Subagent orchestration and delegation tools",
+};
+const SPAWN_DESCRIPTION = "Start an independent background RPC agent. PREFER REUSING EXISTING SUBAGENTS: For subtasks with identical or related functionality, prefer reusing an existing subagent via send_agent (even if in 'done' or 'blocked' state) rather than spawning a fresh subagent each time. Reusing subagents avoids redundant session initialization, preserves ongoing context, and maximizes prompt cache and pi-ext-memory efficiency. Only spawn a new agent when a distinct role or isolated fresh context is genuinely needed. Do NOT freeze, pause, or stop other sub-workers before spawning: idle subagents do not consume compute or interfere, so do not waste an agent turn freezing them. Do NOT poll get_agent or list_agents to wait for the child's work. Results are automatically captured when the child settles, and delivered as a subagent-report message to start your next turn; while you are idle, reports from several children may arrive together. After this tool returns, either end your turn or work on other independent tasks, including spawning more agents in parallel. Do not fabricate or assume the child's results.";
+const SPAWN_SNIPPET = "Start a background RPC agent. Prefer reusing existing subagents via send_agent for related work to preserve context and maximize memory/cache efficiency. No need to freeze/stop other workers. Results arrive as subagent-report; do not poll.";
 const SPAWN_GUIDELINES = [
-    "Do not poll get_subagent or list_subagents waiting for the child to finish.",
-    "Do not sleep, wait, or tail session/log files to detect completion. The harness delivers reports.",
-    "When the child calls contact_parent, a pi-subagent-report message starts your next turn.",
-    "After spawn returns, end your turn or do other independent work, including more parallel spawns.",
+    "Prefer reusing existing subagents: for subtasks that have the same or related functionality, reuse an existing subagent via send_agent (which auto-resumes 'done' or 'blocked' agents) instead of spawning a new one. This preserves conversational continuity and maximizes prompt cache and memory efficiency.",
+    "Do not freeze, pause, or stop other subagents: idle subagents consume no compute and do not interfere. Do not waste a turn stopping them.",
+    "Do not poll get_agent or list_agents waiting for the child to finish.",
+    "Do not sleep, wait, or tail session/log files to detect completion. The harness delivers reports automatically.",
+    "After spawn returns, end your turn or do other independent work, including spawning more agents in parallel.",
     "Do not fabricate, assume, or summarize the child's results before a report arrives.",
 ];
-const SEND_DESCRIPTION = "Send a steer or follow-up message to one owned child. Do NOT poll get_subagent or list_subagents afterwards. Child reports arrive as pi-subagent-report messages that start your next turn.";
-const SEND_SNIPPET = "Send a message to one owned child. Reports arrive as pi-subagent-report; do not poll afterwards.";
-const GET_DESCRIPTION = "Inspect one owned child: state, mode, summary, usage, and whether the view is live or last-known. Use this when you need current identity or state, not to wait for the child to finish.";
-const LIST_DESCRIPTION = "List children owned by this parent session. Use this when you need ids or current state, not to wait for work to finish. Reports still arrive as pi-subagent-report messages.";
+const SEND_DESCRIPTION = "Send a steer or follow-up message to one owned child. PREFERRED FOR SUBSEQUENT/RELATED TASKS: Prefer reusing existing subagents in 'done' or 'blocked' states via send_agent instead of spawning new subagents every time; 'blocked' and 'done' children automatically rebuild and resume with their conversation context intact, maximizing prompt cache and memory efficiency. Subagents in 'error' cannot be continued; use spawn_agent with forkFrom to reference their session context. Do NOT wait for or ask workers to 'freeze': idle subagents are completely dormant and touch nothing until sent to. Dispatch reviewers or follow-up tasks immediately without wasting turns on freeze ceremonies. Do NOT poll get_agent or list_agents afterwards. Child reports arrive as subagent-report messages that start your next turn.";
+const SEND_SNIPPET = "Send a message to one owned child (auto-resumes if finished/blocked). Prefer reusing existing agents for related tasks. Reports arrive as subagent-report; do not poll afterwards.";
+const GET_DESCRIPTION = "Inspect one owned child: state, presentation (panel or background), summary, usage, and whether the view is live or last-known. Use this when you need current identity or state, not to wait for the child to finish.";
+const LIST_DESCRIPTION = "List available interactive agent definitions and running or past subagents owned by this parent session with their state ('running', 'done', 'blocked', 'error'). Use this to inspect existing subagents that can be reused via send_agent before deciding to spawn a new agent, not to wait for work to finish. Reports still arrive as subagent-report messages.";
+const LIST_SNIPPET = "List available interactive agent definitions and running subagents.";
 const STOP_DESCRIPTION = "Persist a stopped intent, then end that child's runtime.";
-const CONTACT_DESCRIPTION = "Report progress, an important finding, a decision you need, or a blocker to the parent. The parent is woken automatically; do not retry the same report. After need_decision or blocked, wait for a parent send_subagent. Do not invent new authority.";
-const CONTACT_SNIPPET = "Report to the parent. The parent is woken automatically; do not retry the same report.";
+const CONTACT_DESCRIPTION = "Notify the parent session when you are BLOCKED and cannot continue without parent decision or intervention. Do NOT call this on success or task completion: simply output your final answer directly as normal text in your response, and the harness will automatically capture and report your result to the parent.";
+const CONTACT_SNIPPET = "Report a blocker to the parent. Do NOT call on success: write normal text to finish.";
 const CONTACT_GUIDELINES = [
-    "Call contact_parent when the parent needs a progress update, finding, decision, or blocker.",
-    "Do not send empty status pings or retry the same report.",
-    "After need_decision or blocked, wait for a parent send_subagent. Do not invent new authority.",
+    "Use contact_parent ONLY if you are blocked or urgently require a parent decision midway.",
+    "Do NOT use contact_parent to deliver final findings or report success: output normal text instead.",
+    "After reporting a blocker, wait for a parent send_agent instruction.",
 ];
+function spawnFooter(result) {
+    const details = result.details;
+    const child = details?.child;
+    if (child !== undefined && typeof child.id === "string") {
+        const agent = child.displayName ?? child.agent;
+        return `#${child.id} · ${agent}`;
+    }
+    return undefined;
+}
+function childStateFooter(result) {
+    const details = result.details;
+    const child = details?.child;
+    if (child !== undefined && typeof child.id === "string") {
+        return `#${child.id} · ${child.state}`;
+    }
+    return undefined;
+}
+function listFooter(result) {
+    const details = result.details;
+    if (isRecord(details) && Array.isArray(details.runningAgents)) {
+        const count = details.runningAgents.length;
+        if (count === 0)
+            return undefined;
+        return count === 1 ? "1 child" : `${count} children`;
+    }
+    if (Array.isArray(details)) {
+        const count = details.length;
+        if (count === 0)
+            return undefined;
+        return count === 1 ? "1 child" : `${count} children`;
+    }
+    return undefined;
+}
 export function registerParentTools(pi, manager) {
     registerToolTuiTrace(pi);
     const tui = getToolTui(pi);
     const spawn = {
-        name: "spawn_subagent",
-        label: "Spawn subagent",
+        name: "spawn_agent",
+        namespace: SUBAGENTS_NAMESPACE,
+        label: "Spawn agent",
         description: SPAWN_DESCRIPTION,
         promptSnippet: SPAWN_SNIPPET,
         promptGuidelines: [...SPAWN_GUIDELINES],
         parameters: spawnSchema,
+        defaultActive: false,
+        annotations: {
+            openWorldHint: true,
+        },
         async execute(_id, params) {
             return result(await manager.spawn(params));
         },
     };
     const send = {
-        name: "send_subagent",
-        label: "Send to subagent",
+        name: "send_agent",
+        namespace: SUBAGENTS_NAMESPACE,
+        label: "Send to agent",
         description: SEND_DESCRIPTION,
         promptSnippet: SEND_SNIPPET,
         promptGuidelines: [
-            "Do not poll get_subagent or list_subagents afterwards.",
-            "Child reports arrive as pi-subagent-report messages that start your next turn.",
+            "Prefer reusing an existing subagent in 'done' or 'blocked' states via send_agent for subsequent or functionally identical/related subtasks instead of spawning a new subagent each time. This preserves context and maximizes memory and prompt cache efficiency.",
+            "Do not wait for or ask workers to 'freeze': idle subagents are dormant and touch nothing. Dispatch reviewers or follow-ups immediately.",
+            "Do not poll get_agent or list_agents afterwards.",
+            "Child reports arrive as subagent-report messages that start your next turn.",
         ],
         parameters: sendSchema,
+        defaultActive: false,
+        annotations: {
+            openWorldHint: true,
+        },
         async execute(_id, params, signal) {
             return result(await manager.send(params.id, params.message, params.mode, signal));
         },
     };
     const get = {
-        name: "get_subagent",
-        label: "Get subagent",
+        name: "get_agent",
+        namespace: SUBAGENTS_NAMESPACE,
+        label: "Get agent",
         description: GET_DESCRIPTION,
         promptSnippet: GET_DESCRIPTION,
         parameters: idSchema,
+        defaultActive: false,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
         async execute(_id, params) {
             return result(await manager.get(params.id));
         },
     };
     const list = {
-        name: "list_subagents",
-        label: "List subagents",
+        name: "list_agents",
+        namespace: SUBAGENTS_NAMESPACE,
+        label: "List agents",
         description: LIST_DESCRIPTION,
-        promptSnippet: LIST_DESCRIPTION,
+        promptSnippet: LIST_SNIPPET,
         parameters: emptySchema,
-        async execute() {
-            return result(await manager.list());
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
+        async execute(_id, _params, _signal, _onUpdate, ctx) {
+            const children = await manager.list();
+            const cwd = ctx !== undefined && typeof ctx === "object" && "cwd" in ctx && typeof ctx.cwd === "string"
+                ? ctx.cwd
+                : process.cwd();
+            let allAgents;
+            try {
+                allAgents = await discoverAgents(cwd);
+            }
+            catch {
+                allAgents = builtinAgents();
+            }
+            const visible = allAgents.filter((agent) => agent.enabled !== false && agent.frontmatter.hidden !== true);
+            const interactiveAgents = visible
+                .filter((agent) => agent.frontmatter.interactive === true)
+                .map((agent) => ({
+                name: agent.name,
+                description: typeof agent.frontmatter.description === "string" &&
+                    agent.frontmatter.description.trim() !== ""
+                    ? agent.frontmatter.description.trim()
+                    : "No description provided.",
+            }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            const lines = [];
+            if (interactiveAgents.length > 0) {
+                lines.push("<interactive_agents>");
+                for (const agent of interactiveAgents) {
+                    lines.push(`- ${agent.name}: ${agent.description}`);
+                }
+                lines.push("</interactive_agents>");
+            }
+            if (children.length > 0) {
+                if (lines.length > 0)
+                    lines.push("");
+                lines.push("<running_agents>");
+                for (const child of children) {
+                    const summaryPart = child.summary ? ` | summary: ${child.summary}` : "";
+                    lines.push(`- id: ${child.id} | agent: ${child.agent} | state: ${child.state}${summaryPart}`);
+                }
+                lines.push("</running_agents>");
+            }
+            if (lines.length === 0) {
+                lines.push("No active or available interactive subagents.");
+            }
+            return textToolResult(lines.join("\n"), {
+                ...(interactiveAgents.length > 0 ? { interactiveAgents } : {}),
+                runningAgents: children,
+            });
         },
     };
     const stop = {
-        name: "stop_subagent",
-        label: "Stop subagent",
+        name: "stop_agent",
+        namespace: SUBAGENTS_NAMESPACE,
+        label: "Stop agent",
         description: STOP_DESCRIPTION,
         parameters: idSchema,
-        async execute(_id, params, signal) {
-            return result(await manager.stop(params.id, signal));
+        defaultActive: false,
+        annotations: {
+            destructiveHint: true,
+        },
+        async execute(_id, params) {
+            return result(await manager.stop(params.id));
         },
     };
-    pi.registerTool(tui.frame(spawn, { summary: (args) => args.agent }));
-    pi.registerTool(tui.frame(send, { summary: (args) => args.id }));
-    pi.registerTool(tui.frame(get, { summary: (args) => args.id }));
-    pi.registerTool(tui.frame(list, { summary: () => "owned children" }));
-    pi.registerTool(tui.frame(stop, { summary: (args) => args.id }));
+    pi.registerTool(tui.frame(spawn, {
+        summary: (args) => args.agent,
+        headerLine: "truncate",
+        footer: spawnFooter,
+    }));
+    pi.registerTool(tui.frame(send, {
+        summary: (args) => args.id,
+        headerLine: "truncate",
+        footer: childStateFooter,
+    }));
+    pi.registerTool(tui.frame(get, {
+        summary: (args) => args.id,
+        headerLine: "truncate",
+        footer: childStateFooter,
+    }));
+    pi.registerTool(tui.frame(list, {
+        summary: () => "owned children",
+        headerLine: "truncate",
+        footer: listFooter,
+    }));
+    pi.registerTool(tui.frame(stop, {
+        summary: (args) => args.id,
+        headerLine: "truncate",
+        footer: childStateFooter,
+    }));
 }
-export function registerChildTools(pi, identity, onReportOrOptions) {
-    const options = typeof onReportOrOptions === "function"
-        ? { onReport: onReportOrOptions }
-        : (onReportOrOptions ?? {});
+export function registerChildTools(pi, identity, options) {
+    registerToolTuiTrace(pi);
+    const tui = getToolTui(pi);
     const tool = {
         name: "contact_parent",
         label: "Contact parent",
@@ -137,22 +276,24 @@ export function registerChildTools(pi, identity, onReportOrOptions) {
             if (options.isBound !== undefined && !options.isBound(sessionId)) {
                 throw new Error("This Pi session is not the bound subagent session; contact_parent is disabled.");
             }
+            const reason = params.reason ?? "blocked";
             const details = {
                 type: "pi_subagent_report",
                 parentSessionId: identity.parentSessionId,
                 childId: identity.subagentId,
                 runtimeIdentity: identity.runtimeIdentity,
-                reason: params.reason,
+                reason,
                 message: params.message,
                 sessionId,
             };
-            await sendReportToRunner(identity, details, signal);
-            options.onReport?.();
-            return {
-                content: [{ type: "text", text: "Report queued for the parent." }],
-                details,
-            };
+            await options.report("contact_parent", details, signal);
+            return textToolResult(reason === "error"
+                ? "Error report delivered to the parent."
+                : "Blocker report queued for the parent.", details);
         },
     };
-    pi.registerTool(tool);
+    pi.registerTool(tui.frame(tool, {
+        summary: (args) => args.message,
+        headerLine: "truncate",
+    }));
 }

package/dist/widget.d.ts

@@ -1,16 +1,12 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import type { PublicSubagent } from "./domain.js";
+import { type PublicSubagent, type SubagentState } from "./domain.js";
+export declare const SUBAGENT_TERMINAL_DISPLAY_DURATION_MS = 15000;
 export interface SubagentWidget {
     refresh(children: readonly PublicSubagent[]): void;
     dispose(): void;
 }
-export declare function isWidgetVisibleChild(child: PublicSubagent): boolean;
+export declare function isTerminalState(state: SubagentState): boolean;
+export declare function isWidgetVisibleChild(child: PublicSubagent, nowMs?: number): boolean;
 export declare function formatElapsed(fromIso: string, nowMs?: number): string;
 export declare function renderSubagentWidget(children: readonly PublicSubagent[], width: number, theme: Theme, nowMs?: number): string[];
 export declare function createSubagentWidget(pi: ExtensionAPI, context: ExtensionContext, signal: AbortSignal, initial?: readonly PublicSubagent[]): SubagentWidget | undefined;
-export interface ChildIdentityWidgetOptions {
-    readonly agent: string;
-    readonly toolCount: number;
-}
-export declare function renderChildIdentityWidget(options: ChildIdentityWidgetOptions, width: number, theme: Theme): string[];
-export declare function createChildIdentityWidget(pi: ExtensionAPI, context: ExtensionContext, signal: AbortSignal, options: ChildIdentityWidgetOptions): SubagentWidget | undefined;

package/dist/widget.js

@@ -1,32 +1,26 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { registerWidget } from "@hheei/pi-ext-core";
+import { toVisualSubagentState, VISUAL_SUBAGENT_GLYPH, VISUAL_SUBAGENT_TONE, } from "./domain.js";
 const WIDGET_ID = "@hheei/pi-subagents:status";
-const CHILD_WIDGET_ID = "@hheei/pi-subagents:child-identity";
 const MAX_ROWS = 8;
 const ELAPSED_TICK_MS = 1_000;
-export function isWidgetVisibleChild(child) {
-    return child.state === "starting" || child.state === "running" || child.state === "idle";
+export const SUBAGENT_TERMINAL_DISPLAY_DURATION_MS = 15_000;
+export function isTerminalState(state) {
+    return state === "done" || state === "blocked" || state === "error";
 }
-function visibleChildren(children) {
-    return children.filter(isWidgetVisibleChild);
-}
-function stateGlyph(state, theme) {
-    if (state === "running")
-        return theme.fg("accent", "◐");
-    if (state === "starting")
-        return theme.fg("muted", "○");
-    return theme.fg("dim", "○");
-}
-function stateLabel(child, theme) {
-    const mode = child.mode === "tui" ? ` ${child.state} tui` : ` ${child.state}`;
-    const freshness = child.freshness === "last_known" ? " last known" : "";
-    const label = `${mode.trim()}${freshness}`;
-    if (child.state === "running" && child.freshness === "live")
-        return theme.fg("accent", label);
-    if (child.interrupted !== undefined || child.freshness === "last_known") {
-        return theme.fg("warning", label);
+export function isWidgetVisibleChild(child, nowMs = Date.now()) {
+    const visual = toVisualSubagentState(child.state, child.interrupted);
+    if (visual === "running") {
+        return true;
     }
-    return theme.fg("dim", label);
+    const updated = Date.parse(child.updatedAt);
+    if (!Number.isNaN(updated) && nowMs - updated < SUBAGENT_TERMINAL_DISPLAY_DURATION_MS) {
+        return true;
+    }
+    return false;
+}
+function visibleChildren(children, nowMs = Date.now()) {
+    return children.filter((c) => isWidgetVisibleChild(c, nowMs));
 }
 export function formatElapsed(fromIso, nowMs = Date.now()) {
     const from = Date.parse(fromIso);
@@ -43,30 +37,42 @@ export function formatElapsed(fromIso, nowMs = Date.now()) {
     return `${minutes}m ${seconds}s`;
 }
 export function renderSubagentWidget(children, width, theme, nowMs = Date.now()) {
-    const visible = visibleChildren(children);
+    const visible = visibleChildren(children, nowMs);
     if (visible.length === 0)
         return [];
-    const running = visible.filter((child) => child.state === "running").length;
-    const headingColor = running > 0 ? "accent" : "dim";
-    const heading = `${theme.fg(headingColor, running > 0 ? "●" : "○")} ${theme.fg("text", `Subagents (${visible.length})`)}`;
-    const lines = [truncateToWidth(heading, width, "...")];
+    const heading = `🤖 ${theme.fg("text", "Agents:")}`;
+    const lines = [truncateToWidth(heading, width, theme.fg("dim", "…"))];
     const rows = visible.slice(0, MAX_ROWS);
+    const sep = theme.fg("dim", " · ");
     for (let index = 0; index < rows.length; index++) {
         const child = rows[index];
         if (child === undefined)
             continue;
-        const last = index === rows.length - 1 && visible.length <= MAX_ROWS;
-        const branch = theme.fg("dim", last ? "└─" : "├─");
-        const name = theme.fg("text", child.displayName ?? child.agent);
+        const visual = toVisualSubagentState(child.state, child.interrupted);
+        const glyph = VISUAL_SUBAGENT_GLYPH[visual];
+        const tone = VISUAL_SUBAGENT_TONE[visual];
+        const glyphStyled = theme.fg(tone, glyph);
+        const idStyled = theme.fg("dim", `#${child.id}`);
+        const nameStyled = theme.fg("text", child.displayName ?? child.agent);
         const elapsed = formatElapsed(child.createdAt, nowMs);
-        const age = elapsed === "" ? "" : `  ${theme.fg("dim", `· ${elapsed}`)}`;
-        const snippet = child.summary === undefined ? "" : child.summary.replace(/\s+/g, " ").trim();
-        const summary = snippet === "" ? "" : `  ${theme.fg("dim", snippet)}`;
-        const id = theme.fg("dim", child.id);
-        lines.push(truncateToWidth(`${branch} ${stateGlyph(child.state, theme)} ${name}  ${stateLabel(child, theme)}${age}${summary}  ${id}`, width, "..."));
+        const timeStyled = theme.fg("dim", elapsed === "" ? "0s" : elapsed);
+        const stateStyled = theme.fg(tone, visual);
+        const turnsCount = child.usage?.turns ?? 0;
+        const turnsLabel = `${turnsCount} turn${turnsCount === 1 ? "" : "s"}`;
+        const turnsStyled = theme.fg("dim", turnsLabel);
+        let detailText = "";
+        if (child.activeTool !== undefined && child.activeTool.trim() !== "") {
+            detailText = child.activeTool.trim();
+        }
+        else if (child.summary !== undefined && child.summary.trim() !== "") {
+            detailText = child.summary.replace(/\s+/g, " ").trim();
+        }
+        const detailStyled = detailText === "" ? "" : `${sep}${theme.fg("dim", detailText)}`;
+        const rowContent = `${glyphStyled} ${idStyled} ${nameStyled}${sep}${timeStyled}${sep}${stateStyled}${sep}${turnsStyled}${detailStyled}`;
+        lines.push(truncateToWidth(rowContent, width, theme.fg("dim", "…")));
     }
     if (visible.length > MAX_ROWS) {
-        lines.push(truncateToWidth(theme.fg("dim", `└─ +${visible.length - MAX_ROWS} more`), width, "..."));
+        lines.push(truncateToWidth(theme.fg("dim", `+${visible.length - MAX_ROWS} more`), width, theme.fg("dim", "…")));
     }
     lines.push("");
     return lines;
@@ -99,10 +105,22 @@ export function createSubagentWidget(pi, context, signal, initial = []) {
             stopTick();
             return;
         }
+        // 仅在有进行中任务或待淡出任务时维持 tick，纯 idle 时静默
+        const hasActiveOrExpiring = children.some((child) => isWidgetVisibleChild(child));
+        if (!hasActiveOrExpiring) {
+            stopTick();
+            return;
+        }
         if (tick !== undefined)
             return;
         tick = setInterval(() => {
-            widget.requestRender();
+            if (!hasRows()) {
+                widget.setVisible(false);
+                stopTick();
+            }
+            else {
+                widget.requestRender();
+            }
         }, ELAPSED_TICK_MS);
     };
     syncTick();
@@ -129,30 +147,3 @@ export function createSubagentWidget(pi, context, signal, initial = []) {
         },
     };
 }
-export function renderChildIdentityWidget(options, width, theme) {
-    const label = options.agent.trim() === "" ? "child" : options.agent.trim();
-    const line = `${theme.fg("accent", `[${label}]`)} ${theme.fg("dim", "child")}  ${theme.fg("muted", "report via contact_parent")}  ${theme.fg("dim", `${options.toolCount} tools`)}`;
-    return [truncateToWidth(line, width, "..."), ""];
-}
-export function createChildIdentityWidget(pi, context, signal, options) {
-    if (context.mode !== "tui")
-        return undefined;
-    const widget = registerWidget(pi, context, signal, {
-        id: CHILD_WIDGET_ID,
-        placement: "aboveEditor",
-        visible: true,
-        create: (_tui, theme) => ({
-            render: (width) => renderChildIdentityWidget(options, width, theme),
-            invalidate: () => undefined,
-            dispose: () => undefined,
-        }),
-    });
-    return {
-        refresh(_next) {
-            widget.requestRender();
-        },
-        dispose() {
-            widget.dispose();
-        },
-    };
-}