@henryqw/pi-subagent 6.0.0 → 6.1.1

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 Pi's default boxed shell and background. Their compact custom content is an immutable call label, foreground aggregate partial-result status, and bounded final summaries—no 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 status widget renders one line per child with: status glyph, role, status label, task summary, activity (thinking… or active tool with elapsed time and path basename), and metrics (completed turns, started tools, model, thinking level, tokens, total duration). Rows are ordered active-first (working items first, stable insertion order for the rest). A hard six-physical-line maximum applies: when total items are six or fewer, all child rows render; above six, five child rows plus one status-aware overflow line render (`… N more · X working · Y complete · Z failed · W stopped`). Terminal rows clear on the next real user input; active rows persist until the child settles. The final `delegate_task` block is deliberately minimal: bounded final summaries with 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.
 
@@ -74,6 +76,18 @@ A rebase that drops all unit commits is a no-op: Flow validates it, skips Review
 
 `delegate_task` remains generic with its ordinary isolation behavior. Flow uses the package-shipped Implementer by default and the package-shipped Reviewer only when a unit requests review; same-named user Roles remain supported overrides.
 
+### Delegate UI summary
+
+| Aspect | Behavior |
+| --- | --- |
+| Call label | `delegate_task · single/parallel/chain · N task(s)`; `delegate_flow · parallel→serial · N unit(s)`; `delegate_flow_continue · repair continuation` |
+| Partial progress | `delegate_task`: aggregate counts (running/pending/complete/failed/skipped); `delegate_flow`: phase transitions (setup → implement → verify/integrate → review → repair) |
+| Widget rows | One line per child: glyph, role, status, task, activity, metrics |
+| Ordering | Active-first stable (working first, then insertion order) |
+| Line cap | 6 physical lines max (≤6 items: all child rows; >6 items: 5 rows + 1 status-aware overflow) |
+| Terminal retention | Active rows persist; terminal rows clear on next user input |
+| Final result | Bounded summaries with recovery paths; no expanded view |
+
 ## Config
 
 pi-subagent owns the extension-named config directory `~/.pi/agent/config/pi-subagent/`, which holds two kinds of user-owned configuration: one Markdown file per Role (see [Roles](#roles)) and its own optional JSON file below. Model routing is *not* configured here; children resolve routes through the shared `@henryqw/pi-task-models` config at `~/.pi/agent/config/pi-task-models.json`.

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;
@@ -106,6 +108,7 @@ type FlowState = {
 };
 
 type UsageMeter = { usage?: Usage };
+type FlowProgress = { line: string };
 
 type CommandResult = {
 	stdout: string;
@@ -129,6 +132,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 +177,44 @@ export function parseDelegateFlowContinue(value: unknown): Static<typeof Delegat
 	};
 }
 
+function unitCount(count: number): string {
+	return `${count} unit${count === 1 ? "" : "s"}`;
+}
+
+function flowCallLabel(args: { units?: unknown }): string {
+	const count = Array.isArray(args.units) ? args.units.length : 0;
+	return `delegate_flow · parallel→serial · ${unitCount(count)}`;
+}
+
+function isFlowProgress(value: unknown): value is FlowProgress {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		&& typeof (value as { line?: unknown }).line === "string";
+}
+
+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 +378,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 +391,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 +508,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 +525,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")) }],
@@ -575,6 +619,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		signal: AbortSignal | undefined,
 		ctx: ExtensionContext,
 		meter: UsageMeter,
+		emitProgress: (line: string) => void,
 	) => {
 		assertCurrent(flow);
 		const main = flow.main!;
@@ -590,6 +635,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 
 			const implementationFailure = settlementFailure(unit.implementation!);
 			if (implementationFailure) return block(flow, unit, "implementer", implementationFailure, meter);
+			emitProgress(`verify/integrate · unit ${flow.index + 1}/${flow.units.length}`);
 
 			let inspected = await inspectUnit(unit, false, signal);
 			assertCurrent(flow);
@@ -656,6 +702,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			if (reviewCriterion !== undefined) {
 				const reviewer = flow.reviewer;
 				if (!reviewer) return terminal(flow, "infrastructure", "Flow Reviewer was not resolved for a unit that requires review.", meter);
+				emitProgress(`review · unit ${flow.index + 1}/${flow.units.length}`);
 				let evidence;
 				try {
 					evidence = await prepareExactReviewEvidence({ base: main.expectedHead, tip, worktree: unit.worktree.path }, signal);
@@ -672,6 +719,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,8 +800,16 @@ 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,
+		renderCall(args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", flowCallLabel(args))], theme);
+		},
+		renderResult(result, { isPartial }, theme, _context) {
+			if (isPartial) return renderToolLines(isFlowProgress(result.details) ? [theme.fg("muted", result.details.line)] : [], theme);
+			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) {
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
 			const request = parseDelegateFlow(params);
 			if (active) throw new Error("delegate_flow rejected because another Flow is active.");
 			const roles = runtime.loadRoles();
@@ -762,6 +818,10 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			const reviewer = needsReviewer ? roles.find(({ name }) => name === "reviewer") : undefined;
 			if (!implementer) throw new Error("delegate_flow requires an implementer Role.");
 			if (needsReviewer && !reviewer) throw new Error("delegate_flow requires a reviewer Role when a unit declares review.");
+			const emitProgress = (line: string) => {
+				const progress: FlowProgress = { line };
+				onUpdate?.({ content: [{ type: "text", text: progress.line }], details: progress });
+			};
 			const flow: FlowState = {
 				phase: "running",
 				generation: runtime.getSessionGeneration(),
@@ -775,6 +835,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 				warnings: [],
 			};
 			active = flow;
+			emitProgress(`setup · ${unitCount(request.units.length)}`);
 			const operationSignal = bindSignal(flow, signal);
 			const meter: UsageMeter = {};
 			let setupComplete = false;
@@ -812,21 +873,27 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 				await checkMain(flow.main, operationSignal);
 				assertCurrent(flow);
 				setupComplete = true;
+				let completedImplementers = 0;
 				const settlements = await Promise.all(flow.units.map((unit, index) => runChild(
 					flow,
 					flow.implementer,
 					unit.modelClass,
 					implementerTask(unit.request),
+					unit.request.task,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${index}:implement`,
 					operationSignal,
 					ctx,
 					meter,
-				)));
+				).then((settlement) => {
+					completedImplementers += 1;
+					emitProgress(`implement · ${completedImplementers}/${flow.units.length} complete`);
+					return settlement;
+				})));
 				for (const [index, settlement] of settlements.entries()) flow.units[index]!.implementation = settlement;
 				assertCurrent(flow);
 				if (operationSignal.aborted) operationSignal.throwIfAborted();
-				return await processFlow(flow, toolCallId, operationSignal, ctx, meter);
+				return await processFlow(flow, toolCallId, operationSignal, ctx, meter, emitProgress);
 			} catch (error) {
 				if (!setupComplete) {
 					for (const unit of [...flow.units].reverse()) {
@@ -848,8 +915,16 @@ 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,
+		renderCall(_args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", "delegate_flow_continue · repair continuation")], theme);
+		},
+		renderResult(result, { isPartial }, theme, _context) {
+			if (isPartial) return renderToolLines(isFlowProgress(result.details) ? [theme.fg("muted", result.details.line)] : [], theme);
+			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) {
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
 			const { guidance, modelClass } = parseDelegateFlowContinue(params);
 			const flow = active;
 			if (!flow) throw new Error("delegate_flow_continue requires an active blocked Flow.");
@@ -864,12 +939,18 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			if (modelClass !== undefined) unit.modelClass = modelClass;
 			const operationSignal = bindSignal(flow, signal);
 			const meter: UsageMeter = {};
+			const emitProgress = (line: string) => {
+				const progress: FlowProgress = { line };
+				onUpdate?.({ content: [{ type: "text", text: progress.line }], details: progress });
+			};
 			try {
+				emitProgress(`repair · unit ${flow.index + 1}/${flow.units.length}`);
 				unit.implementation = await runChild(
 					flow,
 					flow.implementer,
 					unit.modelClass,
 					repairTask(unit.request, blocked, guidance),
+					unit.request.task,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${flow.index}:repair`,
 					operationSignal,
@@ -878,7 +959,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 				);
 				assertCurrent(flow);
 				if (operationSignal.aborted) operationSignal.throwIfAborted();
-				return await processFlow(flow, toolCallId, operationSignal, ctx, meter);
+				return await processFlow(flow, toolCallId, operationSignal, ctx, meter, emitProgress);
 			} catch (error) {
 				return terminal(flow, "infrastructure", errorText(error), meter);
 			}

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,
@@ -54,7 +57,9 @@ import {
 const SUBAGENT_TASK = "pi-subagent/delegateTask";
 const WIDGET_KEY = "subagent-status";
 const WIDGET_INTERVAL_MS = 80;
-const MAX_WIDGET_ROWS = 8;
+const MAX_WIDGET_ITEMS = 8;
+const MAX_WIDGET_LINES = 6;
+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 +76,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 +91,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 +127,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 +178,55 @@ 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 · chain · ${args.chain.length} task${args.chain.length === 1 ? "" : "s"}`;
+	if (Array.isArray(args.tasks)) return `delegate_task · parallel · ${args.tasks.length} task${args.tasks.length === 1 ? "" : "s"}`;
+	return "delegate_task · single · 1 task";
+}
+
+function workflowProgressLine(details: WorkflowTransportDetails): string {
+	let running = 0;
+	let pending = 0;
+	let complete = 0;
+	let failed = 0;
+	let skipped = 0;
+	for (const { status } of details.entries) {
+		switch (status) {
+			case "running": running += 1; break;
+			case "pending": pending += 1; break;
+			case "succeeded": complete += 1; break;
+			case "failed":
+			case "rejected": failed += 1; break;
+			case "skipped": skipped += 1; break;
+		}
+	}
+	return [[running, "running"], [pending, "pending"], [complete, "complete"], [failed, "failed"], [skipped, "skipped"]]
+		.flatMap(([count, label]) => count ? [`${count} ${label}`] : [])
+		.join(" · ");
+}
+
+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)}`;
 	});
 }
 
@@ -156,16 +237,23 @@ function renderWidgetRows(
 	spinnerIndex: number,
 	theme: Theme,
 ): string[] {
-	const visible = items.slice(0, MAX_WIDGET_ROWS);
+	const ordered = [...items.filter(({ status }) => status === "working"), ...items.filter(({ status }) => status !== "working")];
+	const visible = ordered.slice(0, ordered.length > MAX_WIDGET_LINES ? MAX_WIDGET_LINES - 1 : MAX_WIDGET_LINES);
 	if (!visible.length) return [];
-	const indent = " ".repeat(Math.min(2, Math.max(0, width - 1)));
-	const contentWidth = Math.max(1, 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}`),
-	]);
-	if (items.length > visible.length) lines.push(...wrapTextWithAnsi(theme.fg("muted", `… ${items.length - visible.length} more`), Math.max(1, width)));
+	const hidden = ordered.slice(visible.length);
+	const lines = visible.map((item) => truncateToWidth(
+		`${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", item.role)} · ${statusLabel(item.status)} · ${theme.fg("text", item.task)} · ${theme.fg("text", activityLabel(item, now))} · ${theme.fg("muted", activityMetrics(item, now))}`,
+		width,
+	));
+	if (hidden.length) {
+		const counts: Record<WidgetStatus, number> = { working: 0, success: 0, failure: 0, aborted: 0 };
+		for (const { status } of hidden) counts[status] += 1;
+		lines.push(truncateToWidth(theme.fg("muted", [
+			`… ${hidden.length} more`,
+			...(["working", "success", "failure", "aborted"] as const).flatMap((status) =>
+				counts[status] ? [`${counts[status]} ${statusLabel(status)}`] : []),
+		].join(" · ")), width));
+	}
 	return lines;
 }
 
@@ -296,11 +384,11 @@ export default function subagentExtension(
 	) => {
 		if (!ctx.hasUI) return;
 		ensureWidget(ctx);
-		if (!widgetItems.has(id) && widgetItems.size >= MAX_WIDGET_ROWS) {
+		if (!widgetItems.has(id) && widgetItems.size >= MAX_WIDGET_ITEMS) {
 			for (const [oldestId, item] of widgetItems) {
 				if (item.status === "working") continue;
 				widgetItems.delete(oldestId);
-				if (widgetItems.size < MAX_WIDGET_ROWS) break;
+				if (widgetItems.size < MAX_WIDGET_ITEMS) break;
 			}
 		}
 		widgetItems.set(id, {
@@ -311,6 +399,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 +415,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 +590,7 @@ export default function subagentExtension(
 		},
 		startWidget: startWidgetItem,
 		updateWidgetTokens,
+		updateWidgetActivity,
 		finishWidget: finishWidgetItem,
 	});
 
@@ -470,19 +607,20 @@ 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) {
+		renderCall(args, theme, _context) {
+			return renderToolLines([theme.fg("toolTitle", workflowCallLabel(args))], theme);
+		},
+		renderResult(result, { isPartial }, theme, _context) {
 			const details = result.details;
-			if (isWorkflowTransportDetails(details)) {
-				return {
-					invalidate() {},
-					render: (width) => renderWorkflowResult(details, width, theme),
-				};
-			}
+			if (isPartial) return renderToolLines(isWorkflowTransportDetails(details)
+				? [theme.fg("muted", workflowProgressLine(details))]
+				: [], 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 +731,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.1",
   "description": "Delegate bounded single, parallel, or chained tasks to isolated Pi roles.",
   "keywords": [
     "pi-package",