@ferris1225/pi-subagents 4.1.20 → 4.1.23

package/README.md

@@ -184,13 +184,12 @@ that delivers without another gate.
   where they are in `~/.pi/agent/pi-subagents-recovery.json`. Every later session
   start repeats that notice until you remove the artifacts.
 
-## Threads: wait, resume, stop
+## Threads: resume, stop
 
 Every dispatch returns a stable `#id`, which is the handle for the thread tools:
 
 | Tool               | What it does                                                                                                                                                                  |
 | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `subagent_wait`    | Block in-turn until already-dispatched run(s) settle and return their results (`id` or prefix; omit for all active runs).                                                        |
 | `subagent_control` | `resume` a parked or settled thread with its full retained context, optionally appending a new `objective`.                                                                     |
 | `subagent_stop`    | Destructively cancel, deliver the partial output, and retire the thread. Steering and follow-up messages still queued in the child are dropped so nothing can revive it later.  |
 
@@ -198,14 +197,14 @@ Every dispatch returns a stable `#id`, which is the handle for the thread tools:
 subagent_control({ action: "resume", id: 7, objective: "Finish the tests." });
 ```
 
-There is deliberately no status or polling tool. Every result delivers itself,
-the TUI widget shows what is live, and blocking is event-driven only: `wait:
-true` on a dispatch holds the turn for that call's results — the escape hatch
-for one-shot `pi -p` parents, which exit at end of turn and would otherwise
-never see them — and `subagent_wait` does the same for a run that is already
-in flight when the turn cannot proceed without it. Neither wait runs on a
-timer or a timeout the model picks: a waiter resolves the instant its run
-settles, a parked run answers immediately with its resume handle, and
+There is deliberately no status, polling, or wait tool. Every result delivers
+itself as a completion that wakes the main model, so a turn never blocks on a
+running subagent — keep working or end the turn, and the completion continues
+it. The one in-turn block is `wait: true` on a dispatch, which holds that call
+until the runs it started settle: the escape hatch for one-shot `pi -p`
+parents, which exit at end of turn and would otherwise never see them. That
+wait runs on no timer and no timeout the model picks: it resolves the instant
+its run settles, a parked run answers immediately with its resume handle, and
 aborting the turn is the escape hatch. Control operations are all bounded, so
 they never hang on a generation that is still settling.
 
@@ -224,28 +223,41 @@ threads that had already finished keep only their delivered result.
 
 ## Live status and results
 
-The TUI widget renders one compact line per run in fixed columns — status icon,
-right-aligned `#id`, padded agent name, then the task label — so every label
-starts at the same column, with the live activity dimmed after ` — ` and one
-right-aligned telemetry column (worktree badge, model/thinking, wait state,
-elapsed) so times line up at the right edge. A managed workflow adds exactly
-one more line: a `└`-connected stage timeline that carries the live stage's
-telemetry instead of extra child rows:
+The TUI widget renders one line per participant in fixed identity columns —
+status icon, right-aligned `#id`, padded agent name, then the task label — so
+every label starts at the same column, with the live activity dimmed after
+` — ` and the rest of the telemetry flowing inline after ` · `: the worktree
+badge, the token flow in the footer vocabulary (`↑` input, `↓` output,
+`R`/`W` cache read/write), cost, the full `provider/model/thinking` ref, the
+wait state, and an elapsed time that always carries seconds. The first line is
+the parent session itself — what the current model is doing right now while
+its agent loop runs. A managed workflow (the automatic review / fix / re-review
+chain) renders as a tree: the parent line carries the workflow-wide token/cost
+totals and total elapsed, and every stage gets its own `├`/`└`-connected row
+with its own model, token flow, and elapsed — settled stages keep the
+telemetry frozen at settlement, the live stage shows its child's model and
+current activity:
 
 ```text
-◆ #12 worker    src/cache.ts                       wt:a91f3c · 1m42s
-  └ ✓ implement ─ ● review             read src/auth.ts · 10s
-● #15 explorer  src/models.ts — grep fallback    haiku-4-5/low · 22s
-○ #23 worker    src/config.ts                              repo lane
-○ #24 worker ↻  tests/config.test.ts                  queued · 5m02s
+●    pi        subagent Implement the login redirect fix · openai/gpt-5/max · 12m06s
+◆ #12 worker    src/cache.ts · wt:a91f3c · ↑5.2k ↓41.0k R210.0k W6.1k $1.9400 · 12m06s
+  ├ ✓ implement · ↑1.0k ↓12.0k R40.0k W1.2k $0.5100 · xai/grok-4/xhigh · 2m41s
+  ├ ! review · ↑0.9k ↓6.0k R38.0k W0.9k $0.3300 · openai/gpt-5 · 1m12s
+  ├ ● review fix — edit src/auth.ts · ↑0.2k ↓3.0k R12.0k $0.1200 · openai/gpt-5/medium · 41s
+  └ ○ re-review
+● #15 explorer  src/models.ts — grep fallback · ↑1.2k ↓8.4k R31.0k W1.1k $0.0900 · openai/gpt-5-mini/low · 3m07s
+○ #23 worker    src/config.ts · repo lane
+○ #24 worker ↻  tests/config.test.ts · queued · 5m02s
 ```
 
-Queued rows state what they actually wait for in the telemetry column —
-`queued` for a free process slot, `repo lane` for shared-checkout write
-serialization, or `starting` — and a resumed thread carries a dim `↻` in its
-agent column with its cumulative time. The widget is capped at ten lines: when
-many runs are live, the extra ones collapse into a `… +N more` marker so the
-editor keeps its space.
+Telemetry drops leftmost-first when a row runs out of width (badge, wait
+state, usage, model) while the elapsed survives every width. Queued rows state
+what they actually wait for — `queued` for a free process slot, `repo lane`
+for shared-checkout write serialization, or `starting` — and a resumed thread
+carries a dim `↻` in its agent column with its cumulative time. The widget is
+capped at ten lines: when many runs are live, extra roots collapse into a
+`… +N more` marker, and an oversized stage chain keeps a window anchored on
+the live stage so the editor keeps its space.
 
 Completions resume the main agent on their own, with a compact block of at most 40
 lines by default; longer output lands unchanged in a Markdown artifact whose path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "4.1.20",
+  "version": "4.1.23",
   "description": "A managed sub-agent team for pi: specialized roles, pre-commit documentation sync, retained threads, auto-fix chains, model fallback, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/announcements.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { existsSync } from "node:fs";
 import { loadConfig, saveConfig } from "./config.ts";
 import { availableModelsInScope, filterUnavailableModelOverrides } from "./models.ts";
+import { formatToolActivity, monitor } from "./monitor.ts";
 import { announceRecoveryRecords } from "./recovery.ts";
 import type { SubagentRuntime } from "./runtime.ts";
 import { installActiveRunsWidget } from "./widget.ts";
@@ -35,7 +36,32 @@ async function migrateUnavailableAgentModels(
 	}
 }
 
+/** Track the parent pi session itself as the widget's first row: what the
+ * current model is doing while its agent loop runs. Same activity vocabulary
+ * as subagent rows (thinking / responding / tool + target), fed by the
+ * session's own extension events; the row disappears when the loop settles. */
+function trackMainActivity(pi: ExtensionAPI): void {
+	pi.on("agent_start", () => monitor.setMainAgentActive(true));
+	pi.on("agent_end", () => monitor.setMainAgentActive(false));
+	pi.on("agent_settled", () => monitor.setMainAgentActive(false));
+	pi.on("model_select", (event) => monitor.setMainModel(event.model?.id));
+	pi.on("thinking_level_select", (event) => monitor.setMainThinking(event.level));
+	pi.on("message_update", (event) => {
+		if (event.message.role !== "assistant") return;
+		const kind = event.assistantMessageEvent.type;
+		if (kind === "text_start" || kind === "text_delta") monitor.setMainActivity("responding");
+		else if (kind === "thinking_start" || kind === "thinking_delta") monitor.setMainActivity("thinking");
+	});
+	pi.on("tool_execution_start", (event) =>
+		monitor.recordMainToolStart(event.toolName, formatToolActivity(event.toolName, event.args)));
+	pi.on("tool_execution_end", (event) => monitor.recordMainToolEnd(event.toolName, event.isError));
+}
+
 export function registerAnnouncements(pi: ExtensionAPI, runtime: SubagentRuntime): void {
+	// Registered at extension load (not session_start) so a model selection
+	// made during restore is already captured when the widget appears.
+	trackMainActivity(pi);
+
 	pi.on("session_start", async (_event, ctx) => {
 		if (!existsSync(runtime.configPath)) {
 			ctx.ui.notify(

package/src/dispatch.ts

@@ -30,6 +30,7 @@ import {
 	monitor,
 	statusIcon,
 	type RunChainMeta,
+	type RunView,
 	type RunWaitReason,
 	type WorkflowStage,
 	type WorkflowStageStatus,
@@ -151,12 +152,14 @@ function withReviewerFixStageAgent(agent: AgentConfig): AgentConfig {
 	};
 }
 
-/** Event-driven in-turn wait shared by dispatch `wait: true` and
- * subagent_wait: hold the turn until every listed run settles, then hand back
- * their result blocks. No timer: a waiter resolves the moment its run's result
- * registers (children are bounded by the idle watchdog), an already-parked run
- * answers immediately with its resume handle, and the turn's abort signal
- * remains the escape hatch. */
+/** In-turn wait behind dispatch `wait: true` — the escape hatch for one-shot
+ * `pi -p` parents that exit at end of turn: hold the call until every run it
+ * started settles, then hand back their result blocks. Interactive sessions
+ * never take this path; their results arrive as completion wake-ups. No
+ * timer: a waiter resolves the moment its run's result registers (children
+ * are bounded by the idle watchdog), an already-parked run answers
+ * immediately with its resume handle, and the turn's abort signal remains the
+ * escape hatch. */
 export async function awaitRunResults(
 	runtime: SubagentRuntime,
 	runIds: number[],
@@ -237,18 +240,21 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 	const environmentRef: { current: DispatchEnvironment | undefined } = { current: undefined };
 
 	// Finished runs leave the active monitor immediately. Their final findings
-	// are sent as a custom message that starts a follow-up turn.
+	// are sent as a custom message that starts a follow-up turn. Returns the
+	// removed row so workflow callers can freeze its exact elapsed time onto
+	// the stage projection before the row is gone.
 	const finishRun = (
 		runId: number,
 		status: "done" | "failed",
 		opts?: { silent?: boolean },
-	): void => {
+	): RunView | undefined => {
 		monitor.setStatus(runId, status); // stamps endedAt for the elapsed time
 		const run = monitor.removeRun(runId);
-		if (!run) return; // already finished — stay idempotent
-		if (opts?.silent || !runtime.sessionActive) return;
+		if (!run) return undefined; // already finished — stay idempotent
+		if (opts?.silent || !runtime.sessionActive) return run;
 		const icon = status === "done" ? "✓" : "✗";
 		environmentRef.current?.ctx.ui.notify(`${icon} #${run.id} ${monitor.summarize(run)}`, status === "done" ? "info" : "error");
+		return run;
 	};
 
 	// Live sub-agent activity → concise one-line status ("thinking",
@@ -352,7 +358,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			agentOverride?: AgentConfig;
 			session?: { sessionId: string; sessionDir: string };
 		} = {},
-	): Promise<{ runId: number; result: SingleResult }> => {
+	): Promise<{ runId: number; result: SingleResult; elapsedMs?: number }> => {
 		const discoveredAgent = request.agents.find((candidate) => candidate.name === agentName);
 		if (!discoveredAgent) {
 			throw new Error(`Managed workflow requires enabled agent "${agentName}", but discovery did not provide it.`);
@@ -409,11 +415,11 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			runtime.retainSession(result);
 			monitor.setModel(runId, result.model, result.modelFallbackFrom);
 			monitor.setThinking(runId, result.thinking);
-			finishRun(runId, isFailedResult(result) ? "failed" : "done", { silent: true });
+			const finished = finishRun(runId, isFailedResult(result) ? "failed" : "done", { silent: true });
 			runtime.registerRunResult(runId, result);
-			return { runId, result };
+			return { runId, result, elapsedMs: finished?.elapsedMs };
 		} catch (error) {
-			finishRun(runId, "failed", { silent: true });
+			const finished = finishRun(runId, "failed", { silent: true });
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			const crashed: SingleResult = {
 				...queuedResult(route.agent, task, thinkingLevel),
@@ -471,6 +477,11 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			agent: initialStepResult.agent,
 			relation: initialStageRelation,
 			status: workflowStageStatus(initialStepResult),
+			// The initial stage is the parent's own run; freeze its telemetry now,
+			// before the reopened parent row starts counting workflow-wide time.
+			model: initialStepResult.model,
+			usage: initialStepResult.usage,
+			elapsedMs: monitor.getElapsedMs(request.parentRunId),
 		}];
 		let reviewStage: WorkflowStage | undefined;
 		if (enabled("reviewer")) {
@@ -482,6 +493,14 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 		};
 		publishWorkflowStages();
 
+		/** Freeze the settled step's telemetry onto its stage: once the child row
+		 * leaves the monitor, this snapshot is the only per-stage record. */
+		const settleStage = (stage: WorkflowStage, step: { result: SingleResult; elapsedMs?: number }): void => {
+			stage.model = step.result.model;
+			stage.usage = step.result.usage;
+			if (step.elapsedMs !== undefined) stage.elapsedMs = step.elapsedMs;
+		};
+
 		const launchStep = async (
 			agentName: string,
 			task: string,
@@ -504,6 +523,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 					parentRunId: request.parentRunId,
 				}, stageOptions);
 				stage.status = workflowStageStatus(step.result, relation);
+				settleStage(stage, step);
 				publishWorkflowStages();
 				request.rememberLatest(step.result);
 				steps.push({ ...step, relation });

package/src/monitor.ts

@@ -38,6 +38,11 @@ export interface WorkflowStage {
 	agent: string;
 	relation: string;
 	status: WorkflowStageStatus;
+	/** Telemetry snapshot frozen when the stage settled (the live child row
+	 * leaves the monitor at that moment); the active stage reads its live child. */
+	model?: string;
+	usage?: UsageStats;
+	elapsedMs?: number;
 }
 
 export function isRunActiveStatus(status: RunStatus): boolean {
@@ -111,6 +116,17 @@ export interface RunChainMeta {
 	waitReason?: RunWaitReason;
 }
 
+/** Ephemeral activity of the parent pi model while its agent loop runs: the
+ * live model/thinking ref and a one-line "what is it doing now". Not a run —
+ * no id, usage, or chain machinery; the view disappears when the loop settles. */
+export interface MainActivity {
+	model?: string;
+	thinking?: string;
+	activity?: string;
+	/** Epoch ms when the current agent loop started. */
+	activeSince: number;
+}
+
 // ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
@@ -289,14 +305,26 @@ function formatTokens(count: number): string {
 	return String(count);
 }
 
-export function formatUsageCompact(usage: UsageStats): string {
+/** Token flow in the pi-footer vocabulary: ↑input ↓output, R cache-read,
+ * W cache-write; zero components are omitted. No cost — callers place it as
+ * its own droppable part. */
+export function formatUsageTokens(usage: UsageStats | undefined): string | undefined {
+	if (!usage) return undefined;
 	const parts: string[] = [];
 	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
 	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
 	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
 	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join(" ");
+	return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+export function formatUsageCompact(usage: UsageStats): string {
+	return [formatUsageTokens(usage), usageCostPart(usage)].filter(Boolean).join(" ");
+}
+
+/** Cost as its own droppable part: `$0.0421`, undefined when nothing accrued. */
+export function usageCostPart(usage: UsageStats | undefined): string | undefined {
+	return usage?.cost ? `$${usage.cost.toFixed(4)}` : undefined;
 }
 
 /** Aggregate usage across several runs (chain steps or a completion group). */
@@ -319,9 +347,11 @@ export function formatDuration(ms: number): string {
 	if (totalSeconds < 60) return `${totalSeconds}s`;
 	const minutes = Math.floor(totalSeconds / 60);
 	const seconds = totalSeconds % 60;
+	// Seconds stay visible at every magnitude: a long-running chain is judged
+	// by whether it is still moving, and "5s ago" is exactly that signal.
 	if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
 	const hours = Math.floor(minutes / 60);
-	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+	return `${hours}h${String(minutes % 60).padStart(2, "0")}m${String(seconds).padStart(2, "0")}s`;
 }
 
 /** Cumulative active time across generations; parked gaps never count. */
@@ -453,6 +483,71 @@ export class MonitorStore {
 	private runs: RunView[] = [];
 	private nextId = 1;
 	private subscribers = new Set<() => void>();
+	private mainModel?: string;
+	private mainThinking?: string;
+	private mainActivity?: string;
+	private mainActiveSince?: number;
+
+	// --- parent pi model activity ------------------------------------------
+	// Fed by the parent session's extension events (agent loop, streaming,
+	// tool executions); rendered as the widget's first line. Change-guarded so
+	// per-token streaming deltas do not flood subscribers.
+
+	setMainModel(model?: string): void {
+		if (!model || this.mainModel === model) return;
+		this.mainModel = model;
+		this.notify();
+	}
+
+	setMainThinking(thinking?: string): void {
+		if (!thinking || this.mainThinking === thinking) return;
+		this.mainThinking = thinking;
+		this.notify();
+	}
+
+	setMainActivity(text: string): void {
+		const activity = sanitizeActivityText(text) || undefined;
+		if (!activity || this.mainActivity === activity) return;
+		this.mainActivity = activity;
+		this.notify();
+	}
+
+	/** Record the main model starting a tool; the activity shows the tool's
+	 * most telling argument, same vocabulary as subagent rows. */
+	recordMainToolStart(toolName: string, activity: string): void {
+		const safeToolName = sanitizeActivityText(toolName) || "tool";
+		this.setMainActivity(activity || safeToolName);
+	}
+
+	/** Record a failed main-model tool; successful completions keep their last
+	 * activity until the next model event supplies a better description. */
+	recordMainToolEnd(toolName: string, isError: boolean): void {
+		if (isError) this.setMainActivity(`✗ ${sanitizeActivityText(toolName) || "tool"} failed`);
+	}
+
+	/** Track the parent agent loop: started at agent_start, cleared when the
+	 * loop settles (agent_end / agent_settled). */
+	setMainAgentActive(active: boolean): void {
+		if ((this.mainActiveSince !== undefined) === active) return;
+		this.mainActiveSince = active ? Date.now() : undefined;
+		this.mainActivity = undefined;
+		this.notify();
+	}
+
+	/** Live view of the parent model while its agent loop runs; undefined when idle. */
+	getMainActivity(): MainActivity | undefined {
+		if (this.mainActiveSince === undefined) return undefined;
+		return {
+			...(this.mainModel ? { model: this.mainModel } : {}),
+			...(this.mainThinking ? { thinking: this.mainThinking } : {}),
+			...(this.mainActivity ? { activity: this.mainActivity } : {}),
+			activeSince: this.mainActiveSince,
+		};
+	}
+
+	isMainAgentActive(): boolean {
+		return this.mainActiveSince !== undefined;
+	}
 
 	beginTurn(): void {
 		// Clear finished runs from a previous turn, but keep active and parked
@@ -719,6 +814,10 @@ export class MonitorStore {
 	 * finishRun calls from the old session remain safe no-ops. */
 	clear(): void {
 		this.runs = [];
+		this.mainModel = undefined;
+		this.mainThinking = undefined;
+		this.mainActivity = undefined;
+		this.mainActiveSince = undefined;
 		this.notify();
 	}
 

package/src/tools.ts

@@ -1,10 +1,9 @@
 /**
- * Thread controls around the subagent runtime: subagent_control (resume),
- * subagent_wait (event-driven in-turn wait), and destructive subagent_stop.
- * There is no status/poll tool — completions carry each result (with an
- * on-disk artifact when truncated); `wait: true` on dispatch blocks for runs
- * it starts, and subagent_wait blocks for runs already dispatched. Both waits
- * resolve the moment a run settles, never on a timer.
+ * Thread controls around the subagent runtime: subagent_control (resume) and
+ * destructive subagent_stop. There is no status/poll tool — completions carry
+ * each result (with an on-disk artifact when truncated) and wake the main
+ * model, so waiting is never a tool call; the only in-turn block is `wait:
+ * true` on a dispatch, for one-shot parents that exit at end of turn.
  */
 
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -13,11 +12,10 @@ import { Text } from "@earendil-works/pi-tui";
 import { existsSync } from "node:fs";
 import { Type } from "typebox";
 import { DEFAULT_MAX_RESULT_LINES, loadConfig } from "./config.ts";
-import { awaitRunResults } from "./dispatch.ts";
 import { removeThreadRecord } from "./durable.ts";
 import { formatCompletionBlock, matchRunIds } from "./format.ts";
 import { emptyUsage } from "./rpc-run.ts";
-import { formatTaskSummary, isRunActiveStatus, monitor } from "./monitor.ts";
+import { formatTaskSummary, monitor } from "./monitor.ts";
 import { persistRecoveryRecords, recoveryRecordFromFinalization } from "./recovery.ts";
 import type { SubagentRuntime, SubagentThread } from "./runtime.ts";
 import { CONTROL_QUIESCE_TIMEOUT_MS, projectResultsRoot, quiesced } from "./thread-lifecycle.ts";
@@ -112,56 +110,6 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 		},
 	});
 
-	const SubagentWaitParams = Type.Object({
-		id: Type.Optional(
-			Type.String({ description: "Run id or prefix to wait for (see dispatch output). Omit to wait for every active run." }),
-		),
-	});
-
-	pi.registerTool({
-		name: "subagent_wait",
-		label: "Subagent Wait",
-		description:
-			"Block until dispatched background run(s) settle, then return their results — resolves the moment a run settles, never on a timer.",
-		promptSnippet: "Block until dispatched runs settle; returns results the moment they finish.",
-		parameters: SubagentWaitParams,
-
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			await runtime.durableRestore;
-			const config = await loadConfig(runtime.configPath);
-			const active = monitor.getRuns()
-				.filter((run) => isRunActiveStatus(run.status) || run.status === "parked")
-				.map((run) => run.id);
-			const requested = params.id?.trim();
-			// Settled runs stay addressable: a wait issued just after completion
-			// returns that result immediately instead of missing the run.
-			const targets = requested
-				? matchRunIds([...new Set([...active, ...runtime.settledRuns.keys()])], requested)
-				: active;
-			if (targets.length === 0) {
-				const activeList = active.map((id) => `#${id}`).join(", ");
-				return {
-					content: [{
-						type: "text",
-						text: requested
-							? `No subagent run matches "${requested}".${activeList ? ` Active runs: ${activeList}.` : ""}`
-							: "No active subagent runs to wait for.",
-					}],
-					details: {},
-				};
-			}
-			const blocks = await awaitRunResults(runtime, targets, signal, config.maxResultLines, ctx.cwd);
-			return { content: [{ type: "text", text: blocks }], details: {} };
-		},
-
-		renderCall(args, theme) {
-			return new Text(`${theme.fg("toolTitle", theme.bold("subagent_wait "))}${theme.fg("accent", args.id ? `#${args.id}` : "all")}`, 0, 0);
-		},
-		renderResult(result, _options, theme) {
-			return renderFirstLine(result, "subagent_wait ", theme);
-		},
-	});
-
 	// Cancel one or more active runs: aborts the queue controller, which
 	// terminates the child and delivers an aborted result (with whatever partial
 	// output it produced) so the main agent always knows the run stopped.

package/src/widget.ts

@@ -2,16 +2,23 @@
  * Compact, glanceable active-run widget for interactive Pi sessions.
  *
  * Layout contract (redesign):
- * - Aligned columns: `icon  #id  agent` pad to the widest displayed id and
- *   agent so every label starts at the same column; a resumed thread carries
- *   a dim `↻` inside the agent column.
- * - Visual hierarchy: the label (what the run owns) is plain, the live
- *   activity after ` — ` is dim, and all telemetry — worktree badge,
- *   model/thinking, wait state, elapsed — is one dim right-aligned column,
- *   so times and states line up at the right edge.
- * - Two lines per managed workflow: the stable parent line plus a `└`-connected
- *   stage timeline; the live stage's activity/model/elapsed rides right-aligned
- *   on the timeline line. Internal child rows are not repeated as extra lines.
+ * - Aligned identity columns: `icon  #id  agent` pad to the widest displayed
+ *   id and agent so every label starts at the same column; a resumed thread
+ *   carries a dim `↻` inside the agent column.
+ * - Multi-line rows flow inline: the telemetry (`provider/model/thinking`,
+ *   token flow in the pi-footer vocabulary `↑in ↓out R/W cache`, cost, wait
+ *   state, seconds-precision elapsed) follows the content after ` · ` instead
+ *   of a right-aligned column — no blank padding across a multi-line chain.
+ * - Telemetry drops leftmost-first under width pressure (badge, wait, usage,
+ *   model); the elapsed survives every width.
+ * - First line is the parent pi session itself: what the current model is
+ *   doing right now while its agent loop runs (model/thinking, live activity,
+ *   loop elapsed), fed by the session's own extension events.
+ * - A managed workflow renders as a tree chain under its parent line: one
+ *   `├`/`└`-connected row per stage, each carrying its own model, token flow,
+ *   and elapsed — settled stages from the snapshot frozen at settlement, the
+ *   live stage from its child row. An oversized chain keeps a window anchored
+ *   on the live stage.
  * - Queued rows say what they actually wait for ("queued" for a process slot,
  *   "repo lane" for shared-writer serialization, "starting" while the child
  *   process launches) instead of one catch-all "queued".
@@ -20,14 +27,21 @@
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import {
+	formatDuration,
 	formatElapsed,
 	formatTaskSummary,
+	formatUsageTokens,
 	isRunActiveStatus,
 	monitor,
 	statusIcon,
+	sumUsage,
+	usageCostPart,
+	type MainActivity,
 	type RunView,
 	type WorkflowStage,
+	type WorkflowStageStatus,
 } from "./monitor.ts";
+import type { UsageStats } from "./rpc-run.ts";
 
 export const SUBAGENTS_WIDGET_ID = "pi-subagents";
 
@@ -53,17 +67,13 @@ interface ColumnLayout {
 	agentWidth: number;
 }
 
-/** Compose one widget line with a right-aligned telemetry column: the left
- * side truncates first, the right side stays put so elapsed times and badges
- * line up across rows. */
-function layoutLine(left: string, right: string, width: number): string {
-	if (width <= 0) return "";
-	if (!right) return truncateToWidth(left, width, "…");
-	const rightWidth = visibleWidth(right);
-	if (rightWidth >= width) return truncateToWidth(right, width, "");
-	const leftBudget = width - rightWidth - 1;
-	const leftText = visibleWidth(left) > leftBudget ? truncateToWidth(left, leftBudget, "…") : left;
-	return `${leftText}${" ".repeat(Math.max(1, width - visibleWidth(leftText) - rightWidth))}${right}`;
+/** Join left content and telemetry inline — `left · telemetry` — so a
+ * multi-line chain reads as one flowing sentence instead of leaving blank
+ * padding across the width; the whole line truncates as a last resort. */
+function composeLine(left: string, tail: string, theme: Theme, width: number): string {
+	if (!tail) return truncateToWidth(left, width, "…");
+	const line = `${left}${theme.fg("dim", SEPARATOR)}${theme.fg("dim", tail)}`;
+	return visibleWidth(line) <= width ? line : truncateToWidth(line, width, "…");
 }
 
 /** Short truthful wait word for a queued row, shown in the telemetry column. */
@@ -124,27 +134,48 @@ function identitySegment(run: RunView, theme: Theme, layout: ColumnLayout): stri
 	return `${icon} ${theme.fg("dim", id)} ${name}${resumed}${pad}`;
 }
 
-/** One primary line per run. Left: identity  label — activity, where the
- * label stays plain and the live activity is dim. Right: one dim telemetry
- * column (worktree badge, model/thinking, wait state, elapsed). The activity
- * outranks the label when space runs out; the identity and elapsed survive
- * every width. */
-function primaryLine(run: RunView, theme: Theme, width: number, now: number, layout: ColumnLayout): string {
-	const dim = (text: string): string => theme.fg("dim", text);
-	const identity = identitySegment(run, theme, layout);
-	const elapsed = formatElapsed(run, now);
-	const modelId = run.model?.split("/").at(-1);
+/** One footer-style usage part: token flow plus accrued cost, dropped as a
+ * unit before the model under width pressure. */
+function usagePart(usage: UsageStats | undefined): string | undefined {
+	return [formatUsageTokens(usage), usageCostPart(usage)].filter(Boolean).join(" ") || undefined;
+}
+
+/** Telemetry tail parts shared by primary and stage rows: badge and wait word
+ * first (dropped first under pressure), then the usage part, the model, and
+ * the always-surviving elapsed. `usage` defaults to the run's own; the managed
+ * workflow parent overrides it with the workflow-wide aggregate. */
+function telemetryTailParts(run: RunView, now: number, usage: UsageStats = run.usage): Array<string | undefined> {
 	// Queued rows omit the model (the route is re-resolved at actual start);
-	// workflow parents omit it too (each stage owns its own model).
-	const modelPart = run.status === "queued" || run.managedWorkflow || !modelId
+	// workflow parents omit it too (each stage row owns its own model). The
+	// full provider/model ref is kept — "which provider served this run" is
+	// exactly what a multi-provider session needs to see.
+	const modelPart = run.status === "queued" || run.managedWorkflow || !run.model
 		? undefined
-		: `${modelId}${run.thinking ? `/${run.thinking}` : ""}`;
+		: `${run.model}${run.thinking ? `/${run.thinking}` : ""}`;
 	const badge = run.isolation === "worktree" ? worktreeBadge(run) : undefined;
 	const wait = run.status === "queued" ? waitWord(run) : undefined;
-	const tailBudget = Math.max(0, width - visibleWidth(identity) - LEFT_MIN_CONTENT);
-	// Drop order under pressure: badge, then model, then wait word; elapsed
+	// Drop order under pressure: badge, wait word, usage, model; elapsed
 	// survives every width the identity leaves room for.
-	const tail = composeTail([badge, modelPart, wait, elapsed || undefined], tailBudget);
+	return [badge, wait, usagePart(usage), modelPart, formatElapsed(run, now) || undefined];
+}
+
+/** One primary line per run. Left: identity  label — activity, where the
+ * label stays plain and the live activity is dim. Telemetry flows inline
+ * after ` · ` (worktree badge, token flow, cost, model/thinking, wait state,
+ * elapsed). The activity outranks the label when space runs out; the identity
+ * and elapsed survive every width. */
+function primaryLine(
+	run: RunView,
+	theme: Theme,
+	width: number,
+	now: number,
+	layout: ColumnLayout,
+	usage: UsageStats = run.usage,
+): string {
+	const dim = (text: string): string => theme.fg("dim", text);
+	const identity = identitySegment(run, theme, layout);
+	const tailBudget = Math.max(0, width - visibleWidth(identity) - LEFT_MIN_CONTENT);
+	const tail = composeTail(telemetryTailParts(run, now, usage), tailBudget);
 
 	// A chain child rendered at root level (its parent row is gone) keeps its
 	// workflow relation; the templated brief itself would only repeat content.
@@ -159,7 +190,7 @@ function primaryLine(run: RunView, theme: Theme, width: number, now: number, lay
 
 	const contentBudget = width
 		- visibleWidth(identity)
-		- (tail ? visibleWidth(tail) + 1 : 0)
+		- (tail ? visibleWidth(tail) + visibleWidth(SEPARATOR) : 0)
 		- visibleWidth(IDENTITY_GAP);
 	let content = "";
 	if (contentBudget > 0) {
@@ -185,84 +216,156 @@ function primaryLine(run: RunView, theme: Theme, width: number, now: number, lay
 	}
 
 	const left = content ? `${identity}${IDENTITY_GAP}${content}` : identity;
-	return layoutLine(left, tail ? dim(tail) : "", width);
+	return composeLine(left, tail, theme, width);
 }
 
-function workflowStageToken(stage: WorkflowStage, theme: Theme): string {
-	const content = (icon: string): string => `${icon} ${stage.relation}`;
-	switch (stage.status) {
+function stageIcon(status: WorkflowStageStatus, theme: Theme): string {
+	switch (status) {
 		case "done":
-			return theme.fg("success", content("✓"));
+			return theme.fg("success", "✓");
 		case "active":
-			return theme.fg("accent", theme.bold(content("●")));
+			return theme.fg("accent", theme.bold("●"));
 		case "changes":
-			return theme.fg("warning", content("!"));
+			return theme.fg("warning", "!");
 		case "failed":
-			return theme.fg("error", content("✗"));
+			return theme.fg("error", "✗");
 		default:
-			return theme.fg("dim", content("○"));
+			return theme.fg("dim", "○");
 	}
 }
 
-/** Stage timeline, sliced from the active (or next actionable) stage when the
- * full sequence does not fit, so the current position always survives. */
-function timelineSegment(stages: readonly WorkflowStage[], theme: Theme, width: number): string {
-	const separator = theme.fg("dim", " ─ ");
-	const render = (items: readonly WorkflowStage[]): string =>
-		items.map((stage) => workflowStageToken(stage, theme)).join(separator);
-	const full = render(stages);
-	if (visibleWidth(full) <= width) return full;
-	let focusIndex = stages.findIndex((stage) => stage.status === "active");
-	if (focusIndex === -1) {
-		focusIndex = stages.findLastIndex((stage) => stage.status === "changes" || stage.status === "failed");
+/** Stage telemetry source: the live child while the stage runs, the frozen
+ * snapshot once it has settled. */
+interface StageTelemetry {
+	model?: string;
+	thinking?: string;
+	usage?: UsageStats;
+	elapsed: string;
+	activity?: string;
+}
+
+function stageTelemetry(
+	stage: WorkflowStage,
+	live: RunView | undefined,
+	now: number,
+): StageTelemetry {
+	if (live) {
+		return {
+			model: live.model,
+			thinking: live.thinking,
+			usage: live.usage,
+			elapsed: formatElapsed(live, now),
+			activity: live.activity?.trim() || undefined,
+		};
 	}
-	if (focusIndex === -1) focusIndex = stages.findIndex((stage) => stage.status === "pending");
-	if (focusIndex === -1) focusIndex = stages.length - 1;
-	const omittedPrefix = focusIndex > 0 ? theme.fg("dim", "… ─ ") : "";
-	return truncateToWidth(`${omittedPrefix}${render(stages.slice(focusIndex))}`, width, "…");
+	return { model: stage.model, usage: stage.usage, elapsed: stage.elapsedMs !== undefined ? formatDuration(stage.elapsedMs) : "" };
 }
 
-/** Timeline line under a managed workflow parent, tied to it with a dim `└`.
- * The live stage's telemetry (its activity or model, plus stage elapsed) rides
- * right-aligned, so the two workflow lines replace what used to be four
- * (parent, timeline, child row, child activity). */
-function workflowTimelineLine(
-	run: RunView,
+/** The parent pi session's own line — what the current model is doing right
+ * now while its agent loop runs: full model/thinking ref, live activity, loop
+ * elapsed. Not a run, so it owns no `#id`; it joins the identity layout so its
+ * label column lines up with the run rows. */
+function mainLine(main: MainActivity, theme: Theme, width: number, now: number, layout: ColumnLayout): string {
+	const dim = (text: string): string => theme.fg("dim", text);
+	const icon = theme.fg("accent", "●");
+	const name = theme.fg("accent", theme.bold("pi"));
+	const pad = " ".repeat(Math.max(0, layout.agentWidth - visibleWidth("pi")));
+	const identity = `${icon} ${" ".repeat(layout.idWidth + 1)}${name}${pad}`;
+	const modelPart = main.model ? `${main.model}${main.thinking ? `/${main.thinking}` : ""}` : undefined;
+	const elapsed = formatDuration(Math.max(0, now - main.activeSince));
+	const tail = composeTail([modelPart, elapsed], Math.max(0, width - visibleWidth(identity) - LEFT_MIN_CONTENT));
+	const contentBudget = width
+		- visibleWidth(identity)
+		- (tail ? visibleWidth(tail) + visibleWidth(SEPARATOR) : 0)
+		- visibleWidth(IDENTITY_GAP);
+	let left = identity;
+	if (main.activity?.trim() && contentBudget >= ACTIVITY_MIN_WIDTH) {
+		left = `${identity}${IDENTITY_GAP}${dim(formatTaskSummary(main.activity.trim(), contentBudget))}`;
+	}
+	return composeLine(left, tail, theme, width);
+}
+
+/** One `├`/`└`-connected row per managed-workflow stage: status icon,
+ * relation, live activity for the running stage, and its own model/token/
+ * cost/elapsed telemetry flowing inline. The chain hangs off the parent line,
+ * so who dispatched what stays visible while the auto-fix workflow progresses. */
+function workflowStageLines(
+	stages: readonly WorkflowStage[],
 	children: readonly RunView[],
 	theme: Theme,
 	width: number,
 	now: number,
-): string | undefined {
-	const stages = run.workflowStages;
-	const indent = `  ${theme.fg("dim", "└")} `;
-	const budget = width - visibleWidth(indent);
-	if (!stages || stages.length === 0 || budget <= 0) return undefined;
-	const child = children.find((candidate) => candidate.status === "running" || candidate.status === "interrupting")
+): { lines: string[]; activeIndex: number } {
+	const live = children.find((candidate) => candidate.status === "running" || candidate.status === "interrupting")
 		?? children.at(-1);
-	const childDoing = child?.activity?.trim() || child?.model?.split("/").at(-1) || "";
-	const childElapsed = child ? formatElapsed(child, now) : "";
-	const timeline = timelineSegment(stages, theme, budget);
-	const room = budget - visibleWidth(timeline) - 1;
-	let tail = "";
-	if (room >= ACTIVITY_MIN_WIDTH) {
-		const doingBudget = room - (childElapsed ? visibleWidth(childElapsed) + (childDoing ? visibleWidth(SEPARATOR) : 0) : 0);
-		const doingText = childDoing && doingBudget >= ACTIVITY_MIN_WIDTH
-			? formatTaskSummary(childDoing, doingBudget)
-			: "";
-		const parts = [doingText, childElapsed].filter(Boolean);
-		if (parts.length > 0) tail = theme.fg("dim", parts.join(SEPARATOR));
+	const activeIndex = stages.findIndex((stage) => stage.status === "active");
+	const lines: string[] = [];
+	for (const [index, stage] of stages.entries()) {
+		const telemetry = stageTelemetry(stage, index === activeIndex ? live : undefined, now);
+		const connector = theme.fg("dim", index === stages.length - 1 ? "└" : "├");
+		const indent = `  ${connector} `;
+		const budget = width - visibleWidth(indent);
+		if (budget <= 0) break;
+		const icon = stageIcon(stage.status, theme);
+		const label = `${icon} ${stage.relation}`;
+		const modelPart = telemetry.model
+			? `${telemetry.model}${telemetry.thinking ? `/${telemetry.thinking}` : ""}`
+			: undefined;
+		const parts = [
+			usagePart(telemetry.usage),
+			modelPart,
+			telemetry.elapsed || undefined,
+		];
+		const tailBudget = Math.max(0, budget - visibleWidth(label) - ACTIVITY_MIN_WIDTH);
+		const tail = composeTail(parts, tailBudget);
+		const contentBudget = budget - (tail ? visibleWidth(tail) + visibleWidth(SEPARATOR) : 0);
+		let left = label;
+		if (telemetry.activity && contentBudget - visibleWidth(label) - visibleWidth(ACTIVITY_SEPARATOR) >= ACTIVITY_MIN_WIDTH) {
+			const activityBudget = contentBudget - visibleWidth(label) - visibleWidth(ACTIVITY_SEPARATOR);
+			left = `${label}${theme.fg("dim", ACTIVITY_SEPARATOR)}${theme.fg("dim", formatTaskSummary(telemetry.activity, activityBudget))}`;
+		}
+		lines.push(`${indent}${composeLine(left, tail, theme, budget)}`);
 	}
-	return `${indent}${layoutLine(timeline, tail, budget)}`;
+	return { lines, activeIndex };
+}
+
+/** Fit one workflow group into the remaining line budget: the primary line
+ * always survives, and the stage window anchors on the live stage — settled
+ * stages above the window collapse into one `… +N` marker, never the live
+ * stage itself. */
+function fitGroupLines(
+	primary: string,
+	stages: readonly string[],
+	activeIndex: number,
+	remaining: number,
+	theme: Theme,
+): string[] {
+	if (stages.length === 0 || stages.length + 1 <= remaining) return [primary, ...stages];
+	const slots = remaining - 1;
+	if (slots <= 0) return [primary];
+	// Reserve one line for an overflow marker so a cut is always announced.
+	const room = Math.max(1, slots - 1);
+	const anchor = activeIndex >= 0 ? activeIndex : 0;
+	const start = Math.max(0, Math.min(anchor, stages.length - room));
+	const window = stages.slice(start, start + room);
+	const parts = [
+		...(start > 0 ? [theme.fg("dim", `… +${start}`)] : []),
+		...window,
+		...(start + room < stages.length ? [theme.fg("dim", `… +${stages.length - start - room}`)] : []),
+	];
+	while (parts.length > slots) parts.pop();
+	return [primary, ...parts];
 }
 
-/** Render active runs as compact per-run line groups: one line per simple run,
- * two per managed workflow. Internal stage children fold into their parent's
- * timeline instead of adding rows, and all rows share one column layout. */
+/** Render active runs as compact per-run line groups: the parent model's own
+ * line first, then one line per simple run, a tree chain per managed workflow
+ * (parent line + one row per stage). All rows share one column layout. */
 export function formatActiveRunLines(
 	runs: readonly RunView[],
 	theme: Theme,
 	width: number,
 	now: number = Date.now(),
+	main?: MainActivity,
 ): string[] {
 	const active = runs.filter((run) => isRunActiveStatus(run.status));
 	const activeIds = new Set(active.map((run) => run.id));
@@ -279,24 +382,38 @@ export function formatActiveRunLines(
 	}
 	const layout: ColumnLayout = {
 		idWidth: Math.max(...roots.map((root) => visibleWidth(`#${root.id}`)), 0),
-		agentWidth: Math.max(...roots.map((root) => visibleWidth(agentColumnText(root))), 0),
+		agentWidth: Math.max(...roots.map((root) => visibleWidth(agentColumnText(root))), main ? visibleWidth("pi") : 0),
 	};
-	const groups: string[][] = roots.map((root) => {
-		const lines = [primaryLine(root, theme, width, now, layout)];
-		const timeline = root.managedWorkflow
-			? workflowTimelineLine(root, childrenOf.get(root.id) ?? [], theme, width, now)
-			: undefined;
-		if (timeline) lines.push(timeline);
-		return lines;
+	const groups: Array<{ lines: string[]; activeIndex: number }> = roots.map((root) => {
+		const children = childrenOf.get(root.id) ?? [];
+		// Workflow-wide tokens/cost on the parent line: every stage snapshot plus
+		// the live child (whose snapshot is frozen only at settlement). Without
+		// a stage projection the parent's own usage stands in.
+		let usage = root.usage;
+		if (root.managedWorkflow && root.workflowStages) {
+			const settled = root.workflowStages.map((stage) => stage.usage).filter((u): u is UsageStats => Boolean(u));
+			const live = children.find((candidate) => candidate.usage.input || candidate.usage.output || candidate.usage.cost);
+			usage = sumUsage([...(settled.length > 0 ? settled : [root.usage]), ...(live ? [live.usage] : [])]);
+		}
+		const lines = [primaryLine(root, theme, width, now, layout, usage)];
+		let activeIndex = -1;
+		if (root.managedWorkflow && root.workflowStages && root.workflowStages.length > 0) {
+			const rendered = workflowStageLines(root.workflowStages, children, theme, width, now);
+			lines.push(...rendered.lines);
+			activeIndex = rendered.activeIndex;
+		}
+		return { lines, activeIndex };
 	});
 
 	const lines: string[] = [];
+	if (main && MAX_WIDGET_LINES > 1) {
+		lines.push(mainLine(main, theme, width, now, layout));
+	}
 	let shownRoots = 0;
 	for (const group of groups) {
 		const remaining = MAX_WIDGET_LINES - 1 - lines.length;
 		if (remaining <= 0) break;
-		// A group that no longer fits whole keeps its primary line only.
-		lines.push(...(group.length <= remaining ? group : group.slice(0, remaining)));
+		lines.push(...fitGroupLines(group.lines[0]!, group.lines.slice(1), group.activeIndex, remaining, theme));
 		shownRoots++;
 	}
 	const hiddenRoots = roots.length - shownRoots;
@@ -307,13 +424,13 @@ export function formatActiveRunLines(
 }
 
 function hasTickingRun(): boolean {
-	return monitor.getRuns().some(
-		(run) => isRunActiveStatus(run.status) && run.activeSince !== undefined,
-	);
+	return monitor.isMainAgentActive()
+		|| monitor.getRuns().some((run) => isRunActiveStatus(run.status) && run.activeSince !== undefined);
 }
 
-/** Install the widget for one TUI session. Its timer exists only while at least
- * one active run has started and is disposed with the widget. */
+/** Install the widget for one TUI session. Its timer exists only while at
+ * least one active run has started or the parent agent loop is running, and
+ * is disposed with the widget. */
 export function installActiveRunsWidget(ctx: Pick<ExtensionContext, "mode" | "ui">): void {
 	if (ctx.mode !== "tui") return;
 	ctx.ui.setWidget(
@@ -341,7 +458,7 @@ export function installActiveRunsWidget(ctx: Pick<ExtensionContext, "mode" | "ui
 			syncTimer();
 
 			return {
-				render: (width: number) => formatActiveRunLines(monitor.getRuns(), theme, width),
+				render: (width: number) => formatActiveRunLines(monitor.getRuns(), theme, width, Date.now(), monitor.getMainActivity()),
 				invalidate() {},
 				dispose() {
 					disposed = true;