@henryqw/pi-subagent 15.0.0 → 15.0.2

package/README.md

@@ -64,7 +64,9 @@ An explicit `model` (`provider/modelId`) replaces only the route model and must
 
 Parallel tasks start together, settle together, and report in input order. Chains are sequential and fail at the first failure. `{previous}` passes only the immediately preceding successful assistant output.
 
-Foreground failures throw after keeping bounded sibling and recovery evidence. One call has one aggregate 50 KiB cap for Main-visible text. Live updates show task names and statuses without opaque IDs. Final results show summaries first and full evidence below.
+Foreground failures throw after keeping bounded sibling and recovery evidence. One call has one aggregate 50 KiB cap for Main-visible text. Final results show summaries first and full evidence below.
+
+The status widget shows each task group name above at most three indented child rows. Each row shows a one-letter Role badge, status, activity, usage, and duration. Flow stages for one unit share that unit's heading.
 
 Background work belongs to its launching session. Shutdown or reload aborts it and may leave only recoverable-work evidence or no follow-up message.
 

package/extensions/delegate-flow.ts

@@ -65,6 +65,7 @@ type ChildSettlement =
 type UnitState = {
 	request: FlowUnitRequest;
 	modelClass: FlowModelClass;
+	widgetTaskId: string;
 	worktree: WorktreeInfo;
 	base: string;
 	implementation?: ChildSettlement;
@@ -125,12 +126,14 @@ export interface DelegateFlowRuntime {
 	resolveLaunch: (role: Role, modelClass: FlowModelClass, ctx: ExtensionContext) => ResolvedRoleLaunch;
 	startWidget: (
 		id: string,
+		taskId: string,
 		role: string,
 		model: string,
 		thinkingLevel: string | undefined,
 		name: string,
 		ctx: ExtensionContext,
 	) => void;
+	setWidgetTaskRetained: (taskId: string, retained: boolean) => void;
 	updateWidgetTokens: (id: string, tokens: number) => void;
 	updateWidgetActivity: (id: string, event: EphemeralSubagentActivityEvent) => void;
 	finishWidget: (id: string, status: WidgetStatus) => void;
@@ -262,6 +265,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		signal ? AbortSignal.any([signal, flow.sessionController.signal]) : flow.sessionController.signal;
 
 	const invalidateActive = (): void => {
+		if (active?.blocked) runtime.setWidgetTaskRetained(active.blocked.unit.widgetTaskId, false);
 		active?.sessionController.abort(new Error("Flow session ended."));
 		active = undefined;
 	};
@@ -346,6 +350,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		modelClass: FlowModelClass,
 		task: string,
 		widgetName: string,
+		widgetTaskId: string,
 		cwd: string,
 		widgetId: string,
 		signal: AbortSignal | undefined,
@@ -365,7 +370,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					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, widgetName, ctx);
+					runtime.startWidget(widgetId, widgetTaskId, role.name, launch.model.id, launch.thinkingLevel, widgetName, ctx);
 					started = true;
 					return { launch, task, cwd };
 				},
@@ -506,6 +511,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		diagnostic: string,
 		meter: UsageMeter,
 	) => {
+		if (flow.blocked) runtime.setWidgetTaskRetained(flow.blocked.unit.widgetTaskId, false);
 		if (active === flow) active = undefined;
 		return response(flow, "failed", meter, { classification, diagnostic: capOutput(diagnostic) });
 	};
@@ -521,6 +527,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		if (unit.repairUsed) return terminal(flow, classification, bounded, meter);
 		flow.phase = "blocked";
 		flow.blocked = { unit, classification, diagnostic: bounded };
+		runtime.setWidgetTaskRetained(unit.widgetTaskId, true);
 		return response(flow, "blocked", meter);
 	};
 
@@ -687,6 +694,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 						unit.modelClass,
 						reviewerTask(unit.request, reviewCriterion, { base: evidence.base, tip: evidence.tip, patchPath: evidence.patchPath }),
 						unit.request.name,
+						unit.widgetTaskId,
 						unit.worktree.cwd,
 						`${toolCallId}:flow:${flow.index}:review`,
 						signal,
@@ -820,6 +828,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					flow.units.push({
 						request: unit,
 						modelClass: unit.modelClass,
+						widgetTaskId: `${toolCallId}:flow:${index}`,
 						worktree,
 						base: worktree.baseCommit,
 						repairUsed: false,
@@ -839,6 +848,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					unit.modelClass,
 					implementerTask(unit.request),
 					unit.request.name,
+					unit.widgetTaskId,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${index}:implement`,
 					operationSignal,
@@ -884,6 +894,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 			const blocked = flow.blocked;
 			const unit = blocked.unit;
 			if (unit.repairUsed) throw new Error("delegate_flow_continue repair was already used for this Unit.");
+			runtime.setWidgetTaskRetained(unit.widgetTaskId, false);
 			flow.phase = "running";
 			flow.blocked = undefined;
 			unit.repairUsed = true;
@@ -901,6 +912,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 					unit.modelClass,
 					repairTask(unit.request, blocked, guidance),
 					unit.request.name,
+					unit.widgetTaskId,
 					unit.worktree.cwd,
 					`${toolCallId}:flow:${flow.index}:repair`,
 					operationSignal,

package/extensions/subagent.ts

@@ -60,6 +60,7 @@ const WIDGET_KEY = "subagent-status";
 const WIDGET_INTERVAL_MS = 80;
 const MAX_WIDGET_ITEMS = 8;
 const MAX_WIDGET_LINES = 6;
+const MAX_WIDGET_GROUP_ROWS = 3;
 export const MAX_WIDGET_ACTIVE_TOOLS = 8;
 const DEFAULT_TIMEOUT_POLICY = {
 	idleMs: DEFAULT_TIMEOUT_CONFIG.idleMinutes * 60_000,
@@ -87,6 +88,7 @@ type WidgetItem = {
 	role: string;
 	model: string;
 	thinkingLevel: string;
+	taskId: string;
 	name: string;
 	tokens: number;
 	startedAt: number;
@@ -164,13 +166,35 @@ function renderWidgetRows(
 	theme: Theme,
 ): string[] {
 	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 hidden = ordered.slice(visible.length);
-	const lines = visible.map((item) => truncateToWidth(
-		`${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", item.role)} ${theme.fg("text", item.name)} · ${theme.fg("text", activityLabel(item, now))} · ${theme.fg("muted", activityMetrics(item, now))}`,
-		width,
-	));
+	if (!ordered.length) return [];
+	const groups = new Map<string, { name: string; items: WidgetItem[] }>();
+	for (const item of ordered) {
+		const group = groups.get(item.taskId);
+		if (group) group.items.push(item);
+		else groups.set(item.taskId, { name: item.name, items: [item] });
+	}
+	const maxVisibleLines = ordered.length + groups.size > MAX_WIDGET_LINES ? MAX_WIDGET_LINES - 1 : MAX_WIDGET_LINES;
+	const workingGroups = [...groups.values()].filter(({ items }) => items.some(({ status }) => status === "working"));
+	const visibleWorkingGroups = new Set(workingGroups.slice(0, Math.floor(maxVisibleLines / 2)));
+	let remainingWorkingGroups = visibleWorkingGroups.size;
+	const visible = new Set<WidgetItem>();
+	const lines: string[] = [];
+	for (const group of groups.values()) {
+		const working = group.items.some(({ status }) => status === "working");
+		if (working && !visibleWorkingGroups.has(group)) continue;
+		const reservedLines = working ? --remainingWorkingGroups * 2 : 0;
+		const childCount = Math.min(MAX_WIDGET_GROUP_ROWS, group.items.length, maxVisibleLines - lines.length - reservedLines - 1);
+		if (childCount < 1) continue;
+		lines.push(truncateToWidth(theme.fg("text", group.name), width));
+		for (const item of group.items.slice(0, childCount)) {
+			visible.add(item);
+			lines.push(truncateToWidth(
+				`  ${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", item.role)} ${theme.fg("text", activityLabel(item, now))} · ${theme.fg("muted", activityMetrics(item, now))}`,
+				width,
+			));
+		}
+	}
+	const hidden = ordered.filter((item) => !visible.has(item));
 	if (hidden.length) {
 		const counts: Record<WidgetStatus, number> = { working: 0, success: 0, failure: 0, aborted: 0 };
 		for (const { status } of hidden) counts[status] += 1;
@@ -250,6 +274,7 @@ export default function subagentExtension(
 		].join("\n"), outputPad, 0);
 	});
 	const widgetItems = new Map<string, WidgetItem>();
+	const retainedWidgetTaskIds = new Set<string>();
 	// Each child is a full Pi process issuing its own model calls; cap parallel
 	// spend. Precedence: PI_SUBAGENT_MAX_SUBAGENTS env > config/pi-subagent/config.json
 	// maxSubagents > default 5. Invalid present config falls back to the default
@@ -301,6 +326,11 @@ export default function subagentExtension(
 
 	const requestWidgetRender = () => activeTui?.requestRender();
 
+	const setWidgetTaskRetained = (taskId: string, retained: boolean) => {
+		if (retained) retainedWidgetTaskIds.add(taskId);
+		else retainedWidgetTaskIds.delete(taskId);
+	};
+
 	const startWidgetTimer = () => {
 		if (widgetTimer) return;
 		widgetTimer = setInterval(() => {
@@ -324,6 +354,7 @@ export default function subagentExtension(
 
 	const startWidgetItem = (
 		id: string,
+		taskId: string,
 		role: string,
 		model: string,
 		thinkingLevel: string | undefined,
@@ -334,7 +365,7 @@ export default function subagentExtension(
 		ensureWidget(ctx);
 		if (!widgetItems.has(id) && widgetItems.size >= MAX_WIDGET_ITEMS) {
 			for (const [oldestId, item] of widgetItems) {
-				if (item.status === "working") continue;
+				if (item.status === "working" || retainedWidgetTaskIds.has(item.taskId) || item.taskId === taskId) continue;
 				widgetItems.delete(oldestId);
 				if (widgetItems.size < MAX_WIDGET_ITEMS) break;
 			}
@@ -343,6 +374,7 @@ export default function subagentExtension(
 			role: roleBadge(role),
 			model,
 			thinkingLevel: thinkingLevel ?? "default",
+			taskId,
 			name,
 			tokens: 0,
 			startedAt: Date.now(),
@@ -434,6 +466,7 @@ export default function subagentExtension(
 		failedToolPatches.clear();
 		stopWidgetTimer();
 		widgetItems.clear();
+		retainedWidgetTaskIds.clear();
 		activeTui = undefined;
 		widgetInstalled = false;
 		if (ctx.hasUI) ctx.ui.setWidget(WIDGET_KEY, undefined);
@@ -451,7 +484,7 @@ export default function subagentExtension(
 	pi.on("input", (event) => {
 		if (event.source === "extension") return;
 		for (const [id, item] of widgetItems) {
-			if (item.status !== "working") widgetItems.delete(id);
+			if (item.status !== "working" && !retainedWidgetTaskIds.has(item.taskId)) widgetItems.delete(id);
 		}
 		requestWidgetRender();
 	});
@@ -550,6 +583,7 @@ export default function subagentExtension(
 			...(modelClass === undefined ? {} : { modelClass }),
 		}),
 		startWidget: startWidgetItem,
+		setWidgetTaskRetained,
 		updateWidgetTokens,
 		updateWidgetActivity,
 		finishWidget: finishWidgetItem,
@@ -695,7 +729,7 @@ export default function subagentExtension(
 								if (role.isolation === "worktree") {
 									worktree = await createChildWorktree(ctx.cwd, entry.id, undefined, workflowSignal);
 								}
-								startWidgetItem(entry.id, role.name, launch.model.id, launch.thinkingLevel, entry.delegation.name, ctx);
+								startWidgetItem(entry.id, entry.id, role.name, launch.model.id, launch.thinkingLevel, entry.delegation.name, ctx);
 								setState("running", "");
 								emitUpdate(emitToolUpdates);
 								return {

package/package.json

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

package/skills/pi-subagent-delegated-development/SKILL.md

@@ -13,7 +13,9 @@ Before slicing, identify applicable repository prohibitions. If the request or p
 
 Use the fewest cohesive units. `delegate_flow` is for independent units expected to commute: split independent outcomes into units, combine or sequence work that overlaps files, APIs, schemas, generated output, package metadata, lockfiles, or invariants, and never divide one invariant across multiple units. Dependent work remains outside Flow; sequence it in one task or ordinary caller-controlled sequencing.
 
-Give every unit a bounded objective, owned scope and exclusions, and its direct validation command/argument array; each delegation must own one concrete outcome with one focused validation story. If the affected flow or scope is not yet known, perform bounded read-only discovery first. Do not pass the parent request unchanged. Choose `modelClass` according to the delegation tool's guidance. Add non-empty `review` only for an explicit judgment that automated validation cannot establish. Call `delegate_flow` with 1–8 units; the runtime always supplies the effective Implementer and supplies the Reviewer only when a unit needs review.
+Give every unit a bounded objective, owned scope and exclusions, and its direct validation command/argument array. Each task packet must name the neighboring behavior that must stay unchanged. Include the exact test name or error when known CI evidence exists. Never claim a validation command matches unknown CI.
+
+Each delegation must own one concrete outcome with one focused validation story. Order declared validation from the cheapest focused check to broader required checks. If the affected flow or scope is not yet known, perform bounded read-only discovery first. Do not pass the parent request unchanged. Choose `modelClass` according to the delegation tool's guidance. Add non-empty `review` only for an explicit judgment that automated validation cannot establish. Call `delegate_flow` with 1–8 units; the runtime always supplies the effective Implementer and supplies the Reviewer only when a unit needs review.
 
 ## Runtime Flow
 
@@ -27,7 +29,9 @@ A successful Flow owns integration and cleanup. A blocked outcome is repairable
 delegate_flow_continue({ guidance: "Address the reported block and complete the bounded unit.", modelClass: "balanced" })
 ```
 
-Make the guidance specific to the reported implementation, validation, or review failure. Omit `modelClass` to retain an explicit blocked-unit class or otherwise use each frozen Role's default; supply it only to replace both defaults for that one repair. Do not call continuation unless Flow reports a repairable block. If continuation or Flow returns a terminal failure, inspect every retained path reported by the runtime, then reslice or manually recover from Main; do not retry the Flow or guess a rebase resolution. A cleanup warning does not undo successful integration.
+Make the guidance specific to the reported implementation, validation, or review failure. Omit `modelClass` to retain an explicit blocked-unit class or otherwise use each frozen Role's default; supply it only to replace both defaults for that one repair. Do not call continuation unless Flow reports a repairable block. If continuation or Flow returns a terminal failure, inspect every retained path reported by the runtime, then reslice or manually recover from Main; do not retry the Flow or guess a rebase resolution.
+
+A cleanup warning does not undo successful integration. Report a cleanup warning from a successful Flow as-is. Do not investigate it unless the user asks or cleanup is part of acceptance.
 
 ## Ordinary delegation