@linxiraos/pi-tui 1.1.27 → 1.2.1

package/src/tools/streaming-output.d.ts

@@ -31,6 +31,15 @@ export interface OutputSummary {
     columnDroppedBytes?: number;
     /** Number of distinct lines that hit the per-line column cap. */
     columnTruncatedLines?: number;
+    /**
+     * 1-indexed first and last lines the column cap cut, numbered as in the
+     * artifact. Absent when the numbering cannot match the artifact (an inline
+     * substitute was capped, or `replace()` rewrote the buffer).
+     */
+    columnTruncatedRange?: {
+        first: number;
+        last: number;
+    };
     /** Configured per-line column cap in effect (UTF-8 bytes), when > 0. */
     columnMax?: number;
     /** Artifact ID for internal URL access (artifact://<id>) when truncated */
@@ -236,7 +245,8 @@ export declare class OutputSink {
     constructor(options?: OutputSinkOptions);
     /**
      * Push a chunk of output. The buffer management and onChunk callback run
-     * synchronously. File sink writes are deferred and serialized internally.
+     * synchronously; onChunk fires after the chunk is stored, so {@link preview}
+     * already includes it. File sink writes are deferred and serialized internally.
      *
      * `inline` substitutes a bounded representation for the in-memory buffer and
      * live preview while the complete chunk is mirrored to the artifact.
@@ -260,6 +270,15 @@ export declare class OutputSink {
      * branch in `dump()` against stale totals.
      */
     replace(text: string): void;
+    /**
+     * Current inline view without finalizing: the body {@link dump} would
+     * return right now (head + elision marker + rolling tail), minus any notice
+     * and minus the newline `dump()` appends after output that ends in a bare
+     * carriage return. Each call trims the rolling tail to its budget (a copy
+     * of the tail window once it overflowed), so call it from a throttled
+     * onChunk (`chunkThrottleMs`), not once per raw chunk.
+     */
+    preview(): string;
     dump(notice?: string): Promise<OutputSummary>;
     /**
      * Release the artifact spill descriptor on an exit path that skips

package/src/tools/streaming-output.ts

@@ -52,6 +52,12 @@ export interface OutputSummary {
 	columnDroppedBytes?: number;
 	/** Number of distinct lines that hit the per-line column cap. */
 	columnTruncatedLines?: number;
+	/**
+	 * 1-indexed first and last lines the column cap cut, numbered as in the
+	 * artifact. Absent when the numbering cannot match the artifact (an inline
+	 * substitute was capped, or `replace()` rewrote the buffer).
+	 */
+	columnTruncatedRange?: { first: number; last: number };
 	/** Configured per-line column cap in effect (UTF-8 bytes), when > 0. */
 	columnMax?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
@@ -233,6 +239,10 @@ function truncateBytesWindowed(
 				? data.substring(0, Math.min(data.length, maxBytes))
 				: data.substring(Math.max(0, data.length - maxBytes));
 
+		// All-ASCII window: one byte per char, so it is exactly `maxBytes` bytes on a boundary.
+		const windowBytes = Buffer.byteLength(window, "utf-8");
+		if (windowBytes === window.length) return { text: window, bytes: windowBytes };
+
 		const buf = Buffer.from(window, "utf-8");
 
 		if (mode === "head") {
@@ -876,6 +886,8 @@ export class TailBuffer {
 export class OutputSink {
 	#buffer = "";
 	#bufferBytes = 0;
+	/** The overflowed tail window may exceed its budget until {@link #trimTail} runs. */
+	#tailUntrimmed = false;
 	#head = "";
 	#headBytes = 0;
 	#headLines = 0; // newline count inside #head
@@ -895,6 +907,10 @@ export class OutputSink {
 	#columnEllipsisAdded = false;
 	#columnDroppedBytes = 0;
 	#columnTruncatedLines = 0;
+	#columnFirstCutLine = 0;
+	#columnLastCutLine = 0;
+	/** Set once a cut line's number may not match the artifact; the range is then withheld. */
+	#columnCutLinesUnmapped = false;
 	#file?: {
 		path: string;
 		artifactId?: string;
@@ -1002,7 +1018,8 @@ export class OutputSink {
 
 	/**
 	 * Push a chunk of output. The buffer management and onChunk callback run
-	 * synchronously. File sink writes are deferred and serialized internally.
+	 * synchronously; onChunk fires after the chunk is stored, so {@link preview}
+	 * already includes it. File sink writes are deferred and serialized internally.
 	 *
 	 * `inline` substitutes a bounded representation for the in-memory buffer and
 	 * live preview while the complete chunk is mirrored to the artifact.
@@ -1015,6 +1032,8 @@ export class OutputSink {
 		const substituted = inline !== undefined;
 		const inlineChunk = inline === undefined ? chunk : sanitizeText(inline);
 
+		this.#store(chunk, inlineChunk, substituted);
+
 		// Throttled onChunk: coalesce chunks arriving inside the throttle window.
 		// A timer flushes quiet tails at the throttle boundary; dump() catches a
 		// final pending chunk when the process exits before that timer fires.
@@ -1029,9 +1048,15 @@ export class OutputSink {
 				this.#schedulePendingChunkFlush();
 			}
 		}
+	}
 
+	/** Count, cap, mirror, and retain one sanitized chunk. */
+	#store(chunk: string, inlineChunk: string, substituted: boolean): void {
 		const rawBytes = Buffer.byteLength(chunk, "utf-8");
 		this.#totalBytes += rawBytes;
+		// Line the chunk starts on, as numbered in the artifact; 0 when the capped
+		// inline text is a substitute whose lines do not map onto the artifact.
+		const firstLine = substituted ? 0 : this.#totalLines + 1;
 
 		if (chunk.length > 0) {
 			this.#sawData = true;
@@ -1042,7 +1067,7 @@ export class OutputSink {
 		// Per-line column cap. State persists across chunks so a mid-line split
 		// still respects the budget. Operates on the inline chunk; the complete
 		// chunk is mirrored to the artifact before any cap is applied.
-		const capped = this.#maxColumns > 0 ? this.#applyColumnCap(inlineChunk) : inlineChunk;
+		const capped = this.#maxColumns > 0 ? this.#applyColumnCap(inlineChunk, firstLine) : inlineChunk;
 		const cappedBytes = capped === inlineChunk ? inlineBytes : Buffer.byteLength(capped, "utf-8");
 		const cappedThisChunk = cappedBytes < inlineBytes;
 		if (substituted) this.#truncated = true;
@@ -1090,11 +1115,13 @@ export class OutputSink {
 	 * cap; subsequent bytes are skipped until the next `\n`. State persists
 	 * across calls so a long line split across chunks still produces one marker.
 	 */
-	#applyColumnCap(chunk: string): string {
+	#applyColumnCap(chunk: string, firstLine: number): string {
 		if (chunk.length === 0) return chunk;
+		if (!this.#columnEllipsisAdded && this.#fitsColumnCap(chunk)) return chunk;
 		const max = this.#maxColumns;
 		const parts: string[] = [];
 		let cursor = 0;
+		let line = firstLine;
 		while (cursor < chunk.length) {
 			const nlIdx = chunk.indexOf(NL, cursor);
 			const segEnd = nlIdx === -1 ? chunk.length : nlIdx;
@@ -1125,6 +1152,12 @@ export class OutputSink {
 						parts.push(ELLIPSIS);
 						this.#columnDroppedBytes += segBytes - keptBytes;
 						this.#columnTruncatedLines++;
+						if (line > 0) {
+							if (this.#columnFirstCutLine === 0) this.#columnFirstCutLine = line;
+							this.#columnLastCutLine = line;
+						} else {
+							this.#columnCutLinesUnmapped = true;
+						}
 						this.#currentLineBytes += keptBytes + ellipsisBytes;
 						this.#columnEllipsisAdded = true;
 					}
@@ -1135,10 +1168,37 @@ export class OutputSink {
 			this.#currentLineBytes = 0;
 			this.#columnEllipsisAdded = false;
 			cursor = nlIdx + 1;
+			if (line > 0) line++;
 		}
 		return parts.join("");
 	}
 
+	/**
+	 * Fast path for {@link #applyColumnCap}: when every line segment fits the
+	 * remaining cap even at the 3-bytes-per-code-unit UTF-8 worst case, the
+	 * chunk passes through unchanged and only the trailing line width is
+	 * measured. Returns false (state untouched) when any line might trip the cap.
+	 */
+	#fitsColumnCap(chunk: string): boolean {
+		const max = this.#maxColumns;
+		let room = max - this.#currentLineBytes;
+		let cursor = 0;
+		for (;;) {
+			const nlIdx = chunk.indexOf(NL, cursor);
+			const segEnd = nlIdx === -1 ? chunk.length : nlIdx;
+			if ((segEnd - cursor) * 3 > room) return false;
+			if (nlIdx === -1) break;
+			cursor = nlIdx + 1;
+			room = max;
+		}
+		if (cursor === 0) {
+			this.#currentLineBytes += Buffer.byteLength(chunk, "utf-8");
+		} else {
+			this.#currentLineBytes = cursor === chunk.length ? 0 : Buffer.byteLength(chunk.substring(cursor), "utf-8");
+		}
+		return true;
+	}
+
 	// The rolling tail budget is whatever the head window has not consumed of
 	// the inline budget: `spillThreshold - #headBytes`. While the head window
 	// fills it shrinks toward `spillThreshold - headLimit`; after `replace()`
@@ -1172,15 +1232,27 @@ export class OutputSink {
 			const { text, bytes } = truncateTailBytes(chunk, threshold);
 			this.#buffer = text;
 			this.#bufferBytes = bytes;
-		} else {
-			// Intermediate size is bounded (<= threshold + dataBytes), safe to concat.
-			this.#buffer += chunk;
-			this.#bufferBytes += dataBytes;
-
-			const { text, bytes } = truncateTailBytes(this.#buffer, threshold);
-			this.#buffer = text;
-			this.#bufferBytes = bytes;
+			this.#tailUntrimmed = false;
+			return;
 		}
+		// Amortize the trim: let the window grow to 2× the budget before cutting it
+		// back, so steady-state chunks cost an append instead of a window copy.
+		// `#trimTail()` restores the exact budget before the buffer is read.
+		this.#buffer += chunk;
+		this.#bufferBytes += dataBytes;
+		this.#tailUntrimmed = true;
+		if (this.#bufferBytes > threshold * 2) this.#trimTail();
+	}
+
+	/** Cut an overflowed tail window back to the current tail budget. */
+	#trimTail(): void {
+		if (!this.#tailUntrimmed) return;
+		this.#tailUntrimmed = false;
+		const threshold = Math.max(0, this.#spillThreshold - this.#headBytes);
+		if (this.#bufferBytes <= threshold) return;
+		const { text, bytes } = truncateTailBytes(this.#buffer, threshold);
+		this.#buffer = text;
+		this.#bufferBytes = bytes;
 	}
 
 	/**
@@ -1372,6 +1444,7 @@ export class OutputSink {
 		this.#clearPendingChunkTimer();
 		this.#buffer = text;
 		this.#bufferBytes = Buffer.byteLength(text, "utf-8");
+		this.#tailUntrimmed = false;
 		this.#head = "";
 		this.#headBytes = 0;
 		this.#headLines = 0;
@@ -1384,6 +1457,8 @@ export class OutputSink {
 		this.#columnEllipsisAdded = false;
 		this.#columnDroppedBytes = 0;
 		this.#columnTruncatedLines = 0;
+		// The artifact keeps the replaced stream, so later line numbers no longer match it.
+		this.#columnCutLinesUnmapped = true;
 		this.#pendingChunk = "";
 		this.#pendingCarriageReturn = false;
 	}
@@ -1458,22 +1533,31 @@ export class OutputSink {
 		}
 	}
 
-	async dump(notice?: string): Promise<OutputSummary> {
-		if (this.#pendingCarriageReturn) {
-			this.#pendingCarriageReturn = false;
-			this.push(NL);
-		}
-		const noticeLine = notice ? `[${notice}]\n` : "";
+	/**
+	 * Current inline view without finalizing: the body {@link dump} would
+	 * return right now (head + elision marker + rolling tail), minus any notice
+	 * and minus the newline `dump()` appends after output that ends in a bare
+	 * carriage return. Each call trims the rolling tail to its budget (a copy
+	 * of the tail window once it overflowed), so call it from a throttled
+	 * onChunk (`chunkThrottleMs`), not once per raw chunk.
+	 */
+	preview(): string {
+		return this.#composeBody().body;
+	}
 
-		// Flush any chunk still held back by the throttle so the live preview
-		// ends with the complete stream.
-		this.#flushPendingChunk();
+	/**
+	 * Compose the visible output. With head retention, splice head + marker +
+	 * tail when content was elided. Otherwise return the rolling buffer.
+	 */
+	#composeBody(): {
+		body: string;
+		outputBytes: number;
+		outputLines: number;
+		elidedBytes?: number;
+		elidedLines?: number;
+	} {
+		this.#trimTail();
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
-
-		await this.#finalizeFile();
-
-		// Compose the visible output. With head retention, splice head + marker
-		// + tail when content was elided. Otherwise return the rolling buffer.
 		const headBytes = this.#headBytes;
 		const tailBuf = this.#buffer;
 		const tailBytes = this.#bufferBytes;
@@ -1484,39 +1568,50 @@ export class OutputSink {
 		// so column-dropped bytes don't inflate the "elided from middle" count.
 		const effectiveTotalBytes = Math.max(0, this.#totalBytes - this.#columnDroppedBytes);
 
-		let body: string;
-		let outputBytes: number;
-		let outputLines: number;
-		let elidedBytes: number | undefined;
-		let elidedLines: number | undefined;
-
 		if (headBytes > 0 && effectiveTotalBytes > headBytes + tailBytes) {
 			// Middle was elided. Emit head + marker + tail.
-			elidedBytes = Math.max(0, effectiveTotalBytes - headBytes - tailBytes);
-			elidedLines = Math.max(0, totalLines - headLines - tailLines);
+			const elidedBytes = Math.max(0, effectiveTotalBytes - headBytes - tailBytes);
+			const elidedLines = Math.max(0, totalLines - headLines - tailLines);
 			const marker = formatMiddleElisionMarker(elidedLines, elidedBytes);
 			const markerBytes = Buffer.byteLength(marker, "utf-8");
 			const headSep = this.#head.endsWith("\n") ? "" : "\n";
 			const tailSep = tailBuf.startsWith("\n") ? "" : "\n";
-			body = `${this.#head}${headSep}${marker}${tailSep}${tailBuf}`;
-			outputBytes =
-				headBytes +
-				markerBytes +
-				tailBytes +
-				Buffer.byteLength(headSep, "utf-8") +
-				Buffer.byteLength(tailSep, "utf-8");
-			outputLines = headLines + 1 + tailLines;
-			this.#truncated = true;
-		} else if (headBytes > 0) {
+			return {
+				body: `${this.#head}${headSep}${marker}${tailSep}${tailBuf}`,
+				outputBytes: headBytes + markerBytes + tailBytes + headSep.length + tailSep.length,
+				outputLines: headLines + 1 + tailLines,
+				elidedBytes,
+				elidedLines,
+			};
+		}
+		if (headBytes > 0) {
 			// Head + tail combine into the full buffered output (no overlap or elision).
-			body = `${this.#head}${tailBuf}`;
-			outputBytes = headBytes + tailBytes;
-			outputLines = body.length > 0 ? countNewlines(body) + 1 : 0;
-		} else {
-			body = tailBuf;
-			outputBytes = tailBytes;
-			outputLines = tailLines;
+			const body = `${this.#head}${tailBuf}`;
+			return {
+				body,
+				outputBytes: headBytes + tailBytes,
+				outputLines: body.length > 0 ? countNewlines(body) + 1 : 0,
+			};
 		}
+		return { body: tailBuf, outputBytes: tailBytes, outputLines: tailLines };
+	}
+
+	async dump(notice?: string): Promise<OutputSummary> {
+		if (this.#pendingCarriageReturn) {
+			this.#pendingCarriageReturn = false;
+			this.push(NL);
+		}
+		const noticeLine = notice ? `[${notice}]\n` : "";
+
+		// Flush any chunk still held back by the throttle so the live preview
+		// ends with the complete stream.
+		this.#flushPendingChunk();
+		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
+
+		await this.#finalizeFile();
+
+		const { body, outputBytes, outputLines, elidedBytes, elidedLines } = this.#composeBody();
+		if (elidedBytes !== undefined) this.#truncated = true;
 
 		return {
 			output: `${noticeLine}${body}`,
@@ -1530,6 +1625,10 @@ export class OutputSink {
 			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
 			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
 			columnMax: this.#columnTruncatedLines > 0 ? this.#maxColumns : undefined,
+			columnTruncatedRange:
+				this.#columnFirstCutLine > 0 && !this.#columnCutLinesUnmapped
+					? { first: this.#columnFirstCutLine, last: this.#columnLastCutLine }
+					: undefined,
 			artifactId: this.#artifactError ? undefined : this.#file?.artifactId,
 			artifactElidedBytes:
 				this.#artifactError || !this.#file?.artifactId || this.#artifactElidedBytes === 0

package/src/tools/task.d.ts

@@ -107,8 +107,6 @@ export interface TaskItem {
     solutionSpace?: string;
     /** Per-spawn thinking effort: lowest/middle/highest level the resolved model supports. Overrides the agent's default selector (e.g. `auto`). */
     effort?: "lo" | "med" | "hi";
-    /** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
-    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -135,8 +133,6 @@ export interface TaskParams {
     solutionSpace?: string;
     /** Per-spawn thinking effort (flat form): lowest/middle/highest level the resolved model supports. */
     effort?: "lo" | "med" | "hi";
-    /** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
-    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */

package/src/tools/task.ts

@@ -47,7 +47,7 @@ import { assembleYieldResult, type YieldSectionShapes } from "./task-yield-assem
 import type { TspAgentProps, TspTone } from "@linxiraos/pi-wire";
 import { compact, kv, md, node, span, text } from "../native/describe";
 import type { NativeNode } from "../native/node";
-import { OwnerMemo } from "../native/memo";
+import { OwnerMemo, sameItems } from "../native/memo";
 import { plainText } from "../native/spans";
 import { errorText, noteText, resultText } from "./native-view";
 import { taskSummary } from "../overlays/agent-hub-renderer";
@@ -242,6 +242,39 @@ function renderTypedYieldSections(value: unknown, continuePrefix: string, expand
 	return lines;
 }
 
+/**
+ * Per-frame memo for derived agent rows. Live task cards re-render at spinner
+ * cadence, while yield/recent-output arrays only change when the subagent
+ * reports. Entries are keyed by the source array (or object) and validated
+ * against a shallow snapshot of its elements plus the render deps, so in-place
+ * pushes/shifts invalidate correctly.
+ */
+interface SnapshotMemoEntry<T> {
+	items: unknown[];
+	deps: unknown[];
+	value: T;
+}
+
+function memoBySnapshot<T>(
+	cache: WeakMap<object, SnapshotMemoEntry<T>>,
+	source: unknown,
+	deps: unknown[],
+	compute: () => T,
+): T {
+	if (source === null || typeof source !== "object") return compute();
+	const items: unknown[] = Array.isArray(source) ? source.slice() : [source];
+	const entry = cache.get(source);
+	if (entry && sameItems(entry.items, items) && sameItems(entry.deps, deps)) return entry.value;
+	const value = compute();
+	cache.set(source, { items, deps, value });
+	return value;
+}
+
+const yieldSectionsMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+const completedReviewMemo = new WeakMap<object, SnapshotMemoEntry<string[] | null>>();
+const recentOutputMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+const agentResultMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+
 /** Formats sanitized task identifiers as hierarchy breadcrumbs. */
 export function formatTaskId(id: string): string {
 	// Ids are name-based (e.g. "Anna", "Anna-2"); a "." separates nesting levels
@@ -776,27 +809,32 @@ function renderAgentProgress(
 		// For completed tasks, render review verdicts assembled from incremental
 		// yield sections.
 		if (progress.status === "completed") {
-			const completeData = normalizeYieldData(progress.extractedToolData.yield);
-			const incrementalReview = extractIncrementalReviewResult(completeData);
-			if (incrementalReview) {
-				lines.push(
-					...renderReviewResult(
-						incrementalReview.summary,
-						incrementalReview.findings,
-						continuePrefix,
-						expanded,
-						theme,
-					),
-				);
-				return lines; // Review result handles its own rendering
-			}
-			const reviewData = completeData
-				.map(c => c.data as SubmitReviewDetails)
-				.filter(d => d && typeof d === "object" && "overall_correctness" in d);
-			if (reviewData.length > 0) {
-				const summary = reviewData[reviewData.length - 1];
-				const findings: FindingDetails[] = [];
-				lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
+			const yieldValue = progress.extractedToolData.yield;
+			const reviewLines = memoBySnapshot(
+				completedReviewMemo,
+				yieldValue,
+				[continuePrefix, expanded, theme],
+				(): string[] | null => {
+					const completeData = normalizeYieldData(yieldValue);
+					const incrementalReview = extractIncrementalReviewResult(completeData);
+					if (incrementalReview) {
+						return renderReviewResult(
+							incrementalReview.summary,
+							incrementalReview.findings,
+							continuePrefix,
+							expanded,
+							theme,
+						);
+					}
+					const reviewData = completeData
+						.map(c => c.data as SubmitReviewDetails)
+						.filter(d => d && typeof d === "object" && "overall_correctness" in d);
+					if (reviewData.length === 0) return null;
+					return renderReviewResult(reviewData[reviewData.length - 1], [], continuePrefix, expanded, theme);
+				},
+			);
+			if (reviewLines) {
+				lines.push(...reviewLines);
 				return lines; // Review result handles its own rendering
 			}
 		}
@@ -804,7 +842,11 @@ function renderAgentProgress(
 		for (const toolName in progress.extractedToolData) {
 			const dataArray = progress.extractedToolData[toolName];
 			if (toolName === "yield") {
-				lines.push(...renderTypedYieldSections(dataArray, continuePrefix, expanded, theme));
+				lines.push(
+					...memoBySnapshot(yieldSectionsMemo, dataArray, [continuePrefix, expanded, theme], () =>
+						renderTypedYieldSections(dataArray, continuePrefix, expanded, theme),
+					),
+				);
 				continue;
 			}
 
@@ -862,15 +904,19 @@ function renderAgentProgress(
 	// Expanded view: recent output and tools
 	if (expanded && progress.status === "running") {
 		const previewRows = previewWindowRows();
-		const output = capPreviewLines(
-			sanitizeRecentOutput([...progress.recentOutput].reverse().join("\n")).split("\n"),
-			theme,
-			{
-				max: previewRows,
-				expandHint: false,
-			},
-		).join("\n");
-		lines.push(...renderOutputSection(output, continuePrefix, expanded, theme, 2, previewRows));
+		lines.push(
+			...memoBySnapshot(recentOutputMemo, progress.recentOutput, [continuePrefix, theme, previewRows], () => {
+				const output = capPreviewLines(
+					sanitizeRecentOutput([...progress.recentOutput].reverse().join("\n")).split("\n"),
+					theme,
+					{
+						max: previewRows,
+						expandHint: false,
+					},
+				).join("\n");
+				return renderOutputSection(output, continuePrefix, expanded, theme, 2, previewRows);
+			}),
+		);
 	}
 
 	return lines;
@@ -1347,7 +1393,7 @@ export function renderResult(
 	const aborted = abortedCount > 0;
 	const failed = failCount > 0;
 	const mergeFailed = mergeFailedCount > 0;
-	const isError = result.isError === true || aborted || failed;
+	const isError = aborted || failed;
 	const agentCount = hasResults ? details.results.length : (details.progress?.length ?? 0);
 	const icon: ToolUIStatus = options.isPartial ? "running" : isError ? "error" : mergeFailed ? "warning" : "success";
 	// Header meta is the spawn count only; each row carries its own ⟨agent⟩
@@ -1373,6 +1419,25 @@ export function renderResult(
 		theme,
 	);
 
+	// Fallback text is fixed for this snapshot; derive its trailing notice rows
+	// once instead of re-splitting on every spinner frame.
+	const fallbackExtraLines: string[] = [];
+	if (fallbackText.trim()) {
+		const summaryLines = fallbackText.split("\n");
+		const markerIndex = summaryLines.findIndex(
+			line =>
+				line.includes("<system-notification>") ||
+				line.startsWith("Applied patches:") ||
+				line.startsWith("No changes to apply."),
+		);
+		if (markerIndex >= 0) {
+			for (let i = markerIndex; i < summaryLines.length; i++) {
+				const line = summaryLines[i];
+				if (line.trim()) fallbackExtraLines.push(theme.fg("dim", line));
+			}
+		}
+	}
+
 	return framedToolCard(theme, ({ width, contentWidth }) => {
 		const { expanded, isPartial, spinnerFrame } = options;
 		const frozen = options.renderContext?.frozen === true;
@@ -1414,7 +1479,11 @@ export function renderResult(
 			const ordered = orderResultsForDisplay(details.results);
 			const visible = expanded ? ordered : selectCollapsedResults(ordered);
 			for (const res of visible) {
-				lines.push(...renderAgentResult(res, "", "  ", expanded, theme, undefined, 0, contentWidth));
+				lines.push(
+					...memoBySnapshot(agentResultMemo, res, [expanded, theme, contentWidth, isFeedModelBadgeEnabled()], () =>
+						renderAgentResult(res, "", "  ", expanded, theme, undefined, 0, contentWidth),
+					),
+				);
 			}
 			if (visible.length < ordered.length) {
 				const hint = formatExpandHint(theme, false, true);
@@ -1427,11 +1496,14 @@ export function renderResult(
 			// (their payloads deliver through jobs) — keep their rows visible
 			// beside the finalized inline results, live while running and
 			// settled once their jobs finish.
-			const supplementalProgress = details.progress
-				? orderProgressForDisplay(
-						details.progress.filter(progress => !details.results.some(res => res.id === progress.id)),
-					)
-				: [];
+			let supplementalProgress: AgentProgress[] = [];
+			if (details.progress) {
+				const resultIds = new Set<string>();
+				for (const res of details.results) resultIds.add(res.id);
+				supplementalProgress = orderProgressForDisplay(
+					details.progress.filter(progress => !resultIds.has(progress.id)),
+				);
+			}
 			for (const progress of supplementalProgress) {
 				lines.push(
 					...renderAgentProgress(
@@ -1484,22 +1556,7 @@ export function renderResult(
 			};
 		}
 
-		if (fallbackText.trim()) {
-			const summaryLines = fallbackText.split("\n");
-			const markerIndex = summaryLines.findIndex(
-				line =>
-					line.includes("<system-notification>") ||
-					line.startsWith("Applied patches:") ||
-					line.startsWith("No changes to apply."),
-			);
-			if (markerIndex >= 0) {
-				const extra = summaryLines.slice(markerIndex);
-				for (const line of extra) {
-					if (!line.trim()) continue;
-					lines.push(theme.fg("dim", line));
-				}
-			}
-		}
+		for (const line of fallbackExtraLines) lines.push(line);
 
 		while (lines.length > 0 && lines[0].trim() === "") lines.shift();
 		return {
@@ -2149,8 +2206,6 @@ export interface TaskItem {
 	solutionSpace?: string;
 	/** Per-spawn thinking effort: lowest/middle/highest level the resolved model supports. Overrides the agent's default selector (e.g. `auto`). */
 	effort?: "lo" | "med" | "hi";
-	/** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
-	model?: string | string[];
 	/** Caller-provided output schema; its presence overrides the selected agent's schema. */
 	outputSchema?: unknown;
 	/** Validation behavior for a caller-provided or inherited output schema. */
@@ -2178,8 +2233,6 @@ export interface TaskParams {
 	solutionSpace?: string;
 	/** Per-spawn thinking effort (flat form): lowest/middle/highest level the resolved model supports. */
 	effort?: "lo" | "med" | "hi";
-	/** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
-	model?: string | string[];
 	/** Caller-provided output schema; its presence overrides the selected agent's schema. */
 	outputSchema?: unknown;
 	/** Validation behavior for a caller-provided or inherited output schema. */