@oh-my-pi/pi-coding-agent 16.3.8 → 16.3.10

package/src/discovery/claude.ts

@@ -167,17 +167,21 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const userSkillsDir = path.join(getUserClaude(ctx), "skills");
 
-	// Walk up from cwd finding .claude/skills/ in ancestors
+	// Walk up from cwd finding .claude/skills/ in ancestors. Skip $HOME:
+	// that path is already scanned as the Claude user source below, and scanning
+	// it again as project would bypass enableClaudeUser when project skills stay enabled.
 	const projectScans: Promise<LoadResult<Skill>>[] = [];
 	let current = ctx.cwd;
 	while (true) {
-		projectScans.push(
-			scanSkillsFromDir(ctx, {
-				dir: path.join(current, CONFIG_DIR, "skills"),
-				providerId: PROVIDER_ID,
-				level: "project",
-			}),
-		);
+		if (current !== ctx.home) {
+			projectScans.push(
+				scanSkillsFromDir(ctx, {
+					dir: path.join(current, CONFIG_DIR, "skills"),
+					providerId: PROVIDER_ID,
+					level: "project",
+				}),
+			);
+		}
 		if (current === (ctx.repoRoot ?? ctx.home)) break;
 		const parent = path.dirname(current);
 		if (parent === current) break; // filesystem root

package/src/extensibility/skills.ts

@@ -190,12 +190,18 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	const disabledSkillNames = new Set(
 		(disabledExtensions ?? []).filter(id => id.startsWith("skill:")).map(id => id.slice(6)),
 	);
-	// Filter skills by source and patterns first
-	const filteredSkills = result.items.filter(capSkill => {
+	// Select authored skills from the pre-dedup superset. `loadCapability`
+	// dedupes before source toggles, so a disabled high-priority provider must
+	// not hide an enabled lower-priority provider with the same skill name.
+	const seenAuthoredSkillNames = new Set<string>();
+	const filteredSkills = result.all.filter(capSkill => {
+		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) return false;
 		if (disabledSkillNames.has(capSkill.name)) return false;
 		if (!isSourceEnabled(capSkill._source)) return false;
 		if (matchesIgnorePatterns(capSkill.name)) return false;
 		if (!matchesIncludePatterns(capSkill.name)) return false;
+		if (seenAuthoredSkillNames.has(capSkill.name)) return false;
+		seenAuthoredSkillNames.add(capSkill.name);
 		return true;
 	});
 
@@ -213,9 +219,6 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	// Process skills with resolved paths
 	for (let i = 0; i < filteredSkills.length; i++) {
 		const capSkill = filteredSkills[i];
-		// Managed (auto-learn) skills are resolved dead-last (below) so any
-		// authored skill of the same name — from ANY provider or custom dir — wins.
-		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) continue;
 		const resolvedPath = realPaths[i];
 
 		// Skip silently if we've already loaded this exact file (via symlink)

package/src/modes/components/__tests__/skill-message.test.ts

@@ -42,6 +42,8 @@ describe("SkillMessageComponent", () => {
 		// New look: an icon-tagged "skill" header with the name and a single meta line.
 		expect(text).toContain("skill");
 		expect(text).toContain("atomic-commit");
+		expect(text).toContain("skill atomic-commit");
+		expect(text).not.toContain("skill  atomic-commit");
 		expect(text).toContain("88 lines");
 
 		// The card is drawn with an outline.

package/src/modes/components/agent-hub.ts

@@ -34,6 +34,7 @@ import { DynamicBorder } from "./dynamic-border";
 
 /** Refresh cadence for the relative-time column */
 const AGE_TICK_MS = 5_000;
+const DATA_CHANGE_RENDER_COALESCE_MS = 100;
 /** Double-tap window for the table's left-left "close hub" gesture. */
 const LEFT_TAP_WINDOW_MS = 500;
 
@@ -198,6 +199,7 @@ export class AgentHubOverlayComponent extends Container {
 	#hubKeys: KeyId[];
 	#unsubscribers: Array<() => void> = [];
 	#ageTimer: NodeJS.Timeout | undefined;
+	#dataChangeTimer?: NodeJS.Timeout;
 	#remote: AgentHubRemote | undefined;
 	/** Resolves after persisted historical subagents have been registered and rows refreshed. */
 	readonly persistedSubagentsReady: Promise<void>;
@@ -251,8 +253,8 @@ export class AgentHubOverlayComponent extends Container {
 		this.#expandKeys = deps.expandKeys ?? ["ctrl+o"];
 		this.#focusAgent = deps.focusAgent;
 
-		this.#unsubscribers.push(this.#registry.onChange(() => this.#onDataChange()));
-		this.#unsubscribers.push(this.#observers.onChange(() => this.#onDataChange()));
+		this.#unsubscribers.push(this.#registry.onChange(() => this.#scheduleDataChange()));
+		this.#unsubscribers.push(this.#observers.onChange(() => this.#scheduleDataChange()));
 		this.#ageTimer = setInterval(() => this.#requestRender(), AGE_TICK_MS);
 		this.#ageTimer.unref?.();
 
@@ -285,6 +287,10 @@ export class AgentHubOverlayComponent extends Container {
 			clearInterval(this.#ageTimer);
 			this.#ageTimer = undefined;
 		}
+		if (this.#dataChangeTimer) {
+			clearTimeout(this.#dataChangeTimer);
+			this.#dataChangeTimer = undefined;
+		}
 		this.#closeTranscriptOverlay();
 	}
 
@@ -355,6 +361,15 @@ export class AgentHubOverlayComponent extends Container {
 	// Live data plumbing
 	// ========================================================================
 
+	#scheduleDataChange(): void {
+		if (this.#dataChangeTimer) return;
+		this.#dataChangeTimer = setTimeout(() => {
+			this.#dataChangeTimer = undefined;
+			this.#onDataChange();
+		}, DATA_CHANGE_RENDER_COALESCE_MS);
+		this.#dataChangeTimer.unref?.();
+	}
+
 	#onDataChange(): void {
 		this.#refreshRows();
 		this.#requestRender();

package/src/modes/components/skill-message.ts

@@ -50,7 +50,7 @@ export class SkillMessageComponent extends Container {
 
 		// Header: icon-tag + skill name, with the invocation args trailing dimmed.
 		const tag = theme.fg("customMessageLabel", theme.bold(`${theme.icon.extensionSkill} skill`));
-		let header = `${tag}  ${theme.fg("customMessageText", theme.bold(name))}`;
+		let header = `${tag} ${theme.fg("customMessageText", theme.bold(name))}`;
 		if (args) {
 			header += ` ${theme.fg("dim", args)}`;
 		}

package/src/modes/index.ts

@@ -1,6 +1,3 @@
-import { emergencyTerminalRestore } from "@oh-my-pi/pi-tui";
-import { postmortem } from "@oh-my-pi/pi-utils";
-
 /**
  * Interactive mode and embeddable RPC client exports for the coding agent.
  *
@@ -11,7 +8,3 @@ import { postmortem } from "@oh-my-pi/pi-utils";
 export * from "./interactive-mode";
 export * from "./rpc/rpc-client";
 export * from "./rpc/rpc-types";
-
-postmortem.register("terminal-restore", () => {
-	emergencyTerminalRestore();
-});

package/src/modes/interactive-mode.ts

@@ -161,8 +161,11 @@ import {
 } from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { countRunningSubagentBadgeAgents, getRunningSubagentBadgeRegistry } from "./running-subagent-badge";
-import type { ObservableSession } from "./session-observer-registry";
-import { SessionObserverRegistry } from "./session-observer-registry";
+import {
+	type ObservableSession,
+	type SessionObserverChangeKind,
+	SessionObserverRegistry,
+} from "./session-observer-registry";
 import { createSessionTeardown, type SessionTeardown } from "./session-teardown";
 import { runProviderSetupWizard } from "./setup-wizard/lazy";
 import { interruptHint } from "./shared";
@@ -343,9 +346,12 @@ class AnchoredLiveContainer extends Container implements NativeScrollbackLiveReg
  *  before it auto-clears, mirroring the todo HUD's auto-clear timer. */
 const MODEL_CYCLE_TRACK_CLEAR_MS = 4000;
 
+const SUBAGENT_HUD_VISIBLE_LIMIT = 8;
+const SUBAGENT_OBSERVER_UI_COALESCE_MS = 100;
+
 /**
  * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
- * one tree row per running agent in the same `Id: description` shape the
+ * a bounded set of running-agent rows in the same `Id: description` shape the
  * inline task rows use (muted task preview when no description was given).
  * Layout mirrors the Todos HUD exactly: unindented header, then
  * `renderTreeList` rows (dim connectors) shifted right by one space.
@@ -361,9 +367,11 @@ export function renderSubagentHudLines(sessions: ObservableSession[], columns: n
 	if (running.length === 0) return [];
 
 	const dot = theme.styledSymbol("status.done", "accent");
+	const visible = running.slice(0, SUBAGENT_HUD_VISIBLE_LIMIT);
+	const hiddenCount = running.length - visible.length;
 	const rows = renderTreeList(
 		{
-			items: running,
+			items: visible,
 			expanded: true,
 			renderItem: session => {
 				const displayId = formatTaskId(session.id);
@@ -385,6 +393,9 @@ export function renderSubagentHudLines(sessions: ObservableSession[], columns: n
 		},
 		theme,
 	);
+	if (hiddenCount > 0) {
+		rows.push(theme.fg("dim", `… ${hiddenCount} more running — open Agent Hub for full list`));
+	}
 	return ["", theme.bold(theme.fg("accent", "Subagents")), ...rows.map(line => ` ${line}`)];
 }
 
@@ -588,6 +599,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	#observerRegistry: SessionObserverRegistry;
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
+	#observerUiSyncTimer?: NodeJS.Timeout;
+	#observerUiSyncNeedsTodoReconcile = false;
 	#agentRegistryUnsubscribe?: () => void;
 	#agentRegistrySubscriptionTarget?: AgentRegistry;
 	#mcpStatusOrder: string[] = [];
@@ -917,17 +930,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		this.#observerRegistry.setMainSession(this.sessionManager.getSessionFile() ?? undefined);
 		this.syncRunningSubagentBadge();
-		this.#observerRegistry.onChange(() => {
-			this.syncRunningSubagentBadge();
-			// Auto-checkmark todos whose matching subagent just succeeded, then
-			// re-render so the running override (the static "live" glyph when a
-			// subagent is doing the work for a still-pending todo) updates as
-			// subagents start, finish, or fail.
-			this.#reconcileTodosWithSubagents();
-			this.#syncTodoAutoClearTimer();
-			this.#renderTodoList();
-			this.#renderSubagentList();
-			this.ui.requestRender();
+		this.#observerRegistry.onChange(kind => {
+			this.#scheduleObserverUiSync(kind);
 		});
 
 		// Load initial todos
@@ -1521,19 +1525,18 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	/** Refresh the running-subagents status badge from the active local or collab registry. */
-	syncRunningSubagentBadge(): void {
+	syncRunningSubagentBadge(options: { requestRender?: boolean } = {}): void {
 		const registry = getRunningSubagentBadgeRegistry(this.collabGuest);
 		if (this.#agentRegistrySubscriptionTarget !== registry) {
 			this.#agentRegistryUnsubscribe?.();
 			this.#agentRegistrySubscriptionTarget = registry;
 			this.#agentRegistryUnsubscribe = registry.onChange(() => {
 				this.syncRunningSubagentBadge();
-				this.ui.requestRender();
 			});
 		}
 		const count = countRunningSubagentBadgeAgents(registry);
 		this.statusLine.setSubagentCount(count);
-		this.ui.requestRender();
+		if (options.requestRender !== false) this.ui.requestRender();
 	}
 
 	rebuildChatFromMessages(): void {
@@ -1754,6 +1757,38 @@ export class InteractiveMode implements InteractiveModeContext {
 		return active ?? nonEmpty[nonEmpty.length - 1];
 	}
 
+	#scheduleObserverUiSync(kind: SessionObserverChangeKind): void {
+		if (kind !== "progress") {
+			this.#observerUiSyncNeedsTodoReconcile = true;
+		}
+		if (this.#observerUiSyncTimer) return;
+		this.#observerUiSyncTimer = setTimeout(() => {
+			this.#observerUiSyncTimer = undefined;
+			this.#flushObserverUiSync();
+		}, SUBAGENT_OBSERVER_UI_COALESCE_MS);
+		this.#observerUiSyncTimer.unref?.();
+	}
+
+	#flushObserverUiSync(): void {
+		this.syncRunningSubagentBadge({ requestRender: false });
+		if (this.#observerUiSyncNeedsTodoReconcile) {
+			this.#observerUiSyncNeedsTodoReconcile = false;
+			this.#reconcileTodosWithSubagents();
+		}
+		this.#syncTodoAutoClearTimer();
+		this.#renderTodoList();
+		this.#renderSubagentList();
+		this.ui.requestRender();
+	}
+
+	#cancelObserverUiSyncTimer(): void {
+		if (this.#observerUiSyncTimer) {
+			clearTimeout(this.#observerUiSyncTimer);
+			this.#observerUiSyncTimer = undefined;
+		}
+		this.#observerUiSyncNeedsTodoReconcile = false;
+	}
+
 	#renderTodoList(): void {
 		this.todoContainer.clear();
 		const phases = this.todoPhases.filter(phase => phase.tasks.length > 0);
@@ -3306,6 +3341,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		this.#cleanupMicAnimation();
 		this.#cancelTodoAutoClearTimer();
+		this.#cancelObserverUiSyncTimer();
 		this.#cancelGoalContinuation();
 		if (this.#sttController) {
 			this.#sttController.dispose();

package/src/modes/session-observer-registry.ts

@@ -24,6 +24,9 @@ export interface ObservableSession {
 	progress?: AgentProgress;
 }
 
+/** Coarse source of an observer change; callers use it to separate lifecycle work from high-frequency progress. */
+export type SessionObserverChangeKind = "main" | "reset" | "lifecycle" | "progress";
+
 const STATUS_MAP: Record<string, ObservableSession["status"]> = {
 	started: "active",
 	completed: "completed",
@@ -33,20 +36,20 @@ const STATUS_MAP: Record<string, ObservableSession["status"]> = {
 
 export class SessionObserverRegistry {
 	#sessions = new Map<string, ObservableSession>();
-	#listeners = new Set<() => void>();
+	#listeners = new Set<(kind: SessionObserverChangeKind) => void>();
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#sortOrderById = new Map<string, number>();
 	#parentSortOrderById = new Map<string, number>();
 	#nextSortOrder = 0;
 
 	/** Add a change listener. Returns unsubscribe function. */
-	onChange(cb: () => void): () => void {
+	onChange(cb: (kind: SessionObserverChangeKind) => void): () => void {
 		this.#listeners.add(cb);
 		return () => this.#listeners.delete(cb);
 	}
 
-	#notifyListeners(): void {
-		for (const cb of this.#listeners) cb();
+	#notifyListeners(kind: SessionObserverChangeKind): void {
+		for (const cb of this.#listeners) cb(kind);
 	}
 
 	#ensureSortOrder(id: string): number {
@@ -85,7 +88,7 @@ export class SessionObserverRegistry {
 			sessionFile: sessionFile ?? existing?.sessionFile,
 			lastUpdate: Date.now(),
 		});
-		this.#notifyListeners();
+		this.#notifyListeners("main");
 	}
 
 	getSessions(): ObservableSession[] {
@@ -121,7 +124,7 @@ export class SessionObserverRegistry {
 		this.#sortOrderById.clear();
 		this.#parentSortOrderById.clear();
 		this.#nextSortOrder = 0;
-		this.#notifyListeners();
+		this.#notifyListeners("reset");
 	}
 
 	dispose(): void {
@@ -171,7 +174,7 @@ export class SessionObserverRegistry {
 						lastUpdate: Date.now(),
 					});
 				}
-				this.#notifyListeners();
+				this.#notifyListeners("lifecycle");
 			}),
 		);
 
@@ -208,7 +211,7 @@ export class SessionObserverRegistry {
 						progress,
 					});
 				}
-				this.#notifyListeners();
+				this.#notifyListeners("progress");
 			}),
 		);
 	}

package/src/sdk.ts

@@ -2132,6 +2132,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		if (model) {
+			const selectedModel = model;
+			const refreshedModel = await logger.time("refreshInitialModelMetadata", () =>
+				modelRegistry.refreshSelectedModelMetadata(selectedModel),
+			);
+			if (refreshedModel !== selectedModel) {
+				model = refreshedModel;
+				thinkingLevel = pickInitialThinkingLevel(refreshedModel);
+				autoThinking = thinkingLevel === AUTO_THINKING;
+				effectiveThinkingLevel = concreteThinkingLevel(thinkingLevel);
+				effectiveThinkingLevel = logger.time("resolveThinkingLevelForModel", () =>
+					autoThinking
+						? resolveProvisionalAutoLevel(refreshedModel)
+						: resolveThinkingLevelForModel(refreshedModel, effectiveThinkingLevel),
+				);
+			}
+		}
+
 		// Discover custom commands (TypeScript slash commands)
 		const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
 			? { commands: [], errors: [] }

package/src/session/agent-session.ts

@@ -933,6 +933,7 @@ export interface SessionStats {
 	};
 	premiumRequests: number;
 	cost: number;
+	contextUsage?: ContextUsage;
 }
 
 /** Advisor statistics for /advisor status command. */
@@ -1824,13 +1825,19 @@ export class AgentSession {
 	 * Sticky across an in-flight prompt run: a successful `yield` makes the run
 	 * terminal for execution purposes, so any trailing empty/aborted assistant
 	 * stop must NOT trigger empty-stop/unexpected-stop/compaction continuations.
-	 * Cleared in `#promptWithMessage` so the next prompt evaluates cleanly.
+	 * Cleared before every new prompt turn so the next turn evaluates cleanly.
 	 */
 	#yieldTerminationPending = false;
 	#providerSessionState = new Map<string, ProviderSessionState>();
 	#hindsightSessionState: HindsightSessionState | undefined = undefined;
 	readonly rawSseDebugBuffer: RawSseDebugBuffer;
 
+	#resetPromptMaintenanceState(): void {
+		this.#emptyStopRetryCount = 0;
+		this.#unexpectedStopRetryCount = 0;
+		this.#yieldTerminationPending = false;
+	}
+
 	#acquirePowerAssertion(): void {
 		if (process.platform !== "darwin") return;
 		if (isBunTestRuntime()) return;
@@ -1949,6 +1956,7 @@ export class AgentSession {
 		if (parkedFollowUps.length > 0) {
 			this.agent.replaceQueues([...this.agent.peekSteeringQueue()], []);
 		}
+		this.#resetPromptMaintenanceState();
 		this.#beginInFlight();
 		void this.agent
 			.prompt(records)
@@ -7566,12 +7574,7 @@ export class AgentSession {
 			this.#todoReminderAwaitingProgress = false;
 			this.#mutationsSinceLastTodoTouch = 0;
 			this.#midRunNudgeCount = 0;
-			this.#emptyStopRetryCount = 0;
-			this.#unexpectedStopRetryCount = 0;
-			// A new prompt cycle starts: drop any sticky yield-termination from the
-			// previous run so empty-stop / unexpected-stop / compaction maintenance
-			// can evaluate this turn normally.
-			this.#yieldTerminationPending = false;
+			this.#resetPromptMaintenanceState();
 
 			await this.#maybeRestoreRetryFallbackPrimary();
 
@@ -14120,15 +14123,15 @@ export class AgentSession {
 	// =========================================================================
 
 	/**
-	 * Surfaces (and consumes) pending IRC incoming records before the next model
+	 * Surfaces and consumes pending IRC incoming records before the next model
 	 * step can inject them automatically.
 	 *
-	 * The inbox tool injects the formatted body into the tool result, so the
-	 * model sees it once via the result. Leaving the record in either pending
-	 * IRC queue would deliver it a second time at the next step boundary —
-	 * including on `peek`, which is why peek also drains here.
+	 * Tool results already expose the formatted body to the model. Leaving the
+	 * same record in either pending IRC queue would deliver it a second time at
+	 * the next step boundary — including on `peek`, which is why inbox peeks
+	 * also drain here.
 	 */
-	drainPendingIrcInboxMessages(agentId: string): IrcMessage[] {
+	drainPendingIrcInboxMessages(agentId: string, opts?: { from?: string; limit?: number }): IrcMessage[] {
 		const messages: IrcMessage[] = [];
 		const remainingInterrupts: CustomMessage[] = [];
 		const remainingAsides: CustomMessage[] = [];
@@ -14155,6 +14158,14 @@ export class AgentSession {
 					queue.remaining.push(record);
 					continue;
 				}
+				if (opts?.from !== undefined && from !== opts.from) {
+					queue.remaining.push(record);
+					continue;
+				}
+				if (opts?.limit !== undefined && messages.length >= opts.limit) {
+					queue.remaining.push(record);
+					continue;
+				}
 				messages.push({
 					id,
 					from,
@@ -15212,6 +15223,7 @@ export class AgentSession {
 			},
 			cost: totalCost,
 			premiumRequests: totalPremiumRequests,
+			contextUsage: this.getContextUsage(),
 		};
 	}
 

package/src/task/render.test.ts

@@ -2,7 +2,8 @@ import { afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { Settings } from "../config/settings";
 import { getThemeByName, setThemeInstance, type Theme } from "../modes/theme/theme";
 import { renderResult } from "./render";
-import type { AgentProgress, TaskToolDetails } from "./types";
+import { taskToolRenderer } from "./renderer";
+import type { AgentProgress, SingleResult, TaskToolDetails } from "./types";
 
 const strip = (lines: readonly string[]): string =>
 	lines
@@ -42,6 +43,71 @@ function makeProgress(recentOutput: string[]): AgentProgress {
 	};
 }
 
+function makeParentWithNestedProgress(childCount: number): AgentProgress {
+	const children = Array.from(
+		{ length: childCount },
+		(_, index): AgentProgress => ({
+			...makeProgress([]),
+			index,
+			id: `Nested${index + 1}`,
+			task: `nested child ${index + 1}`,
+		}),
+	);
+	return {
+		...makeProgress([]),
+		id: "Parent",
+		task: "parent task",
+		inflightTaskDetails: {
+			projectAgentsDir: null,
+			results: [],
+			totalDurationMs: 1,
+			progress: children,
+		},
+	};
+}
+
+function makeSingleResult(index: number, overrides?: Partial<SingleResult>): SingleResult {
+	return {
+		index,
+		id: `Done${index + 1}`,
+		agent: "task",
+		agentSource: "bundled",
+		task: `finished child ${index + 1}`,
+		exitCode: 0,
+		output: "ok",
+		stderr: "",
+		truncated: false,
+		durationMs: 5,
+		tokens: 0,
+		requests: 1,
+		...overrides,
+	};
+}
+
+function makeParentWithNestedResults(childCount: number): TaskToolDetails {
+	const nested: TaskToolDetails = {
+		projectAgentsDir: null,
+		// Failure on the LAST child in display order (equal durations, index tiebreak):
+		// a plain head-of-list pick would elide it, so its visibility proves the
+		// failure-first selection of `selectCollapsedResults`.
+		results: Array.from({ length: childCount }, (_, index) =>
+			makeSingleResult(index, index === childCount - 1 ? { exitCode: 1, error: "boom" } : undefined),
+		),
+		totalDurationMs: 1,
+	};
+	const parent = makeSingleResult(0, { id: "Parent", extractedToolData: { task: [nested] } });
+	return { projectAgentsDir: null, results: [parent], totalDurationMs: 1 };
+}
+
+function renderResultText(details: TaskToolDetails, expanded: boolean, uiTheme: Theme): string {
+	const component = renderResult(
+		{ content: [{ type: "text", text: "Ran 1 agent" }], details },
+		{ expanded, isPartial: false },
+		uiTheme,
+	);
+	return strip(component.render(120));
+}
+
 function renderProgressText(progress: AgentProgress, expanded: boolean, uiTheme: Theme): string {
 	const details: TaskToolDetails = {
 		projectAgentsDir: null,
@@ -118,4 +184,71 @@ describe("task live progress rendering", () => {
 		expect(collapsedText).not.toContain("line 1");
 		expect(collapsedText).not.toContain("raw output:");
 	});
+
+	it("caps collapsed nested task progress at four rows plus an elision line", () => {
+		setViewportRows(40);
+		const text = renderProgressText(makeParentWithNestedProgress(6), false, uiTheme);
+
+		expect(text).not.toContain("Nested1");
+		expect(text).not.toContain("Nested2");
+		expect(text).toContain("Nested3");
+		expect(text).toContain("Nested4");
+		expect(text).toContain("Nested5");
+		expect(text).toContain("Nested6");
+		expect(text).toContain("2 more agents");
+	});
+
+	it("shows every nested task progress row when expanded", () => {
+		setViewportRows(40);
+		const text = renderProgressText(makeParentWithNestedProgress(6), true, uiTheme);
+
+		for (let index = 1; index <= 6; index++) {
+			expect(text).toContain(`Nested${index}`);
+		}
+		expect(text).not.toContain("more agents");
+	});
+
+	it("caps collapsed finalized nested task results and keeps the failed child visible", () => {
+		setViewportRows(40);
+		const text = renderResultText(makeParentWithNestedResults(6), false, uiTheme);
+
+		expect(text).toContain("Done6"); // failed child wins a slot despite sorting last
+		expect(text).toContain("2 more agents");
+		const visibleChildren = [1, 2, 3, 4, 5, 6].filter(index => text.includes(`Done${index}`));
+		expect(visibleChildren).toHaveLength(4);
+	});
+
+	it("shows every finalized nested task result when expanded", () => {
+		setViewportRows(40);
+		const text = renderResultText(makeParentWithNestedResults(6), true, uiTheme);
+
+		for (let index = 1; index <= 6; index++) {
+			expect(text).toContain(`Done${index}`);
+		}
+		expect(text).not.toContain("more agents");
+	});
+
+	it("does not request spinner ticks for static partial progress", () => {
+		expect("animatedPartialResult" in taskToolRenderer).toBe(false);
+	});
+
+	it("renders running progress identically across spinner frames", () => {
+		const progress = makeProgress([]);
+		const details: TaskToolDetails = {
+			projectAgentsDir: null,
+			results: [],
+			totalDurationMs: 1,
+			progress: [progress],
+		};
+		const render = (spinnerFrame: number) =>
+			strip(
+				renderResult(
+					{ content: [{ type: "text", text: "Running 1 agent..." }], details },
+					{ expanded: false, isPartial: true, spinnerFrame },
+					uiTheme,
+				).render(120),
+			);
+
+		expect(render(0)).toBe(render(1));
+	});
 });