@oh-my-pi/pi-coding-agent 16.3.5 → 16.3.6

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

@@ -4,9 +4,9 @@ import { formatNumber } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
 import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { canonicalizeMessage, formatThinkingForDisplay, hasDisplayableThinking } from "../../utils/thinking-display";
+import { resolveAssistantErrorPresentation } from "../utils/transcript-render-helpers";
 import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cache-invalidation-marker";
 
 /**
@@ -18,15 +18,6 @@ import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cach
  */
 const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
-/**
- * A GFM table delimiter row (`| --- | :--: |`, with or without bounding pipes).
- * The header row alone does not render a table — this delimiter is what makes
- * Markdown lay one out, and a streaming table re-aligns its columns as rows
- * arrive. Requires at least one column pipe so a bare thematic break (`---`)
- * does not match.
- */
-const MARKDOWN_TABLE_DELIMITER = /^ {0,3}\|?(?:[ \t]*:?-+:?[ \t]*\|)+[ \t]*:?-*:?[ \t]*$/;
-
 /** Opening or closing fence of a code block: ≥3 backticks/tildes plus info string. */
 const CODE_FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 
@@ -48,20 +39,15 @@ function resolveThinkingDisplay(block: ThinkingContentBlock, proseOnly: boolean)
 }
 
 /**
- * Whether `text` currently contains reflowing Markdown whose layout is not yet
- * permanent: an open ` ```mermaid ` fence (the diagram reshapes as source
- * arrives) or a GFM table (columns re-align as rows arrive). Used by
- * {@link AssistantMessageComponent.isTranscriptBlockCommitStable}.
- *
- * Fence-aware: a mermaid block is detected by its opener, and table delimiters
- * inside ordinary fenced code (shell pipes, ASCII separators, doc examples) are
- * ignored so a long streamed code block is never held out of native scrollback.
- * A delimiter counts only directly under a pipe-bearing header row, outside any
- * code fence.
+ * Whether `text` contains a ` ```mermaid ` fence (open or closed) outside
+ * ordinary code fences. Mermaid defers native-scrollback settling wholesale
+ * (see {@link AssistantMessageComponent.getTranscriptBlockSettledRows}): its
+ * ASCII rendering resolves asynchronously, so even a completed fence can
+ * re-layout rows that already looked settled. Fence-aware so a mermaid
+ * example inside a regular code block never triggers the deferral.
  */
-function detectLiveReflowingMarkdown(text: string): boolean {
+function containsMermaidFence(text: string): boolean {
 	let fence: string | null = null;
-	let prevLine = "";
 	for (const line of text.split("\n")) {
 		const fenceMatch = CODE_FENCE_LINE.exec(line);
 		if (fence !== null) {
@@ -79,11 +65,7 @@ function detectLiveReflowingMarkdown(text: string): boolean {
 		if (fenceMatch) {
 			if (/^mermaid\b/.test(fenceMatch[2]!.trim())) return true;
 			fence = fenceMatch[1]!;
-			prevLine = "";
-			continue;
 		}
-		if (prevLine.includes("|") && MARKDOWN_TABLE_DELIMITER.test(line)) return true;
-		prevLine = line;
 	}
 	return false;
 }
@@ -194,14 +176,16 @@ export class AssistantMessageComponent extends Container {
 	#kittyConversionsInFlight = new Set<string>();
 	#transcriptBlockFinalized: boolean;
 	/**
-	 * True while a non-finalized text item carries reflowing Markdown — a
-	 * ` ```mermaid ` fence or a GFM table — whose layout re-flows every frame as
-	 * source arrives (a diagram reshaping, a table re-aligning its columns), so
-	 * no prefix is byte-stable until the message finalizes. See
-	 * {@link isTranscriptBlockCommitStable}. Recomputed in {@link updateContent}
-	 * ahead of the fast-path return, so it tracks every stream tick.
+	 * True while any rendered item carries a ` ```mermaid ` fence. Mermaid's
+	 * ASCII form resolves asynchronously and can re-layout rows that already
+	 * looked settled, so settling defers until the message finalizes. See
+	 * {@link getTranscriptBlockSettledRows}. Recomputed in
+	 * {@link updateContent} ahead of the fast-path return, so it tracks every
+	 * stream tick. Streaming GFM tables need no gate: they live in markdown's
+	 * unfrozen tail while re-aligning and render deterministically once their
+	 * block completes.
 	 */
-	#hasLiveReflowingMarkdown = false;
+	#containsMermaidSource = false;
 	/**
 	 * When true, the turn-ending `Error: …` line for `stopReason === "error"` is
 	 * suppressed because the same error is currently shown in the pinned banner
@@ -222,6 +206,9 @@ export class AssistantMessageComponent extends Container {
 	/** Whether the last updateContent carried an in-flight streaming partial; such
 	 *  renders bypass the markdown module LRU (see Markdown.transientRenderCache). */
 	#lastUpdateTransient = false;
+	/** Width of the most recent render(); the settled-rows walk reads child
+	 *  renders at exactly this width (L1 cache hits). */
+	#lastRenderWidth = 0;
 	// Fast-path state: reuse Markdown children when message shape is stable during streaming.
 	#fastPathKey: string | undefined;
 	#fastPathItems:
@@ -299,6 +286,11 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	override render(width: number): readonly string[] {
+		this.#lastRenderWidth = width;
+		return super.render(width);
+	}
+
 	setHideThinkingBlock(hide: boolean): void {
 		this.hideThinkingBlock = hide;
 	}
@@ -415,18 +407,44 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	/**
-	 * Whether this still-live block's scrolled-off rows may be committed to
-	 * immutable native scrollback (the {@link TranscriptContainer} durable-
-	 * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
-	 * table — re-lays-out its body as source arrives (the diagram reshapes, the
-	 * table re-aligns its columns), so committing an intermediate layout strands
-	 * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
-	 * clear. While such content is still streaming the block therefore stays
-	 * wholly in the repaintable live region and commits once, at its final
-	 * layout, when the turn finalizes.
+	 * Settled leading rows for mid-stream native-scrollback commits (see
+	 * `FinalizableBlock.getTranscriptBlockSettledRows`). Completed content
+	 * blocks render in final form (non-transient) and settle in full; the
+	 * actively streaming markdown contributes its rendered frozen-token
+	 * prefix. The walk stops at the first child that is not declared
+	 * byte-stable (the animated thinking pulse, extension components, images,
+	 * error rows), and a cache-invalidation marker above the content defers
+	 * settling entirely. Mermaid anywhere defers wholesale — its ASCII
+	 * rendering resolves asynchronously and can re-layout settled-looking
+	 * rows. Reads only L1-cached child renders at the width recorded by this
+	 * frame's render().
 	 */
-	isTranscriptBlockCommitStable(): boolean {
-		return this.#transcriptBlockFinalized || !this.#hasLiveReflowingMarkdown;
+	getTranscriptBlockSettledRows(): number {
+		if (this.#transcriptBlockFinalized || !this.#lastUpdateTransient) return 0;
+		if (this.#containsMermaidSource) return 0;
+		if (this.#markerSlot.children.length > 0) return 0;
+		const items = this.#fastPathItems;
+		const width = this.#lastRenderWidth;
+		if (!items || items.length === 0 || width <= 0) return 0;
+		const streaming = items[items.length - 1]!.md;
+		// Items are captured in child order: match completed mds positionally.
+		let itemIndex = 0;
+		let settled = 0;
+		for (const child of this.#contentContainer.children) {
+			if (child === streaming) return settled + streaming.getLastRenderSettledRows();
+			if (itemIndex < items.length - 1 && items[itemIndex]!.md === child) {
+				itemIndex++;
+				settled += child.render(width).length;
+				continue;
+			}
+			if (child instanceof Spacer) {
+				settled += child.render(width).length;
+				continue;
+			}
+			// Not declared byte-stable: the boundary stops here.
+			return settled;
+		}
+		return settled;
 	}
 
 	getTranscriptBlockVersion(): number {
@@ -445,6 +463,24 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void {
+		if (!this.#lastMessage || !retryRecovery) return;
+		this.setErrorPinned(false);
+		this.updateContent({ ...this.#lastMessage, retryRecovery });
+	}
+
+	messagePersistenceKey(): string | undefined {
+		if (!this.#lastMessage) return undefined;
+		return [
+			"assistant",
+			this.#lastMessage.timestamp,
+			this.#lastMessage.provider,
+			this.#lastMessage.model,
+			this.#lastMessage.responseId ?? "",
+			this.#lastMessage.stopReason,
+		].join(":");
+	}
+
 	/**
 	 * Render a turn-ending provider error inline. Drops blank lines, clamps the
 	 * line count to {@link MAX_TRANSCRIPT_ERROR_LINES}, and width-truncates each
@@ -454,7 +490,7 @@ export class AssistantMessageComponent extends Container {
 	#appendErrorBlock(message: string): void {
 		const lines = getPreviewLines(message, MAX_TRANSCRIPT_ERROR_LINES, TRUNCATE_LENGTHS.LINE);
 		if (lines.length === 0) lines.push("Unknown error");
-		this.#contentContainer.addChild(new Spacer(1));
+		// The caller owns the separating Spacer; adding one here doubled the gap.
 		this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${lines[0]}`), 1, 0));
 		for (const line of lines.slice(1)) {
 			this.#contentContainer.addChild(new Text(theme.fg("error", `  ${line}`), 1, 0));
@@ -587,15 +623,11 @@ export class AssistantMessageComponent extends Container {
 			if (content.type === "toolCall") return false;
 		}
 		if (this.#toolImagesByCallId.size > 0) return false;
-		if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) return false;
-		if (message.stopReason === "error" && !this.#errorPinned) return false;
-		if (
-			message.errorMessage &&
-			shouldRenderAbortReason(message) &&
-			message.stopReason !== "aborted" &&
-			message.stopReason !== "error"
-		)
+		const errorPresentation = resolveAssistantErrorPresentation(message);
+		if (errorPresentation.kind === "compact-recovered") return false;
+		if (errorPresentation.kind === "full" && !(message.stopReason === "error" && this.#errorPinned)) {
 			return false;
+		}
 		// Extension stability: if thinking renderers exist and any tracked thinking
 		// block's text changed, extensions may produce a different child count.
 		if (this.thinkingRenderers.length > 0 && this.#fastPathItems) {
@@ -626,8 +658,9 @@ export class AssistantMessageComponent extends Container {
 		}
 		const transient = opts?.transient === true;
 		// Shape is identical — setText only on Markdown children whose source changed.
-		for (const item of this.#fastPathItems) {
-			item.md.transientRenderCache = transient;
+		this.#applyItemTransience(transient);
+		for (let i = 0; i < this.#fastPathItems.length; i++) {
+			const item = this.#fastPathItems[i]!;
 			const content = message.content[item.contentIndex];
 			if (!content) {
 				this.#fastPathKey = undefined;
@@ -645,6 +678,14 @@ export class AssistantMessageComponent extends Container {
 				return false;
 			}
 			if (newText !== item.lastText) {
+				// Only the last (actively streaming) block may mutate in place: a
+				// delta into an earlier block would invalidate rows the settled
+				// walk already declared final, so tear down and rebuild instead.
+				if (i < this.#fastPathItems.length - 1) {
+					this.#fastPathKey = undefined;
+					this.#fastPathItems = undefined;
+					return false;
+				}
 				item.md.setText(newText);
 				item.lastText = newText;
 			}
@@ -698,14 +739,19 @@ export class AssistantMessageComponent extends Container {
 			this.#thinkingRateLive = false;
 		}
 
-		// Streaming reflowing Markdown (a mermaid diagram reshaping, a GFM table
-		// re-aligning columns) re-lays-out its body each frame; see
-		// isTranscriptBlockCommitStable. Detect it from raw text — a Markdown
-		// parser only resolves these once the closing fence / delimiter row
-		// arrives, but the stale native-scrollback commits happen mid-stream.
-		this.#hasLiveReflowingMarkdown = message.content.some(
-			content => content.type === "text" && detectLiveReflowingMarkdown(content.text),
-		);
+		// Mermaid ASCII rendering resolves asynchronously, so a fence anywhere
+		// in the rendered source (text or visible thinking) defers settling; see
+		// getTranscriptBlockSettledRows. Detected from raw source — a Markdown
+		// parser only resolves the fence once it closes, but the stale commits
+		// would happen mid-stream.
+		this.#containsMermaidSource = message.content.some(content => {
+			if (content.type === "text") return containsMermaidFence(content.text);
+			if (content.type === "thinking" && !this.hideThinkingBlock) {
+				const display = resolveThinkingDisplay(content, this.proseOnlyThinking);
+				return display.visible && containsMermaidFence(display.text);
+			}
+			return false;
+		});
 
 		// Fast path: reuse Markdown children when shape is stable during streaming
 		if (this.#tryFastPathUpdate(message, opts)) return;
@@ -781,37 +827,43 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		this.#renderToolImages();
-		// Check if aborted - show after partial content
-		// But only if there are no tool calls (tool execution components will show the error)
+		const errorPresentation = resolveAssistantErrorPresentation(message);
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
-		if (!hasToolCalls) {
-			if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) {
-				const abortMessage = resolveAbortLabel(message);
-				if (hasVisibleContent) {
-					this.#contentContainer.addChild(new Spacer(1));
+		if (errorPresentation.kind === "compact-recovered") {
+			this.#contentContainer.addChild(new Spacer(1));
+			this.#contentContainer.addChild(new Text(theme.fg("dim", errorPresentation.text), 1, 0));
+		} else if (!hasToolCalls && errorPresentation.kind === "full") {
+			if (!(message.stopReason === "error" && this.#errorPinned)) {
+				this.#contentContainer.addChild(new Spacer(1));
+				if (message.stopReason === "aborted") {
+					this.#contentContainer.addChild(new Text(theme.fg("error", errorPresentation.text), 1, 0));
 				} else {
-					this.#contentContainer.addChild(new Spacer(1));
+					this.#appendErrorBlock(errorPresentation.text);
 				}
-				this.#contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
-			} else if (message.stopReason === "error" && !this.#errorPinned) {
-				this.#appendErrorBlock(message.errorMessage || "Unknown error");
 			}
 		}
-		if (
-			message.errorMessage &&
-			shouldRenderAbortReason(message) &&
-			message.stopReason !== "aborted" &&
-			message.stopReason !== "error"
-		) {
-			this.#appendErrorBlock(message.errorMessage);
-		}
 		// Store fast-path state for next call
 		if (shouldCapture) {
 			this.#fastPathItems = captureItems;
 			this.#fastPathKey = this.#computeShapeKey(message);
+			this.#applyItemTransience(this.#lastUpdateTransient);
 		} else {
 			this.#fastPathKey = undefined;
 			this.#fastPathItems = undefined;
 		}
 	}
+
+	/**
+	 * Only the actively streaming (last) markdown renders in transient mode;
+	 * completed blocks render final — syntax-highlighted, module-LRU-cached,
+	 * byte-stable — so their rows can settle into native scrollback mid-turn
+	 * and are byte-identical to the finalize render.
+	 */
+	#applyItemTransience(transient: boolean): void {
+		const items = this.#fastPathItems;
+		if (!items) return;
+		for (let i = 0; i < items.length; i++) {
+			items[i]!.md.transientRenderCache = transient && i === items.length - 1;
+		}
+	}
 }

package/src/modes/components/bash-execution.ts

@@ -64,6 +64,15 @@ export class BashExecutionComponent extends Container {
 		this.#contentContainer.addChild(this.#loader);
 	}
 
+	/**
+	 * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+	 * streaming preview rewrites its tail window every chunk, so the block must
+	 * stay out of native scrollback until the command completes.
+	 */
+	isTranscriptBlockFinalized(): boolean {
+		return this.#status !== "running";
+	}
+
 	/**
 	 * Set whether the output is expanded (shows full output) or collapsed (preview only).
 	 */

package/src/modes/components/chat-transcript-builder.ts

@@ -33,7 +33,7 @@ import {
 	buildFileMentionBlock,
 	buildIrcMessageCard,
 	normalizeToolArgs,
-	resolveAssistantErrorMessage,
+	resolveAssistantErrorPresentation,
 } from "../utils/transcript-render-helpers";
 import { createAdvisorMessageCard } from "./advisor-message";
 import { AssistantMessageComponent } from "./assistant-message";
@@ -153,7 +153,7 @@ export class ChatTranscriptBuilder {
 		const previous = this.#waitingPoll;
 		if (!previous) return;
 		this.#waitingPoll = null;
-		if (nextToolName === "job" && previous.isDisplaceableBlock()) {
+		if (nextToolName === "job" && previous.isDisplaceableBlock() && this.container.isBlockUncommitted(previous)) {
 			this.container.removeChild(previous);
 		}
 		previous.seal();
@@ -168,7 +168,9 @@ export class ChatTranscriptBuilder {
 		}
 		if (previous.canBeDisplacedBy(nextToolName)) {
 			this.#todoSnapshot = null;
-			this.container.removeChild(previous);
+			if (this.container.isBlockUncommitted(previous)) {
+				this.container.removeChild(previous);
+			}
 			previous.seal();
 			return;
 		}
@@ -293,7 +295,9 @@ export class ChatTranscriptBuilder {
 			this.#readGroup = null;
 		}
 
-		const { hasErrorStop, errorMessage } = resolveAssistantErrorMessage(message);
+		const errorPresentation = resolveAssistantErrorPresentation(message);
+		const hasErrorStop = errorPresentation.kind === "full";
+		const errorMessage = hasErrorStop ? errorPresentation.text : null;
 
 		for (const content of message.content) {
 			if (content.type !== "toolCall") continue;

package/src/modes/components/eval-execution.ts

@@ -61,6 +61,15 @@ export class EvalExecutionComponent extends Container {
 		this.#contentContainer.addChild(this.#loader);
 	}
 
+	/**
+	 * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+	 * streaming preview rewrites its tail window every chunk, so the block must
+	 * stay out of native scrollback until the cell completes.
+	 */
+	isTranscriptBlockFinalized(): boolean {
+		return this.#status !== "running";
+	}
+
 	setExpanded(expanded: boolean): void {
 		this.#expanded = expanded;
 		this.#updateDisplay();

package/src/modes/components/tool-execution.ts

@@ -697,12 +697,12 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 	/**
 	 * Standalone harnesses may mount a tool component directly under `TUI`
 	 * instead of inside `TranscriptContainer`. In that shape the component must
-	 * report its own live-region seam for provisional previews, or the core
-	 * renderer treats it like shell output and commits tail-window edit/eval/bash
-	 * previews to immutable native scrollback before the result replaces them.
+	 * report its own live-region seam while unfinalized, or the core renderer
+	 * treats it like shell output and commits still-mutating preview rows to
+	 * immutable native scrollback before the result replaces them.
 	 */
 	getNativeScrollbackLiveRegionStart(): number | undefined {
-		return !this.isTranscriptBlockFinalized() && !this.isTranscriptBlockCommitStable() ? 0 : undefined;
+		return this.isTranscriptBlockFinalized() ? undefined : 0;
 	}
 
 	/**
@@ -726,52 +726,6 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		return (this.#result.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 	}
 
-	/**
-	 * Whether this still-live block's settled rows may enter native scrollback
-	 * (see `FinalizableBlock.isTranscriptBlockCommitStable`). Renderers classify
-	 * pending views by durability instead of by tool name: a provisional view is
-	 * allowed to be useful on screen, but finalization may replace or re-anchor
-	 * it wholesale, so committing any of its rows would strand stale preview
-	 * bytes in immutable scrollback. Non-provisional views stream rows whose
-	 * committed prefix survives the remaining transitions.
-	 */
-	isTranscriptBlockCommitStable(): boolean {
-		if (this.#displaceableByToolName) return false;
-		if (this.isTranscriptBlockFinalized()) return true;
-		// `provisionalPendingPreview` describes only the PENDING call preview
-		// (`renderCall`, before any result): the result render may re-anchor it
-		// wholesale, so its rows must never commit. Once a (streaming partial)
-		// result exists the result renderer is usually the live shape — its body
-		// is top-anchored and grows append-only, and `deriveLiveCommitState`
-		// gates per-row durability — so the block is commit-stable like any
-		// settled stream. Gating the flag on the pending phase is what keeps a
-		// collapsed streaming eval/bash/ssh whose box outgrows the viewport from
-		// stranding its head: while commit-unstable its scrolled-off top
-		// committed nowhere and repainted nowhere, so it read as truncated until
-		// ctrl+o (expanded) flipped it stable.
-		//
-		// Renderers whose partial-result chrome (header glyph, frame state)
-		// differs from the final result render set `provisionalPartialResult`
-		// to opt out of stream-commit while `isPartial` holds: the ratchet
-		// would otherwise promote the stable partial chrome to native scrollback
-		// after `STABLE_PREFIX_COMMIT_FRAMES` and leave it stranded above the
-		// final frame once the chrome flips. Once the result settles
-		// (`isPartial === false`) the block is commit-stable again.
-		if (this.#result !== undefined) {
-			if (this.#isPartial) {
-				const tool = this.#tool as { provisionalPartialResult?: boolean } | undefined;
-				const provisionalPartialResult =
-					tool?.provisionalPartialResult ?? toolRenderers[this.#toolName]?.provisionalPartialResult;
-				if (provisionalPartialResult) return false;
-			}
-			return true;
-		}
-		const tool = this.#tool as { provisionalPendingPreview?: boolean | "collapsed" } | undefined;
-		const provisionalPendingPreview =
-			tool?.provisionalPendingPreview ?? toolRenderers[this.#toolName]?.provisionalPendingPreview;
-		return provisionalPendingPreview !== true && (provisionalPendingPreview !== "collapsed" || this.#expanded);
-	}
-
 	/**
 	 * Mark the tool terminal even though no result arrived (the turn aborted or
 	 * abandoned it) and stop animating, so it can freeze and stops pinning the