@linxiraos/pi-tui 1.1.27 → 1.2.0

package/src/prompt/image-source.ts

@@ -4,7 +4,8 @@
  * to the session's `local://` root, and generated video contact-sheet previews.
  * Symbol metadata stays out of serialized/model-bound image data while traveling
  * with the draft object, until AgentSession creates the hidden companion message
- * that tells the model the path (and link materialization prefers it over a blob copy).
+ * that tells the model the path. The model keeps `local://` references across
+ * `/move`; chips for internal URLs instead use a stable blob copy.
  */
 import type { ImageContent } from "@linxiraos/pi-ai";
 import { isRecord } from "@linxiraos/pi-utils";

package/src/prompt/interactive-context-helpers.ts

@@ -1,5 +1,5 @@
 /** Shared assistant transcript construction and model-authored link caching. */
-import type { AssistantMessage, Model } from "@linxiraos/pi-ai";
+import type { AssistantMessage, Model, TextContent } from "@linxiraos/pi-ai";
 import { getMarkdownLinkUrls } from "../index";
 import { EMPTY_LINK_TARGETS } from "../render/render-utils";
 import type { ImageBudget } from "../components/image";
@@ -18,10 +18,13 @@ export interface AssistantMessageHost {
 	readonly proseOnlyThinking: boolean;
 	readonly expandThinkingBlocks: boolean;
 	readonly assistantImagesVisible: boolean;
+	/** Whether the viewed session's tables get charts: the main session's do, a focused subagent's do not. */
+	readonly tableChartsVisible: boolean;
 	readonly hideToolActivity: boolean;
 	readonly toolOutputExpanded: boolean;
 	readonly ui: { requestRender(): void; readonly imageBudget: ImageBudget };
-	resolveAssistantMessageLinks(texts: readonly string[]): Promise<ReadonlyMap<string, string>>;
+	/** Resolve already-extracted Markdown link destinations to local targets. */
+	resolveAssistantMessageLinkHrefs(hrefs: readonly string[]): Promise<ReadonlyMap<string, string>>;
 }
 
 const kMarkdownLinkTargets = Symbol("markdownLinkTargets");
@@ -29,14 +32,26 @@ type SessionWithMarkdownLinkTargets = AssistantMessageSession & {
 	[kMarkdownLinkTargets]?: ReadonlyMap<string, string>;
 };
 
-function assistantTextBlocks(messages: readonly AssistantMessage[]): string[] {
-	const texts: string[] = [];
-	for (const message of messages) {
-		for (const content of message.content) {
-			if (content.type === "text") texts.push(content.text);
+/** Link destinations per text block, revalidated against the block's text (streaming blocks grow in place). */
+const textBlockHrefs = new WeakMap<TextContent, { text: string; hrefs: readonly string[] }>();
+
+/**
+ * Distinct Markdown link destinations authored in `message`'s text blocks.
+ * Each block is lexed once per text revision; transcript rebuilds and the
+ * message_end refresh reuse the result.
+ */
+function assistantMessageLinkHrefs(message: AssistantMessage): string[] {
+	const hrefs = new Set<string>();
+	for (const content of message.content) {
+		if (content.type !== "text") continue;
+		let memo = textBlockHrefs.get(content);
+		if (memo?.text !== content.text) {
+			memo = { text: content.text, hrefs: getMarkdownLinkUrls(content.text) };
+			textBlockHrefs.set(content, memo);
 		}
+		for (const href of memo.hrefs) hrefs.add(href);
 	}
-	return texts;
+	return [...hrefs];
 }
 
 /**
@@ -51,13 +66,12 @@ export async function refreshAssistantMessageLinkTargets(
 ): Promise<ReadonlyMap<string, string>> {
 	const session: SessionWithMarkdownLinkTargets = ctx.viewSession;
 	const previous = session[kMarkdownLinkTargets] ?? EMPTY_LINK_TARGETS;
-	const texts = assistantTextBlocks(messages);
 	const hrefs = new Set<string>();
-	for (const text of texts) {
-		for (const href of getMarkdownLinkUrls(text)) hrefs.add(href);
+	for (const message of messages) {
+		for (const href of assistantMessageLinkHrefs(message)) hrefs.add(href);
 	}
 	if (hrefs.size === 0) return previous;
-	const resolved = await ctx.resolveAssistantMessageLinks(texts);
+	const resolved = await ctx.resolveAssistantMessageLinkHrefs([...hrefs]);
 	let changed = false;
 	for (const href of hrefs) {
 		if (previous.get(href) !== resolved.get(href)) {
@@ -85,12 +99,9 @@ export function assistantMessageLinkTargets(
 	targets: ReadonlyMap<string, string>,
 ): ReadonlyMap<string, string> {
 	const selected = new Map<string, string>();
-	for (const content of message.content) {
-		if (content.type !== "text") continue;
-		for (const href of getMarkdownLinkUrls(content.text)) {
-			const target = targets.get(href);
-			if (target) selected.set(href, target);
-		}
+	for (const href of assistantMessageLinkHrefs(message)) {
+		const target = targets.get(href);
+		if (target) selected.set(href, target);
 	}
 	return selected;
 }
@@ -116,6 +127,7 @@ export function createAssistantMessageComponent(
 		ctx.expandThinkingBlocks,
 	);
 	component.setImagesVisible(ctx.assistantImagesVisible);
+	component.setTableChartsVisible(ctx.tableChartsVisible);
 	component.setToolResultImagesVisible(!ctx.hideToolActivity);
 	component.setExpanded(ctx.toolOutputExpanded);
 	// A wire the `stream-revision` axis marks `possible` can rewrite text it has

package/src/prompt/macos-spelling.ts

@@ -56,6 +56,8 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 	#availabilityChecked = false;
 	#cacheGeneration = 0;
 	#typoCache = new Map<string, readonly native.SpellingRange[]>();
+	/** {@link #projectTypoRanges} answers for the current {@link #typoCache}; segments re-ask every frame. */
+	#projectionMemo = new Map<string, readonly native.SpellingRange[] | undefined>();
 	#typoInFlight = new Map<string, Promise<readonly native.SpellingRange[]>>();
 	#automaticTypoActive = false;
 	#automaticTypoQueue = new Map<string, string>();
@@ -237,6 +239,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		return request;
 	}
 	#projectTypoRanges(text: string): readonly native.SpellingRange[] | undefined {
+		if (this.#projectionMemo.has(text)) return this.#projectionMemo.get(text);
 		let projected: native.SpellingRange[] | undefined;
 		let matchLength = -1;
 		for (const [previous, ranges] of this.#typoCache) {
@@ -265,6 +268,8 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 			});
 			matchLength = prefix + suffix;
 		}
+		if (this.#projectionMemo.size >= CACHE_LIMIT) this.#projectionMemo.clear();
+		this.#projectionMemo.set(text, projected);
 		return projected;
 	}
 
@@ -316,6 +321,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		const hadProjectedRanges = (this.#projectTypoRanges(text)?.length ?? 0) > 0;
 		if (this.#typoCache.size >= CACHE_LIMIT) this.#typoCache.clear();
 		this.#typoCache.set(text, ranges);
+		this.#projectionMemo.clear();
 		if (ranges.length > 0 || hadProjectedRanges) this.onUpdate?.();
 		return ranges;
 	}
@@ -323,6 +329,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 	#clearCaches(): void {
 		this.#cacheGeneration++;
 		this.#typoCache.clear();
+		this.#projectionMemo.clear();
 		this.#typoInFlight.clear();
 		this.#automaticTypoQueue.clear();
 	}

package/src/prompt/magic-keywords.ts

@@ -148,6 +148,9 @@ export function magicKeywordRanges(text: string): { from: number; to: number }[]
 	return ranges.sort((a, b) => a.from - b.from);
 }
 
+/** Last {@link hasMagicKeyword} answer: the live editor asks once per layout segment with the same buffer. */
+let lastProbe: { text: string; registry: readonly RegisteredKeyword[]; found: boolean } | undefined;
+
 /**
  * Cheap test for "does this text contain any registered keyword as standalone
  * prose?". Short-circuits on a substring probe before paying for the
@@ -155,8 +158,14 @@ export function magicKeywordRanges(text: string): { from: number; to: number }[]
  * `String#includes` per word. Used by the live editor to gate the shimmer timer.
  */
 export function hasMagicKeyword(text: string): boolean {
+	if (lastProbe?.text === text && lastProbe.registry === registry) return lastProbe.found;
+	let found = false;
 	for (const keyword of registry) {
-		if (text.includes(keyword.word) && containsMagicKeyword(text, keyword.word)) return true;
+		if (text.includes(keyword.word) && containsMagicKeyword(text, keyword.word)) {
+			found = true;
+			break;
+		}
 	}
-	return false;
+	lastProbe = { text, registry, found };
+	return found;
 }

package/src/prompt/model-mention-autocomplete.ts

@@ -5,9 +5,7 @@ import { modelMentionDisplayName } from "./model-mention-syntax";
 import type {
 	buildSearchAffinity as BuildSearchAffinity,
 	ModelBrowserItem,
-	rankModelItems as RankModelItems,
-	SearchAffinity,
-	SessionModelScope,
+	ModelItemRanker as ModelItemRankerClass,
 	SessionModelScopeCache as SessionModelScopeCacheClass,
 } from "../overlays/model-browser";
 import { theme } from "../theme/theme";
@@ -21,7 +19,7 @@ export type ModelMentionCandidateSource = (query: string) => ReadonlyArray<Model
 interface ModelBrowserModules {
 	SessionModelScopeCache: typeof SessionModelScopeCacheClass;
 	buildSearchAffinity: typeof BuildSearchAffinity;
-	rankModelItems: typeof RankModelItems;
+	ModelItemRanker: typeof ModelItemRankerClass;
 }
 
 /** Synchronous first-use boundary for the interactive model browser implementation. */
@@ -80,7 +78,7 @@ export function applyModelMentionCompletion(
 
 /**
  * Create a session-scoped model candidate lookup using picker ordering. The
- * scope and search affinity are reused across queries until their inputs change.
+ * scope and its prepared ranker are reused across queries until their inputs change.
  */
 export function createModelMentionSource(host: {
 	source: ModelBrowserSource;
@@ -88,20 +86,22 @@ export function createModelMentionSource(host: {
 	scopedModels: () => ReadonlyArray<Model>;
 }): ModelMentionCandidateSource {
 	let scopeCache: SessionModelScopeCacheClass | undefined;
-	let affinityScope: SessionModelScope | undefined;
-	let affinityProviderOrder: readonly string[] | undefined;
-	let affinity: SearchAffinity | undefined;
+	let ranker: ModelItemRankerClass | undefined;
+	let rankerProviderOrder: readonly string[] | undefined;
 	return query => {
-		const { SessionModelScopeCache, buildSearchAffinity, rankModelItems } = loadModelBrowser();
+		const { SessionModelScopeCache, buildSearchAffinity, ModelItemRanker } = loadModelBrowser();
 		scopeCache ??= new SessionModelScopeCache(host.source, host.registry);
 		const scope = scopeCache.get(host.scopedModels());
 		if (!query.trim()) return scope.items;
 		const providerOrder = host.source.modelProviderOrder;
-		if (!affinity || affinityScope !== scope || affinityProviderOrder !== providerOrder) {
-			affinity = buildSearchAffinity(providerOrder, scope.roles, scope.mruOrder);
-			affinityScope = scope;
-			affinityProviderOrder = providerOrder;
+		if (ranker?.items !== scope.items || rankerProviderOrder !== providerOrder) {
+			ranker = new ModelItemRanker(scope.items, {
+				roles: scope.roles,
+				mruOrder: scope.mruOrder,
+				affinity: buildSearchAffinity(providerOrder, scope.roles, scope.mruOrder),
+			});
+			rankerProviderOrder = providerOrder;
 		}
-		return rankModelItems(query, scope.items, { roles: scope.roles, mruOrder: scope.mruOrder, affinity });
+		return ranker.rank(query);
 	};
 }

package/src/prompt/tips.txt

@@ -6,17 +6,17 @@ Start your prompt with `$ ` to run Python — `$$ ` runs it without adding the o
 You can /btw to ask a side question
 Use /tan to fork the current conversation into a background agent
 With default keybindings, {key:ctrl+d} deletes the character under the cursor instead of quitting your draft — see /hotkeys for your exit key
-Find out which model you emotionally abuse the most with `zeta stats`
+Find out which model you emotionally abuse the most with `zetacode stats`
 Try task isolation to create CoW worktrees
-Need a cheap nested model call? Use `completion(x...)`. Have a big batch of tasks? Ask a subagent to use it!
+Need a cheap nested model call? Use `completion(x...)`
 Spaghetti code? Try complaining with /omfg
-Did you know? Each kitty/tmux/cmux/zellij/wezterm split keeps its own session — `zeta -c` resumes the right one
+Did you know? Each kitty/tmux/cmux/zellij/wezterm split keeps its own session — `zetacode -c` resumes the right one
 Drop the word `ultrathink` in your message for harder multi-step reasoning — watch it glow rainbow as you type
 Say `orchestrate` in your message to drive a multi-phase task with parallel subagents — watch it glow as you type
 Say `workflowz` in your message to drive the task with parallel subagents in eval — watch it glow as you type
 Bulk data to classify or triage? Say `jevify` in your message — the eval kernel's `judge()` processes the batch and you read only what it flags — watch it glow as you type
 Log in to several accounts of the same provider — `/login` again — and zeta load-balances across them automatically
-Run `zeta auth-broker serve` once and every machine pulls live tokens over the wire — refresh keys never leave the host; `zeta auth-gateway` fronts it as a drop-in proxy any OpenAI-compatible client can hit
+Run `zetacode auth-broker serve` once and every machine pulls live tokens over the wire — refresh keys never leave the host; `zetacode auth-gateway` fronts it as a drop-in proxy any OpenAI-compatible client can hit
 Press {key:alt+p} (or /switch) to switch provider, and {key:ctrl+p} to cycle role models smol -> slow -> etc
 Press {key:ctrl+r} to search your prompt history and reuse a past message
 `/force read` pins the next turn to one specific tool when the model keeps reaching for the wrong one
@@ -29,4 +29,5 @@ Turn on `/advisor` to attach a second model that reviews every turn and quietly
 Try starting your prompt with a ->, and writing a list (1. Do X, 2. Do Y)
 Press {key:shift+tab} to cycle through reasoning effort levels
 zeta can reconfigure and extend itself — ask any questions you have!
-Lint/type errors piling up? `zeta cleanse` (or /cleanse right here) hunts project diagnostics and fixes them with parallel subagents — {key:escape} cancels
+Lint/type errors piling up? `zetacode cleanse` (or /cleanse right here) hunts project diagnostics and fixes them with parallel subagents — {key:escape} cancels
+[NO-TERN] Psst, zeta has a natural habitat 🐦 [tern](https://scl.so/tern)

package/src/prompt/welcome.ts

@@ -6,17 +6,23 @@ import { getKeybindings, type Keybinding } from "../keybindings";
 import { card, col, kbd, keyed, node, row, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
 import { runTranscriptAction } from "../chat/transcript-actions";
-import { plainLine } from "../native/spans";
+import { compactText, plainLine, plainText } from "../native/spans";
+
 import { isNativeRendering } from "../native/state";
+import { isHyperlinkEnabled, urlHyperlink, urlLinkSpan } from "../render/hyperlink";
 import { TERMINAL } from "../terminal-capabilities";
 import { theme } from "../theme/theme";
 import type { Component } from "../tui";
 import { padding, replaceTabs, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../utils";
 import tipsText from "./tips.txt" with { type: "text" };
 
-/** Tips embedded at build time, one per line; blanks dropped. Key placeholders
+/** Leading marker for a tip that pitches Tern: shown only while no TSP surface
+ *  is live, since a live one means the user is already in Tern. */
+const NO_TERN_TIP_MARKER = /^\[NO-TERN\]\s*/;
+
+/** tips.txt lines embedded at build time; blanks dropped. Key placeholders
  *  (see {@link expandTipKeys}) stay raw until render time. */
-const TIPS: readonly string[] = tipsText
+const TIP_LINES: readonly string[] = tipsText
 	.split("\n")
 	.map(line => line.trim())
 	.filter(line => line.length > 0);
@@ -33,6 +39,12 @@ export const WELCOME_SESSION_SLOTS = 4;
  */
 export const WELCOME_LSP_SLOTS = 4;
 
+/** Tips for the classic renderer: every tip, {@link NO_TERN_TIP_MARKER} stripped. */
+const TIPS: readonly string[] = TIP_LINES.map(line => line.replace(NO_TERN_TIP_MARKER, ""));
+
+/** Tips for a live TSP surface: those marked {@link NO_TERN_TIP_MARKER} dropped. */
+const TSP_TIPS: readonly string[] = TIP_LINES.filter(line => !NO_TERN_TIP_MARKER.test(line));
+
 /** Trailing marker that flags a tip as a "what's new" callout. Stripped before
  *  wrapping (with any preceding whitespace) and replaced by {@link NEW_TAG_TEXT}
  *  painted as a shimmering rainbow. Non-global so `.test` stays stateless. */
@@ -120,14 +132,44 @@ function expandTipKeys(tip: string): string {
 	});
 }
 
-export function renderWelcomeTip(tip: string, boxWidth: number, phase = 0): string[] {
+/** Markdown-style links in tips.txt: `[Tern](https://scl.so/tern)` shows the label, linked to the URL. */
+const TIP_LINK = /\[([^\]]+)\]\(([^\s)]+)\)/g;
+
+/** Tip links as underlined OSC 8 labels, or `label (url)` where the terminal cannot link. */
+function linkTipText(tip: string): string {
+	const linkable = isHyperlinkEnabled();
+	return tip.replace(TIP_LINK, (_link, label: string, url: string) =>
+		linkable ? urlHyperlink(url, theme.underline(label)) : `${label} (${url})`,
+	);
+}
+
+/** The tip as native text: escapes dropped, links as `href` spans. */
+function tipSpans(tip: string): TspSpan[] {
+	const spans: TspSpan[] = [];
+	let cursor = 0;
+	for (const match of tip.matchAll(TIP_LINK)) {
+		const [link, label, url] = match;
+		if (match.index > cursor) spans.push(span(plainText(tip.slice(cursor, match.index))));
+		spans.push(urlLinkSpan(url, label));
+		cursor = match.index + link.length;
+	}
+	if (cursor < tip.length) spans.push(span(plainText(tip.slice(cursor))));
+	return spans;
+}
+
+/**
+ * The welcome tip as lines of at most `width` columns: `Tip:` and the body
+ * wrapped together, with no indent, so the banner can center each line.
+ * `[]` when `width` leaves no room for a useful line.
+ */
+export function renderWelcomeTip(tip: string, width: number, phase = 0): string[] {
 	const label = "Tip: ";
 	const labelWidth = visibleWidth(label);
-	const bodyBudget = boxWidth - labelWidth;
+	const bodyBudget = width - labelWidth;
 	if (bodyBudget < 8) return [];
 
 	const isNew = NEW_TIP_MARKER.test(tip);
-	const body = expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip);
+	const body = linkTipText(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip));
 
 	const wrappedBody = wrapTextWithAnsi(replaceTabs(body), bodyBudget);
 	if (wrappedBody.length === 0) return [];
@@ -152,7 +194,7 @@ export function renderWelcomeTip(tip: string, boxWidth: number, phase = 0): stri
 		const tag = renderNewTag(phase, encoding);
 		const tagWidth = 1 + visibleWidth(NEW_TAG_TEXT); // 1 = space separator
 		const lastLine = lines[lines.length - 1];
-		if (lastLine !== undefined && visibleWidth(lastLine) + tagWidth <= boxWidth) {
+		if (lastLine !== undefined && visibleWidth(lastLine) + tagWidth <= width) {
 			lines[lines.length - 1] = `${lastLine} ${tag}`;
 		} else {
 			lines.push(continuationIndent + tag);
@@ -183,9 +225,10 @@ export class WelcomeComponent implements Component {
 	#animTimer: Timer | null = null;
 	#requestRender: (() => void) | null = null;
 	// Tip randomness is latched once so the tip is stable across renders, but
-	// the nerdfont-nag gate re-reads the live preset: the startup prepaint can
-	// run under the default "unicode" preset before settings resolve the real
-	// one, and a memoized nag would survive the switch to "nerd".
+	// the nerdfont-nag gate re-reads the live preset and the pool re-reads the
+	// live TSP state: the startup prepaint can run under the default "unicode"
+	// preset before settings resolve the real one, and an optimistic Tern start
+	// falls back to the classic renderer when `hello` never confirms.
 	#nagRoll: number | undefined;
 	#tipRoll: number | undefined;
 	// Render cache: the welcome box is the first transcript-area component, so
@@ -209,7 +252,7 @@ export class WelcomeComponent implements Component {
 		if (theme.getSymbolPreset() === "unicode" && this.#nagRoll < 0.1) {
 			return "Please use nerdfont 😭.";
 		}
-		return pickWeightedTip(TIPS, this.#tipRoll) || undefined;
+		return pickWeightedTip(isNativeRendering() ? TSP_TIPS : TIPS, this.#tipRoll) || undefined;
 	}
 
 	invalidate(): void {
@@ -338,7 +381,7 @@ export class WelcomeComponent implements Component {
 		];
 		if (tip) {
 			const isNew = NEW_TIP_MARKER.test(tip);
-			const tipText = plainLine(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip));
+			const tipText = compactText(tipSpans(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip)));
 			const tipRow: NativeChild[] = [
 				node("icon", { name: "lightbulb", role: "zeta.welcome.tip-icon" }),
 				text(tipText, { wrap: "word", role: "zeta.welcome.tip-text" }),

package/src/prompt/word-completion.ts

@@ -56,9 +56,20 @@ interface WordQuery extends WordCompletionQuery {
 
 /** Editor text before the word starting at `start`, truncated to its last {@link BEFORE_LIMIT} code units. */
 function textBefore(lines: readonly string[], cursorLine: number, start: number): string {
-	let text = (lines[cursorLine] ?? "").slice(0, start);
-	for (let line = cursorLine - 1; line >= 0 && text.length < BEFORE_LIMIT; line--) {
-		text = `${lines[line] ?? ""}\n${text}`;
+	const head = (lines[cursorLine] ?? "").slice(0, start);
+	// Find the first line the capped tail reaches, then join once.
+	let length = head.length;
+	let first = cursorLine;
+	while (first > 0 && length < BEFORE_LIMIT) {
+		first--;
+		length += (lines[first] ?? "").length + 1;
+	}
+	let text = head;
+	if (first < cursorLine) {
+		const parts: string[] = [];
+		for (let line = first; line < cursorLine; line++) parts.push(lines[line] ?? "");
+		parts.push(head);
+		text = parts.join("\n");
 	}
 	if (text.length <= BEFORE_LIMIT) return text;
 	let cut = text.length - BEFORE_LIMIT;
@@ -111,6 +122,16 @@ export class WordCompletionProvider implements EditorTextAssistProvider {
 	#lastShown: { before: string; word: string } | undefined;
 	/** What the last `getWordCompletion` returned, so a fetch repaints only when it changes that. */
 	#displayed: { key: string; suffix: string | null } | undefined;
+	/** Last {@link #query} input snapshot (lines are copied: the editor mutates its array in place). */
+	#queryMemo:
+		| {
+				method: WordCompletionMethod;
+				lines: readonly string[];
+				cursorLine: number;
+				cursorCol: number;
+				query: WordQuery | undefined;
+		  }
+		| undefined;
 
 	/** Invoked when an asynchronous answer changes the rendered ghost text. */
 	onUpdate: (() => void) | undefined;
@@ -171,11 +192,23 @@ export class WordCompletionProvider implements EditorTextAssistProvider {
 
 	#query(lines: readonly string[], cursorLine: number, cursorCol: number): WordQuery | undefined {
 		if (this.#method === "off") return undefined;
+		// Rendering asks every frame; reuse the answer until the buffer, caret, or engine changes.
+		const memo = this.#queryMemo;
+		if (
+			memo?.method === this.#method &&
+			memo.cursorLine === cursorLine &&
+			memo.cursorCol === cursorCol &&
+			memo.lines.length === lines.length &&
+			memo.lines.every((line, index) => line === lines[index])
+		) {
+			return memo.query;
+		}
 		const query = wordCompletionQuery(lines, cursorLine, cursorCol, this.#prose);
-		if (!query) return undefined;
 		// The method keeps a request still in flight for the previous engine from
 		// shadowing the same word state on the new one.
-		return { key: `${this.#method}\u0000${query.prefix}\u0000${query.before}`, ...query };
+		const result = query && { key: `${this.#method}\u0000${query.prefix}\u0000${query.before}`, ...query };
+		this.#queryMemo = { method: this.#method, lines: lines.slice(), cursorLine, cursorCol, query: result };
+		return result;
 	}
 
 	#project(query: WordQuery): string | null {

package/src/render/composite.d.ts

@@ -0,0 +1,2 @@
+/** Splice overlay content into a base line at a specific column. Single-pass optimized. */
+export declare function compositeLineAt(baseLine: string, overlayLine: string, startCol: number, overlayWidth: number, totalWidth: number): string;

package/src/render/composite.ts

@@ -0,0 +1,64 @@
+import { TERMINAL } from "../terminal-capabilities";
+import { extractSegments, sliceByColumn, sliceWithWidth, visibleWidth } from "../utils";
+
+const SEGMENT_RESET = "\x1b[0m";
+
+/** Splice overlay content into a base line at a specific column. Single-pass optimized. */
+export function compositeLineAt(
+	baseLine: string,
+	overlayLine: string,
+	startCol: number,
+	overlayWidth: number,
+	totalWidth: number,
+): string {
+	// A full-width image row owns its terminal row; the writer must see its exact placement shape.
+	if (startCol === 0 && overlayWidth >= totalWidth && TERMINAL.isImageLine(overlayLine)) return overlayLine;
+	if (TERMINAL.isImageLine(baseLine)) {
+		// Full-width overlays such as /switch are opaque: replace the
+		// Unicode placeholder cells so the image cannot cover the modal.
+		// Partial overlays cannot safely splice placement control sequences.
+		if (startCol !== 0 || overlayWidth < totalWidth) return baseLine;
+		const overlay = sliceWithWidth(overlayLine, 0, totalWidth, true);
+		return SEGMENT_RESET + overlay.text + " ".repeat(Math.max(0, totalWidth - overlay.width));
+	}
+
+	// Single pass through baseLine extracts both before and after segments
+	const afterStart = startCol + overlayWidth;
+	const base = extractSegments(baseLine, startCol, afterStart, totalWidth - afterStart, true);
+
+	// Extract overlay with width tracking (strict=true to exclude wide chars at boundary)
+	const overlay = sliceWithWidth(overlayLine, 0, overlayWidth, true);
+
+	// Pad segments to target widths
+	const beforePad = Math.max(0, startCol - base.beforeWidth);
+	const overlayPad = Math.max(0, overlayWidth - overlay.width);
+	const actualBeforeWidth = Math.max(startCol, base.beforeWidth);
+	const actualOverlayWidth = Math.max(overlayWidth, overlay.width);
+	const afterTarget = Math.max(0, totalWidth - actualBeforeWidth - actualOverlayWidth);
+	const afterPad = Math.max(0, afterTarget - base.afterWidth);
+
+	// Compose result
+	const r = SEGMENT_RESET;
+	const result =
+		base.before +
+		" ".repeat(beforePad) +
+		r +
+		overlay.text +
+		" ".repeat(overlayPad) +
+		r +
+		base.after +
+		" ".repeat(afterPad);
+
+	// CRITICAL: Always verify and truncate to terminal width.
+	// This is the final safeguard against width overflow which would crash the TUI.
+	// Width tracking can drift from actual visible width due to:
+	// - Complex ANSI/OSC sequences (hyperlinks, colors)
+	// - Wide characters at segment boundaries
+	// - Edge cases in segment extraction
+	const resultWidth = visibleWidth(result);
+	if (resultWidth <= totalWidth) {
+		return result;
+	}
+	// Truncate with strict=true to ensure we don't exceed totalWidth
+	return sliceByColumn(result, 0, totalWidth, true);
+}

package/src/render/output-pane.d.ts

@@ -92,6 +92,7 @@ export declare class OutputPane implements Component {
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];
     invalidate(): void;
+    releaseRenderCaches(): void;
 }
 /** Default styling for plain tool output while preserving existing ANSI. */
 export declare function styleToolOutputLine(line: string, theme: Theme): string;

package/src/render/output-pane.ts

@@ -302,6 +302,12 @@ export class OutputPane implements Component {
 		this.#text.invalidate();
 	}
 
+	releaseRenderCaches(): void {
+		this.#renderKey = "";
+		this.#text.setText("");
+		this.#text.releaseRenderCaches();
+	}
+
 	#appendToTail(text: string): void {
 		if (!text) return;
 		if (this.#lines.length === 0) this.#lines.push("");

package/src/render/render-utils.d.ts

@@ -298,6 +298,7 @@ export interface RenderedStringCache {
 export declare function createRenderedStringCache(): RenderedStringCache;
 /** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
 export declare function invalidateRenderedStringCache(cache: RenderedStringCache): void;
+export declare function releaseRenderedStringCache(cache: RenderedStringCache): void;
 /** Reuse a rendered string while its theme, expansion, content, and salt match. */
 export declare function cachedRenderedString(cache: RenderedStringCache | undefined, theme: Theme, expanded: boolean, salt: string, content: string, render: () => string): string;
 /**

package/src/render/render-utils.ts

@@ -1128,6 +1128,9 @@ export function createCachedComponent(
 		invalidate() {
 			cached = undefined;
 		},
+		releaseRenderCaches() {
+			cached = undefined;
+		},
 	};
 }
 
@@ -1160,6 +1163,14 @@ export function invalidateRenderedStringCache(cache: RenderedStringCache): void
 	cache.theme = null;
 }
 
+export function releaseRenderedStringCache(cache: RenderedStringCache): void {
+	cache.theme = null;
+	cache.expanded = false;
+	cache.salt = "";
+	cache.content = "";
+	cache.value = "";
+}
+
 /** Reuse a rendered string while its theme, expansion, content, and salt match. */
 export function cachedRenderedString(
 	cache: RenderedStringCache | undefined,

package/src/render/tool-card.d.ts

@@ -46,6 +46,11 @@ export interface ToolCardOptions {
     paddingY?: number;
     ignoreTight?: boolean;
     onInvalidate?: () => void;
+    /**
+     * Drop builder-owned memos the next build recomputes. Called by
+     * {@link ToolCard.releaseRenderCaches}, which never calls `onInvalidate`.
+     */
+    onReleaseRenderCaches?: () => void;
     onDispose?: () => void;
 }
 /** Map transcript lifecycle terminology onto the output frame's visual states. */
@@ -71,6 +76,7 @@ export declare class ToolCard implements Component {
     handleInput(data: string): void;
     setIgnoreTight(ignore: boolean): void;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
 }
 /** Construct a lazy framed tool card. */

package/src/render/tool-card.ts

@@ -69,6 +69,11 @@ export interface ToolCardOptions {
 	paddingY?: number;
 	ignoreTight?: boolean;
 	onInvalidate?: () => void;
+	/**
+	 * Drop builder-owned memos the next build recomputes. Called by
+	 * {@link ToolCard.releaseRenderCaches}, which never calls `onInvalidate`.
+	 */
+	onReleaseRenderCaches?: () => void;
 	onDispose?: () => void;
 }
 
@@ -381,6 +386,16 @@ export class ToolCard implements Component {
 		this.#options.onInvalidate?.();
 	}
 
+	releaseRenderCaches(): void {
+		this.#block.invalidate();
+		this.#lastBlockOptions = undefined;
+		this.#plainKey = "";
+		this.#plainText.setText("");
+		this.#plainText.releaseRenderCaches();
+		for (const child of this.#renderedChildren) child.releaseRenderCaches?.();
+		this.#options.onReleaseRenderCaches?.();
+	}
+
 	dispose(): void {
 		if (this.#disposed) return;
 		this.#disposed = true;

package/src/render/width-aware-text.d.ts

@@ -20,6 +20,8 @@ export declare class WidthAwareText implements Component {
     setCustomBgFn(customBgFn?: (text: string) => string): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    /** The formatted text stays: the inner `Text` renders from it, so dropping it would free nothing. */
+    releaseRenderCaches(): void;
     /**
      * Re-run the formatter on the next render because its inputs changed.
      * Unlike {@link invalidate}, the inner `Text` keeps its wrap cache, so a