pi-prompt-template-model 0.6.5 → 0.6.7

package/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Changelog
 
-## [Unreleased]
+## [0.6.7] - 2026-03-28
+
+### Changed
+- Delegation progress widget now shows a unified tool stream where completed tools scroll chronologically with the active tool highlighted at the bottom, replacing the old design where the active tool flashed at the top and disappeared on completion.
+- Delegation progress widget now renders the subagent's model name in the header (e.g., `delegate [fork] gpt-5.3-codex | 14 tools, 170k tok, 2m47s`).
+- Delegation progress widget no longer caps tool history or output lines. The box grows to show the full execution trace.
+- Delegation progress widget now refreshes every second during idle periods (model thinking) so the elapsed timer ticks smoothly instead of freezing between progress updates.
+- Enriched the delegation bridge protocol to pass through full `recentOutputLines`, `recentTools` history, and `model` from pi-subagents progress data, replacing the old single-line `recentOutput` and missing tool/model fields.
+- Removed `lastTool`/`lastToolArgs` tracking from live state (dead code after the unified tool stream redesign).
+
+## [0.6.6] - 2026-03-28
+
+### Added
+- Added `--model=provider/model-id` runtime flag to override a template's model for a single invocation. Works with single execution, loops, and delegation.
+- Added `--fork` runtime flag to enable `inheritContext` (forked context) at invocation time. Implies `--subagent` if not already set.
+- Inline loop iterations now include a `[Loop 2/5]` prefix so the agent knows it's in a loop and which iteration it's on. Delegated (subagent) loops are unaffected.
+- Added `loop: unlimited` (and `loop: true`) frontmatter for open-ended loops that run until convergence, user interrupt, or the 999-iteration safety cap.
+- Added model rotation for loop iterations via `rotate: true` frontmatter. Cycles through comma-separated models and thinking levels each iteration instead of using fallback semantics.
+
+### Fixed
+- Pressing Escape during a loop or chain iteration now stops the loop. Previously, aborted inline turns were treated as "no changes" and the loop continued.
+- Delegation errors during loop iterations no longer abort the entire loop. The error is reported and the loop continues to the next iteration (useful with model rotation where one model may fail but others succeed).
+- Per-step bare `--loop` in chain declarations (e.g., `double-check --loop -> deslop`) now correctly runs unlimited iterations instead of running once.
+
+### Changed
+- Unlimited loops (`--loop` bare or `loop: unlimited`) no longer force convergence on. Convergence follows the `converge` field like bounded loops. Safety cap raised from 50 to 999.
 
 ## [0.6.5] - 2026-03-24
 

package/README.md

@@ -69,7 +69,8 @@ All fields are optional. Templates that don't use any extension features (no `mo
 | Field | Default | What it does |
 |-------|---------|--------------|
 | `restore` | `true` | After the command finishes, switch back to whatever model and thinking level were active before. Set `false` to stay on the new model. |
-| `loop` | — | Run this template multiple times by default (1–999). CLI `--loop` overrides this. See [Loop Execution](#loop-execution). |
+| `loop` | — | Run this template multiple times by default (1–999, `true`, or `unlimited`). CLI `--loop` overrides this. See [Loop Execution](#loop-execution). |
+| `rotate` | `false` | When `true` and looping, cycle through models in the `model` list instead of using fallback semantics. Thinking levels can also be comma-separated to pair with each model. |
 | `fresh` | `false` | When looping, collapse the conversation between iterations to a brief summary instead of carrying the full context forward. Saves tokens on long loops. |
 | `converge` | `true` | When looping, stop early if an iteration makes no file changes. Set `false` to always run every iteration. |
 
@@ -241,6 +242,17 @@ During execution, a live progress widget appears above the editor showing elapse
 
 You can override delegation at runtime per invocation with `--subagent`, `--subagent=<name>`, `--subagent:<name>`, or `--cwd=<path>`. `--cwd=<path>` must be absolute after optional `~/...` expansion. Runtime flags take precedence for that invocation only.
 
+Two additional runtime flags work for any prompt (not just delegated ones):
+
+- `--model=provider/model-id` — override the template's `model` for this invocation. Works with single execution, loops, and delegation.
+- `--fork` — run with `inheritContext` (forked context). Implies `--subagent` if not already set.
+
+```
+/double-check --model=anthropic/claude-opus-4-6
+/double-check --fork --subagent:worker
+/deslop --model=openai/gpt-5.4 --loop 3
+```
+
 ## Loop Execution
 
 Run a template multiple times with `--loop`:
@@ -248,7 +260,7 @@ Run a template multiple times with `--loop`:
 ```
 /deslop --loop 5
 /deslop --loop=5
-/deslop --loop          # unlimited — runs until convergence (50-iteration cap)
+/deslop --loop          # unlimited — runs until convergence or cap (999)
 ```
 
 You can also set a default in frontmatter. CLI `--loop` always overrides:
@@ -259,11 +271,22 @@ loop: 5
 ---
 ```
 
+Use `loop: unlimited` (or `loop: true`) for open-ended loops that run until convergence, user interrupt, or the safety cap of 999 iterations:
+
+```markdown
+---
+loop: unlimited
+converge: false
+fresh: true
+subagent: true
+---
+```
+
 ### How looping works
 
 Each iteration runs the same prompt. By default, context accumulates — iteration 3 sees the full conversation from iterations 1 and 2 and builds on that work.
 
-**Convergence**: If an iteration makes no file changes (no `write` or `edit` tool calls), the loop stops early. This is on by default. Use `--no-converge` or `converge: false` to always run every iteration. Bare `--loop` (unlimited) always forces convergence on, since its whole purpose is "run until nothing changes."
+**Convergence**: If an iteration makes no file changes (no `write` or `edit` tool calls), the loop stops early. This is on by default. Use `--no-converge` or `converge: false` to always run every iteration.
 
 **Fresh context**: Add `--fresh` (or `fresh: true` in frontmatter) to collapse the conversation between iterations. Each iteration gets a clean slate with only brief summaries of what previous iterations did. Good for long loops where accumulated context would blow up the token count.
 
@@ -271,6 +294,60 @@ Each iteration runs the same prompt. By default, context accumulates — iterati
 
 Model, thinking level, and skill are maintained throughout. If `restore: true` (the default), everything is restored after the final iteration.
 
+## Model Rotation
+
+`rotate: true` turns a comma-separated `model` list from a fallback chain into a cycling list. Each loop iteration uses the next model in the list, wrapping around:
+
+```markdown
+---
+model: claude-opus-4-6, gpt-5.4, gpt-5.3-codex
+thinking: high, xhigh, off
+loop: 9
+rotate: true
+fresh: true
+---
+Review and fix issues in this codebase.
+```
+
+Iteration 1 runs Opus + `high`, iteration 2 runs GPT-5.4 + `xhigh`, iteration 3 runs Codex + `off`, then wraps back to Opus. The status bar shows which model is active: `loop 2/9 · gpt-5.4 xhigh`.
+
+This is especially useful for [ralph-style loops](https://ghuntley.com/ralph/) where different models catch different things. The `subagent` examples below require [pi-subagents](https://github.com/nicobailon/pi-subagents/). A single-model ralph loop that delegates with fresh context each iteration:
+
+```markdown
+---
+model: claude-sonnet-4-20250514
+subagent: true
+inheritContext: true
+loop: 5
+fresh: true
+---
+Simplify this code: $@
+```
+
+Add `rotate` and multiple models to cycle different perspectives on each pass:
+
+```markdown
+---
+model: claude-opus-4-6, gpt-5.4, gpt-5.3-codex
+thinking: xhigh, high, high
+loop: 9
+rotate: true
+fresh: true
+subagent: true
+---
+Review and fix issues in this codebase.
+```
+
+Each iteration gets fresh context, a different model, and its own thinking level. Convergence stops the loop when an iteration makes no file changes — use `converge: false` to guarantee every model gets at least one shot.
+
+`thinking` pairing with `rotate: true`:
+
+- Single value (`thinking: high`) — applied to every model.
+- Comma-separated (`thinking: high, xhigh, off`) — positional, must match the number of models.
+- Omitted — each iteration inherits the session default.
+
+Without `loop`, `rotate` has no effect and comma-separated `model` keeps normal fallback behavior.
+
 ## Chaining Templates
 
 `/chain-prompts` runs multiple templates in sequence. Each step uses its own model, skill, and thinking level, while conversation context flows between them:

package/args.ts

@@ -20,6 +20,8 @@ export interface SubagentOverrideExtraction {
 	args: string;
 	override?: SubagentOverride;
 	cwd?: string;
+	model?: string;
+	fork?: boolean;
 }
 
 export function extractLoopCount(argsString: string): LoopExtraction | null {
@@ -113,7 +115,7 @@ export function extractLoopCount(argsString: string): LoopExtraction | null {
 		cleaned = cleaned.slice(0, start) + cleaned.slice(end);
 	}
 
-	const converge = loopCount === null ? true : !noConverge;
+	const converge = !noConverge;
 	return { args: cleaned.trim(), loopCount, fresh, converge };
 }
 
@@ -210,6 +212,8 @@ export function extractChainContextFlag(argsString: string): { args: string; cha
 export function extractSubagentOverride(argsString: string): SubagentOverrideExtraction {
 	let override: SubagentOverride | undefined;
 	let cwdRaw: string | undefined;
+	let modelRaw: string | undefined;
+	let fork = false;
 	const tokensToRemove: Array<{ start: number; end: number }> = [];
 
 	let i = 0;
@@ -250,6 +254,20 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 			tokensToRemove.push({ start: tokenStart, end: i });
 			const value = token.slice("--cwd=".length);
 			cwdRaw = value || undefined;
+			continue;
+		}
+
+		if (token.startsWith("--model=")) {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			const value = token.slice("--model=".length);
+			modelRaw = value || undefined;
+			continue;
+		}
+
+		if (token === "--fork") {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			fork = true;
+			continue;
 		}
 	}
 
@@ -261,10 +279,14 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 		cleaned = cleaned.slice(0, start) + cleaned.slice(end);
 	}
 
+	if (fork && !override) override = { enabled: true };
+
 	return {
 		args: cleaned.trim(),
 		...(override ? { override } : {}),
 		...(cwdRaw !== undefined ? { cwd: cwdRaw } : {}),
+		...(modelRaw !== undefined ? { model: modelRaw } : {}),
+		...(fork ? { fork: true } : {}),
 	};
 }
 

package/chain-parser.ts

@@ -3,7 +3,7 @@ import { parseCommandArgs } from "./args.js";
 export interface ChainStep {
 	name: string;
 	args: string[];
-	loopCount?: number;
+	loopCount?: number | null;
 	withContext?: boolean;
 }
 
@@ -81,11 +81,11 @@ function scanSegmentTokens(segment: string): SegmentToken[] {
 	return tokens;
 }
 
-function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?: number; withContext: boolean } {
+function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?: number | null; withContext: boolean } {
 	const tokens = scanSegmentTokens(segment);
 	const loopTokenRanges: Array<{ start: number; end: number }> = [];
 	const withContextTokenRanges: Array<{ start: number; end: number }> = [];
-	let loopCount: number | undefined;
+	let loopCount: number | null | undefined;
 	let withContext = false;
 
 	for (let i = 1; i < tokens.length; i++) {
@@ -109,17 +109,24 @@ function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?
 			continue;
 		}
 
-		if (token.value === "--loop" && i + 1 < tokens.length) {
-			const next = tokens[i + 1];
-			if (!next.quoted && /^\d+$/.test(next.value)) {
-				loopTokenRanges.push({ start: token.start, end: token.end }, { start: next.start, end: next.end });
-				const parsed = parseInt(next.value, 10);
-				if (parsed >= 1 && parsed <= 999 && loopCount === undefined) {
-					loopCount = parsed;
+		if (token.value === "--loop") {
+			loopTokenRanges.push({ start: token.start, end: token.end });
+			if (i + 1 < tokens.length) {
+				const next = tokens[i + 1];
+				if (!next.quoted && /^\d+$/.test(next.value)) {
+					loopTokenRanges.push({ start: next.start, end: next.end });
+					const parsed = parseInt(next.value, 10);
+					if (parsed >= 1 && parsed <= 999 && loopCount === undefined) {
+						loopCount = parsed;
+					}
+					i++;
+					continue;
 				}
-				i++;
-				continue;
 			}
+			if (loopCount === undefined) {
+				loopCount = null;
+			}
+			continue;
 		}
 	}
 

package/index.ts

@@ -3,7 +3,7 @@ import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@m
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 import { extractChainContextFlag, extractLoopCount, extractLoopFlags, extractSubagentOverride, parseCommandArgs, type SubagentOverride } from "./args.js";
 import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.js";
-import { generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries } from "./loop-utils.js";
+import { generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries, wasIterationAborted } from "./loop-utils.js";
 import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.js";
 import { preparePromptExecution } from "./prompt-execution.js";
 import { buildPromptCommandDescription, expandCwdPath, loadPromptsWithModel, readSkillContent, resolveSkillPath, type PromptWithModel } from "./prompt-loader.js";
@@ -16,6 +16,7 @@ import { renderDelegatedSubagentResult } from "./subagent-renderer.js";
 interface LoopState {
 	currentIteration: number;
 	totalIterations: number | null;
+	rotationLabel?: string;
 }
 
 interface FreshCollapse {
@@ -58,7 +59,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	let accumulatedSummaries: string[] = [];
 	let lastDiagnostics = "";
 	let storedCommandCtx: ExtensionCommandContext | null = null;
-	const UNLIMITED_LOOP_CAP = 50;
+	const UNLIMITED_LOOP_CAP = 999;
 
 	const toolManager = createToolManager(pi, {
 		isActive: () => !!(loopState || chainActive),
@@ -131,9 +132,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 		for (const command of pi.getCommands()) {
 			if (command.source !== "skill") continue;
-			if (!command.sourceInfo.path) continue;
+			const sourceInfo = "sourceInfo" in command
+				? (command as { sourceInfo?: { path?: string } }).sourceInfo
+				: undefined;
+			if (!sourceInfo?.path) continue;
 			if (!candidates.has(command.name)) continue;
-			return command.sourceInfo.path;
+			return sourceInfo.path;
 		}
 
 		return undefined;
@@ -196,6 +200,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		override?: SubagentOverride,
 		inheritedModel?: Model<any>,
 		taskPreamble?: string,
+		loopContext?: string,
 	): Promise<PromptStepResult | "aborted"> {
 		if (shouldDelegatePrompt(prompt, override)) {
 			try {
@@ -216,7 +221,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				return { changed: delegated.changed };
 			} catch (error) {
 				notify(ctx, error instanceof Error ? error.message : String(error), "error");
-				return "aborted";
+				return { changed: false };
 			}
 		}
 
@@ -258,10 +263,14 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
 
 		const startId = ctx.sessionManager.getLeafId();
-		pi.sendUserMessage(prepared.content);
+		const content = loopContext ? `[${loopContext}]\n\n${prepared.content}` : prepared.content;
+		pi.sendUserMessage(content);
 		await waitForTurnStart(ctx);
 		await ctx.waitForIdle();
-		return { changed: didIterationMakeChanges(getIterationEntries(ctx, startId)) };
+
+		const entries = getIterationEntries(ctx, startId);
+		if (wasIterationAborted(entries)) return "aborted";
+		return { changed: didIterationMakeChanges(entries) };
 	}
 
 	async function restoreSessionState(
@@ -353,10 +362,11 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	function updateLoopStatus(ctx: ExtensionContext) {
 		if (!ctx.hasUI) return;
 		if (loopState) {
+			const suffix = loopState.rotationLabel ? ` · ${loopState.rotationLabel}` : "";
 			const label =
 				loopState.totalIterations !== null
-					? `loop ${loopState.currentIteration}/${loopState.totalIterations}`
-					: `loop ${loopState.currentIteration}`;
+					? `loop ${loopState.currentIteration}/${loopState.totalIterations}${suffix}`
+					: `loop ${loopState.currentIteration}${suffix}`;
 			ctx.ui.setStatus("prompt-loop", ctx.ui.theme.fg("warning", label));
 		} else {
 			ctx.ui.setStatus("prompt-loop", undefined);
@@ -385,6 +395,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		ctx: ExtensionCommandContext,
 		subagentOverride?: SubagentOverride,
 		cwdOverride?: string,
+		promptOverrides?: Partial<Pick<PromptWithModel, "models" | "inheritContext">>,
 	) {
 		refreshPrompts(ctx.cwd, ctx);
 		const initialPrompt = prompts.get(name);
@@ -401,7 +412,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const useFresh = freshFlag || initialPrompt.fresh === true;
 		const effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP;
 		const isUnlimited = totalIterations === null;
-		const useConverge = isUnlimited ? true : converge && initialPrompt.converge !== false;
+		const useConverge = converge && initialPrompt.converge !== false;
 		const anchorId = useFresh ? ctx.sessionManager.getLeafId() : null;
 
 		loopState = { currentIteration: 1, totalIterations };
@@ -414,9 +425,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		try {
 			for (let i = 0; i < effectiveMax; i++) {
 				loopState.currentIteration = i + 1;
-				updateLoopStatus(ctx);
 				const iterationLabel = totalIterations !== null ? `${i + 1}/${totalIterations}` : `${i + 1}`;
-				notify(ctx, `Loop ${iterationLabel}: ${name}`, "info");
 
 				refreshPrompts(ctx.cwd, ctx);
 				const prompt = prompts.get(name);
@@ -424,15 +433,40 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					notify(ctx, `Prompt "${name}" no longer exists`, "error");
 					break;
 				}
-				const effectivePrompt = cwdOverride ? { ...prompt, cwd: cwdOverride } : prompt;
+				const effectivePrompt = { ...prompt, ...(cwdOverride ? { cwd: cwdOverride } : {}), ...promptOverrides };
+				let iterationPrompt = effectivePrompt;
+				loopState!.rotationLabel = undefined;
+				if (effectivePrompt.rotate && effectivePrompt.models.length > 1) {
+					const rotationIndex = i % effectivePrompt.models.length;
+					const rotatedThinking = effectivePrompt.thinkingLevels
+						? effectivePrompt.thinkingLevels[rotationIndex]
+						: effectivePrompt.thinking;
+					iterationPrompt = {
+						...effectivePrompt,
+						models: [effectivePrompt.models[rotationIndex]],
+						thinking: rotatedThinking,
+					};
+					const shortModel = effectivePrompt.models[rotationIndex].split("/").pop() || effectivePrompt.models[rotationIndex];
+					const thinkingLabel = rotatedThinking ? ` ${rotatedThinking}` : "";
+					loopState!.rotationLabel = `${shortModel}${thinkingLabel}`;
+				}
+				updateLoopStatus(ctx);
+				const rotationSuffix = loopState!.rotationLabel ? ` [${loopState!.rotationLabel}]` : "";
+				notify(ctx, `Loop ${iterationLabel}: ${name}${rotationSuffix}`, "info");
 
+				const loopContext = loopState!.rotationLabel
+					? `Loop ${iterationLabel} · ${loopState!.rotationLabel}`
+					: `Loop ${iterationLabel}`;
 				const iterationStartId = ctx.sessionManager.getLeafId();
 				const stepResult = await executePromptStep(
-					effectivePrompt,
+					iterationPrompt,
 					parseCommandArgs(cleanedArgs),
 					ctx,
 					currentModel,
 					subagentOverride,
+					undefined,
+					undefined,
+					loopContext,
 				);
 				if (stepResult === "aborted") break;
 
@@ -440,7 +474,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				currentThinking = pi.getThinkingLevel();
 				completedIterations++;
 
-				const iterationChanged = shouldDelegatePrompt(effectivePrompt, subagentOverride)
+				const iterationChanged = shouldDelegatePrompt(iterationPrompt, subagentOverride)
 					? stepResult.changed
 					: didIterationMakeChanges(getIterationEntries(ctx, iterationStartId));
 				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
@@ -567,7 +601,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		pendingSkillMessage = undefined;
 		const effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP;
 		const isUnlimited = totalIterations === null;
-		const useConverge = isUnlimited ? true : converge;
+		const useConverge = converge;
 
 		const anchorId = fresh ? ctx.sessionManager.getLeafId() : null;
 		const chainStepNames = steps
@@ -612,7 +646,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 									...(cwdOverride ? { cwd: cwdOverride } : {}),
 								},
 								stepArgs: step.args,
-								stepLoop: step.loopCount ?? 1,
+								stepLoop: step.loopCount !== undefined ? step.loopCount : 1,
 								stepWithContext: step.withContext === true,
 							},
 						},
@@ -676,7 +710,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					}
 
 					const singleStep = stepTemplate.singleStep;
-					const stepLoop = singleStep.stepLoop;
+					const stepLoopTotal = singleStep.stepLoop;
+					const stepLoopMax = stepLoopTotal ?? UNLIMITED_LOOP_CAP;
+					const isStepLooping = stepLoopMax > 1;
 					const effectiveArgs = singleStep.stepArgs.length > 0 ? singleStep.stepArgs : sharedArgs;
 					const shouldInjectSummary =
 						shouldDelegatePrompt(singleStep.prompt, subagentOverride) &&
@@ -684,19 +720,23 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 						(chainContextEnabled || singleStep.stepWithContext === true);
 					const outerLoopState = loopState ? { ...loopState } : null;
 					const stepStartId = ctx.sessionManager.getLeafId();
-					if (stepLoop > 1) {
-						loopState = { currentIteration: 1, totalIterations: stepLoop };
+					if (isStepLooping) {
+						loopState = { currentIteration: 1, totalIterations: stepLoopTotal };
 						updateLoopStatus(ctx);
 					}
 
 					try {
-						for (let stepIteration = 0; stepIteration < stepLoop; stepIteration++) {
-							if (stepLoop > 1) {
-								loopState = { currentIteration: stepIteration + 1, totalIterations: stepLoop };
+						for (let stepIteration = 0; stepIteration < stepLoopMax; stepIteration++) {
+							if (isStepLooping) {
+								loopState = { currentIteration: stepIteration + 1, totalIterations: stepLoopTotal };
 								updateLoopStatus(ctx);
 							}
 
-							const iterSuffix = stepLoop > 1 ? ` (iter ${stepIteration + 1}/${stepLoop})` : "";
+							const iterSuffix = isStepLooping
+								? stepLoopTotal !== null
+									? ` (iter ${stepIteration + 1}/${stepLoopTotal})`
+									: ` (iter ${stepIteration + 1})`
+								: "";
 							notify(
 								ctx,
 								`${loopPrefix}Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix} ${buildPromptCommandDescription(singleStep.prompt)}`,
@@ -709,6 +749,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								? `[Previous chain steps]\n\n${chainStepSummaries.join("\n\n")}`
 								: undefined;
 
+							const stepLoopContext = isStepLooping
+								? `Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix}`
+								: undefined;
 							const stepIterationStartId = ctx.sessionManager.getLeafId();
 							const stepResult = await executePromptStep(
 								singleStep.prompt,
@@ -718,6 +761,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								subagentOverride,
 								chainInheritedModel,
 								taskPreamble,
+								stepLoopContext,
 							);
 							if (stepResult === "aborted") {
 								aborted = true;
@@ -729,12 +773,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 							const stepIterationEntries = getIterationEntries(ctx, stepIterationStartId);
 							const stepIterationChanged = didIterationMakeChanges(stepIterationEntries);
-							if (stepLoop > 1 && singleStep.prompt.converge !== false && !stepIterationChanged) {
+							if (isStepLooping && singleStep.prompt.converge !== false && !stepIterationChanged) {
 								break;
 							}
 						}
 					} finally {
-						if (stepLoop > 1) {
+						if (isStepLooping) {
 							loopState = outerLoopState ? { ...outerLoopState } : null;
 							updateLoopStatus(ctx);
 						}
@@ -817,10 +861,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const argsWithoutSubagent = subagent.args;
 
 		if (prompt.chain) {
+			if (subagent.model) notify(ctx, `--model is not supported on chain prompts (ignored)`, "warning");
+			if (subagent.fork) notify(ctx, `--fork is not supported on chain prompts (ignored)`, "warning");
 			const extracted = extractChainContextFlag(argsWithoutSubagent);
 			const chainContextEnabled = extracted.chainContext || prompt.chainContext === "summary";
 			const loop = extractLoopCount(extracted.args);
-			let totalIterations: number | null = prompt.loop ?? 1;
+			let totalIterations: number | null = prompt.loop !== undefined ? prompt.loop : 1;
 			let fresh = false;
 			let converge = true;
 			let cleanedArgs = extracted.args;
@@ -863,19 +909,24 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			return;
 		}
 
+		const promptOverrides: Partial<Pick<PromptWithModel, "models" | "inheritContext">> = {
+			...(subagent.model ? { models: [subagent.model] } : {}),
+			...(subagent.fork ? { inheritContext: true } : {}),
+		};
+
 		const loop = extractLoopCount(argsWithoutSubagent);
 		if (loop) {
-			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override, runtimeCwd);
+			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
 			return;
 		}
 
 		if (prompt.loop !== undefined) {
 			const flags = extractLoopFlags(argsWithoutSubagent);
-			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override, runtimeCwd);
+			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
 			return;
 		}
 
-		const effectivePrompt = runtimeCwd ? { ...prompt, cwd: runtimeCwd } : prompt;
+		const effectivePrompt = { ...prompt, ...(runtimeCwd ? { cwd: runtimeCwd } : {}), ...promptOverrides };
 		const savedModel = getCurrentModel(ctx);
 		const savedThinking = pi.getThinkingLevel();
 		const stepResult = await executePromptStep(

package/loop-utils.ts

@@ -153,3 +153,11 @@ export function getIterationEntries(ctx: Pick<ExtensionContext, "sessionManager"
 	if (startIdx < 0) return branch;
 	return branch.slice(startIdx + 1);
 }
+
+export function wasIterationAborted(entries: SessionEntry[]): boolean {
+	for (const entry of entries) {
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		if ((entry.message as AssistantMessage).stopReason === "aborted") return true;
+	}
+	return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",

package/prompt-loader.ts

@@ -42,8 +42,10 @@ export interface PromptWithModel {
 	restore: boolean;
 	skill?: string;
 	thinking?: ThinkingLevel;
+	thinkingLevels?: ThinkingLevel[];
+	rotate?: boolean;
 	fresh?: boolean;
-	loop?: number;
+	loop?: number | null;
 	converge?: boolean;
 	subagent?: true | string;
 	inheritContext?: boolean;
@@ -243,14 +245,43 @@ function normalizeFresh(
 	return false;
 }
 
+function normalizeRotate(
+	value: unknown,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): boolean {
+	if (value === undefined) return false;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "true") return true;
+		if (normalized === "false") return false;
+	}
+
+	diagnostics.push(
+		createDiagnostic(
+			"invalid-rotate",
+			filePath,
+			source,
+			`Using default rotate=false for ${filePath}: frontmatter field "rotate" must be true or false.`,
+		),
+	);
+	return false;
+}
+
 function normalizeLoop(
 	value: unknown,
 	filePath: string,
 	source: PromptSource,
 	diagnostics: PromptLoaderDiagnostic[],
-): number | undefined {
+): number | null | undefined {
 	if (value === undefined) return undefined;
 
+	if (value === true || (typeof value === "string" && value.trim().toLowerCase() === "unlimited")) {
+		return null;
+	}
+
 	let normalizedValue: number | undefined;
 	if (typeof value === "number") {
 		normalizedValue = value;
@@ -267,7 +298,7 @@ function normalizeLoop(
 			"invalid-loop",
 			filePath,
 			source,
-			`Ignoring invalid loop value in ${filePath}: frontmatter field "loop" must be an integer between 1 and 999.`,
+			`Ignoring invalid loop value in ${filePath}: frontmatter field "loop" must be an integer between 1 and 999, true, or "unlimited".`,
 		),
 	);
 	return undefined;
@@ -481,6 +512,48 @@ function normalizeThinking(
 	return undefined;
 }
 
+function normalizeThinkingLevels(
+	value: unknown,
+	modelCount: number,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): ThinkingLevel[] | undefined {
+	if (typeof value !== "string") return undefined;
+
+	const levels = value
+		.split(",")
+		.map((item) => item.trim())
+		.filter(Boolean);
+
+	const invalidLevel = levels.find((level) => !(VALID_THINKING_LEVELS as readonly string[]).includes(level.toLowerCase()));
+	if (invalidLevel) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-thinking-levels",
+				filePath,
+				source,
+				`Ignoring invalid thinking level in ${filePath}: ${JSON.stringify(invalidLevel)}.`,
+			),
+		);
+		return undefined;
+	}
+
+	if (levels.length !== modelCount) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-thinking-level-count",
+				filePath,
+				source,
+				`Ignoring comma-separated thinking levels in ${filePath}: expected ${modelCount} entries to match frontmatter field "model".`,
+			),
+		);
+		return undefined;
+	}
+
+	return levels.map((level) => level.toLowerCase() as ThinkingLevel);
+}
+
 function loadPromptsWithModelFromDir(
 	dir: string,
 	source: PromptSource,
@@ -619,6 +692,7 @@ function loadPromptsWithModelFromDir(
 				const parsedModels = chain ? [] : normalizeModelSpecs(frontmatter.model, fullPath, source, diagnostics);
 				if (!chain && hasModelField && !parsedModels) continue;
 				const models = chain ? [] : (parsedModels ?? []);
+				const rotate = chain ? false : normalizeRotate(frontmatter.rotate, fullPath, source, diagnostics);
 
 				const name = entry.name.slice(0, -3);
 				if (RESERVED_COMMAND_NAMES.has(name)) {
@@ -637,7 +711,15 @@ function loadPromptsWithModelFromDir(
 				const safeCwd = (chain || subagent !== undefined) ? cwd : undefined;
 				const description = normalizeStringField("description", frontmatter.description, fullPath, source, diagnostics) ?? "";
 				const skill = chain ? undefined : normalizeStringField("skill", frontmatter.skill, fullPath, source, diagnostics);
-				const thinking = chain ? undefined : normalizeThinking(frontmatter.thinking, fullPath, source, diagnostics);
+				let thinking: ThinkingLevel | undefined;
+				let thinkingLevels: ThinkingLevel[] | undefined;
+				if (!chain) {
+					if (rotate && typeof frontmatter.thinking === "string" && frontmatter.thinking.includes(",")) {
+						thinkingLevels = normalizeThinkingLevels(frontmatter.thinking, models.length, fullPath, source, diagnostics);
+					} else {
+						thinking = normalizeThinking(frontmatter.thinking, fullPath, source, diagnostics);
+					}
+				}
 				const restore = normalizeRestore(frontmatter.restore, fullPath, source, diagnostics);
 				const fresh = normalizeFresh(frontmatter.fresh, fullPath, source, diagnostics);
 				const loop = normalizeLoop(frontmatter.loop, fullPath, source, diagnostics);
@@ -666,8 +748,10 @@ function loadPromptsWithModelFromDir(
 					restore,
 					skill,
 					thinking,
+					thinkingLevels,
+					rotate: rotate || undefined,
 					fresh: fresh || undefined,
-					loop: loop || undefined,
+					loop: loop !== undefined ? loop : undefined,
 					converge: converge === false ? false : undefined,
 					subagent,
 					inheritContext: safeInheritContext || undefined,
@@ -753,13 +837,15 @@ export function buildPromptCommandDescription(prompt: PromptWithModel): string {
 		return prompt.description ? `${prompt.description} ${details}` : details;
 	}
 	const modelLabel = prompt.models.length > 0 ? prompt.models.map((model) => model.split("/").pop() || model).join("|") : "current";
+	const rotateLabel = prompt.rotate ? " rotate" : "";
 	const skillLabel = prompt.skill ? ` +${prompt.skill}` : "";
-	const thinkingLabel = prompt.thinking ? ` ${prompt.thinking}` : "";
-	const loopLabel = prompt.loop ? ` loop:${prompt.loop}` : "";
+	const thinkingValue = prompt.thinkingLevels ? prompt.thinkingLevels.join(",") : prompt.thinking;
+	const thinkingLabel = thinkingValue ? ` ${thinkingValue}` : "";
+	const loopLabel = prompt.loop !== undefined ? ` loop:${prompt.loop === null ? "unlimited" : prompt.loop}` : "";
 	const subagentLabel = prompt.subagent ? ` subagent:${prompt.subagent === true ? "delegate" : prompt.subagent}` : "";
 	const cwdLabel = prompt.cwd ? ` cwd:${prompt.cwd}` : "";
 	const inheritContextLabel = prompt.inheritContext ? " fork" : "";
-	const details = `[${modelLabel}${thinkingLabel}${skillLabel}${loopLabel}${subagentLabel}${cwdLabel}${inheritContextLabel}] ${sourceLabel}`;
+	const details = `[${modelLabel}${rotateLabel}${thinkingLabel}${skillLabel}${loopLabel}${subagentLabel}${cwdLabel}${inheritContextLabel}] ${sourceLabel}`;
 	return prompt.description ? `${prompt.description} ${details}` : details;
 }
 

package/subagent-runtime.ts

@@ -52,6 +52,9 @@ export interface DelegatedSubagentUpdate {
 	currentTool?: string;
 	currentToolArgs?: string;
 	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
@@ -65,6 +68,9 @@ export interface DelegatedSubagentTaskProgress {
 	currentTool?: string;
 	currentToolArgs?: string;
 	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
@@ -74,9 +80,9 @@ export interface DelegatedSubagentLiveState {
 	status?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
-	lastTool?: string;
-	lastToolArgs?: string;
 	recentOutput: string[];
+	recentTools: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount: number;
 	durationMs: number;
 	tokens: number;
@@ -151,6 +157,7 @@ export function updateDelegatedLiveState(requestId: string, update: Partial<Dele
 	const now = Date.now();
 	const existing = delegatedLiveState.get(requestId) ?? {
 		recentOutput: [],
+		recentTools: [],
 		toolCount: 0,
 		durationMs: 0,
 		tokens: 0,
@@ -158,21 +165,16 @@ export function updateDelegatedLiveState(requestId: string, update: Partial<Dele
 		startedAt: now,
 		updatedAt: now,
 	};
-	// When a tool finishes (currentTool goes undefined), preserve it as lastTool
-	const toolJustCleared = update.currentTool === undefined && existing.currentTool !== undefined;
-	const lastTool = toolJustCleared ? existing.currentTool : (update.currentTool ?? existing.lastTool);
-	const lastToolArgs = toolJustCleared ? existing.currentToolArgs : (update.currentToolArgs ?? existing.lastToolArgs);
-
 	const next: DelegatedSubagentLiveState = {
 		...existing,
 		...update,
 		recentOutput: update.recentOutput ?? existing.recentOutput,
+		recentTools: update.recentTools ?? existing.recentTools,
+		model: update.model ?? existing.model,
 		toolCount: update.toolCount ?? existing.toolCount,
 		durationMs: update.durationMs ?? (now - existing.startedAt),
 		tokens: update.tokens ?? existing.tokens,
 		taskProgress: update.taskProgress ?? existing.taskProgress,
-		lastTool,
-		lastToolArgs,
 		startedAt: existing.startedAt,
 		updatedAt: now,
 	};
@@ -184,6 +186,7 @@ export function appendDelegatedLiveOutput(requestId: string, line?: string): voi
 	const fallbackNow = Date.now();
 	const existing = delegatedLiveState.get(requestId) ?? {
 		recentOutput: [],
+		recentTools: [],
 		toolCount: 0,
 		durationMs: 0,
 		tokens: 0,
@@ -191,7 +194,7 @@ export function appendDelegatedLiveOutput(requestId: string, line?: string): voi
 		startedAt: fallbackNow,
 		updatedAt: fallbackNow,
 	};
-	const recentOutput = [...existing.recentOutput, line].slice(-12);
+	const recentOutput = [...existing.recentOutput, line];
 	delegatedLiveState.set(requestId, {
 		...existing,
 		recentOutput,

package/subagent-step.ts

@@ -204,6 +204,9 @@ function formatProgressStatus(update: DelegatedSubagentUpdate): string | undefin
 	if (update.currentTool) {
 		return `running ${update.currentTool}${update.currentToolArgs ? ` ${update.currentToolArgs}` : ""}`;
 	}
+	if (update.taskProgress?.some((task) => task.status === "running")) {
+		return "running";
+	}
 	if (update.toolCount && update.toolCount > 0) {
 		return `completed ${update.toolCount} tool${update.toolCount === 1 ? "" : "s"}`;
 	}
@@ -216,6 +219,38 @@ function formatParallelProgressStatus(update: DelegatedSubagentUpdate): string |
 	return `parallel ${completed}/${update.taskProgress.length} running`;
 }
 
+function hasOwn<T extends object>(value: T, key: PropertyKey): boolean {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function sanitizeOutputLines(lines: string[] | undefined): string[] {
+	if (!lines || lines.length === 0) return [];
+	return lines.filter((line): line is string => typeof line === "string" && line.trim() && line.trim() !== "(running...)");
+}
+
+function collectNewOutputLines(previous: string[] | undefined, next: string[] | undefined): string[] {
+	const previousLines = sanitizeOutputLines(previous);
+	const nextLines = sanitizeOutputLines(next);
+	if (nextLines.length === 0) return [];
+	if (previousLines.length === 0) return nextLines;
+
+	const overlapLimit = Math.min(previousLines.length, nextLines.length);
+	for (let overlap = overlapLimit; overlap > 0; overlap--) {
+		let matches = true;
+		for (let index = 0; index < overlap; index++) {
+			if (previousLines[previousLines.length - overlap + index] !== nextLines[index]) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) {
+			return nextLines.slice(overlap);
+		}
+	}
+
+	return nextLines;
+}
+
 function mergeTaskProgress(
 	requestTasks: DelegatedSubagentTask[] | undefined,
 	existingProgress: DelegatedSubagentTaskProgress[] | undefined,
@@ -235,6 +270,9 @@ function mergeTaskProgress(
 			currentTool: existing?.currentTool,
 			currentToolArgs: existing?.currentToolArgs,
 			recentOutput: existing?.recentOutput,
+			recentOutputLines: existing?.recentOutputLines,
+			recentTools: existing?.recentTools,
+			model: existing?.model ?? task.model,
 			toolCount: existing?.toolCount,
 			durationMs: existing?.durationMs,
 			tokens: existing?.tokens,
@@ -255,11 +293,20 @@ function mergeTaskProgress(
 		}
 		if (targetIndex < 0) continue;
 		consumed.add(targetIndex);
+		const current = merged[targetIndex]!;
 		merged[targetIndex] = {
-			...merged[targetIndex],
-			...entry,
 			index: targetIndex,
-			agent: merged[targetIndex]!.agent,
+			agent: current.agent,
+			status: entry.status ?? current.status,
+			currentTool: hasOwn(entry, "currentTool") ? entry.currentTool : current.currentTool,
+			currentToolArgs: hasOwn(entry, "currentToolArgs") ? entry.currentToolArgs : current.currentToolArgs,
+			recentOutput: entry.recentOutput ?? current.recentOutput,
+			recentOutputLines: entry.recentOutputLines ?? current.recentOutputLines,
+			recentTools: entry.recentTools ?? current.recentTools,
+			model: entry.model ?? current.model,
+			toolCount: entry.toolCount ?? current.toolCount,
+			durationMs: entry.durationMs ?? current.durationMs,
+			tokens: entry.tokens ?? current.tokens,
 		};
 	}
 
@@ -316,18 +363,29 @@ async function requestDelegatedRun(
 
 		let lastProgressStatus = "";
 		let widgetSet = false;
+		let refreshTimer: ReturnType<typeof setInterval> | null = null;
 
 		const showWidget = () => {
 			if (!ctx.hasUI || widgetSet) return;
 			widgetSet = true;
 			ctx.ui.setWidget(
 				DELEGATED_WIDGET_KEY,
-				(_tui, theme) => createDelegatedProgressWidget(request.requestId, request.agent, request.context, request.task, request.tasks, theme),
+				(_tui, theme) => createDelegatedProgressWidget(request.requestId, request.agent, request.context, request.task, request.tasks, theme, request.model),
 				{ placement: "aboveEditor" },
 			);
+			// Force TUI repaints every second so the elapsed timer ticks during idle periods
+			refreshTimer = setInterval(() => {
+				if (done) return;
+				const statusLine = lastProgressStatus || "running...";
+				ctx.ui.setStatus("prompt-subagent", `delegating to ${requestLabel} · ${statusLine}`);
+			}, 1000);
 		};
 
 		const clearWidget = () => {
+			if (refreshTimer) {
+				clearInterval(refreshTimer);
+				refreshTimer = null;
+			}
 			if (ctx.hasUI && widgetSet) {
 				ctx.ui.setWidget(DELEGATED_WIDGET_KEY, undefined);
 				widgetSet = false;
@@ -338,9 +396,11 @@ async function requestDelegatedRun(
 			if (done || !data || typeof data !== "object") return;
 			const update = data as DelegatedSubagentUpdate;
 			if (update.requestId !== request.requestId) return;
+
+			const previousTaskProgress = getDelegatedLiveState(request.requestId)?.taskProgress;
 			const mergedTaskProgress = mergeTaskProgress(
 				request.tasks,
-				getDelegatedLiveState(request.requestId)?.taskProgress,
+				previousTaskProgress,
 				update.taskProgress,
 			);
 			const isParallel = (request.tasks?.length ?? 0) > 0;
@@ -353,18 +413,46 @@ async function requestDelegatedRun(
 			if (progressStatus) {
 				lastProgressStatus = progressStatus;
 			}
+
 			updateDelegatedLiveState(request.requestId, {
 				status: progressStatus ?? (lastProgressStatus || "running..."),
 				currentTool: update.currentTool,
 				currentToolArgs: update.currentToolArgs,
+				recentTools: update.recentTools,
+				model: update.model,
 				toolCount: update.toolCount,
 				durationMs: update.durationMs,
 				tokens: update.tokens,
 				taskProgress: mergedTaskProgress,
 			});
-			appendDelegatedLiveOutput(request.requestId, update.recentOutput);
-			if (mergedTaskProgress) {
+
+			if (!isParallel) {
+				if (update.recentOutputLines && update.recentOutputLines.length > 0) {
+					updateDelegatedLiveState(request.requestId, {
+						recentOutput: sanitizeOutputLines(update.recentOutputLines),
+					});
+				} else {
+					appendDelegatedLiveOutput(request.requestId, update.recentOutput);
+				}
+			}
+
+			if (isParallel && mergedTaskProgress) {
 				for (const task of mergedTaskProgress) {
+					const previousTask =
+						previousTaskProgress?.find((entry) => entry.index === task.index) ??
+						previousTaskProgress?.find((entry) => entry.agent === task.agent);
+
+					const newOutputLines = collectNewOutputLines(previousTask?.recentOutputLines, task.recentOutputLines);
+					if (newOutputLines.length > 0) {
+						for (const line of newOutputLines) {
+							appendDelegatedLiveOutput(request.requestId, line);
+						}
+						continue;
+					}
+
+					if (!task.recentOutput || task.recentOutput === previousTask?.recentOutput) {
+						continue;
+					}
 					appendDelegatedLiveOutput(request.requestId, task.recentOutput);
 				}
 			}
@@ -567,11 +655,12 @@ export async function executeSubagentPromptStep(options: DelegatedPromptOptions)
 			agent: preparedTasks[0]!.agent,
 		};
 	} catch (error) {
-		const responseText = error instanceof Error ? error.message : String(error);
+		const cause = error instanceof Error ? error : new Error(String(error));
+		const responseText = cause.message;
 		if (isParallelRequest) {
-			throw new Error(`Parallel delegated prompts (${promptLabel}) failed: ${responseText}`);
+			throw new Error(`Parallel delegated prompts (${promptLabel}) failed: ${responseText}`, { cause });
 		}
-		throw new Error(`Prompt \`${preparedTasks[0]!.promptName}\` delegated subagent \`${preparedTasks[0]!.agent}\` failed: ${responseText}`);
+		throw new Error(`Prompt \`${preparedTasks[0]!.promptName}\` delegated subagent \`${preparedTasks[0]!.agent}\` failed: ${responseText}`, { cause });
 	} finally {
 		clearDelegatedLiveState(request.requestId);
 		if (ctx.hasUI) {

package/subagent-widget.ts

@@ -18,6 +18,28 @@ function formatTokens(n: number | undefined): string {
 	return String(n);
 }
 
+function normalizeModelLabel(model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	return model.includes("/") ? model.split("/").pop() : model;
+}
+
+function formatToolCall(tool: string, args: string): string {
+	const safeArgs = args ?? "";
+	switch (tool) {
+		case "bash": {
+			const cmd = safeArgs.replace(/[\n\t]/g, " ").trim();
+			return `$ ${cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd}`;
+		}
+		case "read": return `[read: ${safeArgs}]`;
+		case "write": return `[write: ${safeArgs}]`;
+		case "edit": return `[edit: ${safeArgs}]`;
+		default: {
+			const short = safeArgs.length > 60 ? safeArgs.slice(0, 60) + "..." : safeArgs;
+			return `[${tool}: ${short}]`;
+		}
+	}
+}
+
 export function createDelegatedProgressWidget(
 	requestId: string,
 	agent: string,
@@ -25,11 +47,18 @@ export function createDelegatedProgressWidget(
 	task: string,
 	tasks: DelegatedSubagentTask[] | undefined,
 	theme: Theme,
+	model?: string,
 ): Container & { dispose?(): void } {
 	const contextSuffix = context === "fork" ? theme.fg("warning", " [fork]") : "";
-	const taskPreview = task.length > 120 ? `${task.slice(0, 120)}...` : task;
+	const taskPreview = task.length > 200 ? `${task.slice(0, 200)}...` : task;
 	const parallelTasks = tasks ?? [];
 	const isParallel = parallelTasks.length > 0;
+	const parallelModels = [...new Set(parallelTasks
+		.map((task) => normalizeModelLabel(task.model))
+		.filter((entry): entry is string => !!entry))];
+	const requestModel = isParallel
+		? (parallelModels.length === 1 ? parallelModels[0] : undefined)
+		: normalizeModelLabel(model);
 
 	const container = new Container();
 	container.addChild(new Spacer(1));
@@ -44,7 +73,7 @@ export function createDelegatedProgressWidget(
 		const key = stateKey(state, elapsed);
 		if (key !== lastKey) {
 			lastKey = key;
-			rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme);
+			rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme, requestModel);
 		}
 		return Container.prototype.render.call(container, width);
 	};
@@ -55,11 +84,16 @@ export function createDelegatedProgressWidget(
 function stateKey(state: DelegatedSubagentLiveState | undefined, elapsed: number): string {
 	if (!state) return "none";
 	const elapsedBucket = Math.floor(elapsed / 1000);
-	const tool = state.currentTool ?? state.lastTool ?? "";
+	const tool = state.currentTool ?? "";
+	const outputLen = state.recentOutput.length;
+	const outputTail = state.recentOutput.length > 0
+		? state.recentOutput[state.recentOutput.length - 1]?.slice(0, 80) ?? ""
+		: "";
+	const toolsLen = state.recentTools.length;
 	const taskProgressKey = state.taskProgress
 		.map((entry) => `${entry.index ?? ""}:${entry.agent}:${entry.status ?? ""}:${entry.currentTool ?? ""}:${entry.toolCount ?? 0}`)
 		.join("|");
-	return `${state.status}|${tool}|${state.toolCount}|${state.tokens}|${state.recentOutput.length}|${taskProgressKey}|${elapsedBucket}`;
+	return `${state.status}|${tool}|${state.toolCount}|${state.tokens}|${outputLen}:${outputTail}|${toolsLen}|${state.model ?? ""}|${taskProgressKey}|${elapsedBucket}`;
 }
 
 function rebuildBox(
@@ -72,34 +106,49 @@ function rebuildBox(
 	state: DelegatedSubagentLiveState | undefined,
 	elapsed: number,
 	theme: Theme,
+	requestModel?: string,
 ): void {
 	box.clear();
 
-	const toolCount = state?.toolCount ?? 0;
-	const tokens = formatTokens(state?.tokens);
+	const taskProgress = state?.taskProgress ?? [];
+	const baseToolCount = state?.toolCount ?? 0;
+	const baseTokens = state?.tokens ?? 0;
+	const parallelToolCount = taskProgress.reduce((sum, entry) => sum + (entry.toolCount ?? 0), 0);
+	const parallelTokens = taskProgress.reduce((sum, entry) => sum + (entry.tokens ?? 0), 0);
+	const toolCount = isParallel && parallelToolCount > 0 ? parallelToolCount : baseToolCount;
+	const tokens = isParallel && parallelTokens > 0 ? parallelTokens : baseTokens;
+	const tokensLabel = formatTokens(tokens);
 	const duration = formatDuration(elapsed);
-	const isThinking = toolCount === 0 && (state?.tokens ?? 0) === 0;
+	const isThinking = toolCount === 0 && tokens === 0;
 	const icon = theme.fg("warning", "...");
+	const modelLabel = isParallel
+		? requestModel
+		: normalizeModelLabel(state?.model ?? requestModel);
+	const modelSuffix = modelLabel ? ` ${theme.fg("dim", modelLabel)}` : "";
 	const stats = isThinking
 		? `thinking, ${duration}`
-		: `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokens} tok, ${duration}`;
-	const taskProgress = state?.taskProgress ?? [];
+		: `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokensLabel} tok, ${duration}`;
 
+	// Header
 	if (isParallel) {
 		const completedCount = taskProgress.filter((entry) => entry.status === "completed").length;
 		const runningLabel = `parallel ${completedCount}/${parallelTasks.length} running`;
-		box.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(runningLabel))}${contextSuffix} | ${stats}`, 0, 0));
+		box.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(runningLabel))}${contextSuffix}${modelSuffix} | ${stats}`, 0, 0));
 	} else {
 		box.addChild(new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${contextSuffix} | ${stats}`,
+			`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${contextSuffix}${modelSuffix} | ${stats}`,
 			0, 0,
 		));
 	}
 	box.addChild(new Spacer(1));
+
+	// Task preview
 	if (!isParallel) {
 		box.addChild(new Text(theme.fg("dim", `Task: ${taskPreview}`), 0, 0));
+		box.addChild(new Spacer(1));
 	}
 
+	// Parallel task list
 	if (isParallel) {
 		for (let index = 0; index < parallelTasks.length; index++) {
 			const task = parallelTasks[index]!;
@@ -111,35 +160,38 @@ function rebuildBox(
 			if (taskStatus === "running") {
 				const runningTool = progress.currentTool ? ` ${progress.currentTool}...` : "";
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: running${runningTool}`), 0, 0));
-				continue;
-			}
-			if (taskStatus === "completed") {
+			} else if (taskStatus === "completed") {
 				const toolSuffix =
 					progress?.toolCount !== undefined
 						? ` (${progress.toolCount} tool${progress.toolCount === 1 ? "" : "s"})`
 						: "";
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: completed${toolSuffix}`), 0, 0));
-				continue;
-			}
-			if (taskStatus === "failed") {
+			} else if (taskStatus === "failed") {
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: failed`), 0, 0));
-				continue;
+			} else {
+				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: pending`), 0, 0));
 			}
-			box.addChild(new Text(theme.fg("dim", `  ${task.agent}: pending`), 0, 0));
 		}
 		return;
 	}
 
-	const activeTool = state?.currentTool;
-	const displayTool = activeTool ?? state?.lastTool;
-	if (displayTool) {
-		const toolArgs = activeTool ? state?.currentToolArgs : state?.lastToolArgs;
-		const toolLine = `${displayTool}${toolArgs ? ` ${toolArgs}` : ""}`;
-		box.addChild(new Text(theme.fg("dim", toolLine), 0, 0));
+	// Unified tool stream: completed tools (dim) then active tool (warning) at bottom.
+	// When a tool finishes it moves from active → completed in place — no visual jump.
+	const recentTools = state?.recentTools ?? [];
+	for (const tool of recentTools) {
+		box.addChild(new Text(theme.fg("dim", formatToolCall(tool.tool, tool.args)), 0, 0));
+	}
+	if (state?.currentTool) {
+		const active = formatToolCall(state.currentTool, state.currentToolArgs ?? "");
+		box.addChild(new Text(theme.fg("warning", `> ${active}`), 0, 0));
 	}
 
+	// Recent output
 	if (state && state.recentOutput.length > 0) {
-		for (const line of state.recentOutput.slice(-4)) {
+		if (recentTools.length > 0 || state.currentTool) {
+			box.addChild(new Spacer(1));
+		}
+		for (const line of state.recentOutput) {
 			box.addChild(new Text(theme.fg("dim", `  ${line}`), 0, 0));
 		}
 	}