@oh-my-pi/pi-coding-agent 15.9.5 → 15.10.0

package/src/tools/search.ts

@@ -19,6 +19,8 @@ import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine }
 import {
 	Ellipsis,
 	fileHyperlink,
+	getTreeBranch,
+	getTreeContinuePrefix,
 	renderStatusLine,
 	renderTreeList,
 	truncateToWidth,
@@ -36,7 +38,7 @@ import {
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
-import { formatFullOutputReference, type OutputMeta } from "./output-meta";
+import type { OutputMeta } from "./output-meta";
 import {
 	expandDelimitedPathEntries,
 	hasGlobPathChars,
@@ -56,7 +58,9 @@ import {
 	formatCount,
 	formatEmptyMessage,
 	formatErrorMessage,
+	formatMoreItems,
 	PREVIEW_LIMITS,
+	replaceTabs,
 	splitGroupsByBlankLine,
 } from "./render-utils";
 import { ToolError } from "./tool-errors";
@@ -1169,6 +1173,10 @@ interface SearchRenderArgs {
 }
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+/** Line budget for the expanded view. Larger than collapsed so expanding
+ * reveals more matches with context, but still bounded so a single hot file
+ * whose matches span the whole file can't dump its entire length. */
+const EXPANDED_TEXT_LIMIT = PREVIEW_LIMITS.EXPANDED_LINES * 2;
 
 const SEARCH_CODE_FRAME_LINE_RE = /^\s*\*?(\d+)│/;
 
@@ -1190,6 +1198,160 @@ function parseSearchDisplayLineNumber(line: string): number | undefined {
 	return Number.parseInt(match[1]!, 10);
 }
 
+const SEARCH_MATCH_LINE_RE = /^\s*\*\d+(?:│|[:|])/;
+
+interface RenderedSearchLine {
+	raw: string;
+	styled: string;
+}
+
+function isSearchMatchLine(line: string): boolean {
+	return SEARCH_MATCH_LINE_RE.test(line);
+}
+
+function isSearchHeaderLine(line: string): boolean {
+	return line.startsWith("# ") || line.startsWith("## ");
+}
+
+function renderSearchDisplayGroup(
+	group: string[],
+	searchBase: string | undefined,
+	uiTheme: Theme,
+): RenderedSearchLine[] {
+	// Track directory/file context within a group so headers and code-frame
+	// lines link to the backing file, with line-specific links for matches.
+	let contextDir = searchBase ?? "";
+	const hasFileHeader = group.some(line => line.startsWith("# "));
+	let currentFilePath: string | undefined = hasFileHeader ? undefined : searchBase;
+	return group.map(line => {
+		if (line.startsWith("## ")) {
+			// Strip optional ` (suffix)` and `#hash` before resolving.
+			const fileName = line
+				.slice(3)
+				.trimEnd()
+				.replace(/\s+\([^)]*\)\s*$/, "")
+				.replace(/#[0-9a-f]+$/, "");
+			const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
+			currentFilePath = absPath;
+			const styled = uiTheme.fg("dim", line);
+			return { raw: line, styled: absPath ? fileHyperlink(absPath, styled) : styled };
+		}
+		if (line.startsWith("# ")) {
+			const raw = line
+				.slice(2)
+				.trimEnd()
+				.replace(/\s+\([^)]*\)\s*$/, "");
+			if (INTERNAL_URL_DISPLAY_RE.test(raw)) {
+				contextDir = "";
+				const styled = uiTheme.fg("accent", line);
+				const linked = linkUrlLikeSearchHeader(raw, styled);
+				currentFilePath = linked.absPath;
+				return { raw: line, styled: linked.line };
+			}
+			const isDirectory = raw.endsWith("/");
+			const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
+			if (isDirectory) {
+				const absPath = searchBase ? (name === "." ? searchBase : path.join(searchBase, name)) : undefined;
+				if (absPath) {
+					contextDir = absPath;
+				}
+				currentFilePath = undefined;
+				const styled = uiTheme.fg("accent", line);
+				return { raw: line, styled: absPath ? fileHyperlink(absPath, styled) : styled };
+			}
+			// Root-level file emitted by formatGroupedFiles when the directory is `.`.
+			const absPath = searchBase && name ? path.join(searchBase, name) : undefined;
+			currentFilePath = absPath;
+			const styled = uiTheme.fg("accent", line);
+			return { raw: line, styled: absPath ? fileHyperlink(absPath, styled) : styled };
+		}
+		const styled = uiTheme.fg("toolOutput", line);
+		const lineNumber = parseSearchDisplayLineNumber(line);
+		return {
+			raw: line,
+			styled:
+				currentFilePath && lineNumber !== undefined
+					? fileHyperlink(currentFilePath, styled, { line: lineNumber })
+					: styled,
+		};
+	});
+}
+
+function compactSearchPreviewGroup(group: RenderedSearchLine[]): RenderedSearchLine[] {
+	const compact = group.filter(line => isSearchHeaderLine(line.raw) || isSearchMatchLine(line.raw));
+	return compact.length > 0 ? compact : group;
+}
+
+function countPreviewMatches(lines: readonly RenderedSearchLine[], hasMarkedMatches: boolean): number {
+	if (hasMarkedMatches) return lines.reduce((count, line) => count + (isSearchMatchLine(line.raw) ? 1 : 0), 0);
+	return lines.reduce((count, line) => count + (!isSearchHeaderLine(line.raw) && line.raw.length > 0 ? 1 : 0), 0);
+}
+
+function renderBudgetedSearchGroups(
+	groups: string[][],
+	maxLines: number,
+	matchCount: number,
+	searchBase: string | undefined,
+	uiTheme: Theme,
+	compact: boolean,
+): string[] {
+	if (maxLines <= 0) return [];
+	const renderedGroups = groups
+		.map(group => {
+			const rendered = renderSearchDisplayGroup(group, searchBase, uiTheme);
+			return compact ? compactSearchPreviewGroup(rendered) : rendered;
+		})
+		.filter(group => group.length > 0);
+	if (renderedGroups.length === 0) return [];
+
+	let totalLines = 0;
+	let totalMarkedMatches = 0;
+	let totalFallbackMatches = 0;
+	for (const group of renderedGroups) {
+		totalLines += group.length;
+		totalMarkedMatches += countPreviewMatches(group, true);
+		totalFallbackMatches += countPreviewMatches(group, false);
+	}
+	const hasMarkedMatches = totalMarkedMatches > 0;
+	const needsSummary = totalLines > maxLines;
+	const contentBudget = needsSummary ? Math.max(maxLines - 1, 0) : maxLines;
+	const visibleGroups: RenderedSearchLine[][] = [];
+	let visibleLineCount = 0;
+	let visibleMatches = 0;
+	for (const group of renderedGroups) {
+		if (visibleLineCount >= contentBudget) break;
+		const available = contentBudget - visibleLineCount;
+		const take = Math.min(group.length, available);
+		if (take <= 0) break;
+		const visibleGroup = group.slice(0, take);
+		visibleGroups.push(visibleGroup);
+		visibleLineCount += visibleGroup.length;
+		visibleMatches += countPreviewMatches(visibleGroup, hasMarkedMatches);
+	}
+
+	const totalMatches = hasMarkedMatches ? totalMarkedMatches : Math.max(matchCount, totalFallbackMatches);
+	const hiddenMatches = Math.max(totalMatches - visibleMatches, 0);
+	const hiddenLines = Math.max(totalLines - visibleLineCount, 0);
+	const hasSummary = needsSummary && (hiddenMatches > 0 || hiddenLines > 0);
+	const lines: string[] = [];
+	for (let i = 0; i < visibleGroups.length; i++) {
+		const group = visibleGroups[i]!;
+		const isLast = !hasSummary && i === visibleGroups.length - 1;
+		const prefix = `${uiTheme.fg("dim", getTreeBranch(isLast, uiTheme))} `;
+		const continuePrefix = uiTheme.fg("dim", getTreeContinuePrefix(isLast, uiTheme));
+		lines.push(`${prefix}${replaceTabs(group[0]!.styled)}`);
+		for (let j = 1; j < group.length; j++) {
+			lines.push(`${continuePrefix}${replaceTabs(group[j]!.styled)}`);
+		}
+	}
+	if (hasSummary) {
+		const hiddenLabel =
+			hiddenMatches > 0 ? formatMoreItems(hiddenMatches, "match") : formatMoreItems(hiddenLines, "line");
+		lines.push(`${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", hiddenLabel)}`);
+	}
+	return lines;
+}
+
 export const searchToolRenderer = {
 	inline: true,
 	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
@@ -1291,94 +1453,24 @@ export const searchToolRenderer = {
 		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
 		const matchGroups = splitGroupsByBlankLine(textContent.split("\n"));
 
-		const renderedFileLimit = details?.fileLimitReached;
-		const renderedPerFileLimit = details?.perFileLimitReached;
-		const truncationReasons: string[] = [];
-		if (renderedFileLimit) truncationReasons.push(`first ${renderedFileLimit} files (skip to paginate)`);
-		if (renderedPerFileLimit) truncationReasons.push(`first ${renderedPerFileLimit} matches per file`);
-		if (truncation) truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
-		if (limits?.columnTruncated) truncationReasons.push(`line length ${limits.columnTruncated.maxColumn}`);
-		if (truncation?.artifactId) truncationReasons.push(formatFullOutputReference(truncation.artifactId));
-
 		const extraLines: string[] = [];
-		if (truncationReasons.length > 0) {
-			extraLines.push(uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`));
-		}
 		if (missingNote) extraLines.push(missingNote);
 
 		return createCachedComponent(
 			() => options.expanded,
 			width => {
-				const collapsedMatchLineBudget = Math.max(COLLAPSED_TEXT_LIMIT - extraLines.length, 0);
+				const budget = Math.max(
+					(options.expanded ? EXPANDED_TEXT_LIMIT : COLLAPSED_TEXT_LIMIT) - extraLines.length,
+					0,
+				);
 				const searchBase = details?.searchPath;
-				const matchLines = renderTreeList(
-					{
-						items: matchGroups,
-						expanded: options.expanded,
-						maxCollapsed: matchGroups.length,
-						maxCollapsedLines: collapsedMatchLineBudget,
-						itemType: "match",
-						renderItem: group => {
-							// Track directory/file context within a group so headers and code-frame
-							// lines link to the backing file, with line-specific links for matches.
-							let contextDir = searchBase ?? "";
-							const hasFileHeader = group.some(line => line.startsWith("# "));
-							let currentFilePath: string | undefined = hasFileHeader ? undefined : searchBase;
-							return group.map(line => {
-								if (line.startsWith("## ")) {
-									// Strip optional ` (suffix)` and `#hash` before resolving.
-									const fileName = line
-										.slice(3)
-										.trimEnd()
-										.replace(/\s+\([^)]*\)\s*$/, "")
-										.replace(/#[0-9a-f]+$/, "");
-									const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
-									currentFilePath = absPath;
-									const styled = uiTheme.fg("dim", line);
-									return absPath ? fileHyperlink(absPath, styled) : styled;
-								}
-								if (line.startsWith("# ")) {
-									const raw = line
-										.slice(2)
-										.trimEnd()
-										.replace(/\s+\([^)]*\)\s*$/, "");
-									if (INTERNAL_URL_DISPLAY_RE.test(raw)) {
-										contextDir = "";
-										const styled = uiTheme.fg("accent", line);
-										const linked = linkUrlLikeSearchHeader(raw, styled);
-										currentFilePath = linked.absPath;
-										return linked.line;
-									}
-									const isDirectory = raw.endsWith("/");
-									const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
-									if (isDirectory) {
-										const absPath = searchBase
-											? name === "."
-												? searchBase
-												: path.join(searchBase, name)
-											: undefined;
-										if (absPath) {
-											contextDir = absPath;
-										}
-										currentFilePath = undefined;
-										const styled = uiTheme.fg("accent", line);
-										return absPath ? fileHyperlink(absPath, styled) : styled;
-									}
-									// Root-level file emitted by formatGroupedFiles when the directory is `.`.
-									const absPath = searchBase && name ? path.join(searchBase, name) : undefined;
-									currentFilePath = absPath;
-									const styled = uiTheme.fg("accent", line);
-									return absPath ? fileHyperlink(absPath, styled) : styled;
-								}
-								const styled = uiTheme.fg("toolOutput", line);
-								const lineNumber = parseSearchDisplayLineNumber(line);
-								return currentFilePath && lineNumber !== undefined
-									? fileHyperlink(currentFilePath, styled, { line: lineNumber })
-									: styled;
-							});
-						},
-					},
+				const matchLines = renderBudgetedSearchGroups(
+					matchGroups,
+					budget,
+					matchCount,
+					searchBase,
 					uiTheme,
+					!options.expanded,
 				);
 				return [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 			},

package/src/tools/ssh.ts

@@ -13,11 +13,11 @@ import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
-import { replaceTabs } from "./render-utils";
+import { capPreviewLines, replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -244,16 +244,22 @@ export const sshToolRenderer = {
 		const header = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}]` }, uiTheme);
 		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const outputBlock = new CachedOutputBlock();
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] =>
 				outputBlock.render(
-					{ header, state: "pending", sections: [{ lines: cmdLines }], width, animate: true },
+					{
+						header,
+						state: "pending",
+						sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: _options.expanded }) }],
+						width,
+						animate: true,
+					},
 					uiTheme,
 				),
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 
 	renderResult(
@@ -273,7 +279,7 @@ export const sshToolRenderer = {
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
 		const outputBlock = new CachedOutputBlock();
 
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] => {
 				// REACTIVE: read mutable options at render time
 				const { expanded, renderContext } = options;
@@ -319,7 +325,14 @@ export const sshToolRenderer = {
 					{
 						header,
 						state: "success",
-						sections: [{ lines: cmdLines }, { label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
+						sections: [
+							{
+								lines: options.isPartial
+									? capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded })
+									: cmdLines,
+							},
+							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
+						],
 						width,
 					},
 					uiTheme,
@@ -328,7 +341,7 @@ export const sshToolRenderer = {
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/todo.ts

@@ -777,13 +777,26 @@ function renderNoteAttachments(phases: TodoPhase[], uiTheme: Theme): string[] {
 
 export const todoToolRenderer = {
 	renderCall(args: TodoRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const ops = args?.ops?.map(entry => {
-			const parts = [entry.op ?? "update"];
-			if (entry.task) parts.push(entry.task);
-			if (entry.phase) parts.push(entry.phase);
-			if (entry.items?.length) parts.push(`${entry.items.length} item${entry.items.length === 1 ? "" : "s"}`);
-			return parts.join(" ");
-		}) ?? ["update"];
+		// `args` here is the raw partially-parsed JSON from the streaming
+		// tool-call delta and may not satisfy `TodoRenderArgs` at runtime:
+		// `parseStreamingJson` can hand back `{ ops: "[" }` mid-delta, or
+		// entries that are `null` / strings before fields stream. Guard
+		// against non-array `ops` and non-object entries so a malformed
+		// delta never breaks the TUI render loop (#2005).
+		const opsList = Array.isArray(args?.ops) ? args.ops : [];
+		const ops =
+			opsList.length === 0
+				? ["update"]
+				: opsList.map(entry => {
+						const e = entry && typeof entry === "object" ? entry : ({} as NonNullable<typeof entry>);
+						const parts = [e.op ?? "update"];
+						if (e.task) parts.push(e.task);
+						if (e.phase) parts.push(e.phase);
+						if (Array.isArray(e.items) && e.items.length) {
+							parts.push(`${e.items.length} item${e.items.length === 1 ? "" : "s"}`);
+						}
+						return parts.join(" ");
+					});
 		const text = renderStatusLine({ icon: "pending", title: "Todo", meta: ops }, uiTheme);
 		return new Text(text, 0, 0);
 	},

package/src/tools/write.ts

@@ -37,6 +37,7 @@ import { formatPathRelativeToCwd, isInternalUrlPath } from "./path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
 	formatDiagnostics,
+	formatErrorDetail,
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
@@ -58,7 +59,7 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const LOOSE_HASHLINE_HEADER_RE = /^\s*¶\S+#[^ \t\r\n]*\s*$/;
+const LOOSE_HASHLINE_HEADER_RE = /^\s*\[[^#\r\n]+#[^ \t\r\n]*\]\s*$/;
 
 let fflateModulePromise: Promise<typeof import("fflate")> | undefined;
 async function loadFflate(): Promise<typeof import("fflate")> {
@@ -109,7 +110,7 @@ function stripWriteContentWithPotentialLooseHeader(lines: string[]): { text: str
 /**
  * Strip hashline display prefixes from write content.
  *
- * Only active when hashline edit mode is enabled — the model sees `¶PATH#HASH`
+ * Only active when hashline edit mode is enabled — the model sees `[PATH#HASH]`
  * headers plus `LINE:` prefixes in read output and sometimes copies them into write content.
  */
 function stripWriteContent(session: ToolSession, content: string): { text: string; stripped: boolean } {
@@ -122,7 +123,7 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 /**
  * Record a snapshot of the freshly-written `content` for `absolutePath`
  * so subsequent hashline edits address the new file with a current tag,
- * and return the matching `¶displayPath#TAG` header. Returns `undefined`
+ * and return the matching `[displayPath#TAG]` header. Returns `undefined`
  * when the session is not in hashline mode so callers can no-op cheaply.
  *
  * Mirrors the post-commit snapshot recording the hashline patcher performs
@@ -770,7 +771,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		return untilAborted(signal, async () => {
-			// Strip hashline display prefixes (¶PATH#HASH + LINE:) if the model copied them from read output
+			// Strip hashline display prefixes ([PATH#HASH] + LINE:) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
 			const internalRouter = InternalUrlRouter.instance();
 			if (internalRouter.canHandle(path)) {
@@ -935,11 +936,20 @@ function normalizeDisplayText(text: string): string {
 	return text.replace(/\r/g, "");
 }
 
-function formatStreamingContent(content: string, language: string | undefined, uiTheme: Theme): string {
+function formatStreamingContent(
+	content: string,
+	expanded: boolean,
+	language: string | undefined,
+	uiTheme: Theme,
+): string {
 	if (!content) return "";
 	const lines = normalizeDisplayText(content).split("\n");
 	const totalLines = lines.length;
-	const startIndex = Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
+	// Collapsed: follow the streaming edge with a bounded tail window so the box
+	// stays short enough not to strand its scrolled-off head above the viewport
+	// while the block is volatile. `Ctrl+O` (expanded) lifts the cap for a
+	// deliberate full view — matching the eval streaming preview.
+	const startIndex = expanded ? 0 : Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
 	const visibleLines = lines.slice(startIndex);
 	const hidden = startIndex;
 	const highlighted = highlightCode(visibleLines.join("\n"), language);
@@ -1005,14 +1015,25 @@ export const writeToolRenderer = {
 			return new Text(text, 0, 0);
 		}
 
-		// Show streaming preview of content (tail)
-		text += formatStreamingContent(args.content, lang, uiTheme);
+		// Show streaming preview of content — bounded tail while collapsed, full on Ctrl+O.
+		text += formatStreamingContent(args.content, Boolean(options?.expanded), lang, uiTheme);
 
 		return new Text(text, 0, 0);
 	},
 
+	// Only the expanded (Ctrl+O) preview is append-only: it renders the whole
+	// content top-anchored, so streamed chunks only append rows at the bottom.
+	// The collapsed preview slides a bounded tail window (`formatStreamingContent`
+	// with `WRITE_STREAMING_PREVIEW_LINES`) whose visible rows re-layout as the
+	// window moves — not append-only, but it never overflows the viewport, so its
+	// head is never at risk of being dropped regardless. `write` has no partial
+	// result (content streams as args), so `result` is ignored here.
+	isStreamingPreviewAppendOnly(args: WriteRenderArgs, options: RenderResultOptions, _result?: unknown): boolean {
+		return Boolean(options?.expanded && args.content);
+	},
+
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails },
+		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
 		options: RenderResultOptions,
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
@@ -1023,6 +1044,15 @@ export const writeToolRenderer = {
 		const lang = getLanguageFromPath(rawPath);
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+
+		if (result.isError) {
+			const errorText = result.content?.find(c => c.type === "text")?.text ?? "";
+			const errorHeader = renderStatusLine(
+				{ icon: "error", title: "Write", description: `${langIcon} ${pathDisplay}` },
+				uiTheme,
+			);
+			return new Text(`${errorHeader}\n${formatErrorDetail(errorText, uiTheme)}`, 0, 0);
+		}
 		const lineCount = countLines(fileContent);
 		const lineSuffix = formatLineCountSuffix(lineCount, uiTheme);
 		const execSuffix = result.details?.madeExecutable

package/src/tui/code-cell.ts

@@ -25,6 +25,12 @@ export interface CodeCellOptions {
 	output?: string;
 	outputMaxLines?: number;
 	codeMaxLines?: number;
+	/**
+	 * Show the LAST `codeMaxLines` rows (the live streaming edge) instead of the
+	 * first, with a "… N earlier lines" marker on top. Lets a pending preview
+	 * follow code as it is written while staying bounded. Ignored when `expanded`.
+	 */
+	codeTail?: boolean;
 	expanded?: boolean;
 	/** Animate the cell border with a sweeping segment while pending/running. */
 	animate?: boolean;
@@ -102,13 +108,22 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 	const normalizedCode = replaceTabs(code ?? "");
 	const rawCodeLines = sanitizeTerminalLines(normalizedCode);
 	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
-	const visibleCode = rawCodeLines.slice(0, maxCodeLines).join("\n");
-	const codeLines = highlightCode(visibleCode, language);
 	const hiddenCodeLines = rawCodeLines.length - maxCodeLines;
+	const tail = options.codeTail === true && !expanded && hiddenCodeLines > 0;
+	const startIndex = tail ? rawCodeLines.length - maxCodeLines : 0;
+	const visibleCode = rawCodeLines.slice(startIndex, startIndex + maxCodeLines).join("\n");
+	const codeLines = highlightCode(visibleCode, language);
 	if (hiddenCodeLines > 0) {
 		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
-		const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
-		codeLines.push(theme.fg("dim", moreLine));
+		if (tail) {
+			// Earlier rows scrolled above the live tail window — mark them on top so
+			// the newest streamed line stays pinned to the bottom of the box.
+			const earlier = `… ${hiddenCodeLines} earlier line${hiddenCodeLines === 1 ? "" : "s"}${hint ? ` ${hint}` : ""}`;
+			codeLines.unshift(theme.fg("dim", earlier));
+		} else {
+			const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
+			codeLines.push(theme.fg("dim", moreLine));
+		}
 	}
 
 	const outputLines: string[] = [];

package/src/tui/output-block.ts

@@ -1,6 +1,7 @@
 /**
  * Bordered output container with optional header and sections.
  */
+import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import { getSixelLineMask } from "../utils/sixel";
@@ -19,6 +20,19 @@ export interface OutputBlockOptions {
 	animate?: boolean;
 }
 
+const FRAMED_BLOCK_COMPONENT = Symbol("framedBlockComponent");
+
+export type FramedBlockComponent = Component & { [FRAMED_BLOCK_COMPONENT]?: true };
+
+export function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent {
+	(component as T & FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] = true;
+	return component as T & FramedBlockComponent;
+}
+
+export function isFramedBlockComponent(component: Component): boolean {
+	return (component as FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] === true;
+}
+
 const BORDER_SHIMMER_TICK_MS = 16;
 /** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
  * ms. Position is derived from the wall clock against this fixed cycle so a