@oh-my-pi/pi-tui 18.4.10 → 18.4.12

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.4.12] - 2026-10-02
+
+### Changed
+
+- Changed Ctrl+Z in Tern's native composer to undo the last edit (TSP `undo` event) instead of suspending
+
+## [18.4.11] - 2026-10-02
+
+### Added
+
+- Added subagent completion percentages to the agent tree, task, and wait views.
+
+### Changed
+
+- Updated notebook evaluation cells in native hosts to use directional gutter indicators for inputs and outputs, with a progress indicator while a cell is running.
+
+### Fixed
+
+- Fixed multiline paste on Windows so pasted line breaks are inserted correctly instead of terminal escape sequences.
+
 ## [18.4.10] - 2026-10-02
 
 ### Added

package/dist/types/components/editor.d.ts

@@ -296,7 +296,7 @@ export declare class Editor implements Component, Focusable {
     submit(): void;
     /** Insert text at the current cursor position */
     insertText(text: string): void;
-    /** Terminal-side selection edits on the `editor` node (see {@link applyHostEdit}). */
+    /** Terminal-side selection edits and undo on the `editor` node (see {@link applyHostEdit}). */
     handleNativeEvent(event: NativeUiEvent): void;
     /**
      * Apply an edit the terminal made over its own selection (TSP `edit`):

package/dist/types/components/input.d.ts

@@ -39,7 +39,7 @@ export declare class Input implements Component, Focusable {
     /** Apply terminal paste semantics to text from non-bracketed paste transports
      *  (e.g. kitty's OSC 5522 enhanced clipboard read). Mirrors `Editor.pasteText`. */
     pasteText(text: string): void;
-    /** Terminal-side selection edits on the `input` node (see {@link applyHostEdit}). */
+    /** Terminal-side selection edits and undo on the `input` node (see {@link applyHostEdit}). */
     handleNativeEvent(event: NativeUiEvent): void;
     /**
      * Apply an edit the terminal made over its own selection (TSP `edit`):

package/dist/types/native/encode.d.ts

@@ -27,7 +27,8 @@ export declare function encodeTspJson(verb: TspVerb, value: unknown, params?: Ts
 /**
  * The `hello` query; callers follow it with a DA1 sentinel. `features: ["edit"]`
  * tells the terminal that omp applies its `edit` events (TSP §8.5), so it may keep a
- * native selection in omp's editors; without it, every key stays omp's.
+ * native selection in omp's editors; without it, every key stays omp's. `"undo"`
+ * says omp applies `undo` events, so the terminal may turn ⌃Z in a field into one.
  */
 export declare function encodeTspHelloQuery(version?: string): string;
 /** One decoded APC message: verb, parameters and raw body. */

package/dist/types/native/node.d.ts

@@ -117,7 +117,12 @@ export type NativeUiEvent = {
  | ({
     readonly type: "edit";
     readonly key: string;
-} & NativeTextEdit);
+} & NativeTextEdit)
+/** Undo the last change to an `editor`/`input` node's text (the terminal's ⌃Z); a no-op with no history. */
+ | {
+    readonly type: "undo";
+    readonly key: string;
+};
 /**
  * A primitive edit the terminal made over its own text selection (cut,
  * typing, Backspace/Delete or paste over it, or collapsing it). Offsets are

package/dist/types/tools/agent-tree.d.ts

@@ -27,6 +27,8 @@ export interface AgentTreeRowOptions {
     description?: string;
     preview?: string;
     stats?: AgentStats;
+    /** The agent's own completion estimate (0–100); shown only while live. */
+    completionPercent?: number;
     durationMs?: number;
 }
 /** Render an agent row while reserving its identifier and required status badges. */

package/dist/types/tools/task.d.ts

@@ -255,6 +255,8 @@ export interface AgentProgress {
     resolvedModelRoute?: string;
     /** True when a live advisor was attached to this run's session, not merely enabled in settings. */
     advisor?: boolean;
+    /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbeMs` side request. */
+    completionPercent?: number;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**

package/dist/types/tools/wait.d.ts

@@ -27,6 +27,8 @@ export interface JobSnapshot {
     resolvedThinkingLevel?: ConfiguredThinkingLevel;
     /** True when the task progress reports an attached live advisor. */
     advisor?: boolean;
+    /** The task agent's latest self-estimated completion (0–100); see `AgentProgress.completionPercent`. */
+    completionPercent?: number;
     resultText?: string;
     errorText?: string;
     /** Source-output metadata retained for per-job warnings and persisted row rendering. */

package/dist/types/tools/write.d.ts

@@ -28,6 +28,15 @@ interface WriteRenderArgs {
     file_path?: unknown;
     content?: unknown;
 }
+/** A write tool result as the renderer receives it. */
+interface WriteResult {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: WriteToolDetails;
+    isError?: boolean;
+}
 declare const writeStreamingPreviewStateKey: unique symbol;
 /**
  * Per-component state for incrementally rendering a streamed write.
@@ -66,27 +75,13 @@ export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions & WriteStreamingPreviewStateCarrier & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme): Component | undefined;
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: WriteToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions & {
+    renderResult(result: WriteResult, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme, args?: WriteRenderArgs): Component;
     describeCall(args: WriteRenderArgs, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }): NativeToolView | undefined;
-    describeResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: WriteToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions & {
+    describeResult(result: WriteResult, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, args?: WriteRenderArgs): NativeToolView | undefined;
     mergeCallAndResult: true;

package/dist/types/windows-input-mode.d.ts

@@ -6,8 +6,11 @@
  * deliver Shift+Enter as a bare `\r` (indistinguishable from Enter) and
  * Ctrl+Enter as `\n`. Enabling `CSI ? 9001 h` makes the console host serving
  * this process report every key as `CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _`, which
- * carries the full modifier state. Paste text, mouse reports and terminal
- * replies keep arriving as plain VT, so only key records need translating.
+ * carries the full modifier state. Mouse reports and terminal replies keep
+ * arriving as plain VT. Pasted text mostly does too, but the console host
+ * re-encodes some pasted characters (line breaks) as key records inside the
+ * bracketed paste; {@link Win32InputModeDecoder.decodePaste} turns those back
+ * into text.
  *
  * Unmodified and legacy-expressible keys translate to the bytes a legacy
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
@@ -23,4 +26,12 @@ export declare class Win32InputModeDecoder {
      * events it produces — empty for key releases and bare modifier presses.
      */
     decode(data: string): string[] | undefined;
+    /**
+     * Replace the key records embedded in bracketed paste `content` with the
+     * text they type, so a pasted line break stays a line break instead of
+     * acting as Enter. Key-downs yield their character (`\r` for Enter);
+     * releases and keys without text yield nothing. Text that merely looks like
+     * a record without ESC is left alone.
+     */
+    decodePaste(content: string): string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.4.10",
+	"version": "18.4.12",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.4.10",
-		"@oh-my-pi/pi-agent-core": "18.4.10",
-		"@oh-my-pi/pi-ai": "18.4.10",
-		"@oh-my-pi/pi-catalog": "18.4.10",
-		"@oh-my-pi/pi-natives": "18.4.10",
-		"@oh-my-pi/pi-utils": "18.4.10",
-		"@oh-my-pi/pi-wire": "18.4.10",
-		"@oh-my-pi/snapcompact": "18.4.10"
+		"@oh-my-pi/omptype": "18.4.12",
+		"@oh-my-pi/pi-agent-core": "18.4.12",
+		"@oh-my-pi/pi-ai": "18.4.12",
+		"@oh-my-pi/pi-catalog": "18.4.12",
+		"@oh-my-pi/pi-natives": "18.4.12",
+		"@oh-my-pi/pi-utils": "18.4.12",
+		"@oh-my-pi/pi-wire": "18.4.12",
+		"@oh-my-pi/snapcompact": "18.4.12"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/apps/git/sidebar.ts

@@ -1007,7 +1007,7 @@ export class Sidebar {
 	 * text field being edited. False when not the sidebar's event.
 	 */
 	handleNativeEvent(event: NativeUiEvent): boolean {
-		if (event.type === "edit") {
+		if (event.type === "edit" || event.type === "undo") {
 			const editing = this.editing ? this.selected?.kind : undefined;
 			const field =
 				editing === "summary"
@@ -1017,7 +1017,7 @@ export class Sidebar {
 						: editing === "description"
 							? this.description
 							: undefined;
-			field?.applyHostEdit(event);
+			field?.handleNativeEvent(event);
 			return field !== undefined;
 		}
 		if (event.type === "select" || event.type === "activate") {

package/src/components/editor.ts

@@ -2862,9 +2862,10 @@ export class Editor implements Component, Focusable {
 		this.#insertTextAtCursor(text);
 	}
 
-	/** Terminal-side selection edits on the `editor` node (see {@link applyHostEdit}). */
+	/** Terminal-side selection edits and undo on the `editor` node (see {@link applyHostEdit}). */
 	handleNativeEvent(event: NativeUiEvent): void {
 		if (event.type === "edit") this.applyHostEdit(event);
+		else if (event.type === "undo") this.#applyUndo();
 	}
 
 	/**

package/src/components/input.ts

@@ -284,9 +284,10 @@ export class Input implements Component, Focusable {
 		this.#handlePaste(text);
 	}
 
-	/** Terminal-side selection edits on the `input` node (see {@link applyHostEdit}). */
+	/** Terminal-side selection edits and undo on the `input` node (see {@link applyHostEdit}). */
 	handleNativeEvent(event: NativeUiEvent): void {
 		if (event.type === "edit") this.applyHostEdit(event);
+		else if (event.type === "undo") this.#undo();
 	}
 
 	/**

package/src/native/backend.ts

@@ -671,6 +671,7 @@ export class NativeBackend {
 			case "action":
 			case "change":
 			case "edit":
+			case "undo":
 				this.#routeUiEvent(event);
 				return;
 			case "focus": {
@@ -687,7 +688,7 @@ export class NativeBackend {
 	}
 
 	#routeUiEvent(
-		event: Extract<TspEvent, { ev: "toggle" | "select" | "activate" | "action" | "change" | "edit" }>,
+		event: Extract<TspEvent, { ev: "toggle" | "select" | "activate" | "action" | "change" | "edit" | "undo" }>,
 	): void {
 		const reconciler = this.#surfaceFor(event.sf)?.reconciler;
 		const target = reconciler?.target(event.id);
@@ -721,6 +722,9 @@ export class NativeBackend {
 				ui = { type: "edit", key: target.keypath, from, to, text, cursor, len };
 				break;
 			}
+			case "undo":
+				ui = { type: "undo", key: target.keypath };
+				break;
 		}
 		target.component.handleNativeEvent(ui);
 		this.#host.requestRender();

package/src/native/encode.ts

@@ -109,10 +109,11 @@ export function encodeTspJson(verb: TspVerb, value: unknown, params?: TspParams,
 /**
  * The `hello` query; callers follow it with a DA1 sentinel. `features: ["edit"]`
  * tells the terminal that omp applies its `edit` events (TSP §8.5), so it may keep a
- * native selection in omp's editors; without it, every key stays omp's.
+ * native selection in omp's editors; without it, every key stays omp's. `"undo"`
+ * says omp applies `undo` events, so the terminal may turn ⌃Z in a field into one.
  */
 export function encodeTspHelloQuery(version?: string): string {
-	return encodeTspJson("q", { q: "hello", v: [TSP_VERSION], app: "omp", features: ["edit"], ver: version });
+	return encodeTspJson("q", { q: "hello", v: [TSP_VERSION], app: "omp", features: ["edit", "undo"], ver: version });
 }
 
 /** One decoded APC message: verb, parameters and raw body. */
@@ -172,6 +173,7 @@ const EVENT_REQUIRED: Readonly<Record<string, Readonly<Record<string, "string" |
 	// `value` varies by control (boolean, number, string, string[], null): the handler checks it.
 	change: { id: "string", item: "string" },
 	edit: { id: "string", from: "number", to: "number", text: "string", cursor: "number", len: "number" },
+	undo: { id: "string" },
 	focus: { id: "string" },
 	error: { msg: "string" },
 	gone: { ids: "array" },

package/src/native/node.ts

@@ -113,7 +113,9 @@ export type NativeUiEvent =
 			readonly value: boolean | number | string | readonly string[] | null;
 	  }
 	/** An edit over the terminal's own selection in an `editor`/`input` node (see {@link NativeTextEdit}). */
-	| ({ readonly type: "edit"; readonly key: string } & NativeTextEdit);
+	| ({ readonly type: "edit"; readonly key: string } & NativeTextEdit)
+	/** Undo the last change to an `editor`/`input` node's text (the terminal's ⌃Z); a no-op with no history. */
+	| { readonly type: "undo"; readonly key: string };
 
 /**
  * A primitive edit the terminal made over its own text selection (cut,

package/src/terminal.ts

@@ -1615,10 +1615,12 @@ export class ProcessTerminal implements Terminal {
 		// Re-wrap paste content with bracketed paste markers for existing editor
 		// handling. An Enter that shared the paste's stdin read rides along so
 		// paste and submit reach the component focused right now, not one the
-		// paste itself is about to open.
+		// paste itself is about to open. Under win32-input-mode the console host
+		// encodes pasted line breaks as key records; decode them as text (#14065).
 		this.#stdinBuffer.on("paste", (content: string, enter?: string) => {
 			if (this.#inputHandler) {
-				this.#inputHandler(`\x1b[200~${content}\x1b[201~${enter ?? ""}`);
+				const text = this.#win32InputDecoder?.decodePaste(content) ?? content;
+				this.#inputHandler(`\x1b[200~${text}\x1b[201~${enter ?? ""}`);
 			}
 		});
 

package/src/tools/agent-tree.ts

@@ -60,6 +60,8 @@ export interface AgentTreeRowOptions {
 	description?: string;
 	preview?: string;
 	stats?: AgentStats;
+	/** The agent's own completion estimate (0–100); shown only while live. */
+	completionPercent?: number;
 	durationMs?: number;
 }
 
@@ -120,6 +122,9 @@ export function renderAgentTreeRow(
 	}
 	let line = `${lead}${modelLead}${title}${badges}`;
 	if (options.preview) line += options.preview;
+	if (live && options.completionPercent !== undefined) {
+		line += `${theme.sep.dot}${theme.fg("accent", `${options.completionPercent}%`)}`;
+	}
 	if (options.stats) line += formatAgentStatRun(options.stats, theme);
 	if (options.durationMs !== undefined && options.durationMs > 0) {
 		line += `${theme.sep.dot}${theme.fg("dim", formatDuration(options.durationMs))}`;

package/src/tools/eval.ts

@@ -689,8 +689,9 @@ interface EvalCellSection {
 }
 
 /**
- * A notebook cell with separate input and output gutters. Only multi-cell
- * calls repeat titles; prompts show execution state, never invented counts.
+ * A notebook cell: a gutter mark beside the input (←, muted until the cell
+ * runs, omp's thinking starburst while it does) and beside its output (→).
+ * Only multi-cell calls repeat titles; marks never invent execution counts.
  */
 function evalCellSection(cell: EvalCellSection, index: number, total: number): NativeNode {
 	let head: TspSpan[] | undefined;
@@ -701,7 +702,15 @@ function evalCellSection(cell: EvalCellSection, index: number, total: number): N
 		if (cell.status === "error") head.push(span(" · failed", "error"));
 		if (cell.durationMs !== undefined) head.push(span(` · ${(cell.durationMs / 1000).toFixed(2)}s`, "muted"));
 	}
-	const prompt = cell.status === "running" ? "In [*]:" : !cell.status || cell.status === "pending" ? "In [ ]:" : "In:";
+	const inputMark =
+		cell.status === "running"
+			? node("spinner", { style: "starburst", role: "omp.tool.eval.prompt", aria: "Running" })
+			: node("icon", {
+					name: "arrow-left",
+					role: "omp.tool.eval.prompt",
+					aria: "Input",
+					tone: !cell.status || cell.status === "pending" ? "muted" : undefined,
+				});
 	return node(
 		"col",
 		{
@@ -714,7 +723,7 @@ function evalCellSection(cell: EvalCellSection, index: number, total: number): N
 				"row",
 				{ role: "omp.tool.eval.input", align: "start" },
 				[
-					text(prompt, { role: "omp.tool.eval.prompt", wrap: "none" }),
+					inputMark,
 					keyed(codeNode(cell.code, { lang: languageForHighlighter(cell.language), numbers: false }), "code"),
 				],
 				"input",
@@ -724,7 +733,7 @@ function evalCellSection(cell: EvalCellSection, index: number, total: number): N
 						"row",
 						{ role: "omp.tool.eval.result", align: "start" },
 						[
-							text("Out:", { role: "omp.tool.eval.prompt", wrap: "none" }),
+							node("icon", { name: "arrow-right", role: "omp.tool.eval.prompt", aria: "Output" }),
 							node("col", { role: "omp.tool.eval.outputs" }, cell.output),
 						],
 						"output",

package/src/tools/task.ts

@@ -715,6 +715,7 @@ function renderAgentProgress(
 					? ` ${theme.fg("muted", previewLine(sanitizeText(progress.assignment ?? progress.task), 40))}`
 					: undefined,
 			stats: progress.status === "running" || progress.status === "completed" ? progress : undefined,
+			completionPercent: progress.completionPercent,
 		},
 		theme,
 	);
@@ -1837,6 +1838,7 @@ function describeProgressAgent(progress: AgentProgress, state: AgentDescribeStat
 				requests: progress.requests || undefined,
 				tokens: progress.tokens || undefined,
 				...contextStats(progress.contextTokens, progress.contextWindow),
+				done: running && progress.completionPercent !== undefined ? progress.completionPercent / 100 : undefined,
 				cost: progress.cost > 0 ? progress.cost : undefined,
 				...(running ? { age: progress.durationMs } : { took: progress.durationMs }),
 			},
@@ -2312,6 +2314,8 @@ export interface AgentProgress {
 	resolvedModelRoute?: string;
 	/** True when a live advisor was attached to this run's session, not merely enabled in settings. */
 	advisor?: boolean;
+	/** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbeMs` side request. */
+	completionPercent?: number;
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
 	/**

package/src/tools/wait.ts

@@ -61,6 +61,8 @@ export interface JobSnapshot {
 	resolvedThinkingLevel?: ConfiguredThinkingLevel;
 	/** True when the task progress reports an attached live advisor. */
 	advisor?: boolean;
+	/** The task agent's latest self-estimated completion (0–100); see `AgentProgress.completionPercent`. */
+	completionPercent?: number;
 	resultText?: string;
 	errorText?: string;
 	/** Source-output metadata retained for per-job warnings and persisted row rendering. */
@@ -309,7 +311,11 @@ function jobsRenderResult(
 							job.status === "running" ? options.spinnerFrame : undefined,
 						)}${job.exitCode === undefined ? "" : `${uiTheme.sep.dot}${uiTheme.fg(job.exitCode === 0 ? "muted" : "error", `exit ${job.exitCode}`)}`}`;
 						const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
-						const durationSuffix = `${uiTheme.sep.dot}${uiTheme.fg("dim", formatDuration(job.durationMs))}`;
+						const completion =
+							job.status === "running" && job.completionPercent !== undefined
+								? `${uiTheme.sep.dot}${uiTheme.fg("accent", `${job.completionPercent}%`)}`
+								: "";
+						const durationSuffix = `${completion}${uiTheme.sep.dot}${uiTheme.fg("dim", formatDuration(job.durationMs))}`;
 						const displayId = truncateToWidth(
 							replaceTabs(job.id).replace(/\s+/g, " "),
 							Math.max(0, rowWidth - visibleWidth(`${icon} ${typeBadge} ${durationSuffix}`)),
@@ -601,11 +607,19 @@ function describeJob(job: JobSnapshot, isPartial: boolean): NativeNode {
 		{ role: "omp.wait.job", tone },
 		compact([
 			row(
-				[
+				compact([
 					node("badge", { text: job.type, tone }),
 					text(spans, { truncate: "end", grow: 1 }),
+					job.status === "running" && job.completionPercent !== undefined
+						? node("progress", {
+								value: job.completionPercent / 100,
+								label: `${job.completionPercent}%`,
+								tone: "accent",
+								title: "Agent's own completion estimate",
+							})
+						: undefined,
 					elapsed(job.durationMs, !running),
-				],
+				]),
 				{ gap: "sm" },
 			),
 			artifactError && text([span(formatArtifactErrorNotice(artifactError), "warning")], { wrap: "word" }),

package/src/tools/write.ts

@@ -32,7 +32,8 @@ import {
 } from "./proc-render";
 import type { TspTone } from "@oh-my-pi/pi-wire";
 import { code, compact, node, span } from "../native/describe";
-import type { NativeChild } from "../native/node";
+import { registerNativeBlob } from "../native/blobs";
+import type { NativeChild, NativeNode } from "../native/node";
 import { diagnosticsBadge, diagnosticsSection, displayPath, errorText, fileHref, resultText } from "./native-view";
 import { describeCfgWrite, renderCfgWrite, type CfgWriteDetails } from "./cfg-render";
 import type { FileDiagnosticsResult } from "./lsp";
@@ -90,6 +91,37 @@ interface WriteRenderArgs {
 const WRITE_PREVIEW_LINES = 6;
 /** Collapsed native write body: the first lines of the file (§7.3). */
 const NATIVE_WRITE_PREVIEW = { lines: 8 } as const;
+/** Tallest rendered SVG preview, in lines; collapsed, the card shows just the picture. */
+const NATIVE_SVG_PREVIEW_LINES = 16;
+
+/** A write tool result as the renderer receives it. */
+interface WriteResult {
+	content: Array<{ type: string; text?: string }>;
+	details?: WriteToolDetails;
+	isError?: boolean;
+}
+
+/** Cached SVG preview node on its result, so the content is encoded and hashed once per write. */
+const kSvgPreview = Symbol("write.svgPreview");
+
+interface TaggedWriteResult extends WriteResult {
+	[kSvgPreview]?: { content: string; node: NativeNode };
+}
+
+/** Native `image` node drawing written SVG `content`, cached on `result`. */
+function describeSvgPreview(result: TaggedWriteResult, content: string, alt: string): NativeNode {
+	const cached = result[kSvgPreview];
+	if (cached?.content === content) return cached.node;
+	const blob = registerNativeBlob(new TextEncoder().encode(content), "image/svg+xml");
+	const preview = node("image", {
+		blob,
+		alt,
+		role: "omp.tool.write.image",
+		max: { h: `${NATIVE_SVG_PREVIEW_LINES}lines` },
+	});
+	result[kSvgPreview] = { content, node: preview };
+	return preview;
+}
 
 function countLines(text: string): number {
 	if (!text) return 0;
@@ -589,7 +621,7 @@ export const writeToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
+		result: WriteResult,
 		options: RenderResultOptions & { renderContext?: WriteRenderContext },
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
@@ -722,7 +754,7 @@ export const writeToolRenderer = {
 	},
 
 	describeResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
+		result: WriteResult,
 		options: RenderResultOptions & { renderContext?: WriteRenderContext },
 		args?: WriteRenderArgs,
 	): NativeToolView | undefined {
@@ -744,10 +776,13 @@ export const writeToolRenderer = {
 		});
 		if (result.isError) return { tool, tone: "error", body: [errorText(resultText(result))] };
 		const progressText = resultText(result);
+		// A finished SVG write leads with the drawing; its source follows below the collapsed clamp.
+		const svg = !isPartial && fileContent.trim().length > 0 && rawPath.toLowerCase().endsWith(".svg");
 		const body = compact<NativeChild>([
 			isPartial &&
 				progressText.length > 0 &&
 				node("text", { spans: [span(progressText, "muted")], truncate: "end" }),
+			svg && describeSvgPreview(result, fileContent, displayPath(rawPath)),
 			fileContent.length > 0 &&
 				code(fileContent, {
 					lang: rawPath ? getLanguageFromPath(rawPath) : undefined,
@@ -755,7 +790,7 @@ export const writeToolRenderer = {
 				}),
 			diagnosticsSection(diagnostics),
 		]);
-		return { tool, body, preview: NATIVE_WRITE_PREVIEW };
+		return { tool, body, preview: svg ? { lines: NATIVE_SVG_PREVIEW_LINES } : NATIVE_WRITE_PREVIEW };
 	},
 	mergeCallAndResult: true,
 	// The collapsed pending preview follows the streaming edge with a tail

package/src/windows-input-mode.ts

@@ -6,8 +6,11 @@
  * deliver Shift+Enter as a bare `\r` (indistinguishable from Enter) and
  * Ctrl+Enter as `\n`. Enabling `CSI ? 9001 h` makes the console host serving
  * this process report every key as `CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _`, which
- * carries the full modifier state. Paste text, mouse reports and terminal
- * replies keep arriving as plain VT, so only key records need translating.
+ * carries the full modifier state. Mouse reports and terminal replies keep
+ * arriving as plain VT. Pasted text mostly does too, but the console host
+ * re-encodes some pasted characters (line breaks) as key records inside the
+ * bracketed paste; {@link Win32InputModeDecoder.decodePaste} turns those back
+ * into text.
  *
  * Unmodified and legacy-expressible keys translate to the bytes a legacy
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
@@ -16,6 +19,7 @@
  */
 
 const W32IM_PATTERN = /^\x1b\[([\d;]*)_$/;
+const W32IM_RECORDS = /\x1b\[[\d;]*_/g;
 
 const RIGHT_ALT_PRESSED = 0x0001;
 const LEFT_ALT_PRESSED = 0x0002;
@@ -189,6 +193,26 @@ export class Win32InputModeDecoder {
 		return Array.from({ length: record.repeat }, () => encoded);
 	}
 
+	/**
+	 * Replace the key records embedded in bracketed paste `content` with the
+	 * text they type, so a pasted line break stays a line break instead of
+	 * acting as Enter. Key-downs yield their character (`\r` for Enter);
+	 * releases and keys without text yield nothing. Text that merely looks like
+	 * a record without ESC is left alone.
+	 */
+	decodePaste(content: string): string {
+		if (!content.includes("\x1b[")) return content;
+		this.#pendingHighSurrogate = 0;
+		const decoded = content.replace(W32IM_RECORDS, match => {
+			const record = parseRecord(match);
+			if (!record) return match;
+			if (!record.down) return "";
+			return this.#emitText(record.uc, record.repeat).join("");
+		});
+		this.#pendingHighSurrogate = 0;
+		return decoded;
+	}
+
 	#emitText(codeUnit: number, repeat = 1): string[] {
 		if (codeUnit === 0) return [];
 		if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {