@oh-my-pi/pi-tui 18.13.2 → 18.14.0

package/src/app-keybindings.ts

@@ -59,10 +59,13 @@ interface AppKeybindings {
 	"app.session.rename": true;
 	"app.session.delete": true;
 	"app.session.deleteNoninvasive": true;
+	"app.session.pin": true;
+	"app.session.unpin": true;
 	"app.tree.previousBranch": true;
 	"app.tree.nextBranch": true;
 	"app.plan.toggle": true;
 	"app.history.search": true;
+	"app.links.hint": true;
 	"app.stt.pushToTalk": true;
 	"app.stt.toggle": true;
 	"app.live.toggle": true;
@@ -239,6 +242,14 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+backspace",
 		description: "Delete session (non-invasive)",
 	},
+	"app.session.pin": {
+		defaultKeys: "alt+k",
+		description: "Pin the selected session in the resume picker",
+	},
+	"app.session.unpin": {
+		defaultKeys: "alt+shift+k",
+		description: "Unpin the selected session in the resume picker",
+	},
 	"app.tree.previousBranch": {
 		defaultKeys: [],
 		description: "Jump to the previous branch in /tree",
@@ -255,6 +266,10 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+r",
 		description: "Search history",
 	},
+	"app.links.hint": {
+		defaultKeys: "alt+o",
+		description: "Pick an extension link on screen by its hint tag",
+	},
 	"app.stt.pushToTalk": {
 		defaultKeys: "space",
 		description: "Hold to record speech-to-text",

package/src/apps/session-picker.ts

@@ -11,6 +11,9 @@ export interface SessionPickerHost<T extends SessionSelectorEntry = SessionSelec
 	loadPinnedIds?(): Promise<ReadonlySet<string>>;
 	loadHistoryMatcher?(): SessionHistoryMatcher;
 	deleteSession?(session: T): Promise<boolean>;
+	/** Rename the session and resolve with the title as stored, or null when it did not happen. */
+	renameSession?(session: T, title: string): Promise<string | null>;
+	setSessionPinned?(session: T, pinned: boolean): Promise<void>;
 	loadAllSessions?(): Promise<T[]>;
 }
 
@@ -21,6 +24,8 @@ export interface SessionPickerOptions<T extends SessionSelectorEntry = SessionSe
 	scopeLabel?: string | false;
 	showCwd?: boolean;
 	allowDelete?: boolean;
+	/** Rename the selected session; resolve with the title as stored, or null when it did not happen. */
+	onRename?: (session: T, title: string) => Promise<string | null>;
 	allowGlobalScope?: boolean;
 	historySearch?: boolean;
 	pinnedIds?: ReadonlySet<string>;
@@ -63,6 +68,8 @@ export async function selectSession<T extends SessionSelectorEntry>(
 				},
 				{
 					onDelete: options.allowDelete === false ? undefined : host.deleteSession,
+					onRename: options.onRename ?? host.renameSession,
+					onSetPinned: host.setSessionPinned,
 					historyMatcher,
 					loadAllSessions: options.allowGlobalScope === false ? undefined : host.loadAllSessions,
 					allSessions: options.allSessions,

package/src/charts/chart-plan.ts

@@ -33,7 +33,6 @@ import {
 	isNumber,
 	type NumberCell,
 	parseCell,
-	plainCell,
 	type Status,
 	type TableAnalysis,
 	type TableColumn,
@@ -536,20 +535,6 @@ const NEST_SEPARATORS = [" — ", " – ", ": ", " · ", ", ", " ", "/", "-", "_
 /** Where a long row name's description starts (`Payroll (10 people…)`, `@watzon — #19, #53`). */
 const DESCRIPTION = / [—–] | - |: | \(/;
 
-/**
- * Measures that improve upward, by header: pass and success rates, retrieval
- * scores, throughput, speedups and savings.
- */
-const HIGHER_BETTER =
-	/(?:^|[^\w])(?:pass(?:ed|es|ing)?|pass ?%|pass ?rate|success(?:es|ful)?|succeeded|accuracy|acc|recall|precision|prec|f1|em|exact[_ ]?match|scores?|wins?|win ?rate|hit ?rate|throughput|qps|rps|ops\/s|req\/s|tok\/s|tokens\/s|speedup|faster|improvement|savings?|saved|gain|coverage|quality|relevance|correct|solved|ok|renders|completion ?rate|uptime|performance|profits?|roi|pnl|growth|per \$|\/\$)(?![\w])/i;
-/** Measures that improve downward, by header: cost, time, failures. */
-const LOWER_BETTER =
-	/(?:^|[^\w])(?:cost|costs|price|bill|spend|usd|latency|time|duration|wall(?: ?clock)?|elapsed|errors?|err|fail(?:s|ed|ures?)?|timeouts?|miss(?:es)?|crash(?:es)?|regressions?|bugs?|warnings?|retries|turns|p\d{2}|blockers|violations|leaks?|stalls?|load|\$\/\w+)(?![\w])/i;
-/** Resources a before/after change aims to shrink: lower is better only beside a baseline. */
-const LOWER_IN_CHANGE =
-	/(?:^|[^\w])(?:tokens?|tok|rss|memory|mem|heap|allocs?|allocations?|clones|size|bytes|cpu|gc|input|output)(?![\w])/i;
-/** Names of shares and counts that describe rather than score: no polarity whatever else they say. */
-const NEUTRAL = /(?:^|[^\w])(?:share|shares|% of|portion|fraction|distribution|breakdown)(?![\w])/i;
 /** Label headers naming rival options a table compares (models, configs, arms). */
 const RIVALS =
 	/(?:^|[^\w])(?:models?|config(?:uration)?s?|arms?|variants?|approach(?:es)?|options?|plans?|polic(?:y|ies)|providers?|modes?|strateg(?:y|ies)|candidates?|settings?|shapes?|backends?|engines?|librar(?:y|ies)|implementations?|vendors?|tools?|methods?|algorithms?|setups?|runs?)(?![\w])/i;
@@ -606,13 +591,16 @@ export function planChart(table: TableAnalysis): ChartPlan | undefined {
 
 /**
  * Whether a model should pick `table`'s chart (`tui.autoGraph: smart`):
- * multi-series tables, and tables whose rows may be named by a number the
- * `guess` plots (`Thread | State`, `Finding | Current`), where only meaning
- * tells a name from a measure.
+ * multi-series tables, tables whose rows may be named by a number the
+ * `guess` plots (`Thread | State`, `Finding | Current`), and any other chart
+ * the guess would draw — only meaning tells a measure from page references,
+ * step numbers or figures quoted in prose, which the judge charts as none.
  */
 export function shouldJudge(table: TableAnalysis, guess: ChartPlan | undefined): boolean {
 	if (!guess || table.rows.length < 3) return false;
-	return table.measures.length >= 2 || leadingMeasures(table, guess).length > 0;
+	if (table.measures.length >= 2 || leadingMeasures(table, guess).length > 0) return true;
+	const spec = buildChart(table, guess);
+	return spec !== undefined && worthCharting(spec);
 }
 
 /** Measure columns before `guess`'s text label column: numbers that may only name their rows. */
@@ -696,38 +684,33 @@ export function drawnNames(spec: ChartSpec): Set<string> {
 }
 
 /**
- * The local guess at what `plan`'s rows and measures mean: header keywords
- * for each measure's {@link Polarity} (resources like tokens or memory only
- * beside a baseline), rivals from the label's header, focus from bolded or
- * `(current)` row names, and a status column whose cells vary.
+ * The local guess at what `plan`'s rows and measures mean: each measure's
+ * {@link Polarity} as far as its unit says ({@link dimPolarity}; what a name
+ * means — `Memory` as a capacity or a cost — is the judge's call), rivals from
+ * the label's header, focus from bolded or `(current)` row names, and a status
+ * column whose cells vary.
  */
 export function guessMeaning(
 	table: TableAnalysis,
 	plan: ChartPlan,
 ): Pick<ChartPlan, "polarity" | "rowPolarity" | "rivals" | "focus" | "status"> {
 	const label = plan.label === undefined ? undefined : table.columns[plan.label];
-	// A comparison of two conditions reads resources (tokens, memory) the way a change does.
+	// A comparison of two conditions reads money and sizes the way a change does: as what it cuts.
 	const change =
 		plan.kind === "change" || plan.kind === "stat" || table.columns.some(column => BEFORE.test(column.header));
 	const polarity: Record<number, Polarity> = {};
 	for (const column of table.columns) {
-		if (column === label) continue;
 		// A signed delta's sign convention (saved vs. spent) is not in its unit.
-		const delta = DELTA.test(column.header) || column.signedShare >= 0.5;
-		const guessed =
-			headerPolarity(column.header, change) ??
-			(column.role === "measure" && !delta
-				? dimPolarity(column.dim, column.unit, change, column.scores)
-				: undefined);
+		if (column === label || column.role !== "measure" || DELTA.test(column.header) || column.signedShare >= 0.5)
+			continue;
+		const guessed = dimPolarity(column.dim, column.unit, change, column.scores);
 		if (guessed) polarity[column.index] = guessed;
 	}
 	const rowPolarity: Record<number, Polarity> = {};
 	if (label && rowsAreMetrics(table, plan))
 		for (const row of [...table.rows, ...table.totals]) {
 			const first = plan.series.map(index => table.columns[index]!.cells[row]).find(isNumber);
-			const guessed =
-				headerPolarity(label.cells[row]!.text, true) ??
-				(first ? dimPolarity(first.dim, first.unit, true, false) : undefined);
+			const guessed = first && dimPolarity(first.dim, first.unit, change, false);
 			if (guessed) rowPolarity[row] = guessed;
 		}
 	return {
@@ -745,23 +728,10 @@ export function rowsAreMetrics(table: TableAnalysis, plan: ChartPlan): boolean {
 }
 
 /**
- * A measure's {@link Polarity} from its name (`undefined` when it names
- * none); `change` admits resources a change aims to shrink.
- */
-function headerPolarity(name: string, change: boolean): Polarity | undefined {
-	// `gtTagRelevance`: camelCase words read apart.
-	const plain = plainCell(name).text.replace(/([a-z])([A-Z])/g, "$1 $2");
-	if (NEUTRAL.test(plain)) return undefined;
-	if (HIGHER_BETTER.test(plain)) return "higher";
-	if (LOWER_BETTER.test(plain)) return "lower";
-	if (change && LOWER_IN_CHANGE.test(plain)) return "lower";
-	return undefined;
-}
-
-/**
- * A measure's {@link Polarity} from its unit when its name gives none:
+ * A measure's {@link Polarity} from the unit its values are written in:
  * scores out of a total and rates per second climb, durations shrink, and
- * money and sizes shrink beside a baseline.
+ * money and sizes shrink beside a baseline (`change`). Elsewhere a size may
+ * be a capacity (`L2 cache`, `Memory`) and money a budget: no polarity.
  */
 function dimPolarity(dim: Dimension | undefined, unit: string, change: boolean, scores: boolean): Polarity | undefined {
 	if (scores) return "higher";

package/src/chat/advisor-message.ts

@@ -2,6 +2,7 @@ import { type Component } from "../tui";
 import { Disclosure } from "../components/disclosure";
 import { visibleWidth } from "../utils";
 import type { AdvisorMessageDetails, AdvisorNote, AdvisorSeverity } from "./messages";
+import { chatTranscriptDisplayPreferences } from "./display-preferences";
 import { formatBadge, replaceTabs, type ToolUIColor, wrapTextWithAnsi } from "../render/render-utils";
 import { Ellipsis, truncateToWidth } from "../render";
 import type { Theme } from "../theme";
@@ -274,6 +275,7 @@ export function createAdvisorMessageCard(
 		body: () => new AdvisorNotes(notes, 0, uiTheme),
 		expanded: getExpanded(),
 		paddingX: 1,
+		maxCollapsedRows: chatTranscriptDisplayPreferences.advisorCollapsedLines || undefined,
 	});
 	// The tool-output toggle owns expansion state; synchronize the controlled
 	// disclosure from the callback on every render.

package/src/chat/assistant-message.ts

@@ -5,6 +5,7 @@ import { Image, type ImageBudget } from "../components/image";
 import { ImageProtocol, TERMINAL } from "../terminal-capabilities";
 import {
 	type DefaultTextStyle,
+	endsInsideOpenFence,
 	holdPartialTableRow,
 	Markdown,
 	type MarkdownTheme,
@@ -14,10 +15,10 @@ import {
 } from "../components/markdown";
 import { Spacer } from "../components/spacer";
 import { Text } from "../components/text";
-import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, logger } from "@oh-my-pi/pi-utils";
 import chalk from "@oh-my-pi/pi-utils/chalk";
 import { LRUCache } from "@oh-my-pi/pi-utils/lru";
-import type { AssistantThinkingRenderer } from "./extension-types";
+import type { AssistantTextRenderer, AssistantTextRendering, AssistantThinkingRenderer } from "./extension-types";
 import { ensureThemeSync, getMarkdownTheme, getMarkdownThemeWithLinkTargets, getThemeEpoch, theme } from "../theme";
 import { card, col, elapsed, node, span, text } from "../native/describe";
 import { hasTranscriptActions, runTranscriptAction } from "./transcript-actions";
@@ -51,6 +52,8 @@ import { chartFence, hasChartTable, lookupTableChart, splitTableCharts } from ".
  */
 const MAX_TRANSCRIPT_ERROR_ROWS = 8;
 const EMPTY_STABLE_RENDER: readonly string[] = [];
+/** Text renderers that threw once; each failure is logged once per renderer, not per frame. */
+const failedTextRenderers = new WeakSet<AssistantTextRenderer>();
 
 /** The native head of a finished thinking block: "Thought for 12s", or "Thought" when it was never seen streaming. */
 function thoughtLabel(clock: { start: number; end?: number } | undefined): string {
@@ -245,6 +248,19 @@ function lerpHex(from: string, to: string, t: number): string {
 	return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
 }
 
+/**
+ * Drop the closing border the renderer draws for a source that ends inside an
+ * open fence. That row is not part of the message yet: the live block reaches
+ * it only when the closer arrives, so publishing it would make the settled
+ * prefix disagree with the block render and freeze mid-stream retirement.
+ */
+function trimFabricatedCloser(rows: readonly string[], source: string): readonly string[] {
+	if (!endsInsideOpenFence(source)) return rows;
+	let last = rows.length;
+	while (last > 0 && rows[last - 1]!.trim() === "") last--;
+	return last > 0 ? rows.slice(0, last - 1) : rows;
+}
+
 /**
  * Renders an assistant message; streaming content remains mutable until the
  * provider finalizes it because later deltas can revise earlier Markdown.
@@ -390,8 +406,10 @@ export class AssistantMessageComponent extends Container {
 	#reactionTarget: ReactionTarget | undefined;
 	/** Reaction lifted from the reply's opening emoji, once resolved. */
 	#reaction: string | undefined;
-	/** Display form of {@link #lastMessage} (reaction handled) the native description is built from. */
+	/** Display form of {@link #lastMessage} (reaction handled, extension text renderers applied) the native description is built from. */
 	#displayedMessage: AssistantMessage | undefined;
+	/** {@link #displayedMessage} before extension text renderers: the reply as written, which thinking state and the native Copy follow. */
+	#answerMessage: AssistantMessage | undefined;
 	/** Thinking-extension components per content index, recorded when the slow path mounts them. */
 	#thinkingExtensions = new Map<number, Component[]>();
 	/** Collapse state of thinking sections toggled in the terminal, by content index; cleared by {@link setHideThinkingBlock}. */
@@ -523,9 +541,65 @@ export class AssistantMessageComponent extends Container {
 		content[index] = { ...block, text };
 		return { ...message, content };
 	}
+
+	/**
+	 * Display form with the extension text renderers applied, in registration order: each gets the
+	 * previous one's output. A renderer that throws or returns a non-string leaves its input drawn;
+	 * a throw is logged once per renderer. A block whose text and `streaming` flag are unchanged
+	 * since its last render reuses that output: a block sealed at a tool call keeps receiving
+	 * updates while the call's arguments stream. {@link rerenderMessage} and
+	 * {@link setTextRenderers} drop the reused output.
+	 */
+	#renderText(message: AssistantMessage, streaming: boolean): AssistantMessage {
+		const rendering = this.#textRendering;
+		if (!rendering) return message;
+		// Renderers are display-only: hand them a deep copy so no edit, however nested, reaches the stored message.
+		let view: AssistantMessage | undefined;
+		let content: AssistantMessage["content"] | undefined;
+		// Blocks stream in order: only the last one can still grow.
+		const tail = message.content.length - 1;
+		for (let index = 0; index < message.content.length; index++) {
+			const block = message.content[index]!;
+			if (block.type !== "text" || block.text.length === 0) continue;
+			const blockStreaming = streaming && index === tail;
+			const cached = this.#renderedText.get(index);
+			let text: string;
+			if (cached?.input === block.text && cached.streaming === blockStreaming) {
+				text = cached.output;
+			} else {
+				view ??= structuredClone(message);
+				text = block.text;
+				for (const renderer of rendering.renderers) {
+					try {
+						const rendered = renderer({
+							message: view,
+							contentIndex: rendering.contentOffset + index,
+							text,
+							streaming: blockStreaming,
+						});
+						if (typeof rendered === "string") text = rendered;
+					} catch (error) {
+						if (failedTextRenderers.has(renderer)) continue;
+						failedTextRenderers.add(renderer);
+						logger.warn("Assistant text renderer failed; drawing its input", { error: String(error) });
+					}
+				}
+				this.#renderedText.set(index, { input: block.text, streaming: blockStreaming, output: text });
+			}
+			if (text === block.text) continue;
+			content ??= message.content.slice();
+			content[index] = { ...block, text };
+		}
+		return content ? { ...message, content } : message;
+	}
 	#hideThinkingBlock: boolean;
 	readonly #onImageUpdate?: () => void;
 	readonly #thinkingRenderers: readonly AssistantThinkingRenderer[];
+	#textRendering: AssistantTextRendering | undefined;
+	/** Index in the full reply's `content` of this component's first block, kept across renderer swaps. */
+	readonly #textContentOffset: number;
+	/** Last renderer output per content index, reused while the block's input and `streaming` flag hold; see {@link #renderText}. */
+	readonly #renderedText = new Map<number, { input: string; streaming: boolean; output: string }>();
 	readonly #imageBudget?: ImageBudget;
 	#proseOnlyThinking: boolean;
 	#expandThinkingBlocks: boolean;
@@ -539,11 +613,14 @@ export class AssistantMessageComponent extends Container {
 		proseOnlyThinking = true,
 		linkTargets?: ReadonlyMap<string, string>,
 		expandThinkingBlocks = false,
+		textRendering?: AssistantTextRendering,
 	) {
 		super();
 		this.#hideThinkingBlock = hideThinkingBlock;
 		this.#onImageUpdate = onImageUpdate;
 		this.#thinkingRenderers = thinkingRenderers;
+		this.#textRendering = textRendering?.renderers.length ? textRendering : undefined;
+		this.#textContentOffset = textRendering?.contentOffset ?? 0;
 		this.#imageBudget = imageBudget;
 		this.#proseOnlyThinking = proseOnlyThinking;
 		this.#expandThinkingBlocks = expandThinkingBlocks;
@@ -792,8 +869,9 @@ export class AssistantMessageComponent extends Container {
 		return this.#transcriptBlockFinalized;
 	}
 
-	/** Whether a figure still waits for the raster of its final source; the transcript holds retirement meanwhile. */
+	/** Hold image and figure rendering until the completed block can enter immutable scrollback. */
 	isTranscriptBlockPending(): boolean {
+		if (this.#showImages && this.#kittyConversionsAwaited.size > 0) return true;
 		for (const block of this.#figureBlocks.values()) if (block.pending) return true;
 		return false;
 	}
@@ -815,7 +893,7 @@ export class AssistantMessageComponent extends Container {
 	 */
 	override describe(cx?: DescribeContext): NativeNode {
 		const media = cx?.supports("media") === true;
-		const tail = this.#displayedMessage ? this.#thinkingTailIndex(this.#displayedMessage) : undefined;
+		const tail = this.#answerMessage ? this.#thinkingTailIndex(this.#answerMessage) : undefined;
 		const rate =
 			tail !== undefined && this.#lastUpdateTransient && this.#thinkingRateLive
 				? Math.round(Math.min(SPEED_MAX, sharedSpeedTracker.getSpeed()) * 10) / 10
@@ -886,13 +964,15 @@ export class AssistantMessageComponent extends Container {
 		let answered = false;
 		if (message) {
 			const live = !this.#transcriptBlockFinalized && this.#lastUpdateTransient;
+			// Which block streams, and whether there is an answer to copy, follow the reply as written:
+			// text renderers change only how it is drawn (one may hide all of it).
+			const answer = this.#answerMessage ?? message;
 			let tailIndex = -1;
-			for (let index = 0; index < message.content.length; index++) {
-				const content = message.content[index]!;
-				if (
-					(content.type === "text" && canonicalizeMessage(content.text)) ||
-					(content.type === "thinking" && canonicalizeMessage(content.thinking))
-				) {
+			for (let index = 0; index < answer.content.length; index++) {
+				const content = answer.content[index]!;
+				const answerText = content.type === "text" && canonicalizeMessage(content.text) !== "";
+				answered ||= answerText;
+				if (answerText || (content.type === "thinking" && canonicalizeMessage(content.thinking))) {
 					tailIndex = index;
 				}
 			}
@@ -900,7 +980,6 @@ export class AssistantMessageComponent extends Container {
 				const content = message.content[index]!;
 				const streaming = live && index === tailIndex;
 				if (content.type === "text" && canonicalizeMessage(content.text)) {
-					answered = true;
 					// A native terminal sizes table columns by every row it gets: send a growing row once
 					// its line ends. Hold before trimming, which would drop the newline ending a finished row.
 					const source = (streaming ? holdPartialTableRow(content.text) : content.text).trim();
@@ -1152,7 +1231,7 @@ export class AssistantMessageComponent extends Container {
 	/** The answer as the transcript shows it: its text blocks' markdown, a blank line apart, without thinking or tool calls. */
 	#answerText(): string {
 		const blocks: string[] = [];
-		for (const content of this.#displayedMessage?.content ?? []) {
+		for (const content of this.#answerMessage?.content ?? []) {
 			if (content.type === "text" && canonicalizeMessage(content.text)) blocks.push(content.text.trim());
 		}
 		return blocks.join("\n\n");
@@ -1214,7 +1293,8 @@ export class AssistantMessageComponent extends Container {
 	 * every guard skips publication and nothing ever retracts it.
 	 */
 	#publishStableSnapshot(rendered: readonly string[], width: number): void {
-		if (!this.#midStreamPublication) return;
+		// Extension text renderers may rewrite text they already drew, and published rows never retract.
+		if (!this.#midStreamPublication || this.#textRendering) return;
 		const parts = this.#currentStableSnapshot();
 		if (!parts) return;
 		const last = parts.at(-1);
@@ -1359,12 +1439,12 @@ export class AssistantMessageComponent extends Container {
 		const renderer = role === "head" ? head : role === "replay" ? replay : head?.index === index ? head : replay;
 		if (renderer?.index === index && renderer.kind === kind) {
 			renderer.md.setText(trimmed);
-			return renderer.md.render(width);
+			return trimFabricatedCloser(renderer.md.render(width), trimmed);
 		}
 		const md = this.#createMarkdown(kind, trimmed);
 		if (role === "head") this.#stableHeadRenderer = { index, kind, md };
 		else if (role === "replay") this.#stableReplayRenderer = { index, kind, md };
-		return md.render(width);
+		return trimFabricatedCloser(md.render(width), trimmed);
 	}
 
 	/** Markdown for a text or thinking block; live children and stable-row renders share it so stable rows prefix the block render. */
@@ -1491,11 +1571,30 @@ export class AssistantMessageComponent extends Container {
 		this.#stopThinkingAnimation();
 		// If the live pulse was on screen when the block sealed, drop the fast path
 		// and rebuild so the placeholder is removed — finalized blocks never animate.
+		// A sealed block's text is also complete and can retire to scrollback before the
+		// reply's final update reaches it: give the text renderers their final call now
+		// (sealed renders pass `streaming: false`).
+		const sealRenderers = this.#textRendering !== undefined && this.#lastUpdateTransient;
 		if (this.#thinkingDots) {
 			this.#fastPathKey = undefined;
 			this.#fastPathItems = undefined;
-			if (this.#lastMessage) this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
 		}
+		if ((this.#thinkingDots || sealRenderers) && this.#lastMessage) {
+			this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
+		}
+	}
+
+	/**
+	 * Swap the extension text renderers (the setting enabling them changed) and redraw with them.
+	 * Enabling them also drops rows already published as stable, since a renderer may rewrite them;
+	 * callers MUST pair this with a scrollback-clearing display reset, as for
+	 * {@link resetTranscriptStableRows}.
+	 */
+	setTextRenderers(renderers: readonly AssistantTextRenderer[]): void {
+		this.#textRendering = renderers.length ? { renderers, contentOffset: this.#textContentOffset } : undefined;
+		this.#renderedText.clear();
+		if (this.#textRendering) this.resetTranscriptStableRows();
+		if (this.#lastMessage) this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
 	}
 
 	applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void {
@@ -1504,6 +1603,18 @@ export class AssistantMessageComponent extends Container {
 		this.updateContent({ ...this.#lastMessage, retryRecovery });
 	}
 
+	/**
+	 * Draw the current message again when it is the reply sent at `timestamp`, re-running the
+	 * extension text renderers; returns whether it was. The caller schedules the frame.
+	 */
+	rerenderMessage(timestamp: number): boolean {
+		if (this.#lastMessage?.timestamp !== timestamp) return false;
+		// The renderers' state may have changed: run them again rather than reuse their last output.
+		this.#renderedText.clear();
+		this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
+		return true;
+	}
+
 	messagePersistenceKey(): string | undefined {
 		if (!this.#lastMessage) return undefined;
 		return [
@@ -1615,6 +1726,7 @@ export class AssistantMessageComponent extends Container {
 				})
 				.catch(() => {
 					this.#kittyConversionsAwaited.delete(key);
+					this.#onImageUpdate?.();
 				});
 		}
 	}
@@ -1806,6 +1918,12 @@ export class AssistantMessageComponent extends Container {
 		// verbatim message so re-renders re-derive the reaction deterministically.
 		// Narration the provider returned as thinking renders as answer text.
 		message = this.#displayMessage(presentNarrationAsAnswer(message), this.#lastUpdateTransient);
+		this.#answerMessage = message;
+		// A sealed block (closed at a tool call) keeps receiving transient updates; its text is final.
+		// Thinking state below reads `answer`: renderers transform display only, so one that hides the
+		// streaming text must not make the closed thought before it look live again.
+		const answer = message;
+		message = this.#renderText(message, this.#lastUpdateTransient && !this.#transcriptBlockFinalized);
 		this.#displayedMessage = message;
 
 		// Streaming-speed gauge: only a live, in-flight render of the single
@@ -1823,7 +1941,7 @@ export class AssistantMessageComponent extends Container {
 		// Native terminals show the live rate on visible thinking too, not only the hidden pulse.
 		const isThinkingNow =
 			this.#lastUpdateTransient &&
-			(isNativeRendering() ? this.#thinkingTailIndex(message) !== undefined : this.#shouldAnimateThinking(message));
+			(isNativeRendering() ? this.#thinkingTailIndex(answer) !== undefined : this.#shouldAnimateThinking(answer));
 		if (isThinkingNow) {
 			const currentTokens = message.usage.reasoningTokens ?? message.usage.output;
 			this.#thinkingTokens = currentTokens;
@@ -1926,7 +2044,7 @@ export class AssistantMessageComponent extends Container {
 			if (this.#figureBlocks.get(index) !== block) block.dispose();
 		}
 
-		if (this.#shouldAnimateThinking(message)) {
+		if (this.#shouldAnimateThinking(answer)) {
 			if (hasVisibleContent) this.#contentContainer.addChild(new Spacer(1));
 			this.#thinkingDots = new Text(this.#thinkingDotsLabel(), 1, 0);
 			this.#contentContainer.addChild(this.#thinkingDots);

package/src/chat/background-tan-message.ts

@@ -3,6 +3,7 @@ import { replaceTabs } from "../render/render-utils";
 import { theme } from "../theme";
 import type { TranscriptBlock } from "../chrome/transcript-container";
 import { TranscriptStatusBlock } from "../chrome/transcript-status";
+import { span } from "../native/describe";
 
 const TAN_WORK_PREVIEW_LENGTH = 56;
 
@@ -22,6 +23,8 @@ export function createBackgroundTanDispatchBlock(message: CustomMessage<unknown>
 	const details = (message as CustomMessage<Partial<BackgroundTanDispatchDetails>>).details;
 	const jobId = details?.jobId ?? "unknown";
 	const work = details?.work ? previewWork(details.work) : undefined;
+	const spans = [span("Tangent dispatched"), span(" · ", "dim"), span(`task ${jobId}`, "dim")];
+	if (work) spans.push(span(" · ", "dim"), span(work, "dim"));
 	return new TranscriptStatusBlock([
 		{
 			parts: [
@@ -30,6 +33,7 @@ export function createBackgroundTanDispatchBlock(message: CustomMessage<unknown>
 				{ text: jobId, color: "accent" },
 				work ? { text: `${theme.format.dash} ${work}`, color: "dim" } : undefined,
 			],
+			native: { tone: "info", icon: "output", message: spans },
 		},
 	]);
 }

package/src/chat/bash-execution.ts

@@ -16,6 +16,7 @@ import type { TruncationMeta } from "../tools/output-meta";
 import { resolveImageOptions } from "../render/render-utils";
 import { OutputPane } from "../render/output-pane";
 import { loadXtermTerminal, readTerminalRows, styleTerminalRow } from "../tools/terminal-output";
+import { normalizeInputForPty } from "../tools/bash-interactive";
 import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../render/sixel";
 import {
 	buildExecutionFrame,
@@ -286,6 +287,11 @@ export class BashExecutionComponent extends Container {
 		this.#drainPtyQueue();
 	}
 
+	/** Bytes a terminal would send for a key event, honoring the command's cursor-key mode; "" for key releases. */
+	encodePtyInput(data: string): string {
+		return normalizeInputForPty(data, this.#ptyTerminal?.modes.applicationCursorKeysMode ?? false);
+	}
+
 	#drainPtyQueue(): void {
 		const terminal = this.#ptyTerminal;
 		if (!terminal || this.#ptyWriting) return;