@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.1

package/src/modes/components/transcript-container.ts

@@ -1,12 +1,18 @@
-import { type Component, Container, type NativeScrollbackLiveRegion, type RenderStablePrefix } from "@oh-my-pi/pi-tui";
+import {
+	type Component,
+	Container,
+	type NativeScrollbackCommittedRows,
+	type NativeScrollbackLiveRegion,
+	type RenderStablePrefix,
+} from "@oh-my-pi/pi-tui";
 
 const kSnapshot = Symbol("transcript.liveDiffSnapshot");
 
 /**
- * Per-block diff cache: the block's previous stripped contribution plus the
- * derived append-only state. Purely an input to {@link deriveLiveCommitState}
- * for still-live blocks — it is never replayed as render output. Every block
- * renders its current content on every frame.
+ * Per-block render cache: the block's previous stripped contribution plus the
+ * derived append-only state. Still-live blocks use it as input to
+ * {@link deriveLiveCommitState}; finalized blocks wholly inside already
+ * committed native scrollback can replay it without calling render().
  */
 interface LiveDiffSnapshot {
 	width: number;
@@ -47,6 +53,16 @@ interface SnapshotCarrier {
  */
 interface FinalizableBlock {
 	isTranscriptBlockFinalized?(): boolean;
+	/**
+	 * Monotonic content version for blocks that can still mutate *after*
+	 * reporting finalized (e.g. `AssistantMessageComponent`: the inline error
+	 * restored at the next turn's `agent_start`, late tool-result images). The
+	 * committed-scrollback render bypass only replays a block's previous rows
+	 * when the version is unchanged; without this signal a post-finalize
+	 * mutation would stay invisible until a global invalidation. Blocks that
+	 * never mutate post-finalize simply omit the method.
+	 */
+	getTranscriptBlockVersion?(): number;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -54,6 +70,11 @@ function isBlockFinalized(child: Component): boolean {
 	return fn ? fn.call(child) : true;
 }
 
+function getBlockVersion(child: Component): number | undefined {
+	const fn = (child as Component & FinalizableBlock).getTranscriptBlockVersion;
+	return fn ? fn.call(child) : undefined;
+}
+
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -87,11 +108,16 @@ interface BlockSegment {
 	rawRef: readonly string[];
 	contribution: readonly string[];
 	width: number;
+	generation: number;
 	/** Frame row of this block's first emitted row (the separator when present). */
 	startRow: number;
 	/** Rows emitted: separator + contribution (0 for empty contributions). */
 	rowCount: number;
 	sep: number;
+	/** Whether the block reported finalized when this segment was rendered. */
+	finalized: boolean;
+	/** Block version observed when this segment was rendered (see {@link FinalizableBlock}). */
+	version: number | undefined;
 }
 
 const EMPTY_SEGMENTS: BlockSegment[] = [];
@@ -369,7 +395,10 @@ function deriveLiveCommitState(
  * through {@link RenderStablePrefix} so the engine can skip marker scanning,
  * line preparation, and the committed-prefix audit for those rows.
  */
-export class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, RenderStablePrefix {
+export class TranscriptContainer
+	extends Container
+	implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix
+{
 	// Bumped to retire every block's diff snapshot at once (theme change /
 	// clear); a snapshot is only honored when its stored generation matches.
 	#generation = 0;
@@ -390,6 +419,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	#lines: string[] = [];
 	#segments: BlockSegment[] = EMPTY_SEGMENTS;
 	#renderWidth = -1;
+	// Local rows already committed to native scrollback by the previous frame.
+	// Finalized blocks wholly before this boundary are immutable on-screen history;
+	// their previous contribution can be replayed without calling render().
+	#committedRows = 0;
 	// Stable-prefix floor accumulated across renders since the last
 	// getRenderStablePrefixRows() read (see RenderStablePrefix: reading
 	// consumes the report and re-bases the baseline). Out-of-band renders
@@ -407,6 +440,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 		super.clear();
 	}
 
+	setNativeScrollbackCommittedRows(rows: number): void {
+		this.#committedRows = Number.isFinite(rows) ? Math.max(0, Math.trunc(rows)) : 0;
+	}
+
 	getRenderStablePrefixRows(): number {
 		const value = Math.min(this.#stableRowsFloor, this.#lines.length);
 		this.#stableRowsFloor = this.#lines.length;
@@ -497,21 +534,43 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 
 			// This child's contribution: its current render with plain-blank
 			// top/bottom edges stripped (the container owns inter-block gaps).
-			// Always the latest content — committed history keeps whatever bytes
-			// it was written with, but the window must reflect the present state
-			// (late tool results, post-finalize re-layouts, expand toggles).
-			// A block whose render returned the same array reference reuses the
-			// previously stripped contribution (same ref ⇒ identical rows).
+			// Finalized blocks wholly inside committed native scrollback can reuse
+			// their previous contribution without calling render(): those rows are
+			// immutable terminal history for the current width/generation. Blocks
+			// outside committed history still render normally so late results,
+			// post-finalize re-layouts, and expand toggles remain visible.
 			const previousSnapshot = child[kSnapshot];
-			const raw = child.render(width);
 			const previous = previousSegments[i];
-			const reusable =
+			const finalized = isBlockFinalized(child);
+			const version = getBlockVersion(child);
+			const committedReusable =
 				previous !== undefined &&
 				previous.component === child &&
-				previous.rawRef === raw &&
-				previous.width === width;
+				previous.width === width &&
+				previous.generation === this.#generation &&
+				previous.startRow === row &&
+				previous.startRow + previous.rowCount <= this.#committedRows &&
+				finalized &&
+				// Only replay bytes that were themselves produced by a finalized
+				// render: a block finalizing between frames may have changed content
+				// while its rows were already committed via the append-only live
+				// path, so the first post-transition frame must render. Defense in
+				// depth on the transcript side — the TUI commit policy should keep
+				// that window closed, but the safety must not live there alone.
+				previous.finalized &&
+				// Post-finalize mutations (inline error restore, late tool images)
+				// bump the block version; a mismatch forces a real render so the
+				// committed-prefix audit can observe and re-anchor the change.
+				previous.version === version;
+			const raw = committedReusable ? previous.rawRef : child.render(width);
+			const reusable =
+				committedReusable ||
+				(previous !== undefined &&
+					previous.component === child &&
+					previous.rawRef === raw &&
+					previous.width === width &&
+					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
-			const finalized = isBlockFinalized(child);
 			let liveCommitState: LiveCommitState | undefined;
 			if (i >= liveStartIndex && !finalized) {
 				liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
@@ -540,7 +599,18 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 					lines.length = row;
 				}
 				if (chainStable) stableRows = row;
-				segments[i] = { component: child, rawRef: raw, contribution, width, startRow: row, rowCount: 0, sep: 0 };
+				segments[i] = {
+					component: child,
+					rawRef: raw,
+					contribution,
+					width,
+					generation: this.#generation,
+					startRow: row,
+					rowCount: 0,
+					sep: 0,
+					finalized,
+					version,
+				};
 				continue;
 			}
 
@@ -584,7 +654,18 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 				if (!(finalized && safeLength >= contribution.length)) commitSafeOpen = false;
 			}
 
-			segments[i] = { component: child, rawRef: raw, contribution, width, startRow: row, rowCount, sep };
+			segments[i] = {
+				component: child,
+				rawRef: raw,
+				contribution,
+				width,
+				generation: this.#generation,
+				startRow: row,
+				rowCount,
+				sep,
+				finalized,
+				version,
+			};
 			row += rowCount;
 		}
 		// Trailing shrink: blocks removed from the tail leave stale rows behind

package/src/modes/components/tree-selector.ts

@@ -518,6 +518,7 @@ class TreeList implements Component {
 			const renderedIndent = Math.min(displayIndent, maxIndentLevels);
 			const scrollOffset = displayIndent - renderedIndent;
 			const connectorPositionDisplay = hasConnector ? renderedIndent - 1 : -1;
+			const chainGutter = !hasConnector ? flatNode.gutters[flatNode.gutters.length - 1] : undefined;
 
 			// Build prefix char by char, placing gutters and connector at their positions
 			const totalChars = renderedIndent * 3;
@@ -530,8 +531,12 @@ class TreeList implements Component {
 				// Check if there's a gutter at this level (translated to original tree depth)
 				const gutter = flatNode.gutters.find(g => g.position === originalLevel);
 				if (gutter) {
+					// Chain rows (no connector of their own) extend only their
+					// nearest connector gutter so the flattened conversation flow
+					// stays anchored without reviving unrelated `└─` ancestors (#2298).
+					const showVertical = gutter.show || gutter === chainGutter;
 					if (posInLevel === 0) {
-						prefixChars.push(gutter.show ? theme.tree.vertical : " ");
+						prefixChars.push(showVertical ? theme.tree.vertical : " ");
 					} else {
 						prefixChars.push(" ");
 					}

package/src/modes/components/ttsr-notification.ts

@@ -2,16 +2,24 @@ import { Box, Container, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { Rule } from "../../capability/rule";
 import { theme } from "../../modes/theme/theme";
 
+/** Collapsed view shows at most this many rules before eliding the rest. */
+const MAX_COLLAPSED_RULES = 4;
+
 /**
  * Component that renders a TTSR (Time Traveling Stream Rules) notification.
  * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
  */
 export class TtsrNotificationComponent extends Container {
 	#box: Box;
 	#expanded = false;
+	#rules: Rule[];
 
-	constructor(private readonly rules: Rule[]) {
+	constructor(rules: Rule[]) {
 		super();
+		this.#rules = [...rules];
 
 		this.addChild(new Spacer(1));
 
@@ -22,6 +30,17 @@ export class TtsrNotificationComponent extends Container {
 		this.#rebuild();
 	}
 
+	/** Merge additional rules into this block (deduped by rule name). */
+	addRules(rules: Rule[]): void {
+		let changed = false;
+		for (const rule of rules) {
+			if (this.#rules.some(existing => existing.name === rule.name)) continue;
+			this.#rules.push(rule);
+			changed = true;
+		}
+		if (changed) this.#rebuild();
+	}
+
 	setExpanded(expanded: boolean): void {
 		if (this.#expanded !== expanded) {
 			this.#expanded = expanded;
@@ -35,46 +54,69 @@ export class TtsrNotificationComponent extends Container {
 
 	#rebuild(): void {
 		this.#box.clear();
+		// fg colors conflict with inverse, so styling inside the block is limited
+		// to bold (names) and italic (descriptions).
+		if (this.#rules.length === 1) {
+			this.#rebuildSingle(this.#rules[0]!);
+		} else {
+			this.#rebuildMulti();
+		}
+	}
 
-		// Build header: warning symbol + rule name + rewind icon
-		const ruleNames = this.rules.map(r => theme.bold(r.name)).join(", ");
-		const label = this.rules.length === 1 ? "rule" : "rules";
-		const header = `${theme.icon.warning} Injecting ${label}: ${ruleNames}`;
+	#rebuildSingle(rule: Rule): void {
+		const header = `${theme.icon.warning} Injecting rule: ${theme.bold(rule.name)}  ${theme.icon.rewind}`;
+		this.#box.addChild(new Text(header, 0, 0));
 
-		// Create header with rewind icon on the right
-		const rewindIcon = theme.icon.rewind;
+		const desc = (rule.description || rule.content)?.trim();
+		if (!desc) return;
 
-		this.#box.addChild(new Text(`${header}  ${rewindIcon}`, 0, 0));
+		let displayText = desc;
+		let truncated = false;
+		if (!this.#expanded) {
+			const lines = desc.split("\n");
+			if (lines.length > 2) {
+				displayText = `${lines.slice(0, 2).join("\n")}…`;
+				truncated = true;
+			}
+		}
 
-		// Show description(s) - italic and truncated
-		for (const rule of this.rules) {
-			const desc = rule.description || rule.content;
-			if (desc) {
-				this.#box.addChild(new Spacer(1));
+		this.#box.addChild(new Spacer(1));
+		this.#box.addChild(new Text(theme.italic(displayText), 0, 0));
+		if (truncated) {
+			this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+		}
+	}
+
+	#rebuildMulti(): void {
+		const header = `${theme.icon.warning} Injecting ${this.#rules.length} rules:  ${theme.icon.rewind}`;
+		this.#box.addChild(new Text(header, 0, 0));
+		this.#box.addChild(new Spacer(1));
 
-				let displayText = desc.trim();
+		const visible = this.#expanded ? this.#rules : this.#rules.slice(0, MAX_COLLAPSED_RULES);
+		let elidedDetail = false;
+		for (const rule of visible) {
+			const desc = (rule.description || rule.content)?.trim();
+			let line = theme.bold(rule.name);
+			if (desc) {
+				let displayText = desc;
 				if (!this.#expanded) {
-					// Truncate to first 2 lines
-					const lines = displayText.split("\n");
-					if (lines.length > 2) {
-						displayText = `${lines.slice(0, 2).join("\n")}…`;
+					// One line per rule when collapsed; full description when expanded.
+					const newline = desc.indexOf("\n");
+					if (newline !== -1) {
+						displayText = `${desc.slice(0, newline).trimEnd()}…`;
+						elidedDetail = true;
 					}
 				}
-
-				// Use italic for subtle distinction (fg colors conflict with inverse)
-				this.#box.addChild(new Text(theme.italic(displayText), 0, 0));
+				line += `: ${theme.italic(displayText)}`;
 			}
+			this.#box.addChild(new Text(line, 0, 0));
 		}
 
-		// Show expand hint if collapsed and there's more content
-		if (!this.#expanded) {
-			const hasMoreContent = this.rules.some(r => {
-				const desc = r.description || r.content;
-				return desc && desc.split("\n").length > 2;
-			});
-			if (hasMoreContent) {
-				this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
-			}
+		const hidden = this.#rules.length - visible.length;
+		if (hidden > 0) {
+			this.#box.addChild(new Text(theme.italic(`… +${hidden} more (ctrl+o to expand)`), 0, 0));
+		} else if (elidedDetail) {
+			this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
 		}
 	}
 }

package/src/modes/components/welcome.ts

@@ -18,14 +18,8 @@ const TIPS: readonly string[] = tipsText
 	.filter(line => line.length > 0);
 
 /**
- * Tip chosen once per process so the pre-TUI startup splash and the in-TUI
- * welcome screen show the same tip instead of shuffling on the swap.
- */
-const PROCESS_TIP: string | undefined = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : undefined;
-
-/**
- * Fixed number of session rows in the welcome box so its height doesn't shift
- * between the pre-TUI splash (loading placeholder) and the loaded state.
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
  */
 export const WELCOME_SESSION_SLOTS = 4;
 
@@ -76,10 +70,8 @@ export interface LspServerInfo {
 export class WelcomeComponent implements Component {
 	#animStart: number | null = null;
 	#animTimer: ReturnType<typeof setInterval> | null = null;
-	/** When set, a non-animating render shows the intro's first frame instead of the resting frame. */
-	#holdIntroFirstFrame = false;
-	/** Per-process tip so re-renders (intro, LSP updates, splash swap) don't shuffle it. */
-	readonly #tip: string | undefined = PROCESS_TIP;
+	/** Tip chosen once per instance so re-renders (intro, LSP updates) don't shuffle it. */
+	readonly #tip: string | undefined = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : undefined;
 	// Render cache: the welcome box is the first transcript-area component, so
 	// returning a stable array reference keeps the whole frame prefix stable.
 	// Bypassed while the intro animation runs (every frame differs).
@@ -90,7 +82,7 @@ export class WelcomeComponent implements Component {
 		private readonly version: string,
 		private modelName: string,
 		private providerName: string,
-		private recentSessions: RecentSession[] | null = [],
+		private recentSessions: RecentSession[] = [],
 		private lspServers: LspServerInfo[] = [],
 	) {}
 
@@ -99,16 +91,6 @@ export class WelcomeComponent implements Component {
 		this.#cachedLines = undefined;
 	}
 
-	/**
-	 * Freeze the logo on the intro animation's first frame. The pre-TUI startup
-	 * splash uses this so the in-TUI intro — which starts at that exact frame —
-	 * picks up seamlessly from the splash's static box.
-	 */
-	holdIntroFirstFrame(): void {
-		this.#holdIntroFirstFrame = true;
-		this.invalidate();
-	}
-
 	/**
 	 * Play a one-shot intro that sweeps the gradient through every phase
 	 * before settling on the resting frame. Safe to call multiple times —
@@ -116,7 +98,6 @@ export class WelcomeComponent implements Component {
 	 */
 	playIntro(requestRender: () => void): void {
 		this.#stopAnimation();
-		this.#holdIntroFirstFrame = false;
 		this.#animStart = performance.now();
 		requestRender();
 		this.#animTimer = setInterval(() => {
@@ -217,9 +198,7 @@ export class WelcomeComponent implements Component {
 
 		// Recent sessions content
 		const sessionLines: string[] = [];
-		if (this.recentSessions === null) {
-			sessionLines.push(` ${theme.fg("dim", "Loading…")}`);
-		} else if (this.recentSessions.length === 0) {
+		if (this.recentSessions.length === 0) {
 			sessionLines.push(` ${theme.fg("dim", "No recent sessions")}`);
 		} else {
 			// Reserve width for the bullet prefix (" • ") and the trailing " (timeAgo)"
@@ -238,7 +217,7 @@ export class WelcomeComponent implements Component {
 				);
 			}
 		}
-		// Pad to the fixed slot count so the box doesn't grow when sessions load in.
+		// Pad to the fixed slot count so the box height doesn't depend on session count.
 		while (sessionLines.length < WELCOME_SESSION_SLOTS) {
 			sessionLines.push("");
 		}
@@ -377,9 +356,9 @@ export class WelcomeComponent implements Component {
 		return str + padding(width - visLen);
 	}
 
-	/** Pick the logo frame for the current intro phase, or the resting/held frame. */
+	/** Pick the logo frame for the current intro phase, or the resting frame. */
 	#currentLogoFrame(): readonly string[] {
-		if (this.#animStart == null) return this.#holdIntroFirstFrame ? INTRO_FIRST_FRAME : REST_FRAME;
+		if (this.#animStart == null) return REST_FRAME;
 		const elapsed = performance.now() - this.#animStart;
 		if (elapsed >= INTRO_MS) return REST_FRAME;
 		return introLogoFrame(elapsed / INTRO_MS);
@@ -510,8 +489,5 @@ function introLogoFrame(progress: number): string[] {
 	return gradientLogo(PI_LOGO, phase, { strength: shineStrength, pos: shinePos });
 }
 
-/** First intro frame, cached for splash-held renders (resize re-renders reuse it). */
-const INTRO_FIRST_FRAME = introLogoFrame(0);
-
 /** Resting gradient frame, cached for re-renders outside of the intro. */
 const REST_FRAME = gradientLogo(PI_LOGO, 0);