@oh-my-pi/pi-coding-agent 15.11.4 → 15.11.7

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

@@ -4,12 +4,12 @@ import {
 	type Component,
 	Container,
 	extractPrintableText,
-	fuzzyFilter,
+	fuzzyRank,
 	getKeybindings,
 	getSettingItemFilterText,
+	type ImageBudget,
 	Input,
 	matchesKey,
-	padding,
 	parseSgrMouse,
 	type SelectItem,
 	SelectList,
@@ -23,6 +23,7 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import type { ShapeTarget } from "@oh-my-pi/snapcompact";
 import { getDefault, type SettingPath, settings } from "../../config/settings";
 import type {
 	SettingTab,
@@ -37,6 +38,7 @@ import { getTabBarTheme } from "../shared";
 import { bottomBorder, divider, row, topBorder } from "./overlay-box";
 import { handleInputOrEscape, PluginSettingsComponent } from "./plugin-settings";
 import { getSettingDef, getSettingsForTab, type SettingDef } from "./settings-defs";
+import { SnapcompactShapePreview } from "./snapcompact-shape-preview";
 import { getPreset } from "./status-line/presets";
 
 /**
@@ -68,8 +70,6 @@ class TextInputSubmenu extends Container {
 		this.#input = new Input();
 		if (currentValue) {
 			this.#input.setValue(currentValue);
-			// Move cursor to end of pre-filled value (ctrl+e = cursorLineEnd).
-			this.#input.handleInput("\x05");
 		}
 		this.#input.onSubmit = value => {
 			this.onSubmit(value); // empty string clears the setting
@@ -100,6 +100,7 @@ class SelectSubmenu extends Container {
 		onCancel: () => void,
 		onSelectionChange?: (value: string) => void | Promise<void>,
 		private readonly getPreview?: () => string,
+		footer?: Component,
 	) {
 		super();
 
@@ -161,6 +162,13 @@ class SelectSubmenu extends Container {
 		// Hint
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.fg("dim", "  Enter to select · Esc to go back"), 0, 0));
+
+		// Footer (e.g. the snapcompact shape preview) below the interactive rows,
+		// so the list never shifts while browsing.
+		if (footer) {
+			this.addChild(new Spacer(1));
+			this.addChild(footer);
+		}
 	}
 
 	#updatePreview(): void {
@@ -252,6 +260,12 @@ export interface SettingsRuntimeContext {
 	availableThemes: string[];
 	/** Working directory for plugins tab */
 	cwd: string;
+	/** Active model (api + id); resolves what the snapcompact `auto` shape maps to. */
+	model?: ShapeTarget;
+	/** Shared TUI image budget (graphics ids + transmit-once) for image previews. */
+	imageBudget?: ImageBudget;
+	/** Schedules a re-render after async preview work completes. */
+	requestRender?: () => void;
 }
 
 /** Status line settings subset for preview */
@@ -291,6 +305,8 @@ export class SettingsSelectorComponent implements Component {
 	#currentTabId: SettingTab | "plugins" = "appearance";
 	#preSearchTabId: SettingTab | "plugins" = "appearance";
 	#searchQuery = "";
+	/** Single-line editor backing the search banner (cursor, word ops, paste). */
+	#searchInput = new Input();
 	#searchMatchCount = 0;
 	/** First matching item id per tab id, for Tab-key jumps while searching. */
 	#searchFirstMatch = new Map<string, string>();
@@ -354,7 +370,7 @@ export class SettingsSelectorComponent implements Component {
 
 	#footerHintText(): string {
 		if (this.#searchList) {
-			return "Enter/Space to change · Tab to jump tabs · Backspace to edit · Esc to exit search";
+			return "Enter to change · Tab to jump tabs · Esc to exit search";
 		}
 		if (this.#currentTabId === "plugins") {
 			return "Tab to switch tabs · Esc to close";
@@ -366,28 +382,17 @@ export class SettingsSelectorComponent implements Component {
 		return `Enter/Space to change · ${nav} · Type to search · Esc to close`;
 	}
 
-	/** Single-line search banner: accent icon, bold query + caret, right-aligned match count. */
+	/** Single-line search banner: accent icon, editable query with live cursor, right-aligned match count. */
 	#renderSearchBanner(width: number): string {
 		const icon = theme.symbol("icon.search");
 		const countText = this.#searchMatchCount === 1 ? "1 match" : `${this.#searchMatchCount} matches`;
 		const rightWidth = visibleWidth(countText) + 1; // trailing margin
-		// Fixed chrome: " <icon> " prefix plus the "▌" cursor cell.
-		const queryBudget = Math.max(4, width - visibleWidth(icon) - 4 - rightWidth - 1);
-
-		// Keep the tail visible (where the cursor is) when the query overflows.
-		let display = this.#searchQuery;
-		if (visibleWidth(display) > queryBudget) {
-			const chars = [...display];
-			while (chars.length > 1 && visibleWidth(chars.join("")) > queryBudget - 1) {
-				chars.shift();
-			}
-			display = `…${chars.join("")}`;
-		}
-
-		const left = ` ${theme.fg("accent", icon)} ${theme.bold(display)}${theme.fg("accent", "▌")}`;
+		const prefix = ` ${theme.fg("accent", icon)} `;
+		// The input pads itself to exactly this width and keeps the cursor in view.
+		const inputWidth = Math.max(4, width - visibleWidth(prefix) - rightWidth - 1);
+		const inputLine = this.#searchInput.render(inputWidth)[0] ?? "";
 		const count = theme.fg(this.#searchMatchCount > 0 ? "dim" : "warning", countText);
-		const gap = Math.max(1, width - visibleWidth(left) - rightWidth);
-		return truncateToWidth(`${left}${padding(gap)}${count} `, width);
+		return truncateToWidth(`${prefix}${theme.bold(inputLine)} ${count} `, width);
 	}
 
 	/**
@@ -511,6 +516,9 @@ export class SettingsSelectorComponent implements Component {
 	/** Swap the tab content for the global search result list. */
 	#startSearch(initialQuery: string): void {
 		this.#preSearchTabId = this.#currentTabId;
+		this.#searchInput = new Input();
+		this.#searchInput.prompt = "";
+		this.#searchInput.setValue(initialQuery);
 		const list = new SettingsList(
 			[],
 			10,
@@ -547,6 +555,7 @@ export class SettingsSelectorComponent implements Component {
 
 		const counts = new Map<SettingTab, number>();
 		const items: SettingItem[] = [];
+		const tabResults: { tab: SettingTab; matched: SettingItem[]; bestScore: number; order: number }[] = [];
 		this.#searchFirstMatch.clear();
 		let total = 0;
 		for (const tab of SETTING_TABS) {
@@ -555,24 +564,40 @@ export class SettingsSelectorComponent implements Component {
 				const item = this.#defToItem(def);
 				if (item) candidates.push(item);
 			}
-			const matched = fuzzyFilter(candidates, query, getSettingItemFilterText);
+			const ranked = fuzzyRank(candidates, query, getSettingItemFilterText);
+			const matched = ranked.map(result => result.item);
 			counts.set(tab, matched.length);
 			if (matched.length === 0) continue;
 			total += matched.length;
-			const meta = TAB_METADATA[tab];
+			tabResults.push({
+				tab,
+				matched,
+				bestScore: ranked[0]?.score ?? 0,
+				order: SETTING_TABS.indexOf(tab),
+			});
+		}
+
+		tabResults.sort((a, b) => a.bestScore - b.bestScore || a.order - b.order);
+		for (const result of tabResults) {
+			const meta = TAB_METADATA[result.tab];
 			items.push({
-				id: `__tab:${tab}`,
+				id: `__tab:${result.tab}`,
 				label: `${theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0])} ${meta.label}`,
 				currentValue: "",
 				heading: true,
 			});
-			this.#searchFirstMatch.set(tab, matched[0].id);
-			items.push(...matched);
+			this.#searchFirstMatch.set(result.tab, result.matched[0]?.id ?? "");
+			items.push(...result.matched);
 		}
 
 		this.#searchList.setItems(items);
 		this.#searchMatchCount = total;
-		this.#tabBar.setTabs(this.#buildSearchTabs(counts));
+		this.#tabBar.setTabs(
+			this.#buildSearchTabs(
+				counts,
+				tabResults.map(result => result.tab),
+			),
+		);
 		this.#syncTabBarToSelection(this.#searchList.getSelectedItem());
 	}
 
@@ -597,20 +622,25 @@ export class SettingsSelectorComponent implements Component {
 		}
 	}
 
-	/** Matching tabs first (counts attached), the rest muted at the end. */
-	#buildSearchTabs(counts: Map<SettingTab, number>): Tab[] {
+	/** Matching tabs first (counts attached), ordered by best result score; the rest stay muted at the end. */
+	#buildSearchTabs(counts: Map<SettingTab, number>, matchedTabOrder: readonly SettingTab[]): Tab[] {
 		const matched: Tab[] = [];
 		const empty: Tab[] = [];
-		for (const id of SETTING_TABS) {
+		const matchedIds = new Set<SettingTab>(matchedTabOrder);
+		for (const id of matchedTabOrder) {
 			const meta = TAB_METADATA[id];
 			const icon = theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0]);
 			const count = counts.get(id) ?? 0;
 			if (count > 0) {
 				matched.push({ id, label: `${icon} ${meta.label} (${count})`, short: `${icon} ${count}` });
-			} else {
-				empty.push({ id, label: `${icon} ${meta.label}`, short: icon, muted: true });
 			}
 		}
+		for (const id of SETTING_TABS) {
+			if (matchedIds.has(id)) continue;
+			const meta = TAB_METADATA[id];
+			const icon = theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0]);
+			empty.push({ id, label: `${icon} ${meta.label}`, short: icon, muted: true });
+		}
 		// Plugins hosts its own UI; it is not part of the schema-backed search.
 		empty.push({ id: "plugins", label: `${theme.icon.package} Plugins`, short: theme.icon.package, muted: true });
 		return [...matched, ...empty];
@@ -745,6 +775,7 @@ export class SettingsSelectorComponent implements Component {
 		// Preview handlers
 		let onPreview: ((value: string) => void | Promise<void>) | undefined;
 		let onPreviewCancel: (() => void) | undefined;
+		let footer: Component | undefined;
 
 		const activeThemeBeforePreview = getCurrentThemeName() ?? currentValue;
 		if (def.path === "theme.dark" || def.path === "theme.light") {
@@ -784,6 +815,14 @@ export class SettingsSelectorComponent implements Component {
 				const separator = settings.get("statusLine.separator");
 				this.callbacks.onStatusLinePreview?.({ separator });
 			};
+		} else if (def.path === "snapcompact.shape") {
+			const shapePreview = new SnapcompactShapePreview(currentValue, {
+				model: this.context.model,
+				imageBudget: this.context.imageBudget,
+				requestRender: this.context.requestRender,
+			});
+			onPreview = value => shapePreview.setValue(value);
+			footer = shapePreview;
 		}
 
 		// Provide status line preview for theme selection
@@ -806,6 +845,7 @@ export class SettingsSelectorComponent implements Component {
 			},
 			onPreview,
 			getPreview,
+			footer,
 		);
 	}
 
@@ -1029,25 +1069,27 @@ export class SettingsSelectorComponent implements Component {
 			this.#endSearch(true);
 			return;
 		}
-		if (kb.matches(data, "tui.editor.deleteCharBackward")) {
-			this.#setSearchQuery([...this.#searchQuery].slice(0, -1).join(""));
-			return;
-		}
-		if (
-			matchesKey(data, "tab") ||
-			matchesKey(data, "shift+tab") ||
-			matchesKey(data, "left") ||
-			matchesKey(data, "right")
-		) {
+		if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
 			// Jump between tabs that have matches (muted tabs are skipped).
 			this.#tabBar.handleInput(data);
 			return;
 		}
-		const printable = extractPrintableText(data);
-		if (printable !== undefined) {
-			this.#setSearchQuery(this.#searchQuery + printable);
+		// Selection, paging, and activation stay with the result list.
+		if (
+			kb.matches(data, "tui.select.up") ||
+			kb.matches(data, "tui.select.down") ||
+			kb.matches(data, "tui.select.pageUp") ||
+			kb.matches(data, "tui.select.pageDown") ||
+			kb.matches(data, "tui.select.confirm") ||
+			data === "\n"
+		) {
+			list.handleInput(data);
 			return;
 		}
-		list.handleInput(data);
+		// Everything else edits the query like a regular single-line editor:
+		// cursor movement, word ops, kill ring, undo, paste.
+		this.#searchInput.handleInput(data);
+		const value = this.#searchInput.getValue();
+		if (value !== this.#searchQuery) this.#setSearchQuery(value);
 	}
 }

package/src/modes/components/snapcompact-shape-preview-doc.md

@@ -0,0 +1,11 @@
+[User]: Fix the settings overlay crash. Wheeling past the last row throws.
+
+[Assistant tool calls]: read(path="src/select-list.ts:140-180")
+
+[Tool result]: 162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
+
+[Assistant]: Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
+
+[User]: Does the fix survive filtering?
+
+[Assistant]: Yes. The clamp applies after the filter pass, so a narrowed list keeps the hit map in sync. Added a regression test that wheels past the last row with a filter active and asserts no throw.

package/src/modes/components/snapcompact-shape-preview.ts

@@ -0,0 +1,192 @@
+/**
+ * Live preview for the `snapcompact.shape` setting: renders a sample session
+ * transcript through the real snapcompact rasterizer as a miniature page and
+ * shows it zoomed, so cell size, ink hues, highlight bands, and dim tool-result
+ * spans are legible at terminal scale.
+ *
+ * The mini-frame (a {@link SRC_FRAME_PX}px page) is upscaled with
+ * nearest-neighbor so the glyph pixels stay crisp when the terminal scales the
+ * placement box. Graphics display requires the Kitty unicode-placeholder path —
+ * `renderImage` returning `lines` is the gate — because the bordered settings
+ * frame re-fits every row, which direct cursor-positioned placements (iTerm2,
+ * Sixel, Kitty `a=p`) do not survive. Everything else falls back to the stats
+ * line plus a dim notice.
+ */
+import { type Component, type ImageBudget, renderImage, TERMINAL } from "@oh-my-pi/pi-tui";
+import {
+	DIM_OFF,
+	DIM_ON,
+	geometry,
+	isShapeVariantName,
+	normalize,
+	renderMany,
+	resolveShape,
+	SHAPE_VARIANT_NAMES,
+	SHAPE_VARIANTS,
+	type Shape,
+	type ShapeTarget,
+	type ShapeVariantName,
+} from "@oh-my-pi/snapcompact";
+import { theme } from "../theme/theme";
+import sampleDoc from "./snapcompact-shape-preview-doc.md" with { type: "text" };
+
+/** Mini-frame edge in px — a small page from the real rasterizer ≈ a zoomed crop. */
+const SRC_FRAME_PX = 128;
+/** Nearest-neighbor upscale factor; keeps glyph pixels crisp on HiDPI cell boxes. */
+const ZOOM_SCALE = 4;
+/** Display box in terminal cells (square-ish at the typical 1:2 cell aspect). */
+const MAX_IMAGE_COLS = 28;
+const MAX_IMAGE_ROWS = 14;
+
+/** Sample transcript with `[Tool result]:` bodies wrapped in dim-ink toggles. */
+const PREVIEW_TEXT = sampleDoc
+	.trim()
+	.replace(/\[Tool result\]: ([^[]*)/g, (_match, body: string) => `[Tool result]: ${DIM_ON}${body}${DIM_OFF}`);
+
+type PreviewEntry =
+	| { state: "rendering" }
+	| { state: "failed" }
+	| { state: "ready"; data: string; edgePx: number; imageId: number; transmitted: boolean };
+
+export interface SnapcompactShapePreviewOptions {
+	/** Active model (api + id); resolves what `auto` maps to for this reader. */
+	model?: ShapeTarget;
+	/** Shared TUI image budget: stable graphics ids, transmit-once, exit cleanup. */
+	imageBudget?: ImageBudget;
+	/** Schedules a re-render once an async sample render completes. */
+	requestRender?: () => void;
+}
+
+export class SnapcompactShapePreview implements Component {
+	#model: ShapeTarget | undefined;
+	#budget: ImageBudget | undefined;
+	#requestRender: () => void;
+	#variant: ShapeVariantName | "auto" = "auto";
+	#entries = new Map<ShapeVariantName, PreviewEntry>();
+
+	constructor(currentValue: string, options: SnapcompactShapePreviewOptions = {}) {
+		this.#model = options.model;
+		this.#budget = options.imageBudget;
+		this.#requestRender = options.requestRender ?? (() => {});
+		this.setValue(currentValue);
+	}
+
+	/** Track the highlighted option; the next render reflects it. */
+	setValue(value: string): void {
+		this.#variant = isShapeVariantName(value) ? value : "auto";
+	}
+
+	render(width: number): readonly string[] {
+		const shape = resolveShape(this.#model, this.#variant);
+		const name = resolvedVariantName(shape);
+		const geo = geometry(shape);
+		const label = this.#variant === "auto" ? `auto → ${name}` : name;
+		const chars = geo.capacity >= 1000 ? `${(geo.capacity / 1000).toFixed(1)}k` : String(geo.capacity);
+		const tokens =
+			shape.frameTokenEstimate >= 1000
+				? `${(shape.frameTokenEstimate / 1000).toFixed(1)}k`
+				: String(shape.frameTokenEstimate);
+		const stats = `full frame ${geo.cols}×${geo.rows} cells ≈ ${chars} chars ≈ ${tokens} tokens`;
+		const lines: string[] = [theme.fg("muted", `  Sample (zoomed) · ${label} · ${stats}`), ""];
+
+		if (!this.#budget || !TERMINAL.imageProtocol) {
+			lines.push(theme.fg("dim", "  (graphic sample needs a Kitty-graphics terminal)"));
+			return lines;
+		}
+
+		const entry = this.#ensureEntry(name, shape);
+		if (entry.state === "rendering") {
+			lines.push(theme.fg("dim", "  rendering sample…"));
+			return lines;
+		}
+		if (entry.state === "failed") {
+			lines.push(theme.fg("dim", "  (sample render failed)"));
+			return lines;
+		}
+
+		const result = renderImage(
+			entry.data,
+			{ widthPx: entry.edgePx, heightPx: entry.edgePx },
+			{
+				maxWidthCells: Math.max(8, Math.min(MAX_IMAGE_COLS, width - 4)),
+				maxHeightCells: MAX_IMAGE_ROWS,
+				imageId: entry.imageId,
+				includeTransmit: !entry.transmitted,
+			},
+		);
+		// Only the unicode-placeholder path returns text-cell `lines`; cursor-moving
+		// placements would corrupt the bordered settings frame, so skip them.
+		if (!result?.lines) {
+			lines.push(theme.fg("dim", "  (graphic sample needs Kitty unicode-placeholder graphics)"));
+			return lines;
+		}
+		if (result.transmit) {
+			this.#budget.enqueueTransmit(entry.imageId, result.transmit);
+			entry.transmitted = true;
+		}
+		for (const line of result.lines) {
+			lines.push(`  ${line}`);
+		}
+		return lines;
+	}
+
+	#ensureEntry(name: ShapeVariantName, shape: Shape): PreviewEntry {
+		let entry = this.#entries.get(name);
+		if (!entry) {
+			entry = { state: "rendering" };
+			this.#entries.set(name, entry);
+			void this.#buildEntry(name, shape);
+		}
+		return entry;
+	}
+
+	async #buildEntry(name: ShapeVariantName, shape: Shape): Promise<void> {
+		try {
+			// Fill the mini-page so every variant shows a fully inked window.
+			const capacity = geometry(shape, SRC_FRAME_PX).capacity;
+			let text = PREVIEW_TEXT;
+			while (normalize(text).length < capacity) {
+				text += ` ${PREVIEW_TEXT}`;
+			}
+			const frame = renderMany(text, { shape, frameSize: SRC_FRAME_PX, maxFrames: 1 })[0];
+			if (!frame) throw new Error("empty sample frame");
+			const edgePx = SRC_FRAME_PX * ZOOM_SCALE;
+			const zoomed = await new Bun.Image(Buffer.from(frame.data, "base64"))
+				.resize(edgePx, edgePx, { filter: "nearest" })
+				.png()
+				.bytes();
+			this.#entries.set(name, {
+				state: "ready",
+				data: zoomed.toBase64(),
+				edgePx,
+				// Keyed id: reopening settings reuses the id, so data already in the
+				// terminal store is never re-transmitted (enqueueTransmit no-ops).
+				imageId: this.#budget?.acquireId(`snapshape:${name}:${edgePx}`) ?? 0,
+				transmitted: false,
+			});
+		} catch {
+			this.#entries.set(name, { state: "failed" });
+		}
+		this.#requestRender();
+	}
+}
+
+/** Research name of the concrete geometry `resolveShape` picked (for `auto`). */
+function resolvedVariantName(shape: Shape): ShapeVariantName {
+	for (const name of SHAPE_VARIANT_NAMES) {
+		const candidate = SHAPE_VARIANTS[name];
+		if (
+			candidate.font === shape.font &&
+			candidate.cellWidth === shape.cellWidth &&
+			candidate.cellHeight === shape.cellHeight &&
+			candidate.variant === shape.variant &&
+			candidate.lineRepeat === shape.lineRepeat &&
+			candidate.frameSize === shape.frameSize
+		) {
+			return name;
+		}
+	}
+	// resolveShape only hands out table geometries; the legacy shape is the
+	// conservative label if that invariant ever changes.
+	return "5x8-sent";
+}

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

@@ -589,6 +589,32 @@ export class ToolExecutionComponent extends Container {
 		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`). Classification is
+	 * per renderer (`ToolRenderer.provisionalPendingPreview`): tail-window
+	 * streaming views (edit's streamed-diff tail, bash/ssh command caps, eval
+	 * cells) are re-anchored top-first by the result render, so promoting
+	 * their visually static head — e.g. an edit preview idling on its last
+	 * frame while the apply + LSP pass runs — would strand a stale copy of
+	 * the call box above the final block the moment the result lands. Every
+	 * other pending preview streams top-anchored append-shaped rows the
+	 * result render preserves (a task call's context/assignment markdown, a
+	 * write's content), so it stays commit-eligible — a call taller than the
+	 * viewport scrolls into native history mid-stream instead of reading as
+	 * cut off until the result. Expanded blocks always stream top-anchored
+	 * (the over-tall write/eval scrollback contract). Displaceable waiting
+	 * polls are removed wholesale by the next poll and must never commit.
+	 */
+	isTranscriptBlockCommitStable(): boolean {
+		if (this.#displaceable) return false;
+		if (this.#expanded || this.isTranscriptBlockFinalized()) return true;
+		if ((this.#tool as { provisionalPendingPreview?: boolean } | undefined)?.provisionalPendingPreview) {
+			return false;
+		}
+		return !toolRenderers[this.#toolName]?.provisionalPendingPreview;
+	}
+
 	/**
 	 * 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

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

@@ -63,6 +63,19 @@ interface FinalizableBlock {
 	 * never mutate post-finalize simply omit the method.
 	 */
 	getTranscriptBlockVersion?(): number;
+	/**
+	 * Whether a still-live block's visually settled leading rows are durable —
+	 * guaranteed to survive the block's remaining transitions (finalize,
+	 * displacement) byte-stable — and may therefore be promoted as commit-safe
+	 * by {@link deriveLiveCommitState}. Blocks whose pending render is
+	 * provisional (a tool call's tail-window streaming preview, replaced
+	 * wholesale by the result render) return `false`: committing such rows
+	 * strands a stale copy in immutable terminal history the moment the real
+	 * content re-lays-out the block (the engine audit recommits below it —
+	 * "duplication, never loss"). Absent = `true`, the default for blocks
+	 * whose live rows persist (a streaming assistant message).
+	 */
+	isTranscriptBlockCommitStable?(): boolean;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -75,6 +88,11 @@ function getBlockVersion(child: Component): number | undefined {
 	return fn ? fn.call(child) : undefined;
 }
 
+function isBlockCommitStable(child: Component): boolean {
+	const fn = (child as Component & FinalizableBlock).isTranscriptBlockCommitStable;
+	return fn ? fn.call(child) : true;
+}
+
 // 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
@@ -598,7 +616,11 @@ export class TranscriptContainer
 					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
 			let liveCommitState: LiveCommitState | undefined;
-			if (i >= liveStartIndex && !finalized) {
+			// Provisional live renders (commit-unstable blocks) never feed the
+			// promotion machinery: their settled-looking rows are replaced
+			// wholesale on finalize, so offering them would commit a stale
+			// preview the result render can only duplicate, never erase.
+			if (i >= liveStartIndex && !finalized && isBlockCommitStable(child)) {
 				liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
 			}
 			// Cache the latest contribution as the next frame's diff input.

package/src/modes/controllers/command-controller.ts

@@ -456,7 +456,7 @@ export class CommandController {
 	}
 
 	handleContextCommand(): void {
-		const breakdown = computeContextBreakdown(this.ctx.session);
+		const breakdown = computeContextBreakdown(this.ctx.session, { snapcompactSavings: true });
 		if (breakdown.contextWindow <= 0) {
 			this.ctx.showWarning("Context usage is unavailable: no model is selected for this session.");
 			return;
@@ -1528,6 +1528,29 @@ function renderUsageReports(
 			lines.push(`  ${uiTheme.fg("accent", "in use by this session:")} ${activeAccountLabel}`);
 		}
 
+		const resetAccountLines: string[] = [];
+		for (const report of providerReports) {
+			const count = report.resetCredits?.availableCount ?? 0;
+			if (count <= 0) continue;
+			const label =
+				(report.metadata?.email as string | undefined) ??
+				(report.metadata?.accountId as string | undefined) ??
+				"account";
+			const isActive =
+				!!activeAccount &&
+				((!!activeAccount.accountId && activeAccount.accountId === report.metadata?.accountId) ||
+					(!!activeAccount.email && activeAccount.email === report.metadata?.email));
+			resetAccountLines.push(
+				`    • ${label}: ${count} saved reset${count === 1 ? "" : "s"}${isActive ? " (active)" : ""}`,
+			);
+		}
+		if (resetAccountLines.length > 0) {
+			lines.push(
+				`  ${uiTheme.fg("accent", "Saved rate-limit resets")} ${uiTheme.fg("dim", "(/usage reset to spend)")}`,
+			);
+			for (const line of resetAccountLines) lines.push(uiTheme.fg("dim", line));
+		}
+
 		const renderableGroups = Array.from(limitGroups.values()).map(group => {
 			const entries = group.limits.map((limit, index) => ({
 				limit,

package/src/modes/controllers/input-controller.ts

@@ -4,6 +4,7 @@ import type { AutocompleteProvider, SlashCommand } from "@oh-my-pi/pi-tui";
 import { $env, logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import { getRoleInfo } from "../../config/model-roles";
 import { isSettingsInitialized, settings } from "../../config/settings";
+import { AssistantMessageComponent } from "../../modes/components/assistant-message";
 import { renderSegmentTrack } from "../../modes/components/segment-track";
 import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-title-download-progress";
 import { expandEmoticons } from "../../modes/emoji-autocomplete";
@@ -1039,18 +1040,19 @@ export class InputController {
 
 	toggleThinkingBlockVisibility(): void {
 		this.ctx.hideThinkingBlock = !this.ctx.hideThinkingBlock;
-		settings.set("hideThinkingBlock", this.ctx.hideThinkingBlock);
+		this.ctx.settings.set("hideThinkingBlock", this.ctx.hideThinkingBlock);
 		this.ctx.session.agent.hideThinkingSummary = this.ctx.hideThinkingBlock;
 
-		// Rebuild chat from session messages
-		this.ctx.chatContainer.clear();
-		this.ctx.rebuildChatFromMessages();
+		for (const child of this.ctx.chatContainer.children) {
+			if (child instanceof AssistantMessageComponent) {
+				child.setHideThinkingBlock(this.ctx.hideThinkingBlock);
+				child.invalidate();
+			}
+		}
 
-		// If streaming, re-add the streaming component with updated visibility and re-render
 		if (this.ctx.streamingComponent && this.ctx.streamingMessage) {
 			this.ctx.streamingComponent.setHideThinkingBlock(this.ctx.hideThinkingBlock);
 			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
-			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
 		}
 
 		this.ctx.showStatus(`Thinking blocks: ${this.ctx.hideThinkingBlock ? "hidden" : "visible"}`);