@henryqw/pi-subagent 6.1.0 → 6.1.1

package/README.md

@@ -30,7 +30,7 @@ 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.
+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`
 
@@ -53,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 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.
+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.
 
@@ -76,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/extensions/delegate-flow.ts

@@ -108,6 +108,7 @@ type FlowState = {
 };
 
 type UsageMeter = { usage?: Usage };
+type FlowProgress = { line: string };
 
 type CommandResult = {
 	stdout: string;
@@ -176,9 +177,18 @@ 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 · working: ${count} unit${count === 1 ? "" : "s"}`;
+	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[] {
@@ -609,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!;
@@ -624,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);
@@ -690,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);
@@ -787,16 +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,
-		renderShell: "self",
 		renderCall(args, theme, _context) {
 			return renderToolLines([theme.fg("toolTitle", flowCallLabel(args))], theme);
 		},
-		renderResult(result, _options, theme, _context) {
+		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();
@@ -805,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(),
@@ -818,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;
@@ -855,6 +873,7 @@ 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,
@@ -866,11 +885,15 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					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()) {
@@ -892,16 +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,
-		renderShell: "self",
 		renderCall(_args, theme, _context) {
-			return renderToolLines([theme.fg("toolTitle", "delegate_flow_continue · working: repair continuation")], theme);
+			return renderToolLines([theme.fg("toolTitle", "delegate_flow_continue · repair continuation")], theme);
 		},
-		renderResult(result, _options, theme, _context) {
+		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.");
@@ -916,7 +939,12 @@ 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,
@@ -931,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

@@ -57,7 +57,8 @@ 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,
@@ -178,9 +179,30 @@ function isWorkflowTransportDetails(value: unknown): value is WorkflowTransportD
 }
 
 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";
+	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[] {
@@ -215,18 +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(0, width - indent.length);
-	const lines = visible.flatMap((item) => [
-		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(truncateToWidth(theme.fg("muted", `… ${items.length - visible.length} more`), 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;
 }
 
@@ -357,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, {
@@ -580,13 +607,14 @@ 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,
-		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 (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 renderToolLines([theme.fg("muted", "Background workflow accepted.")], theme);

package/package.json

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