@oh-my-pi/pi-tui 18.14.2 → 18.16.0

package/src/components/editor.ts

@@ -71,6 +71,7 @@ import {
 export type { EditorBorderStyle, EditorTopBorder };
 
 import { type SelectItem, SelectList, type SelectListLayoutOptions, type SelectListTheme } from "./select-list";
+import { editorKey } from "../chrome/keybinding-hints";
 
 /** The TSP root an {@link Editor.describeLayout} hook builds around the `editor` node. */
 export interface NativeEditorLayout {
@@ -866,9 +867,19 @@ export class Editor implements Component, Focusable {
 	#autocompleteList?: SelectList;
 	#autocompleteState: "regular" | "force" | "assist" | null = null;
 	#textAssistReplacement:
-		| { line: number; startCol: number; endCol: number; original: string; cursorOffset: number }
+		| {
+				line: number;
+				startCol: number;
+				endCol: number;
+				original: string;
+				cursorOffset: number;
+				/** The list offers {@link predictions} for the whole line rather than spelling replacements. */
+				prediction?: boolean;
+		  }
 		| undefined;
 	#autocompletePrefix: string = "";
+	/** The line a prediction insert (Tab, Right, or the alternatives list) left in the buffer; any later edit clears it. */
+	#insertedPrediction: string | undefined;
 	/** False while the popup's untouched top row is a description-only slash hit ({@link AutocompleteItem.descriptionMatch}): Enter then submits the typed text. */
 	#enterAcceptsSelection = true;
 	#autocompleteRequestId: number = 0;
@@ -945,12 +956,21 @@ export class Editor implements Component, Focusable {
 	 *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive
 	 *  it from live state. */
 	placeholder?: () => string | undefined;
-	/** Whole-message prediction for the next prompt, painted as ghost text after the cursor while
-	 *  the single-line buffer is a strict prefix of it, the cursor sits at its end, and no
-	 *  autocomplete is open. A shown prediction replaces the {@link placeholder}; Tab or Right inserts
-	 *  the rest without submitting. Must be a single line. Re-evaluated on every render, so hosts can
-	 *  derive it from live state. */
-	prediction?: () => string | undefined;
+	/** Whole-message predictions for the next prompt, most likely first. The first one the single-line
+	 *  buffer is a strict prefix of is painted as ghost text after the cursor while the cursor sits at
+	 *  its end and no autocomplete is open. A shown prediction replaces the {@link placeholder}; Tab or
+	 *  Right inserts the rest without submitting. A buffer the user typed keeps the ghost even when it
+	 *  equals a shorter prediction; once Tab, Right, or the list has inserted one of two or more
+	 *  predictions, no ghost extends it to a longer one, and Tab instead opens a list of all of them
+	 *  that swaps the whole line, also without submitting. Each must be a single line. Re-evaluated on
+	 *  every render, so hosts can derive them from live state. */
+	predictions?: () => readonly string[] | undefined;
+	/** Called with the prediction's index in {@link predictions} after Tab or Right inserts the rest of
+	 *  a shown prediction, or the alternatives list swaps a different one into the buffer. */
+	onPredictionAccepted?: (index: number) => void;
+	/** Called for each frame that paints a prediction as ghost text: a terminal frame that draws at
+	 *  least one cell of it, or a native frame that carries it as the editor's ghost. */
+	onPredictionShown?: () => void;
 
 	// Custom top border (for status line integration). Either an eager `content`
 	// (set once, reused every frame) or a `provider` that recomputes lazily just
@@ -1599,6 +1619,10 @@ export class Editor implements Component, Focusable {
 		// against the cursor, or the placeholder flush right.
 		const placeholder = this.#getPlaceholder();
 		const inlineHint = placeholder ? null : this.#getInlineHint();
+		// Whether the hint is the prediction, and how many of its cells this frame draws: a full row,
+		// an unfocused hardware-cursor row, or the IME-safe layout can leave it unpainted.
+		const hintIsPrediction = inlineHint !== null && inlineHint === this.#getPredictionSuffix();
+		let hintCellsPainted = 0;
 		const hintStyle = this.#theme.hintStyle ?? ((t: string) => `\x1b[2m${t}\x1b[0m`);
 		const hintTail = (avail: number): { text: string; width: number } | undefined => {
 			if (placeholder) {
@@ -1713,6 +1737,7 @@ export class Editor implements Component, Focusable {
 					} else if (tail) {
 						displayText = before + marker + tail.text;
 						displayWidth += tail.width;
+						hintCellsPainted += tail.width;
 					} else if (after.length === 0 && !isSideBordered && displayWidth >= lineContentWidth) {
 						displayText = this.#renderTerminalCursorMarker(before, marker, lineContentWidth);
 					} else {
@@ -1759,6 +1784,7 @@ export class Editor implements Component, Focusable {
 						const tail = hintTail(Math.max(0, lineContentWidth - displayWidth - overrideWidth));
 						displayText = before + marker + this.cursorOverride + (tail?.text ?? "");
 						displayWidth += overrideWidth + (tail?.width ?? 0);
+						hintCellsPainted += tail?.width ?? 0;
 					}
 				} else {
 					// Cursor is at the end - add thin cursor glyph
@@ -1773,6 +1799,7 @@ export class Editor implements Component, Focusable {
 						const tail = hintTail(Math.max(0, lineContentWidth - displayWidth - cursorWidth));
 						displayText = before + marker + cursor + (tail?.text ?? "");
 						displayWidth += cursorWidth + (tail?.width ?? 0);
+						hintCellsPainted += tail?.width ?? 0;
 					}
 					if (displayWidth > lineContentWidth && paddingX > 0) {
 						cursorPaddingOverflow = displayWidth - lineContentWidth;
@@ -1815,6 +1842,7 @@ export class Editor implements Component, Focusable {
 				}),
 			);
 		}
+		if (hintIsPrediction && hintCellsPainted > 0) this.onPredictionShown?.();
 
 		const bottomRow = style.renderBottom(chromeCtx);
 		if (bottomRow !== undefined) result.push(bottomRow);
@@ -1879,6 +1907,7 @@ export class Editor implements Component, Focusable {
 				: placeholder && plainText(placeholder).trim();
 		const atLineEnd = cursorCol >= (lines[cursorLine]?.length ?? 0);
 		const ghost = nativePlaceholder || !atLineEnd ? null : this.#getInlineHint();
+		if (ghost && ghost === this.#getPredictionSuffix()) this.onPredictionShown?.();
 		const vim = this.#vim;
 		let anchor: number | null = null;
 		if (vim?.visual && vim.anchor !== null) {
@@ -2130,7 +2159,7 @@ export class Editor implements Component, Focusable {
 					kb.matchesCanonical(canonical, "tui.input.tab") ||
 					rightArrowAccepts)
 			) {
-				this.#applySpellingSuggestion();
+				this.#applyAssistReplacement();
 				return;
 			}
 			// Let the autocomplete list handle navigation and selection
@@ -3260,6 +3289,7 @@ export class Editor implements Component, Focusable {
 
 	#notifyChange(text?: string): void {
 		this.#textRevision++;
+		this.#insertedPrediction = undefined;
 		this.onChange?.(text ?? this.getText());
 	}
 
@@ -5077,7 +5107,7 @@ export class Editor implements Component, Focusable {
 		// A pointer pick on the popup (TSP `select`/`activate`) accepts it like Tab.
 		list.onSelect = item => {
 			if (this.#autocompleteList !== list) return;
-			if (this.#autocompleteState === "assist") this.#applySpellingSuggestion();
+			if (this.#autocompleteState === "assist") this.#applyAssistReplacement();
 			else this.#acceptAutocompleteSelection(item);
 		};
 		return list;
@@ -5085,6 +5115,7 @@ export class Editor implements Component, Focusable {
 
 	async #handleTabCompletion(): Promise<void> {
 		if (this.#acceptPrediction()) return;
+		if (this.#showPredictionAlternatives()) return;
 		if (this.#acceptWordCompletion({ space: true })) return;
 		if (!this.#autocompleteProvider) return;
 
@@ -5122,11 +5153,37 @@ export class Editor implements Component, Focusable {
 		if (space) this.#lastAction = "accept-word";
 		return true;
 	}
-	/** Insert the rest of the shown {@link prediction}, if any. Never submits. */
+	/** Insert the rest of the shown prediction, if any. Never submits. */
 	#acceptPrediction(): boolean {
-		const suffix = this.#getPredictionSuffix();
-		if (!suffix) return false;
-		this.#insertTextAtCursor(suffix);
+		const shown = this.#getShownPrediction();
+		if (!shown) return false;
+		this.#insertTextAtCursor(shown.suffix);
+		this.#insertedPrediction = this.#state.lines[0];
+		this.onPredictionAccepted?.(shown.index);
+		return true;
+	}
+
+	/** Open the list of every prediction over a buffer that equals one of them, that one selected. */
+	#showPredictionAlternatives(): boolean {
+		const alternatives = this.#getPredictionAlternatives();
+		if (!alternatives) return false;
+		const original = this.#state.lines[0] ?? "";
+		this.#autocompletePrefix = original;
+		this.#autocompleteList = this.#createAutocompleteList(
+			"",
+			alternatives.choices.map(value => ({ value, label: value })),
+		);
+		this.#autocompleteList.setSelectedIndex(alternatives.index);
+		this.#autocompleteState = "assist";
+		this.#textAssistReplacement = {
+			line: 0,
+			startCol: 0,
+			endCol: original.length,
+			original,
+			cursorOffset: 0,
+			prediction: true,
+		};
+		this.onAutocompleteUpdate?.();
 		return true;
 	}
 
@@ -5169,7 +5226,7 @@ export class Editor implements Component, Focusable {
 		this.onAutocompleteUpdate?.();
 	}
 
-	#applySpellingSuggestion(): void {
+	#applyAssistReplacement(): void {
 		const replacement = this.#textAssistReplacement;
 		const selected = this.#autocompleteList?.getSelectedItem();
 		if (!replacement || !selected) {
@@ -5177,8 +5234,13 @@ export class Editor implements Component, Focusable {
 			return;
 		}
 		const line = this.#state.lines[replacement.line] ?? "";
-		if (line.slice(replacement.startCol, replacement.endCol) !== replacement.original) {
+		// A mismatch means the list went stale; picking the prediction already in the buffer changes nothing.
+		if (
+			line.slice(replacement.startCol, replacement.endCol) !== replacement.original ||
+			(replacement.prediction && selected.value === replacement.original)
+		) {
 			this.#cancelAutocomplete();
+			this.onAutocompleteUpdate?.();
 			return;
 		}
 		this.#recordUndoState();
@@ -5190,6 +5252,11 @@ export class Editor implements Component, Focusable {
 		this.#cancelAutocomplete();
 		this.onAutocompleteUpdate?.();
 		this.#notifyChange();
+		if (replacement.prediction) {
+			this.#insertedPrediction = selected.value;
+			const index = this.predictions?.()?.indexOf(selected.value) ?? -1;
+			if (index >= 0) this.onPredictionAccepted?.(index);
+		}
 	}
 	async #handleSlashCommandCompletion(): Promise<void> {
 		await this.#tryTriggerAutocomplete();
@@ -5395,7 +5462,8 @@ export class Editor implements Component, Focusable {
 
 	/**
 	 * Get inline hint text to show as dim ghost text after the cursor.
-	 * Checks the selected autocomplete item's hint first, then the prediction, then the provider.
+	 * Checks the selected autocomplete item's hint first, then the prediction and its alternatives,
+	 * then the provider.
 	 */
 	#getInlineHint(): string | null {
 		// Check selected autocomplete item for a hint
@@ -5406,7 +5474,12 @@ export class Editor implements Component, Focusable {
 
 		const prediction = this.#getPredictionSuffix();
 		if (prediction) return prediction;
-
+		const alternatives = this.#getPredictionAlternatives();
+		if (alternatives) {
+			// Tab opens the alternatives list from here; without a bound key there is nothing to hint.
+			const tab = editorKey("tui.input.tab");
+			if (tab) return ` ${tab} ${alternatives.choices.length - 1} more`;
+		}
 		// Fall back to provider's getInlineHint
 		if (this.#autocompleteProvider?.getInlineHint) {
 			const hint = this.#autocompleteProvider.getInlineHint(
@@ -5423,18 +5496,44 @@ export class Editor implements Component, Focusable {
 		if (this.#autocompleteState || !this.#isEditorEmpty() || this.#getPredictionSuffix()) return undefined;
 		return this.placeholder?.() || undefined;
 	}
-	/** The part of {@link prediction} not yet typed, or `null` when no prediction is shown. */
+	/** The part of the shown prediction not yet typed, or `null` when no prediction is shown. */
 	#getPredictionSuffix(): string | null {
+		return this.#getShownPrediction()?.suffix ?? null;
+	}
+	/**
+	 * The prediction painted as ghost text: the first one the single-line buffer is a strict prefix of,
+	 * with the cursor at its end and no autocomplete open. None while the buffer is a prediction insert
+	 * that equals one of two or more predictions, so Tab opens their list rather than extending to a
+	 * longer one; a buffer the user typed keeps its ghost.
+	 */
+	#getShownPrediction(): { index: number; suffix: string } | null {
 		if (this.#autocompleteState) return null;
-		const prediction = this.prediction?.();
-		if (!prediction) return null;
+		const predictions = this.predictions?.();
+		if (!predictions?.length) return null;
 		const { lines, cursorCol } = this.#state;
 		if (lines.length !== 1) return null;
 		const typed = lines[0] ?? "";
-		if (cursorCol !== typed.length || typed.length >= prediction.length || !prediction.startsWith(typed)) {
-			return null;
-		}
-		return prediction.slice(typed.length);
+		if (cursorCol !== typed.length) return null;
+		if (predictions.length > 1 && typed === this.#insertedPrediction && predictions.includes(typed)) return null;
+		const index = predictions.findIndex(
+			prediction => typed.length < prediction.length && prediction.startsWith(typed),
+		);
+		return index < 0 ? null : { index, suffix: predictions[index]!.slice(typed.length) };
+	}
+	/**
+	 * Two or more predictions, and which one the single-line buffer equals with the cursor at its end:
+	 * Tab then opens the list of all of them.
+	 */
+	#getPredictionAlternatives(): { choices: readonly string[]; index: number } | null {
+		if (this.#autocompleteState) return null;
+		const choices = this.predictions?.();
+		if (!choices || choices.length < 2) return null;
+		const { lines, cursorCol } = this.#state;
+		if (lines.length !== 1) return null;
+		const typed = lines[0] ?? "";
+		if (cursorCol !== typed.length) return null;
+		const index = choices.indexOf(typed);
+		return index < 0 ? null : { choices, index };
 	}
 	/** Typing `typed` where it diverges from the shown ghost completion rejects that ghost. */
 	#reportTypedPastWordCompletion(typed: string): void {

package/src/components/key-value-list.ts

@@ -2,7 +2,15 @@ import { compactText, styleSpans } from "../native/spans";
 import { node } from "../native/describe";
 import type { DescribeContext, NativeNode } from "../native/node";
 import type { Component } from "../tui";
-import { Ellipsis, getWidthConfigEpoch, replaceTabs, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../utils";
+import {
+	Ellipsis,
+	finiteWidth,
+	getWidthConfigEpoch,
+	singleLine,
+	truncateToWidth,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "../utils";
 
 /** One label/value entry in a {@link KeyValueList}. */
 export interface KeyValueRow {
@@ -21,14 +29,6 @@ export interface KeyValueListOptions {
 	readonly labelOverflow?: "allow" | "truncate";
 }
 
-function finiteWidth(width: number): number {
-	return Number.isFinite(width) ? Math.max(0, Math.trunc(width)) : 0;
-}
-
-function singleLine(text: string): string {
-	return replaceTabs(text).replace(/[\r\n]+/g, " ");
-}
-
 /** A bounded ANSI-aware label/value list with replaceable rows and aligned wrapped continuations. */
 export class KeyValueList implements Component {
 	#rows: readonly KeyValueRow[];

package/src/components/loader.ts

@@ -325,6 +325,13 @@ export class Loader extends Text {
 	dispose() {
 		this.stop();
 	}
+
+	/** The current spinner frame and message as one styled line, for hosts that set it into their own chrome. */
+	inlineText(): string {
+		const spinner = this.spinnerColorFn(this.#frames[this.#currentFrame]);
+		return `${spinner} ${this.messageColorFn(this.#resolveMessage())}`;
+	}
+
 	/** Install a lazy right-docked suffix for the spinner row (e.g. a styled
 	 * session title). Re-evaluated every paint; dropped when the row leaves
 	 * less than a two-cell gap. */

package/src/components/section.ts

@@ -2,20 +2,12 @@ import { compactText, rowsText, styledSpans } from "../native/spans";
 import { node } from "../native/describe";
 import type { DescribeContext, NativeNode } from "../native/node";
 import type { Component } from "../tui";
-import { Ellipsis, getWidthConfigEpoch, replaceTabs, truncateToWidth, visibleWidth } from "../utils";
+import { Ellipsis, finiteWidth, getWidthConfigEpoch, singleLine, truncateToWidth, visibleWidth } from "../utils";
 
 function isComponent(body: Component | readonly string[]): body is Component {
 	return !Array.isArray(body);
 }
 
-function finiteWidth(width: number): number {
-	return Number.isFinite(width) ? Math.max(0, Math.trunc(width)) : 0;
-}
-
-function singleLine(text: string): string {
-	return replaceTabs(text).replace(/[\r\n]+/g, " ");
-}
-
 function fillCells(glyph: string, width: number): string {
 	const cleanGlyph = singleLine(glyph);
 	const glyphWidth = visibleWidth(cleanGlyph);

package/src/components/table.ts

@@ -3,7 +3,7 @@ import { compactText, styleSpans } from "../native/spans";
 import { node } from "../native/describe";
 import type { DescribeContext, NativeNode } from "../native/node";
 import type { Component } from "../tui";
-import { Ellipsis, getWidthConfigEpoch, replaceTabs, truncateToWidth, visibleWidth } from "../utils";
+import { Ellipsis, finiteWidth, getWidthConfigEpoch, singleLine, truncateToWidth, visibleWidth } from "../utils";
 
 /** One table cell. Styling is applied after alignment so padding shares the cell style. */
 export interface TableCell {
@@ -29,14 +29,6 @@ export interface TableOptions {
 	readonly fit?: boolean;
 }
 
-function finiteWidth(width: number, fallback = 0): number {
-	return Number.isFinite(width) ? Math.max(0, Math.trunc(width)) : fallback;
-}
-
-function singleLine(text: string): string {
-	return replaceTabs(text).replace(/[\r\n]+/g, " ");
-}
-
 function fitWidths(columns: readonly TableColumn[], maxWidth: number, gapWidth: number): number[] {
 	const widths = columns.map(column => finiteWidth(column.width));
 	let overflow = widths.reduce((sum, width) => sum + width, 0) + Math.max(0, columns.length - 1) * gapWidth - maxWidth;

package/src/keybinding-matchers.ts

@@ -120,3 +120,16 @@ export function appApproveKeys(): readonly KeyId[] {
 export function matchesAppApprove(data: string): boolean {
 	return matchesEffectiveKeys(data, appApproveKeys());
 }
+
+/**
+ * Effective /btw inject key (Alt+I by default). No fallback: it sends text into the main
+ * session, so a user who unbinds it gets no key at all.
+ */
+export function appBtwInjectKey(): KeyId | undefined {
+	return getKeybindings().getKeys("app.btw.inject")[0];
+}
+
+/** Match the key that sends a /btw answer's steering prompt to the main session. */
+export function matchesAppBtwInject(data: string): boolean {
+	return getKeybindings().matches(data, "app.btw.inject");
+}

package/src/overlays/btw-history-panel.ts

@@ -18,7 +18,10 @@ import {
 	getBtwLatestTurn,
 	getBtwTopicLabel,
 	getBtwTurns,
+	type BtwInjectParts,
+	splitBtwInject,
 } from "./btw-history";
+import { BtwInjectAnswer, type BtwInjectState, describeBtwInjectAnswer } from "./btw-inject";
 import { compactImageMarkers, formatVisionMarker } from "../prompt/composer-attachments";
 import { extractImagePastePathsFromText } from "../prompt/custom-editor";
 import { BracketedPasteHandler } from "../bracketed-paste";
@@ -29,6 +32,8 @@ import {
 	matchesSelectPageDown,
 	matchesSelectPageUp,
 	matchesSelectUp,
+	appBtwInjectKey,
+	matchesAppBtwInject,
 } from "../keybinding-matchers";
 import type { SpaceHoldHandler } from "../space-hold";
 import { sanitizeErrorLine } from "../chrome/error-block";
@@ -77,6 +82,25 @@ interface BtwHistoryPanelOptions {
 	 * first. For a host with no inline panel to fall back to (Tern).
 	 */
 	escapeHides?: boolean;
+	/** `btw.inject` hooks, given only while it is on for this view. */
+	inject?: BtwHistoryInject;
+}
+
+interface BtwHistoryInject {
+	/**
+	 * How a finished turn's closed `<inject>` block shows: apart from its prose while pending or
+	 * sent, plain text when `undefined`. A streaming turn always shows its block.
+	 */
+	state: (record: BtwHistoryRecord, turnIndex: number) => BtwInjectState | undefined;
+	/** Whether the inject key may send the record's latest block now. */
+	canSend: (record: BtwHistoryRecord) => boolean;
+	send: (record: BtwHistoryRecord) => void;
+}
+
+/** A turn's `<inject>` block as displayed apart from its prose. */
+interface InjectBlock {
+	parts: BtwInjectParts;
+	state: BtwInjectState;
 }
 
 interface FollowUpComposer {
@@ -95,6 +119,8 @@ interface RenderedTurn {
 	turn: BtwHistoryTurn;
 	question: Markdown;
 	answer: Markdown;
+	/** How the answer's `<inject>` block showed; `undefined` when it rendered as plain text. */
+	block: BtwInjectState | undefined;
 	lines: readonly string[];
 	width: number;
 }
@@ -110,6 +136,8 @@ interface BtwHistoryNativeMemo {
 	followUpPending: boolean;
 	canFollowUp: boolean;
 	copied: boolean;
+	canInject: boolean;
+	latestInject: BtwInjectState | undefined;
 	scroll: NativeScroll | undefined;
 	node: NativeNode;
 }
@@ -512,6 +540,10 @@ export class BtwHistoryPanel implements Component, Focusable {
 			if (record && getBtwCopyText(record) !== undefined) this.#options.onCopy(record);
 			return;
 		}
+		if (this.#options.inject && matchesAppBtwInject(data)) {
+			this.#sendInject(record);
+			return;
+		}
 		// Legacy terminals deliver Ctrl+/ (and Ctrl+_) as US without Kitty protocol.
 		if (
 			matchesKey(data, "tab") ||
@@ -576,6 +608,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 		const composer = this.#composer;
 		const canFollowUp = record !== undefined && this.#canFollowUp(record);
 		const copied = record !== undefined && this.#isCopied(record);
+		const canInject = record !== undefined && this.#options.inject?.canSend(record) === true;
+		const latestInject = record && this.#options.inject?.state(record, getBtwTurns(record).length - 1);
 		const memo = this.#native;
 		if (
 			memo?.records === this.#records &&
@@ -587,6 +621,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 			memo.followUpPending === this.#followUpPending &&
 			memo.canFollowUp === canFollowUp &&
 			memo.copied === copied &&
+			memo.canInject === canInject &&
+			memo.latestInject === latestInject &&
 			memo.scroll === this.#scroll
 		) {
 			return memo.node;
@@ -612,7 +648,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 		} else {
 			children.push(this.#describeEmpty());
 		}
-		children.push(this.#describeActions(record, canFollowUp, copied));
+		children.push(this.#describeActions(record, canFollowUp, copied, canInject));
 		// The sheet is the frame (`nativeOverlay`); its last row is the pinned footer.
 		const described = col(children, { gap: "none" });
 		this.#native = {
@@ -625,6 +661,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 			followUpPending: this.#followUpPending,
 			canFollowUp,
 			copied,
+			canInject,
+			latestInject,
 			scroll: this.#scroll,
 			node: described,
 		};
@@ -641,6 +679,9 @@ export class BtwHistoryPanel implements Component, Focusable {
 				case "copy-answer":
 					if (record && getBtwCopyText(record) !== undefined) this.#options.onCopy(record);
 					break;
+				case "inject":
+					this.#sendInject(record);
+					break;
 				case "follow-up":
 					if (record) this.openFollowUp(record.id);
 					break;
@@ -698,12 +739,31 @@ export class BtwHistoryPanel implements Component, Focusable {
 	/** The selected side question as a short document: the asked question titles each answer. */
 	#describeThread(record: BtwHistoryRecord): NativeNode {
 		const turns = getDisplayTurns(record);
-		const children: NativeChild[] = turns.map((turn, index) => this.#describeTurn(turn, index, `turn-${index}`));
+		const children: NativeChild[] = turns.map((turn, index) =>
+			this.#describeTurn(turn, index, `turn-${index}`, this.#injectBlock(record, turn, index)),
+		);
 		if (this.#composer) children.push(this.#describeComposer(this.#composer));
 		return node("col", { role: "omp.btw.thread" }, children, "thread");
 	}
 
-	#describeTurn(turn: BtwHistoryTurn, index: number, key: string): NativeNode {
+	#sendInject(record: BtwHistoryRecord | undefined): void {
+		const inject = this.#options.inject;
+		if (!record || !inject?.canSend(record)) return;
+		inject.send(record);
+		this.#detailDirty = true;
+		this.#options.requestRender();
+	}
+
+	/** The turn's `<inject>` block to show apart from its prose, if any (see {@link BtwHistoryInject.state}). */
+	#injectBlock(record: BtwHistoryRecord, turn: BtwHistoryTurn, index: number): InjectBlock | undefined {
+		const inject = this.#options.inject;
+		const parts = inject ? splitBtwInject(turn.answer) : undefined;
+		if (!inject || !parts) return undefined;
+		const state = turn.status === "running" ? "pending" : parts.closed ? inject.state(record, index) : undefined;
+		return state && { parts, state };
+	}
+
+	#describeTurn(turn: BtwHistoryTurn, index: number, key: string, block: InjectBlock | undefined): NativeNode {
 		const meta: TspSpan[] =
 			index === 0
 				? [span(this.#dateFormat.format(turn.createdAt))]
@@ -717,11 +777,12 @@ export class BtwHistoryPanel implements Component, Focusable {
 		];
 		// A failed turn with no text says only why it failed.
 		if (turn.answer.trim() || !turn.error) {
-			const answer = turn.answer.trim()
-				? md(sanitizeDisplayText(turn.answer), { stream: turn.status === "running" })
-				: text([span(turn.status === "running" ? "Thinking…" : "No answer text.", "dim")], {
-						role: "omp.btw.pending",
-					});
+			const stream = turn.status === "running";
+			const answer = block
+				? describeBtwInjectAnswer(block.parts, block.state === "sent", stream)
+				: turn.answer.trim()
+					? md(sanitizeDisplayText(turn.answer), { stream })
+					: text([span(stream ? "Thinking…" : "No answer text.", "dim")], { role: "omp.btw.pending" });
 			children.push(node("col", { role: "omp.btw.answer" }, [answer], "answer"));
 		}
 		if (turn.error) {
@@ -772,7 +833,12 @@ export class BtwHistoryPanel implements Component, Focusable {
 	 * primary action (Follow up, or Send while composing) in the corner. Keys
 	 * live in the buttons' tooltips.
 	 */
-	#describeActions(record: BtwHistoryRecord | undefined, canFollowUp: boolean, copied: boolean): NativeNode {
+	#describeActions(
+		record: BtwHistoryRecord | undefined,
+		canFollowUp: boolean,
+		copied: boolean,
+		canInject: boolean,
+	): NativeNode {
 		if (this.#composer) {
 			return actionBar([
 				null,
@@ -784,6 +850,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 		const hides = this.#options.escapeHides === true;
 		const buttons: (NativeNode | null)[] = [];
 		if (running) buttons.push(actionButton("Stop answer", "stop", { keys: hides ? "x" : "escape" }));
+		if (canInject) buttons.push(actionButton("Inject into main", "inject", { keys: appBtwInjectKey() }));
 		if (record && getBtwCopyText(record) !== undefined) {
 			buttons.push(actionButton(copied ? "Copy again" : "Copy answer", "copy-answer", { keys: "c" }));
 			if (copied) buttons.push(text([span("✓ Copied", "success")], { role: "omp.btw.copied" }));
@@ -847,7 +914,12 @@ export class BtwHistoryPanel implements Component, Focusable {
 		});
 	}
 
-	#renderTurn(turn: BtwHistoryTurn, cached: RenderedTurn | undefined, width: number): RenderedTurn {
+	#renderTurn(
+		turn: BtwHistoryTurn,
+		cached: RenderedTurn | undefined,
+		width: number,
+		block: InjectBlock | undefined,
+	): RenderedTurn {
 		const previous = cached?.turn;
 		if (
 			cached &&
@@ -856,14 +928,16 @@ export class BtwHistoryPanel implements Component, Focusable {
 			turn.answer === previous?.answer &&
 			turn.status === previous?.status &&
 			turn.error === previous?.error &&
-			turn.createdAt === previous?.createdAt
+			turn.createdAt === previous?.createdAt &&
+			block?.state === cached.block
 		) {
 			return cached;
 		}
 		const question = cached?.question ?? new Markdown("", 0, 0, getMarkdownTheme());
 		const answer = cached?.answer ?? new Markdown("", 0, 0, getMarkdownTheme());
 		if (turn.question !== previous?.question) question.setText(sanitizeDisplayText(turn.question));
-		if (turn.answer !== previous?.answer) answer.setText(sanitizeDisplayText(turn.answer));
+		// A block's state can change while the answer stays the same, so the plain text is reset on every miss.
+		if (!block) answer.setText(sanitizeDisplayText(turn.answer));
 		const status = STATUS[turn.status];
 		const lines = [
 			...wrapTextWithAnsi(
@@ -876,7 +950,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 			"",
 			theme.bold(theme.fg("accent", "Answer")),
 		];
-		if (turn.answer.trim()) lines.push(...answer.render(width));
+		if (block) lines.push(...new BtwInjectAnswer(block.parts, block.state === "sent").render(width));
+		else if (turn.answer.trim()) lines.push(...answer.render(width));
 		else
 			lines.push(
 				...wrapTextWithAnsi(
@@ -898,6 +973,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 			},
 			question,
 			answer,
+			block: block?.state,
 			lines,
 			width,
 		};
@@ -915,7 +991,12 @@ export class BtwHistoryPanel implements Component, Focusable {
 			if (record) {
 				const turns = getDisplayTurns(record);
 				for (let index = 0; index < turns.length; index++) {
-					const cached = this.#renderTurn(turns[index]!, this.#turns[index], inner);
+					const cached = this.#renderTurn(
+						turns[index]!,
+						this.#turns[index],
+						inner,
+						this.#injectBlock(record, turns[index]!, index),
+					);
 					this.#turns[index] = cached;
 					if (index > 0) lines.push("", theme.fg("dim", theme.boxRound.horizontal.repeat(inner)), "");
 					lines.push(...cached.lines);
@@ -975,6 +1056,9 @@ export class BtwHistoryPanel implements Component, Focusable {
 				];
 		if (!composer) {
 			if (record && this.#canFollowUp(record)) actions.push(rawKeyHint(["f", "enter"], "follow up"));
+			const injectKey = appBtwInjectKey();
+			if (injectKey && record && this.#options.inject?.canSend(record))
+				actions.push(rawKeyHint(injectKey, "inject"));
 			if (record && getBtwCopyText(record) !== undefined) {
 				if (this.#isCopied(record))
 					actions.push(theme.fg("success", `✓ copied · ${formatKeyHint("c")} to copy again`));