@henryqw/pi-subagent 6.0.0 → 6.1.0

package/README.md

@@ -30,6 +30,8 @@ pi install npm:@henryqw/pi-subagent
 | `delegate_flow` | tool | Package-owned parallel implementation and declared-order Git integration for 1–8 independent units. |
 | `delegate_flow_continue` | tool | Repair the blocked Flow unit once in its existing worktree. |
 
+All three delegation tool blocks use a compact self-rendered shell and never exceed five physical lines, including Pi's leading spacer: one call line plus at most three result lines in either collapsed or expanded view.
+
 ### `delegate_task`
 
 Select exactly one shape:
@@ -51,7 +53,7 @@ Parallel mode starts entries concurrently, waits for every entry, and reports th
 
 Background workflows are session-scoped. Session shutdown or reload aborts them and may deliver only recoverable-work evidence or no follow-up message.
 
-The transient status widget owns live progress: spinner or terminal state, wrapped task summary, model, thinking level, tokens, and duration; at capacity, it evicts the oldest terminal row so new active work remains visible, and terminal rows otherwise clear on the next real user input. The final `delegate_task` block is deliberately minimal: bounded final summaries, role attribution for parallel/chain, and only retained-worktree recovery paths. It has no expanded view.
+The transient two-line status widget owns deterministic live progress: status and task summary above thinking or the active tool (with elapsed time and path basename), completed turns, started tools, model, thinking level, tokens, and total duration; terminal activity is Done, Failed, or Stopped. At capacity, it evicts the oldest terminal row so new active work remains visible, and terminal rows otherwise clear on the next real user input. The final `delegate_task` block is deliberately minimal: bounded final summaries, role attribution for parallel/chain, and only retained-worktree recovery paths. It has no expanded view.
 
 Each delegation resolves its own Role, resources, route, and optional worktree request. When available, `isolation: worktree` gives each entry a deterministic separate worktree; non-Git or unborn-`HEAD` contexts may use Main's cwd. Siblings and chain steps never implicitly share one created worktree.
 

package/dist/ephemeral.d.ts

@@ -8,10 +8,23 @@ export interface EphemeralSubagentExecutorOptions {
     maxConcurrency: number;
     timeout: EphemeralSubagentTimeout;
 }
+export type EphemeralSubagentActivityEvent = {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    path?: string;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: "message_end";
+};
 export interface EphemeralSubagentRunInput {
     signal?: AbortSignal;
     onUpdate?: (text: string) => void;
     onTokens?: (tokens: number) => void;
+    onActivity?: (event: EphemeralSubagentActivityEvent) => void;
     prepare: () => Promise<{
         launch: PiLaunch;
         task: string;

package/dist/ephemeral.js

@@ -4,6 +4,9 @@ import { basename } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 const MAX_OUTPUT_BYTES = 50 * 1024;
 const MAX_JSON_EVENT_BYTES = 1024 * 1024;
+const MAX_ACTIVITY_TEXT_BYTES = 4 * 1024;
+// A JSON string byte can take six source bytes (for example, \u0000).
+const MAX_ACTIVITY_PREFIX_BYTES = 2 * MAX_ACTIVITY_TEXT_BYTES * 6 + 1024;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const POST_EXIT_STDIO_IDLE_MS = 250;
 const POST_EXIT_STDIO_HARD_MS = 1_000;
@@ -34,6 +37,8 @@ const PI_JSON_EVENTS = {
 };
 const CONSUMED_JSON_EVENTS = new Set(["message_start", "message_update", "message_end"]);
 const JSON_EVENT_TYPE = /^\s*\{\s*"type"\s*:\s*"([^"\\]+)"/;
+const JSON_STRING = `"(?:[^"\\\\\u0000-\u001f]|\\\\(?:["\\\\/bfnrt]|u[0-9a-fA-F]{4}))*"`;
+const JSON_OVERSIZED_TOOL_START = new RegExp(`^\\s*\\{\\s*"type"\\s*:\\s*"tool_execution_start"\\s*,\\s*"toolCallId"\\s*:\\s*(${JSON_STRING})\\s*,\\s*"toolName"\\s*:\\s*(${JSON_STRING})(?=\\s*,)`);
 export class EphemeralSubagentError extends Error {
     name = "EphemeralSubagentError";
     code;
@@ -85,11 +90,15 @@ function validateRunInput(value) {
     if (input.onTokens !== undefined && typeof input.onTokens !== "function") {
         throw new TypeError("run.onTokens must be a function.");
     }
+    if (input.onActivity !== undefined && typeof input.onActivity !== "function") {
+        throw new TypeError("run.onActivity must be a function.");
+    }
     return {
         signal: input.signal,
         prepare: input.prepare,
         onUpdate: input.onUpdate,
         onTokens: input.onTokens,
+        onActivity: input.onActivity,
     };
 }
 function record(value, field) {
@@ -229,6 +238,33 @@ function assistantText(message) {
         .join("\n");
     return text || undefined;
 }
+function activityTooLong(value) {
+    return typeof value === "string" && Buffer.byteLength(value, "utf8") > MAX_ACTIVITY_TEXT_BYTES;
+}
+function hasTerminalControlChars(text) {
+    return Array.from(text).some((character) => {
+        const code = character.codePointAt(0);
+        return code <= 0x1f || code >= 0x7f && code <= 0x9f || code === 0x2028 || code === 0x2029;
+    });
+}
+function activityText(value) {
+    return typeof value === "string" && value.trim().length > 0 && !activityTooLong(value) && !hasTerminalControlChars(value);
+}
+function oversizedToolStart(prefix) {
+    const match = JSON_OVERSIZED_TOOL_START.exec(prefix);
+    if (!match)
+        return;
+    try {
+        const toolCallId = JSON.parse(match[1]);
+        const toolName = JSON.parse(match[2]);
+        if (!activityText(toolCallId) || !activityText(toolName))
+            return;
+        return { type: "tool_execution_start", toolCallId, toolName };
+    }
+    catch {
+        return;
+    }
+}
 function utf8Prefix(text, maxBytes) {
     return new StringDecoder().write(Buffer.from(text).subarray(0, maxBytes));
 }
@@ -471,16 +507,26 @@ async function runPi(prepared, input, timeoutPolicy, invocation) {
             signalCallbackFailure();
             stop(true);
         };
+        let activityQueue = Promise.resolve();
         const invokeCallback = (name, callback, value) => {
             if (!callback || callbackFailure)
                 return;
             let pending;
-            try {
-                pending = Promise.resolve(callback(value)).then(undefined, (cause) => { failCallback(name, cause); });
+            if (name === "onActivity") {
+                pending = activityQueue.then(() => {
+                    if (!callbackFailure)
+                        return callback(value);
+                }).catch((cause) => { failCallback(name, cause); });
+                activityQueue = pending;
             }
-            catch (cause) {
-                failCallback(name, cause);
-                return;
+            else {
+                try {
+                    pending = Promise.resolve(callback(value)).then(undefined, (cause) => { failCallback(name, cause); });
+                }
+                catch (cause) {
+                    failCallback(name, cause);
+                    return;
+                }
             }
             pendingCallbacks.add(pending);
             void pending.then(() => pendingCallbacks.delete(pending));
@@ -550,6 +596,29 @@ async function runPi(prepared, input, timeoutPolicy, invocation) {
                 }
                 return;
             }
+            if (record.type === "tool_execution_start" || record.type === "tool_execution_end") {
+                const { toolCallId, toolName } = record;
+                if (!activityText(toolCallId) || !activityText(toolName))
+                    return;
+                if (record.type === "tool_execution_start") {
+                    const args = record.args;
+                    const path = args && typeof args === "object" && !Array.isArray(args)
+                        ? args.path
+                        : undefined;
+                    if (activityTooLong(path))
+                        return;
+                    invokeCallback("onActivity", input.onActivity, {
+                        type: "tool_execution_start",
+                        toolCallId,
+                        toolName,
+                        ...(activityText(path) ? { path } : {}),
+                    });
+                }
+                else {
+                    invokeCallback("onActivity", input.onActivity, { type: "tool_execution_end", toolCallId, toolName });
+                }
+                return;
+            }
             if (record.type !== "message_end")
                 return;
             const text = assistantText(record.message);
@@ -566,6 +635,7 @@ async function runPi(prepared, input, timeoutPolicy, invocation) {
                     currentTokens = 0;
                     currentUsage = undefined;
                     invokeCallback("onTokens", input.onTokens, completedTokens);
+                    invokeCallback("onActivity", input.onActivity, { type: "message_end" });
                 }
                 if (typeof message.stopReason === "string")
                     stopReason = message.stopReason;
@@ -628,7 +698,9 @@ async function runPi(prepared, input, timeoutPolicy, invocation) {
                 const end = newline === -1 ? data.length : newline;
                 const part = data.slice(offset, end);
                 if (!ignoreLine) {
-                    linePrefix += part.slice(0, Math.max(0, 256 - linePrefix.length));
+                    const remainingPrefix = MAX_ACTIVITY_PREFIX_BYTES - Buffer.byteLength(linePrefix, "utf8");
+                    if (remainingPrefix > 0)
+                        linePrefix += utf8Prefix(part, remainingPrefix);
                     const eventType = JSON_EVENT_TYPE.exec(linePrefix)?.[1];
                     if (eventType && !lineEventType)
                         lineEventType = eventType;
@@ -652,6 +724,13 @@ async function runPi(prepared, input, timeoutPolicy, invocation) {
                     return;
                 if (!ignoreLine)
                     processLine(lineParts.join(""));
+                else if (lineEventType === "tool_execution_start") {
+                    const activity = oversizedToolStart(linePrefix);
+                    if (activity) {
+                        observeEvent();
+                        invokeCallback("onActivity", input.onActivity, activity);
+                    }
+                }
                 if (callbackFailure)
                     return;
                 lineParts = [];

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type HerdrExecutor } from "@henryqw/pi-herdr";
 import { type AvailableModel, type ProfileName, type ResolvedTaskRoute, type ThinkingLevel } from "@henryqw/pi-task-models";
-export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, formatDuration, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
+export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, formatDuration, type EphemeralSubagentActivityEvent, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, worktreeContextNote, type WorktreeDirtyInspection, type WorktreeInfo, type WorktreePayload, } from "./worktree.ts";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, type PreparedReviewEvidence, type PrepareExactReviewEvidenceInput, } from "./review-evidence.ts";
 export declare const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";

package/docs/orchestration.md

@@ -165,7 +165,7 @@ const executorOptions = {
 };
 ```
 
-Concurrency is FIFO. `run` accepts optional `signal`, `onUpdate(text)`, and `onTokens(number)` callbacks plus required `prepare()`. A queued run receives its permit before `prepare` executes, so resource and route resolution can use the latest Pi state. Queued time does not consume child timeout. `maxConcurrency`, `idleMs`, and `maxMs` must be positive; `maxMs` must exceed `idleMs`.
+Concurrency is FIFO. `run` accepts optional `signal`, `onUpdate(text)`, `onTokens(number)`, and `onActivity(event)` callbacks plus required `prepare()`. A queued run receives its permit before `prepare` executes, so resource and route resolution can use the latest Pi state. Queued time does not consume child timeout. `maxConcurrency`, `idleMs`, and `maxMs` must be positive; `maxMs` must exceed `idleMs`.
 
 The executor is **active-Pi-only**. It reuses the currently running Pi invocation and does not locate or support a standalone Node.js Pi installation. Once direct Pi exits, stdout/stderr drain normally until EOF; an escaped descendant retaining either stream is cut off after short output inactivity or a one-second hard deadline so it cannot retain the FIFO permit.
 
@@ -231,6 +231,18 @@ async function runRole(role, task, options = {}) {
 
 `run` resolves to `EphemeralSubagentResult`. Both outcome variants contain `exitCode`, `output`, `stderr`, and optional `stopReason`, `errorMessage`, and `usage`. A launched child/model failure is a typed `{ outcome: "failure", ... }` result. Abort, timeout, spawn, protocol, preparation, and callback failures reject with `EphemeralSubagentError` and a stable `code`. Assistant `output` and `stderr` are bounded, and `usage` contains aggregate child usage when Pi supplies it.
 
+### Activity callbacks
+
+The optional `onActivity` callback receives structured activity events serially in child JSON-event order. This ordering applies only to `onActivity`; `onUpdate` and `onTokens` remain independent. A thrown or rejected activity callback fails the run with an `EphemeralSubagentError` whose code is `callback`.
+
+| Event type | Fields |
+| --- | --- |
+| `tool_execution_start` | `toolCallId: string`, `toolName: string`, `path?: string` |
+| `tool_execution_end` | `toolCallId: string`, `toolName: string` |
+| `message_end` | none |
+
+Activity text is limited to 4 KiB per field. An invalid `toolCallId` or `toolName`, or an oversized `path`, drops the event. A blank path or one containing C0/C1 terminal controls or Unicode line/paragraph separators is omitted from an otherwise valid start event.
+
 The low-level executor does not interpret `Role.isolation`, discover resources, compose modes, create shared state, or promote child failure outcomes to tool errors. A direct caller that wants worktrees must call `createChildWorktree` after the permit, choose the returned `cwd`, call `finalizeChildWorktree` on every exit path, and preserve its recovery payload.
 
 Generic managed Herdr exports (`managedSubagentWorkspaceId`, reconciliation helpers, `startManagedSubagent`, prompting/listing, and retirement) consume the same launch policy for durable workers. They intentionally contain no workflow prompts, semantic state, or retry policy.

package/extensions/delegate-flow.ts

@@ -10,6 +10,7 @@ import {
 	inspectWorktreeDirty,
 	prepareExactReviewEvidence,
 	WorktreeSetupError,
+	type EphemeralSubagentActivityEvent,
 	type EphemeralSubagentExecutor,
 	type EphemeralSubagentResult,
 	type ResolvedRoleLaunch,
@@ -19,6 +20,7 @@ import {
 import { Type, type Static } from "typebox";
 import { Check } from "typebox/value";
 import { runDelegation } from "./delegation.ts";
+import { renderToolLines } from "./tool-render.ts";
 
 const MAX_UNITS = 8;
 const GIT_TIMEOUT_MS = 30_000;
@@ -129,6 +131,7 @@ export interface DelegateFlowRuntime {
 		ctx: ExtensionContext,
 	) => void;
 	updateWidgetTokens: (id: string, tokens: number) => void;
+	updateWidgetActivity: (id: string, event: EphemeralSubagentActivityEvent) => void;
 	finishWidget: (id: string, status: WidgetStatus) => void;
 }
 
@@ -173,6 +176,35 @@ export function parseDelegateFlowContinue(value: unknown): Static<typeof Delegat
 	};
 }
 
+function flowCallLabel(args: { units?: unknown }): string {
+	const count = Array.isArray(args.units) ? args.units.length : 0;
+	return `delegate_flow · working: ${count} unit${count === 1 ? "" : "s"}`;
+}
+
+function flowResultLines(text: string): string[] {
+	const lines = text.split(/\r?\n/).filter((line) => line.trim());
+	const diagnosticHeader = lines.findIndex((line) => line.trim() === "Diagnostic:");
+	const diagnostic = diagnosticHeader === -1 ? undefined : lines[diagnosticHeader + 1];
+	const recoveryHeader = lines.findIndex((line) => line.trim() === "Retained Flow state:" || line.trim() === "Attempted allocations preserved without cleanup:");
+	const recovery = recoveryHeader === -1 || !lines[recoveryHeader + 1]?.trim().startsWith("- unit=")
+		? undefined
+		: lines[recoveryHeader + 1];
+	if (diagnostic === undefined) {
+		if (recovery === undefined) return lines;
+		const recoveryIndex = lines.indexOf(recovery);
+		return [lines[0]!, recovery, ...lines.filter((_, index) => index !== 0 && index !== recoveryIndex)];
+	}
+	const leading = lines.slice(0, Math.min(1, diagnosticHeader));
+	if (recovery !== undefined) return [...leading, `Diagnostic: ${diagnostic}`, recovery];
+	// Promote the first diagnostic ahead of the result cap.
+	return [
+		...leading,
+		`Diagnostic: ${diagnostic}`,
+		...lines.slice(leading.length, diagnosticHeader),
+		...lines.slice(diagnosticHeader + 2),
+	];
+}
+
 function errorText(error: unknown): string {
 	return capOutput(error instanceof Error ? error.message : String(error));
 }
@@ -336,6 +368,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		role: Role,
 		modelClass: FlowModelClass,
 		task: string,
+		widgetTask: string,
 		cwd: string,
 		widgetId: string,
 		signal: AbortSignal | undefined,
@@ -348,13 +381,14 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			const result = await runDelegation(runtime.executor, {
 				signal,
 				onTokens: (tokens) => runtime.updateWidgetTokens(widgetId, tokens),
+				onActivity: (event) => runtime.updateWidgetActivity(widgetId, event),
 				prepare: async () => {
 					assertCurrent(flow);
 					const launch = runtime.resolveLaunch(role, modelClass, ctx);
 					if (launch.missingSkills.length) {
 						ctx.ui.notify(`Subagent role ${role.name} skipped unavailable Pi skills: ${launch.missingSkills.join(", ")}.`, "warning");
 					}
-					runtime.startWidget(widgetId, role.name, launch.model.id, launch.thinkingLevel, task, ctx);
+					runtime.startWidget(widgetId, role.name, launch.model.id, launch.thinkingLevel, widgetTask, ctx);
 					started = true;
 					return { launch, task, cwd };
 				},
@@ -464,6 +498,14 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		const lines = [
 			`Flow ${outcome}.`,
 			flow.completed.length ? `Completed units: ${flow.completed.map(({ id, noOp }) => `${JSON.stringify(id)}${noOp ? " (no-op)" : ""}`).join(", ")}` : "Completed units: none.",
+			...(flow.setupRecoveries.length ? [
+				"Attempted allocations preserved without cleanup:",
+				...flow.setupRecoveries.map((recovery) => `- unit=${JSON.stringify(recovery.id)} path=${JSON.stringify(recovery.path)} branch=${JSON.stringify(recovery.branch)} base=${recovery.base}`),
+			] : []),
+			...(retainedUnits.length ? [
+				"Retained Flow state:",
+				...retainedUnits.map((unit) => `- unit=${JSON.stringify(unit.id)} path=${JSON.stringify(unit.path)} branch=${JSON.stringify(unit.branch)} base=${unit.base} worktree=${unit.worktreeRetained} branch_ref=${unit.branchRetained}`),
+			] : []),
 			...(blocked ? [
 				`Blocked unit: ${JSON.stringify(blocked.unit.request.id)}.`,
 				`Classification: ${blocked.classification}.`,
@@ -473,14 +515,6 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			] : []),
 			...(failure ? [`Classification: ${failure.classification}.`, `Diagnostic:\n${failure.diagnostic}`] : []),
 			...(flow.warnings.length ? ["Warnings:", ...flow.warnings.map((warning) => `- ${warning}`)] : []),
-			...(flow.setupRecoveries.length ? [
-				"Attempted allocations preserved without cleanup:",
-				...flow.setupRecoveries.map((recovery) => `- unit=${JSON.stringify(recovery.id)} path=${JSON.stringify(recovery.path)} branch=${JSON.stringify(recovery.branch)} base=${recovery.base}`),
-			] : []),
-			...(retainedUnits.length ? [
-				"Retained Flow state:",
-				...retainedUnits.map((unit) => `- unit=${JSON.stringify(unit.id)} path=${JSON.stringify(unit.path)} branch=${JSON.stringify(unit.branch)} base=${unit.base} worktree=${unit.worktreeRetained} branch_ref=${unit.branchRetained}`),
-			] : []),
 		];
 		return {
 			content: [{ type: "text" as const, text: capOutput(lines.join("\n")) }],
@@ -672,6 +706,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 						reviewer,
 						unit.modelClass,
 						reviewerTask(unit.request, reviewCriterion, { base: evidence.base, tip: evidence.tip, patchPath: evidence.patchPath }),
+						unit.request.task,
 						unit.worktree.cwd,
 						`${toolCallId}:flow:${flow.index}:review`,
 						signal,
@@ -752,6 +787,14 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			"If a Flow blocks, inspect its classification and call delegate_flow_continue once with explicit repair guidance; modelClass may replace that one repair's current class.",
 		],
 		parameters: DelegateFlowSchema,
+		renderShell: "self",
+		renderCall(args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", flowCallLabel(args))], theme);
+		},
+		renderResult(result, _options, theme, _context) {
+			const text = result.content.find((part) => part.type === "text")?.text ?? "(no output)";
+			return renderToolLines(flowResultLines(text), theme);
+		},
 		prepareArguments: parseDelegateFlow,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			const request = parseDelegateFlow(params);
@@ -817,6 +860,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					flow.implementer,
 					unit.modelClass,
 					implementerTask(unit.request),
+					unit.request.task,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${index}:implement`,
 					operationSignal,
@@ -848,6 +892,14 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		promptSnippet: "Repair and continue the blocked deterministic Flow",
 		promptGuidelines: ["Call delegate_flow_continue only after delegate_flow reports a repairable block, with explicit guidance addressing that block."],
 		parameters: DelegateFlowContinueSchema,
+		renderShell: "self",
+		renderCall(_args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", "delegate_flow_continue · working: repair continuation")], theme);
+		},
+		renderResult(result, _options, theme, _context) {
+			const text = result.content.find((part) => part.type === "text")?.text ?? "(no output)";
+			return renderToolLines(flowResultLines(text), theme);
+		},
 		prepareArguments: parseDelegateFlowContinue,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			const { guidance, modelClass } = parseDelegateFlowContinue(params);
@@ -870,6 +922,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					flow.implementer,
 					unit.modelClass,
 					repairTask(unit.request, blocked, guidance),
+					unit.request.task,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${flow.index}:repair`,
 					operationSignal,

package/extensions/subagent.ts

@@ -1,6 +1,7 @@
+import { basename } from "node:path";
 import type { Usage } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
-import { type Component, type TUI, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { type Component, type TUI, truncateToWidth } from "@earendil-works/pi-tui";
 import {
 	availableTaskModels,
 	type ThinkingLevel,
@@ -21,6 +22,7 @@ import {
 	loadRoles,
 	resolveTaskRoute,
 	worktreeContextNote,
+	type EphemeralSubagentActivityEvent,
 	type EphemeralSubagentResult,
 	type EphemeralSubagentTimeout,
 	type Role,
@@ -29,6 +31,7 @@ import {
 } from "@henryqw/pi-subagent";
 import { DEFAULT_TIMEOUT_CONFIG, readSubagentConfig, type SubagentTimeoutConfig } from "./config.ts";
 import { registerDelegateFlow } from "./delegate-flow.ts";
+import { renderToolLines } from "./tool-render.ts";
 import { runDelegation } from "./delegation.ts";
 import {
 	formatBackgroundWorkflowResult,
@@ -55,6 +58,7 @@ const SUBAGENT_TASK = "pi-subagent/delegateTask";
 const WIDGET_KEY = "subagent-status";
 const WIDGET_INTERVAL_MS = 80;
 const MAX_WIDGET_ROWS = 8;
+export const MAX_WIDGET_ACTIVE_TOOLS = 8;
 const DEFAULT_TIMEOUT_POLICY = {
 	idleMs: DEFAULT_TIMEOUT_CONFIG.idleMinutes * 60_000,
 	maxMs: DEFAULT_TIMEOUT_CONFIG.maxMinutes * 60_000,
@@ -71,6 +75,12 @@ export function resolveTimeoutPolicy(partial: SubagentTimeoutConfig | undefined)
 	};
 }
 type WidgetStatus = "working" | "success" | "failure" | "aborted";
+type WidgetActiveTool = {
+	toolName: string;
+	path?: string;
+	startedAt: number;
+	order: number;
+};
 type WidgetItem = {
 	role: string;
 	model: string;
@@ -80,6 +90,11 @@ type WidgetItem = {
 	startedAt: number;
 	status: WidgetStatus;
 	finishedAt?: number;
+	completedAssistantTurns: number;
+	startedToolCount: number;
+	activeTools: Map<string, WidgetActiveTool>;
+	activeToolId?: string;
+	activityOrder: number;
 };
 
 function taskSummary(task: string): string {
@@ -111,6 +126,34 @@ function statusLabel(status: WidgetStatus): string {
 	}
 }
 
+function activityLabel(item: WidgetItem, now: number): string {
+	if (item.status === "success") return "Done";
+	if (item.status === "failure") return "Failed";
+	if (item.status === "aborted") return "Stopped";
+	const activeTool = item.activeToolId === undefined ? undefined : item.activeTools.get(item.activeToolId);
+	if (!activeTool) return "thinking…";
+	return [
+		activeTool.toolName,
+		formatDuration(now - activeTool.startedAt),
+		...(activeTool.path === undefined ? [] : [activeTool.path]),
+	].join(" · ");
+}
+
+function activityMetrics(item: WidgetItem, now: number): string {
+	return [
+		...(item.completedAssistantTurns === 0
+			? []
+			: [`${item.completedAssistantTurns} turn${item.completedAssistantTurns === 1 ? "" : "s"}`]),
+		...(item.startedToolCount === 0
+			? []
+			: [`${item.startedToolCount} tool${item.startedToolCount === 1 ? "" : "s"}`]),
+		item.model,
+		item.thinkingLevel,
+		`${formatTokens(item.tokens)} tok`,
+		formatDuration((item.finishedAt ?? now) - item.startedAt),
+	].join(" · ");
+}
+
 function isWorkflowTransportDetails(value: unknown): value is WorkflowTransportDetails {
 	const isRecord = (candidate: unknown): candidate is Record<string, unknown> => typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
 	const isOptionalString = (candidate: unknown) => candidate === undefined || typeof candidate === "string";
@@ -134,18 +177,34 @@ function isWorkflowTransportDetails(value: unknown): value is WorkflowTransportD
 		&& entries.every((entry, index) => index === 0 || (entry as { index: number }).index > (entries[index - 1] as { index: number }).index);
 }
 
-function renderWorkflowResult(details: WorkflowTransportDetails, width: number, theme: Theme): string[] {
+function workflowCallLabel(args: { tasks?: unknown; chain?: unknown }): string {
+	if (Array.isArray(args.chain)) return `delegate_task · working: chain · ${args.chain.length} task${args.chain.length === 1 ? "" : "s"}`;
+	if (Array.isArray(args.tasks)) return `delegate_task · working: parallel · ${args.tasks.length} task${args.tasks.length === 1 ? "" : "s"}`;
+	return "delegate_task · working: single · 1 task";
+}
+
+function workflowResultLines(details: WorkflowTransportDetails, theme: Theme): string[] {
 	if (details.entries.some(({ status }) => status === "pending" || status === "running")) return [];
-	return details.entries.flatMap((entry) => {
-		if (entry.status === "skipped") return [];
+	const entries = details.entries.filter(({ status }) => status !== "skipped");
+	const withRecovery = (entry: typeof entries[0]) => entry.worktree && !entry.worktree.pruned;
+	const isTerminalFailure = (entry: typeof entries[0]) => entry.status === "failed" || entry.status === "rejected";
+	const sorted = [...entries].sort((a, b) => {
+		const aFailure = isTerminalFailure(a);
+		const bFailure = isTerminalFailure(b);
+		if (aFailure !== bFailure) return aFailure ? -1 : 1;
+		const aRecovery = !aFailure && withRecovery(a);
+		const bRecovery = !bFailure && withRecovery(b);
+		if (aRecovery !== bRecovery) return aRecovery ? -1 : 1;
+		return 0;
+	});
+	return sorted.map((entry) => {
 		const summary = entry.summary || "(no output)";
 		const text = details.mode === "single" ? summary : `${entry.role}: ${summary}`;
 		const style = entry.status === "failed" || entry.status === "rejected" ? "error" : "text";
-		const recovery = entry.worktree && !entry.worktree.pruned ? `Recovery: ${entry.worktree.path}` : undefined;
-		return [
-			...wrapTextWithAnsi(theme.fg(style, text), Math.max(1, width)),
-			...(recovery ? wrapTextWithAnsi(theme.fg("warning", recovery), Math.max(1, width)) : []),
-		];
+		const recovery = withRecovery(entry) ? `Recovery: ${entry.worktree!.path}` : undefined;
+		return recovery === undefined
+			? theme.fg(style, text)
+			: `${theme.fg("warning", recovery)} · ${theme.fg(style, text)}`;
 	});
 }
 
@@ -159,13 +218,15 @@ function renderWidgetRows(
 	const visible = items.slice(0, MAX_WIDGET_ROWS);
 	if (!visible.length) return [];
 	const indent = " ".repeat(Math.min(2, Math.max(0, width - 1)));
-	const contentWidth = Math.max(1, width - indent.length);
+	const contentWidth = Math.max(0, width - indent.length);
 	const lines = visible.flatMap((item) => [
-		...wrapTextWithAnsi(`${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", item.role)} · ${statusLabel(item.status)}`, Math.max(1, width)),
-		...wrapTextWithAnsi(theme.fg("text", item.task), contentWidth).map((line) => `${indent}${line}`),
-		...wrapTextWithAnsi(theme.fg("muted", `${item.model} · ${item.thinkingLevel} · ${formatTokens(item.tokens)} tok · ${formatDuration((item.finishedAt ?? now) - item.startedAt)}`), contentWidth).map((line) => `${indent}${line}`),
+		truncateToWidth(
+			`${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", item.role)} · ${statusLabel(item.status)} · ${theme.fg("text", item.task)}`,
+			width,
+		),
+		`${indent}${truncateToWidth(`${theme.fg("text", activityLabel(item, now))} · ${theme.fg("muted", activityMetrics(item, now))}`, contentWidth)}`,
 	]);
-	if (items.length > visible.length) lines.push(...wrapTextWithAnsi(theme.fg("muted", `… ${items.length - visible.length} more`), Math.max(1, width)));
+	if (items.length > visible.length) lines.push(truncateToWidth(theme.fg("muted", `… ${items.length - visible.length} more`), width));
 	return lines;
 }
 
@@ -311,6 +372,10 @@ export default function subagentExtension(
 			tokens: 0,
 			startedAt: Date.now(),
 			status: "working",
+			completedAssistantTurns: 0,
+			startedToolCount: 0,
+			activeTools: new Map(),
+			activityOrder: 0,
 		});
 		startWidgetTimer();
 		requestWidgetRender();
@@ -323,11 +388,55 @@ export default function subagentExtension(
 		requestWidgetRender();
 	};
 
+	const updateWidgetActivity = (id: string, event: EphemeralSubagentActivityEvent) => {
+		const item = widgetItems.get(id);
+		if (!item || item.status !== "working") return;
+		switch (event.type) {
+			case "tool_execution_start": {
+				if (item.activeTools.has(event.toolCallId)) break;
+				if (item.activeTools.size >= MAX_WIDGET_ACTIVE_TOOLS) {
+					let oldest: [string, WidgetActiveTool] | undefined;
+					for (const candidate of item.activeTools) {
+						if (!oldest || candidate[1].order < oldest[1].order) oldest = candidate;
+					}
+					if (oldest) item.activeTools.delete(oldest[0]);
+				}
+				const path = event.path === undefined ? undefined : basename(event.path);
+				item.startedToolCount += 1;
+				item.activeTools.set(event.toolCallId, {
+					toolName: event.toolName,
+					...(path ? { path } : {}),
+					startedAt: Date.now(),
+					order: ++item.activityOrder,
+				});
+				item.activeToolId = event.toolCallId;
+				break;
+			}
+			case "tool_execution_end": {
+				item.activeTools.delete(event.toolCallId);
+				if (item.activeToolId === event.toolCallId) {
+					let latest: [string, WidgetActiveTool] | undefined;
+					for (const candidate of item.activeTools) {
+						if (!latest || candidate[1].order > latest[1].order) latest = candidate;
+					}
+					item.activeToolId = latest?.[0];
+				}
+				break;
+			}
+			case "message_end":
+				item.completedAssistantTurns += 1;
+				break;
+		}
+		requestWidgetRender();
+	};
+
 	const finishWidgetItem = (id: string, status: Exclude<WidgetStatus, "working">) => {
 		const item = widgetItems.get(id);
 		if (!item) return;
 		item.status = status;
 		item.finishedAt = Date.now();
+		item.activeTools.clear();
+		item.activeToolId = undefined;
 		if (![...widgetItems.values()].some(({ status }) => status === "working")) stopWidgetTimer();
 		requestWidgetRender();
 	};
@@ -454,6 +563,7 @@ export default function subagentExtension(
 		},
 		startWidget: startWidgetItem,
 		updateWidgetTokens,
+		updateWidgetActivity,
 		finishWidget: finishWidgetItem,
 	});
 
@@ -470,19 +580,19 @@ export default function subagentExtension(
 			"delegate_task background applies to the whole selected workflow and returns before results exist; use it only when the user explicitly asks for non-blocking work.",
 		],
 		parameters: WorkflowSchema,
-		renderResult(result, _options, theme, _context) {
+		renderShell: "self",
+		renderCall(args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", workflowCallLabel(args))], theme);
+		},
+		renderResult(result, { isPartial }, theme, _context) {
+			if (isPartial) return renderToolLines([], theme);
 			const details = result.details;
-			if (isWorkflowTransportDetails(details)) {
-				return {
-					invalidate() {},
-					render: (width) => renderWorkflowResult(details, width, theme),
-				};
-			}
+			if (isWorkflowTransportDetails(details)) return renderToolLines(workflowResultLines(details, theme), theme);
 			if (typeof details === "object" && details !== null && (details as { background?: unknown }).background === true) {
-				return { invalidate() {}, render: (width) => wrapTextWithAnsi(theme.fg("muted", "Background workflow accepted."), Math.max(1, width)) };
+				return renderToolLines([theme.fg("muted", "Background workflow accepted.")], theme);
 			}
 			const text = result.content.find((part) => part.type === "text")?.text ?? "(no output)";
-			return { invalidate() {}, render: (width) => wrapTextWithAnsi(theme.fg("muted", text), Math.max(1, width)) };
+			return renderToolLines([theme.fg("muted", text)], theme);
 		},
 		prepareArguments(args) {
 			try {
@@ -593,6 +703,7 @@ export default function subagentExtension(
 								emitUpdate(emitToolUpdates);
 							},
 							onTokens: (tokens) => updateWidgetTokens(entry.id, tokens),
+							onActivity: (event) => updateWidgetActivity(entry.id, event),
 							prepare: async () => {
 								// Route and effective Role resources resolve only after this entry's
 								// shared executor permit, before isolated state is created.

package/extensions/tool-render.ts

@@ -0,0 +1,16 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth } from "@earendil-works/pi-tui";
+
+export const MAX_RENDERED_RESULT_LINES = 3;
+
+export function renderToolLines(lines: readonly string[], theme: Theme): Component {
+	return {
+		invalidate() {},
+		render: (width) => {
+			const shown = lines.length > MAX_RENDERED_RESULT_LINES
+				? [...lines.slice(0, MAX_RENDERED_RESULT_LINES - 1), theme.fg("muted", `… ${lines.length - MAX_RENDERED_RESULT_LINES + 1} more`)]
+				: lines;
+			return shown.map((line) => truncateToWidth(line.replace(/[\r\n]+/g, " "), width));
+		},
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "Delegate bounded single, parallel, or chained tasks to isolated Pi roles.",
   "keywords": [
     "pi-package",