@xmoon76/dsh-pi-tui 0.3.1 → 0.3.2

package/dist/{src-ClAKiW0z.mjs → src-oZjot5jQ.mjs}

@@ -2,13 +2,13 @@ import { TUI_STARTUP_SERVICE } from "./startup.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
-import { execFileSync, execSync, spawn } from "node:child_process";
+import { execFile, execFileSync, execSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
 import { accessSync, appendFileSync, closeSync, constants, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import * as os from "node:os";
 import { homedir, tmpdir } from "node:os";
 import * as path from "node:path";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, win32 } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
@@ -27,10 +27,11 @@ import { homedir as homedir$1 } from "os";
 import { basename as basename$1, dirname as dirname$1, join as join$1 } from "path";
 import { eastAsianWidth } from "get-east-asian-width";
 import { performance } from "node:perf_hooks";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { EventEmitter } from "events";
 import { Service } from "@deepseek-ai/cordis";
 import { isUserInvocable, renderSkillContent } from "@deepseek-ai/dsh-skill";
+import { readFile, realpath, stat } from "node:fs/promises";
 import { AuthorizationDeclinedError } from "@deepseek-ai/dsh-authorization";
 import { credentialKeyId, credentialKeyScope } from "@deepseek-ai/dsh-credentials";
 //#region src/present.ts
@@ -427,6 +428,177 @@ function parseReadEnvelopes(result) {
 	return out;
 }
 /**
+* Parse the write tool's XML confirmation envelope (`<path>…</path> <type>
+* …</type> <content>Created file</content>` — no file content is echoed).
+* The verb + path are the only material the envelope carries. A malformed
+* envelope — including a blank `<path>` — yields undefined, never a
+* partial parse (a whitespace path would surface as an invalid card row).
+* @param result - the tool result text.
+* @returns the envelope's verb and path, or undefined when the result is
+* not a well-formed write envelope.
+*/
+function parseWriteEnvelope(result) {
+	const match = /<path>([\s\S]*?)<\/path>\s*<type>[^<]*<\/type>\s*<content>([\s\S]*?)<\/content>/.exec(result);
+	if (match === null) return void 0;
+	const verb = /^\s*(Created|Updated)\s+file\s*$/.exec(match[2] ?? "")?.[1];
+	if (verb !== "Created" && verb !== "Updated") return void 0;
+	const path = (match[1] ?? "").trim();
+	if (path === "") return void 0;
+	return {
+		verb,
+		path
+	};
+}
+/**
+* The folded preview suffix for a write card: ` — Created` / ` — Updated`
+* when the result is the tool's XML confirmation envelope, empty otherwise.
+* The folded row must NEVER dump the raw envelope (the read-card no-XML
+* rule; a malformed envelope yields no preview at all, not the raw text).
+* @param result - the tool result text.
+* @returns the verb suffix, or '' when the result is not a write envelope.
+*/
+function writeFoldedPreview(result) {
+	const envelope = parseWriteEnvelope(result);
+	return envelope === void 0 ? "" : ` — ${envelope.verb}`;
+}
+/**
+* Parse the skill tool's XML instruction envelope (`<skill_content
+* name="…"> <skill_resources>…</skill_resources> <skill_instructions>…
+* </skill_instructions> </skill_content>`). The name attribute is XML-
+* escaped by the producer (escapeAttr: `&amp;`/`&quot;`/`&lt;`) and is
+* decoded here; the instructions body is embedded VERBATIM by the producer
+* (skills are trusted local content), so it is returned unmodified.
+*
+* The boundaries are OUTER-envelope-aware: the opener is the first
+* `<skill_content name="…">`, the instructions opener the first
+* `<skill_instructions>` after it, and the closers the last
+* `</skill_instructions>` / `</skill_content>` — so a body that itself
+* documents envelope-shaped XML (a complete nested block, or an unclosed
+* tag) never truncates the outer body. A MALFORMED first envelope never
+* borrows a later envelope's boundaries: a second `<skill_content name="…">`
+* opener between the first opener and its instructions opener means the
+* first envelope is incomplete, and the selected instructions body must
+* close every `<skill_content name="…">` opener it contains (unmatched
+* closing tags are tolerated) — without those guards, a first envelope
+* whose own boundaries are unclosed would cross-pair with a later
+* envelope's. An unclosed `<skill_content name="…">` example inside a body
+* is indistinguishable from such a malformed concatenation and degrades to
+* a header-only card, never raw tags.
+* @param result - the tool result text.
+* @returns the envelope's name and instruction body, or undefined when the
+* result is not a well-formed skill envelope (a blank name is malformed).
+*/
+function parseSkillEnvelope(result) {
+	const open = result.indexOf("<skill_content name=\"");
+	if (open < 0) return void 0;
+	const nameStart = open + 21;
+	const nameEnd = result.indexOf("\"", nameStart);
+	if (nameEnd < 0) return void 0;
+	const instrOpen = result.indexOf("<skill_instructions>", nameEnd);
+	if (instrOpen < 0) return void 0;
+	const nestedOpen = result.indexOf("<skill_content name=\"", nameEnd);
+	if (nestedOpen >= 0 && nestedOpen < instrOpen) return void 0;
+	const outerClose = result.lastIndexOf("</skill_content>");
+	if (outerClose < instrOpen) return void 0;
+	const instrClose = result.lastIndexOf("</skill_instructions>", outerClose);
+	if (instrClose <= instrOpen) return void 0;
+	const bodyRegion = result.slice(instrOpen, instrClose);
+	let contentDepth = 0;
+	for (const token of bodyRegion.matchAll(/<skill_content name="|<\/skill_content>/g)) if (token[0] === "<skill_content name=\"") contentDepth += 1;
+	else contentDepth = Math.max(0, contentDepth - 1);
+	if (contentDepth > 0) return void 0;
+	const rawName = result.slice(nameStart, nameEnd).trim();
+	if (rawName === "") return void 0;
+	const name = rawName.replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+	let body = result.slice(instrOpen + 20, instrClose);
+	if (body.startsWith("\n")) body = body.slice(1);
+	if (body.endsWith("\n")) body = body.slice(0, -1);
+	return {
+		name,
+		instructions: body
+	};
+}
+/**
+* The folded preview suffix for a skill card: ` — N lines` (the instruction
+* body's line count — the header already carries `skill · <name>`), empty
+* otherwise. The folded row never dumps the raw `<skill_content>` block.
+* @param result - the tool result text.
+* @returns the line-count suffix, or '' when the result is not a skill
+* envelope.
+*/
+function skillFoldedPreview(result) {
+	const envelope = parseSkillEnvelope(result);
+	if (envelope === void 0) return "";
+	const lines = envelope.instructions.split("\n").filter((line) => line !== "").length;
+	return lines === 0 ? "" : ` — ${lines} lines of instructions`;
+}
+/**
+* The human-facing body lines of one injected context row, derived from the
+* model-facing text so the expanded row never leaks the envelope's raw XML
+* (the same no-XML rule as the read/write/skill tool cards):
+*
+* - a well-formed skill envelope (`<skill_content …>` — the skill loader
+*   tool result and the user-explicit invocation injection share this
+*   shape) renders its instructions body;
+* - a `<system-reminder>`-wrapped producer (the skill catalog, workspace
+*   instructions — both bake their complete frame into the content,
+*   harness caller-owned framing) renders its content with the wrapper tag
+*   lines stripped; `<available_skills>` markers are stripped only when the
+*   pair is present, so a lone marker inside real content survives;
+* - any OTHER text returns undefined and the caller keeps its raw-body
+*   behavior (plain context rows are unchanged).
+*
+* A malformed skill envelope yields an EMPTY body, never the raw tags: the
+* header still names the producer, and the model-facing bytes are untouched
+* (presentation only).
+* @param text - the injected context message text, exactly as logged.
+* @returns the body lines to render, or undefined when no envelope shape
+* applies.
+*/
+function systemContextBody(text) {
+	const skill = parseSkillEnvelope(text);
+	if (skill !== void 0) return skill.instructions.split("\n");
+	if (text.trimStart().startsWith("<skill_content")) return [];
+	const lines = text.split("\n");
+	const first = lines[0]?.trim();
+	const last = lines[lines.length - 1]?.trim();
+	if (first !== "<system-reminder>" || last !== "</system-reminder>") return void 0;
+	const body = lines.slice(1, -1);
+	if (!(body.some((line) => line.trim() === "<available_skills>") && body.some((line) => line.trim() === "</available_skills>"))) return body;
+	return body.filter((line) => line.trim() !== "<available_skills>" && line.trim() !== "</available_skills>");
+}
+/**
+* Parse the read_image tool's XML confirmation envelope (`<path>…</path>
+* <type>image</type> <content>PNG image, 800x600 px, … bytes</content>`).
+* @param result - the tool result text.
+* @returns the envelope's path and the content summary line, or undefined
+* when the result is not a well-formed image envelope (blank path or blank
+* summary are malformed).
+*/
+function parseImageEnvelope(result) {
+	const match = /<path>([\s\S]*?)<\/path>\s*<type>image<\/type>\s*<content>\s*\n?\s*([\s\S]*?)\s*\n?\s*<\/content>/.exec(result);
+	if (match === null) return void 0;
+	const path = (match[1] ?? "").trim();
+	const summary = (match[2] ?? "").trim();
+	if (path === "" || summary === "") return void 0;
+	return {
+		path,
+		summary
+	};
+}
+/**
+* The folded preview suffix for a read_image card: ` — <summary>` (e.g.
+* `PNG image · 800x600 px`), empty otherwise. The folded row never dumps
+* the raw envelope (the read-card no-XML rule).
+* @param result - the tool result text.
+* @returns the summary suffix, or '' when the result is not an image
+* envelope.
+*/
+function imageFoldedPreview(result) {
+	const envelope = parseImageEnvelope(result);
+	return envelope === void 0 ? "" : ` — ${firstLine(envelope.summary)}`;
+}
+/**
 * The folded preview suffix for a read card: `— {N} lines` when the envelope
 * reports a total (or a line count), empty otherwise. A merged group card
 * (multiple envelopes) yields nothing — its head already carries "N files".
@@ -540,6 +712,7 @@ function genericRawInputLines(name, rawInput) {
 function resultTextLines(blocks, error) {
 	const lines = [];
 	for (const block of blocks) if (block.type === "text") lines.push(...block.text.split("\n"));
+	else if (block.type === "image") lines.push("[image]");
 	else lines.push(JSON.stringify(block, null, 2));
 	if (lines.length === 0 && error !== void 0) lines.push(`${error.name}: ${error.code}`);
 	return lines;
@@ -910,6 +1083,32 @@ function contextSummary(source) {
 function textOf(blocks) {
 	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
+/** Flat text with image positions preserved: text blocks verbatim, image
+* blocks as an inline `🖼️ name` marker AT their position (the queue-preview
+* format; U+FE0F keeps the marker 2 cells wide in emoji fonts). A marker
+* boundary always carries a single separating space — the /image insertion
+* leaves NO space before the placeholder, so `这张图是啥[image…]` must not
+* read as `这张图是啥🖼️ shot.png` — while a space the user already typed is
+* never doubled. The structured `content` blocks stay the canonical form
+* for thumbnail rendering; this projection feeds the flat-text consumers
+* (transcript search, loader-less fallback rendering, the user bubble's
+* inline marker) so a mixed message never reads as if the image was not
+* there, and an image-only message is not empty. Identical to
+* {@link textOf} for text-only content. */
+function textWithImageMarkers(blocks) {
+	let text = "";
+	let boundary = false;
+	for (const block of blocks) if (block.type === "text") {
+		if (boundary && text !== "" && !/\s$/.test(text) && !/^\s/.test(block.text)) text += " ";
+		boundary = false;
+		text += block.text;
+	} else if (block.type === "image") {
+		if (text !== "" && !/\s$/.test(text)) text += " ";
+		text += `🖼️ ${block.attachment.name ?? "image"}`;
+		boundary = true;
+	}
+	return text;
+}
 /** Key identifying one step's model output (turn + step). */
 function stepKey$1(turn, step) {
 	return `${turn}/${step}`;
@@ -1310,12 +1509,14 @@ var TranscriptFolder = class TranscriptFolder {
 				this.currentTurn = event.data.turn;
 				break;
 			case "user/message": {
-				const text = textOf(event.data.content);
-				if (text === "") break;
+				const blocks = event.data.content;
+				const text = textWithImageMarkers(blocks);
+				if (text === "" && !blocks.some((block) => block.type === "image")) break;
 				if (event.data.source.kind === "user") this.appendItem({
 					kind: "user",
 					turn: this.currentTurn,
-					text
+					text,
+					content: blocks
 				});
 				else {
 					const provenance = contextProvenance(event.data.source);
@@ -1341,14 +1542,18 @@ var TranscriptFolder = class TranscriptFolder {
 			}
 			case "assistant/message": {
 				const key = stepKey$1(event.data.turn, event.data.step);
-				const text = textOf(event.data.message.content);
+				const messageBlocks = event.data.message.content;
+				const text = textOf(messageBlocks);
 				const entry = this.assistantEntries.get(key);
-				if (entry !== void 0) entry.text = text;
-				else if (text !== "") {
+				if (entry !== void 0) {
+					entry.text = text;
+					if (messageBlocks.some((block) => block.type !== "text")) entry.content = messageBlocks;
+				} else if (text !== "" || messageBlocks.some((block) => block.type !== "text")) {
 					const created = {
 						kind: "assistant",
 						turn: event.data.turn,
-						text
+						text,
+						...messageBlocks.some((block) => block.type !== "text") ? { content: messageBlocks } : {}
 					};
 					this.assistantEntries.set(key, created);
 					this.appendItem(created);
@@ -1563,6 +1768,29 @@ function childOwnEvents(events) {
 	return cut === 0 ? events : events.slice(cut);
 }
 /** Render one session's log as a readable markdown transcript for `/export md`. */
+/** The markdown projection of content blocks (review finding 4): text
+* blocks verbatim, image blocks as a compact `🖼️` line (U+FE0F marker,
+* same convention as the transcript and queue summaries) with the durable
+* attachment id — the binary is NEVER embedded, and an image-only message
+* still renders a User/Assistant section. */
+function markdownContent(blocks) {
+	const parts = [];
+	let buffer = "";
+	const flush = () => {
+		if (buffer !== "") {
+			parts.push(buffer);
+			buffer = "";
+		}
+	};
+	for (const block of blocks) if (block.type === "text") buffer += block.text;
+	else if (block.type === "image") {
+		flush();
+		const attachment = block.attachment;
+		parts.push(`> 🖼️ ${attachment.name ?? "image"} · ${attachment.width}×${attachment.height} · attachment \`${attachment.attachmentId}\``);
+	}
+	flush();
+	return parts.join("\n\n");
+}
 function renderTranscriptMarkdown(session) {
 	const lines = [
 		`# Session ${session.header.id}`,
@@ -1572,12 +1800,12 @@ function renderTranscriptMarkdown(session) {
 	];
 	for (const event of session.events) switch (event.type) {
 		case "user/message": {
-			const text = textOf(event.data.content);
+			const text = markdownContent(event.data.content);
 			if (text !== "") lines.push(`## User\n\n${text}\n`);
 			break;
 		}
 		case "assistant/message": {
-			const text = textOf(event.data.message.content);
+			const text = markdownContent(event.data.message.content);
 			if (text !== "") lines.push(`## Assistant\n\n${text}\n`);
 			break;
 		}
@@ -1588,7 +1816,7 @@ function renderTranscriptMarkdown(session) {
 		}
 		case "tool/result": {
 			const block = event.data.message.content[0];
-			const text = textOf(block?.content ?? []);
+			const text = markdownContent(block?.content ?? []);
 			if (text !== "") lines.push(`<details><summary>result</summary>\n\n${text}\n\n</details>\n`);
 			break;
 		}
@@ -1869,8 +2097,10 @@ const darkColors = {
 	diffRemovedStrong: "#F08585",
 	diffGutter: "#6B6B6B",
 	diffMeta: "#888888",
-	roleUser: "#FFCB6B",
-	shellMode: "#BD93F9"
+	roleUser: "#679EFE",
+	shellMode: "#BD93F9",
+	/** dsh-web `--dsw-specific-bubble` (dark): neutral bluish-850. */
+	roleUserBg: "#2C2C2F"
 };
 /** Light palette, tuned for ≥ 4.5:1 contrast on white (pi's values). */
 const lightColors = {
@@ -1891,8 +2121,10 @@ const lightColors = {
 	diffRemovedStrong: "#B91C1C",
 	diffGutter: "#737373",
 	diffMeta: "#5F5F5F",
-	roleUser: "#9A4A00",
-	shellMode: "#7C3AED"
+	roleUser: "#4177E6",
+	shellMode: "#7C3AED",
+	/** dsh-web `--dsw-specific-bubble` (light): deepseek-100. */
+	roleUserBg: "#E4EDFD"
 };
 /** The active palette; style helpers read it on every call, so swapping is live. */
 let currentPalette = darkColors;
@@ -1947,6 +2179,7 @@ const PALETTE_KEYS = [
 	"diffGutter",
 	"diffMeta",
 	"roleUser",
+	"roleUserBg",
 	"shellMode"
 ];
 /**
@@ -2054,6 +2287,10 @@ const color = {
 	diffGutter: (text) => hex("diffGutter")(text),
 	diffMeta: (text) => hex("diffMeta")(text),
 	roleUser: (text) => hex("roleUser")(text),
+	/** User-bubble background paint (dsh-web `--dsw-specific-bubble`
+	* parity): the whole user row reads as a floating block. The token is
+	* optional — an absent `roleUserBg` makes this an identity function. */
+	roleUserBg: (text) => currentPalette.roleUserBg === void 0 ? text : chalk.bgHex(currentPalette.roleUserBg)(text),
 	shellMode: (text) => hex("shellMode")(text),
 	/** Plain italics (kimi thinking parity). */
 	italic: (text) => chalk.italic(text),
@@ -5031,6 +5268,16 @@ function parseTerminalColorSchemeReport(data) {
 	return match[1] === "2" ? "light" : "dark";
 }
 let cachedCapabilities = null;
+let cellDimensions = {
+	widthPx: 9,
+	heightPx: 18
+};
+function getCellDimensions() {
+	return cellDimensions;
+}
+function setCellDimensions(dims) {
+	cellDimensions = dims;
+}
 /**
 * Checks whether the attached tmux client forwards OSC 8 hyperlinks to the
 * outer terminal. tmux only re-emits them when its `client_termfeatures` lists
@@ -5139,6 +5386,41 @@ function isImageLine(line) {
 	return line.includes(KITTY_PREFIX) || line.includes(ITERM2_PREFIX);
 }
 /**
+* Generate a random image ID for Kitty graphics protocol.
+* Uses random IDs to avoid collisions between different module instances
+* (e.g., main app vs extensions).
+*/
+function allocateImageId() {
+	return Math.floor(Math.random() * 4294967294) + 1;
+}
+function encodeKitty(base64Data, options = {}) {
+	const CHUNK_SIZE = 4096;
+	const params = [
+		"a=T",
+		"f=100",
+		"q=2"
+	];
+	if (options.moveCursor === false) params.push("C=1");
+	if (options.columns) params.push(`c=${options.columns}`);
+	if (options.rows) params.push(`r=${options.rows}`);
+	if (options.imageId) params.push(`i=${options.imageId}`);
+	if (base64Data.length <= CHUNK_SIZE) return `\x1b_G${params.join(",")};${base64Data}\x1b\\`;
+	const chunks = [];
+	let offset = 0;
+	let isFirst = true;
+	while (offset < base64Data.length) {
+		const chunk = base64Data.slice(offset, offset + CHUNK_SIZE);
+		const isLast = offset + CHUNK_SIZE >= base64Data.length;
+		if (isFirst) {
+			chunks.push(`\x1b_G${params.join(",")},m=1;${chunk}\x1b\\`);
+			isFirst = false;
+		} else if (isLast) chunks.push(`\x1b_Gm=0;${chunk}\x1b\\`);
+		else chunks.push(`\x1b_Gm=1;${chunk}\x1b\\`);
+		offset += CHUNK_SIZE;
+	}
+	return chunks.join("");
+}
+/**
 * Delete a Kitty graphics image by ID.
 * Uses uppercase 'I' to also free the image data.
 */
@@ -5156,7 +5438,31 @@ function deleteAllKittyImages() {
 function deleteAllKittyPlacements() {
 	return "\x1B_Ga=d,d=a,q=2\x1B\\";
 }
+function encodeITerm2(base64Data, options = {}) {
+	const params = [`inline=${options.inline !== false ? 1 : 0}`, `size=${Buffer.byteLength(base64Data, "base64")}`];
+	if (options.width !== void 0) params.push(`width=${options.width}`);
+	if (options.height !== void 0) params.push(`height=${options.height}`);
+	if (options.name) {
+		const nameBase64 = Buffer.from(options.name).toString("base64");
+		params.push(`name=${nameBase64}`);
+	}
+	if (options.preserveAspectRatio === false) params.push("preserveAspectRatio=0");
+	return `\x1b]1337;File=${params.join(";")}:${base64Data}\x07`;
+}
 const kittyImageMetadata = /* @__PURE__ */ new Map();
+let kittyTransmissionGeneration = 0;
+function registerKittyImageMetadata(metadata) {
+	kittyTransmissionGeneration += 1;
+	kittyImageMetadata.delete(metadata.imageId);
+	kittyImageMetadata.set(metadata.imageId, {
+		...metadata,
+		transmissionGeneration: kittyTransmissionGeneration
+	});
+	if (kittyImageMetadata.size > 1e3) {
+		const oldestImageId = kittyImageMetadata.keys().next().value;
+		if (oldestImageId !== void 0) kittyImageMetadata.delete(oldestImageId);
+	}
+}
 function getRegisteredKittyImageMetadata(line) {
 	const controls = /\x1b_G([^;]*);/.exec(line)?.[1];
 	if (!controls) return void 0;
@@ -5235,6 +5541,157 @@ function cropKittyImageLine(line, hiddenRows, visibleRows) {
 	controls.push(`y=${sourceY}`, `h=${sourceHeight}`, `r=${croppedRows}`);
 	return `${line.slice(0, match.index)}\x1b_G${controls.join(",")};${line.slice(match.index + match[0].length)}`;
 }
+function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeightCells, cellDimensions = {
+	widthPx: 9,
+	heightPx: 18
+}) {
+	const maxWidth = Math.max(1, Math.floor(maxWidthCells));
+	const maxHeight = maxHeightCells === void 0 ? void 0 : Math.max(1, Math.floor(maxHeightCells));
+	const imageWidth = Math.max(1, imageDimensions.widthPx);
+	const imageHeight = Math.max(1, imageDimensions.heightPx);
+	const widthScale = maxWidth * cellDimensions.widthPx / imageWidth;
+	const heightScale = maxHeight === void 0 ? widthScale : maxHeight * cellDimensions.heightPx / imageHeight;
+	const scale = Math.min(widthScale, heightScale);
+	const scaledWidthPx = imageWidth * scale;
+	const scaledHeightPx = imageHeight * scale;
+	const columns = Math.ceil(scaledWidthPx / cellDimensions.widthPx);
+	const rows = Math.ceil(scaledHeightPx / cellDimensions.heightPx);
+	return {
+		columns: Math.max(1, Math.min(maxWidth, columns)),
+		rows: Math.max(1, maxHeight === void 0 ? rows : Math.min(maxHeight, rows))
+	};
+}
+function getPngDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 24) return null;
+		if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) return null;
+		return {
+			widthPx: buffer.readUInt32BE(16),
+			heightPx: buffer.readUInt32BE(20)
+		};
+	} catch {
+		return null;
+	}
+}
+function getJpegDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 2) return null;
+		if (buffer[0] !== 255 || buffer[1] !== 216) return null;
+		let offset = 2;
+		while (offset < buffer.length - 9) {
+			if (buffer[offset] !== 255) {
+				offset++;
+				continue;
+			}
+			const marker = buffer[offset + 1];
+			if (marker >= 192 && marker <= 194) {
+				const height = buffer.readUInt16BE(offset + 5);
+				return {
+					widthPx: buffer.readUInt16BE(offset + 7),
+					heightPx: height
+				};
+			}
+			if (offset + 3 >= buffer.length) return null;
+			const length = buffer.readUInt16BE(offset + 2);
+			if (length < 2) return null;
+			offset += 2 + length;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function getGifDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 10) return null;
+		const sig = buffer.slice(0, 6).toString("ascii");
+		if (sig !== "GIF87a" && sig !== "GIF89a") return null;
+		return {
+			widthPx: buffer.readUInt16LE(6),
+			heightPx: buffer.readUInt16LE(8)
+		};
+	} catch {
+		return null;
+	}
+}
+function getWebpDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 30) return null;
+		const riff = buffer.slice(0, 4).toString("ascii");
+		const webp = buffer.slice(8, 12).toString("ascii");
+		if (riff !== "RIFF" || webp !== "WEBP") return null;
+		const chunk = buffer.slice(12, 16).toString("ascii");
+		if (chunk === "VP8 ") {
+			if (buffer.length < 30) return null;
+			return {
+				widthPx: buffer.readUInt16LE(26) & 16383,
+				heightPx: buffer.readUInt16LE(28) & 16383
+			};
+		} else if (chunk === "VP8L") {
+			if (buffer.length < 25) return null;
+			const bits = buffer.readUInt32LE(21);
+			return {
+				widthPx: (bits & 16383) + 1,
+				heightPx: (bits >> 14 & 16383) + 1
+			};
+		} else if (chunk === "VP8X") {
+			if (buffer.length < 30) return null;
+			return {
+				widthPx: (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1,
+				heightPx: (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1
+			};
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function getImageDimensions(base64Data, mimeType) {
+	if (mimeType === "image/png") return getPngDimensions(base64Data);
+	if (mimeType === "image/jpeg") return getJpegDimensions(base64Data);
+	if (mimeType === "image/gif") return getGifDimensions(base64Data);
+	if (mimeType === "image/webp") return getWebpDimensions(base64Data);
+	return null;
+}
+function renderImage(base64Data, imageDimensions, options = {}) {
+	const caps = getCapabilities();
+	if (!caps.images) return null;
+	const size = calculateImageCellSize(imageDimensions, options.maxWidthCells ?? 80, options.maxHeightCells, getCellDimensions());
+	if (caps.images === "kitty") {
+		if (options.imageId !== void 0) registerKittyImageMetadata({
+			imageId: options.imageId,
+			columns: size.columns,
+			rows: size.rows,
+			widthPx: imageDimensions.widthPx,
+			heightPx: imageDimensions.heightPx
+		});
+		return {
+			sequence: encodeKitty(base64Data, {
+				columns: size.columns,
+				rows: size.rows,
+				imageId: options.imageId,
+				moveCursor: options.moveCursor
+			}),
+			columns: size.columns,
+			rows: size.rows,
+			imageId: options.imageId
+		};
+	}
+	if (caps.images === "iterm2") return {
+		sequence: encodeITerm2(base64Data, {
+			width: size.columns,
+			height: "auto",
+			preserveAspectRatio: options.preserveAspectRatio ?? true
+		}),
+		columns: size.columns,
+		rows: size.rows
+	};
+	return null;
+}
 /**
 * Wrap text in an OSC 8 hyperlink sequence.
 * The text is rendered as a clickable hyperlink in terminals that support OSC 8
@@ -5248,6 +5705,28 @@ function cropKittyImageLine(line, hiddenRows, visibleRows) {
 function hyperlink(text, url) {
 	return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
 }
+/** Shorten home-prefixed absolute paths to ~/... for compact display. */
+function shortenImagePath(filename) {
+	const home = homedir();
+	if (home && (filename === home || filename.startsWith(`${home}/`) || filename.startsWith(`${home}\\`))) return `~${filename.slice(home.length)}`;
+	return filename;
+}
+/**
+* Text fallback when the terminal cannot render inline images.
+* Absolute paths are shown shortened (~/...) and, when OSC 8 hyperlinks are
+* available, linked to file:// so the full path remains openable.
+*/
+function imageFallback(mimeType, dimensions, filename) {
+	const parts = [];
+	if (filename) {
+		const display = shortenImagePath(filename);
+		if (getCapabilities().hyperlinks && isAbsolute(filename)) parts.push(hyperlink(display, pathToFileURL(filename).href));
+		else parts.push(display);
+	}
+	parts.push(`[${mimeType}]`);
+	if (dimensions) parts.push(`${dimensions.widthPx}x${dimensions.heightPx}`);
+	return `[Image: ${parts.join(" ")}]`;
+}
 /**
 * Minimal TUI implementation with differential rendering
 */
@@ -5753,6 +6232,10 @@ var TuiBase = class TuiBase extends Container {
 		const heightPx = parseInt(match[1], 10);
 		const widthPx = parseInt(match[2], 10);
 		if (heightPx <= 0 || widthPx <= 0) return true;
+		setCellDimensions({
+			widthPx,
+			heightPx
+		});
 		this.invalidate();
 		this.requestRender();
 		return true;
@@ -8424,6 +8907,75 @@ var HStack = class extends Stack {
 		return result;
 	}
 };
+var Image = class {
+	base64Data;
+	mimeType;
+	dimensions;
+	theme;
+	options;
+	imageId;
+	cachedLines;
+	cachedWidth;
+	constructor(base64Data, mimeType, theme, options = {}, dimensions) {
+		this.base64Data = base64Data;
+		this.mimeType = mimeType;
+		this.theme = theme;
+		this.options = options;
+		this.dimensions = dimensions || getImageDimensions(base64Data, mimeType) || {
+			widthPx: 800,
+			heightPx: 600
+		};
+		this.imageId = options.imageId;
+	}
+	/** Get the Kitty image ID used by this image (if any). */
+	getImageId() {
+		return this.imageId;
+	}
+	invalidate() {
+		this.cachedLines = void 0;
+		this.cachedWidth = void 0;
+	}
+	render(width) {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		const maxWidth = Math.max(1, Math.min(width - 2, this.options.maxWidthCells ?? 60));
+		const cellDimensions = getCellDimensions();
+		const defaultMaxHeight = Math.max(1, Math.ceil(maxWidth * cellDimensions.widthPx / cellDimensions.heightPx));
+		const maxHeight = this.options.maxHeightCells ?? defaultMaxHeight;
+		const caps = getCapabilities();
+		let lines;
+		if (caps.images) {
+			if (caps.images === "kitty" && this.imageId === void 0) this.imageId = allocateImageId();
+			const result = renderImage(this.base64Data, this.dimensions, {
+				maxWidthCells: maxWidth,
+				maxHeightCells: maxHeight,
+				imageId: this.imageId,
+				moveCursor: false
+			});
+			if (result) {
+				if (result.imageId) this.imageId = result.imageId;
+				if (caps.images === "kitty") {
+					lines = [result.sequence];
+					for (let i = 0; i < result.rows - 1; i++) lines.push("");
+				} else {
+					lines = [];
+					for (let i = 0; i < result.rows - 1; i++) lines.push("");
+					const rowOffset = result.rows - 1;
+					const moveUp = rowOffset > 0 ? `\x1b[${rowOffset}A` : "";
+					lines.push(moveUp + result.sequence);
+				}
+			} else {
+				const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
+				lines = [truncateToWidth(this.theme.fallbackColor(fallback), width)];
+			}
+		} else {
+			const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
+			lines = [truncateToWidth(this.theme.fallbackColor(fallback), width)];
+		}
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		return lines;
+	}
+};
 const SYMBOLS = {
 	alpha: "α",
 	beta: "β",
@@ -13159,6 +13711,164 @@ var TuiMainScreen = class extends TuiBase {
 	}
 };
 //#endregion
+//#region src/image/errors.ts
+/**
+* Image-pipeline error vocabulary (plan §20). Every error carries an
+* ACTIONABLE message; callers surface them to the user verbatim (or as
+* notices), never as bare stack traces.
+* @module @xmoon76/dsh-pi-tui/image/errors
+*/
+/** Base class for every TUI image-pipeline failure. */
+var ImageInputError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ImageInputError";
+	}
+};
+/** The bytes do not decode to a supported raster format. */
+var UnsupportedImageTypeError = class extends ImageInputError {
+	constructor(detail = "") {
+		super(`Unsupported image format. Supported: PNG, JPEG, WebP, GIF.${detail === "" ? "" : ` ${detail}`}`);
+		this.name = "UnsupportedImageTypeError";
+	}
+};
+/** The source bytes exceed the deployment's per-image attachment limit. */
+var ImageTooLargeError = class extends ImageInputError {
+	constructor(bytes, limit) {
+		super(`Image is ${formatBytes$1(bytes)}; current attachment limit is ${formatBytes$1(limit)}.`);
+		this.name = "ImageTooLargeError";
+	}
+};
+/** The image violates the deployment's dimension/pixel limits. */
+var ImageDimensionError = class extends ImageInputError {
+	constructor(message) {
+		super(message);
+		this.name = "ImageDimensionError";
+	}
+};
+/** The clipboard lookup failed (distinct from "clipboard has no image"). */
+var ClipboardImageError = class extends ImageInputError {
+	constructor(message = "Failed to read image from clipboard.") {
+		super(message);
+		this.name = "ClipboardImageError";
+	}
+};
+/** The harness rejected the staged images at admission time. */
+var ImageAdmissionError = class extends ImageInputError {
+	constructor(message) {
+		super(message);
+		this.name = "ImageAdmissionError";
+	}
+};
+/** A durable attachment could not be restored from session storage. */
+var ImageLoadError = class extends ImageInputError {
+	constructor(message = "Image attachment could not be restored from session storage.") {
+		super(message);
+		this.name = "ImageLoadError";
+	}
+};
+/** The current provider/model cannot accept image input. */
+var ModelImageUnsupportedError = class extends ImageInputError {
+	constructor(provider, model) {
+		super(`Current model \`${provider}/${model}\` does not support image input.`);
+		this.name = "ModelImageUnsupportedError";
+	}
+};
+/** Human byte-size formatting for limit messages (1024-based). */
+function formatBytes$1(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KiB`;
+	return `${(bytes / 1048576).toFixed(1)} MiB`;
+}
+/** A component rendering one durable attachment ref as an inline image. */
+var ImageThumbnail = class {
+	loader;
+	theme;
+	ref;
+	collapsedRef;
+	unsubscribe;
+	instance;
+	cachedLines;
+	cachedKey;
+	constructor(ref, loader, theme, collapsedRef) {
+		this.ref = ref;
+		this.loader = loader;
+		this.theme = theme;
+		this.collapsedRef = collapsedRef;
+		this.unsubscribe = loader.subscribe(ref.attachmentId, () => this.invalidate());
+	}
+	/** Whether this thumbnail participates in the fullscreen collapse
+	* toggle: only instances the host wired a `collapsedRef` for (user and
+	* assistant message attachments). Tool-card images stay inside their
+	* card's own click surface — their rows must never swallow a click that
+	* would otherwise fold/unfold the card. */
+	get collapsible() {
+		return this.collapsedRef !== void 0;
+	}
+	/** Whether the image rows are collapsed (the info line stays constant). */
+	collapsed() {
+		return this.collapsedRef?.() === true;
+	}
+	/** Fallback display name (never a path). */
+	label() {
+		return this.ref.name ?? "image";
+	}
+	/** Release the loader subscription (transcript trim / cache eviction).
+	* Idempotent; a disposed thumbnail stops repainting with loader settles
+	* (round-1 finding 7). */
+	dispose() {
+		if (this.unsubscribe !== void 0) {
+			this.unsubscribe();
+			this.unsubscribe = void 0;
+		}
+		this.invalidate();
+	}
+	/** The constant info line (§17.1): the attachment's identity — name +
+	* dimensions + size — visible in EVERY state. The marker is `🖼️` WITH
+	* the U+FE0F variation selector: U+1F5BC alone has no default emoji
+	* presentation, so the width math measures it as ONE cell while fonts
+	* with an emoji face render it TWO cells wide — the glyph overhang then
+	* eats the space and overlaps the name (font-dependent). VS16 forces the
+	* wide 2-cell rendering the measurement expects. */
+	infoLine() {
+		return `🖼️ ${this.label()} · ${this.ref.width}×${this.ref.height} · ${formatBytes$1(this.ref.bytes)}`;
+	}
+	invalidate() {
+		this.instance = void 0;
+		this.cachedLines = void 0;
+		this.cachedKey = void 0;
+	}
+	render(width) {
+		const key = `${width}:${getCapabilities().images ?? "none"}:${this.collapsed() ? "collapsed" : "expanded"}`;
+		if (this.cachedLines !== void 0 && this.cachedKey === key) return this.cachedLines;
+		const lines = this.renderLines(width);
+		this.cachedLines = lines;
+		this.cachedKey = key;
+		return lines;
+	}
+	renderLines(width) {
+		if (width < 42) return [this.theme.fallbackColor(this.infoLine())];
+		if (getCapabilities().images === null) return [this.theme.fallbackColor(this.infoLine())];
+		const state = this.loader.get(this.ref);
+		if (state.state === "idle") {
+			this.loader.load(this.ref);
+			return [this.theme.fallbackColor(this.infoLine())];
+		}
+		if (state.state === "loading") return [this.theme.fallbackColor(`${this.infoLine()} …`)];
+		if (state.state === "error") return [this.theme.fallbackColor(`${this.infoLine()} — ${state.error.message}`)];
+		if (this.collapsed()) return [this.theme.fallbackColor(this.infoLine())];
+		if (this.instance === void 0) this.instance = new Image(state.base64, this.ref.mediaType, { fallbackColor: this.theme.fallbackColor }, {
+			maxHeightCells: 12,
+			maxWidthCells: Math.min(40, Math.max(1, width - 2)),
+			filename: this.label()
+		}, {
+			widthPx: this.ref.width,
+			heightPx: this.ref.height
+		});
+		return [this.theme.fallbackColor(this.infoLine()), ...this.instance.render(width)];
+	}
+};
+//#endregion
 //#region src/diff.ts
 /**
 * Whether a tool result should render as a diff: edit-class tools always,
@@ -14836,6 +15546,118 @@ function toMentionItem(candidate) {
 		description: candidate.absolutePath
 	};
 }
+/** Expand a leading `~` in one argument token (other tokens unchanged). */
+function expandHomeToken(token) {
+	if (token === "~") return homedir();
+	if (token.startsWith("~/")) return join(homedir(), token.slice(2));
+	return token;
+}
+/**
+* Pure token → search-dir/prefix resolution (no filesystem access): which
+* directory a completion token reads and what basename prefix it filters.
+* Exported so the POSIX and Windows ROOT semantics are pinned without
+* touching the fs — `dirname` leaves a trailing separator ONLY on roots,
+* and a root must stay a root (`/` stripped would read `''`; a drive root
+* keeps its trailing separator while the drive-relative form drops it; a
+* UNC share keeps its legal trailing form).
+* @param token - the parsed argument token (no leading separator
+*   whitespace).
+* @param cwd - the session workspace (relative forms resolve against it).
+* @param expanded - `expandHomeToken(token)` (the caller already computed
+*   it; kept as a param so the fs-free contract stays pure).
+* @returns the readdir target, the basename prefix, and whether the token
+*   is genuinely Windows-dialect (the caller's display math needs it).
+*/
+function resolvePathSearch(token, cwd, expanded) {
+	const posixAbsolute = isAbsolute(expanded);
+	const winAbsolute = !posixAbsolute && win32.isAbsolute(expanded);
+	const absolute = token.startsWith("~") || posixAbsolute || winAbsolute;
+	const pathDirname = winAbsolute ? win32.dirname : dirname;
+	const pathBasename = winAbsolute ? win32.basename : basename;
+	if (token === "./" || token === "../" || token === "~" || token === "~/" || token === "/" || token === "") return {
+		searchDir: absolute ? expanded : join(cwd, expanded),
+		searchPrefix: "",
+		winAbsolute
+	};
+	if (token.endsWith("/") || token.endsWith("\\")) return {
+		searchDir: absolute ? expanded : join(cwd, expanded),
+		searchPrefix: "",
+		winAbsolute
+	};
+	return {
+		searchDir: absolute ? pathDirname(expanded) : join(cwd, dirname(expanded)),
+		searchPrefix: pathBasename(expanded),
+		winAbsolute
+	};
+}
+/**
+* Slash-command PATH-argument completion (`/image <path>`): complete the
+* single argument token against the session cwd — shell-style and
+* directory-local (the fd whole-tree fuzzy search stays `@`'s job). Handles
+* `~`, absolute and relative forms and mirrors the fork's getFileSuggestions
+* display rules so a completed value always reads like what the user typed
+* (`./`, `~/` and `dir/` forms preserved); directories keep their trailing
+* `/` so Tab-accepting one continues completion. Returns null when the
+* argument is not a single completable token (embedded spaces) or the
+* directory cannot be read — the editor then shows no suggestions.
+* @param argumentText - the text after the command name (the fork passes
+*   everything up to the cursor; its argument apply replaces that whole
+*   range, so only single-token arguments can complete).
+* @param cwd - the session workspace (resolve relative forms against it).
+*/
+function suggestPathArgument(argumentText, cwd) {
+	const token = argumentText;
+	const leading = token.match(/^[ \t]+/)?.[0] ?? "";
+	const parsed = token.slice(leading.length);
+	if (parsed === "" || parsed.includes(" ") || parsed.includes("	")) return null;
+	const { searchDir, searchPrefix, winAbsolute } = resolvePathSearch(parsed, cwd, expandHomeToken(parsed));
+	let entries;
+	try {
+		entries = readdirSync(searchDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	const items = [];
+	for (const entry of entries) {
+		if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) continue;
+		let isDirectory = entry.isDirectory();
+		if (!isDirectory && entry.isSymbolicLink()) try {
+			isDirectory = statSync(winAbsolute ? win32.join(searchDir, entry.name) : join(searchDir, entry.name)).isDirectory();
+		} catch {}
+		const name = entry.name;
+		let relativePath;
+		if (parsed.endsWith("/") || parsed.endsWith("\\")) relativePath = parsed + name;
+		else if (winAbsolute) relativePath = win32.join(win32.dirname(parsed), name);
+		else if (parsed.includes("/") || parsed.includes("\\")) {
+			if (parsed.startsWith("~/")) {
+				const dir = dirname(parsed.slice(2));
+				relativePath = `~/${dir === "." ? name : join(dir, name)}`;
+			} else if (parsed.startsWith("/")) {
+				const dir = dirname(parsed);
+				relativePath = dir === "/" ? `/${name}` : `${dir}/${name}`;
+			} else {
+				relativePath = join(dirname(parsed), name);
+				if (parsed.startsWith("./") && !relativePath.startsWith("./")) relativePath = `./${relativePath}`;
+			}
+		} else relativePath = parsed.startsWith("~") ? `~/${name}` : name;
+		const pathValue = isDirectory ? `${relativePath}/` : relativePath;
+		const value = leading + (pathValue.includes(" ") ? `"${pathValue}"` : pathValue);
+		items.push({
+			value,
+			label: `${name}${isDirectory ? "/" : ""}`,
+			description: winAbsolute ? win32.join(searchDir, entry.name) : join(searchDir, entry.name)
+		});
+	}
+	if (items.length === 0) return null;
+	items.sort((left, right) => {
+		const leftIsDir = left.label.endsWith("/");
+		const rightIsDir = right.label.endsWith("/");
+		if (leftIsDir && !rightIsDir) return -1;
+		if (!leftIsDir && rightIsDir) return 1;
+		return left.label.localeCompare(right.label);
+	});
+	return items;
+}
 /** The recursive fallback suggestion set for one `@` prefix. */
 function fsMentionSuggestions(workDir, atPrefix, signal) {
 	if (signal.aborted) return null;
@@ -14867,10 +15689,16 @@ var MentionProvider = class {
 	inner;
 	workDir;
 	fdPath;
+	/** The slash commands whose argument completion is a PATH (the host
+	* attaches `getArgumentCompletions`, e.g. `/image`): ONLY these tolerate
+	* a trailing-space argument as a Tab file-completion site — every other
+	* command keeps the fork's judgment. */
+	pathArgumentCommands;
 	constructor(slashCommands, workDir, fdPath) {
 		this.workDir = workDir;
 		this.fdPath = fdPath;
 		this.inner = new CombinedAutocompleteProvider([...slashCommands], workDir, fdPath);
+		this.pathArgumentCommands = new Set(slashCommands.filter((command) => command.getArgumentCompletions !== void 0).map((command) => command.name));
 	}
 	async getSuggestions(lines, cursorLine, cursorCol, options) {
 		const currentLine = lines[cursorLine] ?? "";
@@ -14909,7 +15737,15 @@ var MentionProvider = class {
 		return this.inner.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
 	}
 	shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
-		return this.inner.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? false;
+		const trimmedStart = (lines[cursorLine] ?? "").slice(0, cursorCol).trimStart();
+		if (trimmedStart.startsWith("/")) {
+			const separatorIndex = trimmedStart.search(/[ \t]/);
+			if (separatorIndex > 0) {
+				const commandName = trimmedStart.slice(1, separatorIndex);
+				if (this.pathArgumentCommands.has(commandName)) return true;
+			}
+		}
+		return this.inner.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
 	}
 };
 //#endregion
@@ -16723,6 +17559,7 @@ var EditorSeatHolder = class {
 			isShowingAutocomplete: () => editor.isShowingAutocomplete?.() ?? false,
 			getCursor: () => editor.getCursor?.() ?? 0,
 			setCursor: (offset) => editor.setCursor?.(offset),
+			insertTextAtCursor: (text) => editor.insertTextAtCursor?.(text),
 			get focused() {
 				return editor.focused;
 			},
@@ -17078,9 +17915,64 @@ var EditorSeatHolder = class {
 * Tab-accepting a directory immediately shows its children (kimi's
 * reopenAutocompleteAfterInput). Esc while autocomplete is active closes
 * it WITHOUT re-triggering (kimi parity).
+*
+* The editor also carries the terminal-prompt `❯ ` prefix: the fork's
+* Editor is constructed with `paddingX: 2` (kimi's CustomEditor reserves
+* padding for its `>` prompt the same way), and render() paints the
+* prompt over the first content row's leading padding — kimi's
+* injectPromptSymbol pattern, consumer-side only. The prompt reads like
+* the transcript's user messages (`❯ text`), so what the user is about
+* to send matches what their sent input looks like.
 * @module @xmoon76/dsh-pi-tui/tui-editor
 */
+/** Visible width of the `❯ ` prompt — must equal the editor's paddingX,
+* so content and wrapped continuations start right after the prompt. */
+const PROMPT_WIDTH = 2;
+/** Whether the text before the cursor is a slash-command line WITH an
+* argument position (`/cmd <arg>`): the command name is the first
+* whitespace-delimited (space OR tab — the fork's path delimiters) token
+* after the leading `/`; anything after it is the argument the completion
+* re-trigger targets. */
+function isSlashCommandArgument(textBeforeCursor) {
+	const trimmed = textBeforeCursor.trimStart();
+	if (!trimmed.startsWith("/")) return false;
+	const separatorIndex = trimmed.search(/[ \t]/);
+	if (separatorIndex <= 0) return false;
+	const commandName = trimmed.slice(1, separatorIndex);
+	return commandName !== "" && !commandName.includes("/");
+}
+/**
+* Paint the terminal-prompt `❯ ` over the first content row of the fork's
+* editor render. The fork renders every content row with `paddingX` spaces
+* on each side; the first visible content row's leading padding is replaced
+* by the prompt (kimi's injectPromptSymbol, which requires the same leading
+* padding). Wrapped continuation rows keep their padding, so they indent
+* under the prompt exactly like the transcript's user-message bullet
+* (BulletedComponent). No SGR is emitted for the trailing space, so the
+* text after the prompt keeps its own colouring.
+*
+* When the draft is scrolled (the fork paints `↑ N more` as the top row),
+* the first visible row is NOT the first line of the draft, so no prompt is
+* painted — a floating `❯` on a continuation line would lie about where the
+* input starts (kimi paints unconditionally; the scroll indicator makes the
+* skip unambiguous here).
+*/
+function injectEditorPrompt(lines) {
+	if (lines.length < 3) return lines;
+	if (lines[0].includes("↑")) return lines;
+	const first = lines[1];
+	if (first.length < PROMPT_WIDTH) return lines;
+	for (let i = 0; i < PROMPT_WIDTH; i++) if (first[i] !== " ") return lines;
+	lines[1] = `${color.roleUser("❯")} ${first.slice(PROMPT_WIDTH)}`;
+	return lines;
+}
 var TuiEditor = class extends Editor {
+	constructor(tui, theme) {
+		super(tui, theme, { paddingX: PROMPT_WIDTH });
+	}
+	render(width) {
+		return injectEditorPrompt(super.render(width));
+	}
 	handleInput(data) {
 		if (matchesKey(data, "escape") && this.isShowingAutocomplete()) {
 			this.cancelAutocomplete();
@@ -17090,13 +17982,17 @@ var TuiEditor = class extends Editor {
 		this.reopenAutocompleteAfterInput();
 	}
 	/** Reopen `@dir/` mention completion right after a key closed it (e.g.
-	* Tab accepted a directory). Mirrors kimi's reopenAutocompleteAfterInput
-	* for the @-mention case only. */
+	* Tab accepted a directory), and the same for a slash-command path
+	* argument (`/image subdir/`): the editor's natural trigger only fires on
+	* letters, so a freshly accepted trailing `/` would otherwise leave the
+	* children hidden until the next keystroke. Mirrors kimi's
+	* reopenAutocompleteAfterInput for the @-mention case, extended to
+	* path-argument commands. */
 	reopenAutocompleteAfterInput() {
 		if (this.isShowingAutocomplete()) return;
 		const { line, col } = this.getCursor();
 		const textBeforeCursor = this.getLines()[line]?.slice(0, col) ?? "";
-		if (textBeforeCursor.endsWith("/") && extractAtPrefix(textBeforeCursor) !== null) this.requestAutocomplete({
+		if (textBeforeCursor.endsWith("/") && (extractAtPrefix(textBeforeCursor) !== null || isSlashCommandArgument(textBeforeCursor))) this.requestAutocomplete({
 			force: false,
 			explicitTab: false
 		});
@@ -17343,6 +18239,19 @@ var UnstableMountedComponentAdapter = class {
 		}
 	}
 };
+/**
+* Tools whose result is a structured XML envelope (read/write/read_image/
+* skill). Each has its own parser branch in the folded-card logic; this
+* set is the DEFENSIVE backstop: if a future envelope tool is added
+* without its parser, its raw `<…>` result never leaks into the folded
+* preview. Register new envelope tools here AND add their parser branch.
+*/
+const XML_ENVELOPE_RESULT_TOOLS = /* @__PURE__ */ new Set([
+	"read",
+	"write",
+	"read_image",
+	"skill"
+]);
 /** First lines of a multi-line text, joined for folded previews. */
 function preview(text, lines) {
 	const parts = text.split("\n");
@@ -17557,6 +18466,54 @@ var BulletedComponent = class {
 	}
 };
 /**
+* User-message bubble: the whole row is painted with the role background
+* (dsh-web `--dsw-specific-bubble` parity — user input is a floating
+* block, NOT a text colour, so it never collides with the assistant's
+* brand-blue whale or kimi's amber), the ❯ marker leads the FIRST line in
+* the role colour, and wrapped continuation lines indent under it with the
+* background kept across the row.
+*
+* The child stays LIVE (a resize re-wraps at the new width — the 5a76526
+* rule) and the prefixed output is REFERENCE-STABLE like BulletedComponent:
+* same child array + same width → same prefixed array, so the fork's
+* per-frame processed-line reuse keeps hitting on steady frames.
+*/
+var UserBubbleComponent = class {
+	child;
+	marker;
+	markerWidth;
+	bg;
+	lastChild;
+	lastWidth = -1;
+	cached;
+	constructor(child, marker, bg) {
+		this.child = child;
+		this.marker = marker;
+		this.markerWidth = visibleWidth(marker);
+		this.bg = bg;
+	}
+	invalidate() {
+		this.child.invalidate?.();
+	}
+	dispose() {
+		this.child.dispose?.();
+	}
+	render(width) {
+		const inner = Math.max(1, width - this.markerWidth);
+		const child = this.child.render(inner);
+		if (child === this.lastChild && width === this.lastWidth && this.cached !== void 0) return this.cached;
+		this.lastChild = child;
+		this.lastWidth = width;
+		const indent = " ".repeat(this.markerWidth);
+		this.cached = child.map((line, index) => {
+			const prefix = index === 0 ? this.marker : indent;
+			const pad = " ".repeat(Math.max(0, inner - visibleWidth(line)));
+			return this.bg(prefix + line + pad);
+		});
+		return this.cached;
+	}
+};
+/**
 * Longest prefix of `text` whose WRAPPED height fits `budget` rows at
 * `width`, with an ellipsis marking a cut — the approval dialog's height
 * budget must count wrapped rows, not raw lines, because a single long
@@ -17959,6 +18916,10 @@ var TuiApp = class TuiApp {
 	lastRendererRevision = -1;
 	/** M9: the editor seat holder (the atomic handoff + current occupant). */
 	editorSeatHolder;
+	/** The durable-image loader (plan M8): optional, wired by the runner. */
+	imageLoader;
+	/** The thumbnail fallback theme (plan M9): optional, wired by the runner. */
+	imageTheme;
 	/** The busy indicator row directly above the editor border; idle renders nothing. */
 	working;
 	/** The fullscreen transcript ScrollView, for click hit-testing offsets. */
@@ -17970,6 +18931,19 @@ var TuiApp = class TuiApp {
 	* keyboard behavior is unaffected by mouse toggles.
 	*/
 	expandedOverride = /* @__PURE__ */ new Map();
+	/**
+	* Per-OCCURRENCE image-display collapse overrides from fullscreen clicks:
+	* a collapsed attachment occurrence renders its constant info bar
+	* (`🖼️ name · W×H · bytes`) only — the image rows collapse, the identity
+	* never does. Keyed by message object + the image block's index within
+	* `message.content` (the folder's entry objects are stable within one
+	* folder lifetime — the same identity the per-message render cache and
+	* `expandedOverride` use), so the SAME durable attachment displayed twice
+	* collapses independently: clicking "this position's picture" never
+	* touches the other occurrence. Absent = expanded. Cleared on session
+	* switch with the other click overrides.
+	*/
+	collapsedOccurrences = /* @__PURE__ */ new Map();
 	/** Rendered row heights per transcript message, for mouse hit-testing. */
 	messageRows = [];
 	/** ONE external-editor ownership at a time: set synchronously at launch,
@@ -18029,6 +19003,8 @@ var TuiApp = class TuiApp {
 			if (this.tasksActive) this.renderFooter();
 			this.editorSeatHolder.notifyChanged();
 		};
+		this.imageLoader = options.imageLoader;
+		this.imageTheme = options.imageTheme;
 		this.editorSeatHolder = new EditorSeatHolder({
 			hostAdapter: () => this.hostEditorAdapter(),
 			surfaceId: `tui-${Date.now().toString(36)}`,
@@ -18171,7 +19147,7 @@ var TuiApp = class TuiApp {
 		}
 		this.terminalSchemeListeners.clear();
 		this.expandedOverride.clear();
-		this.messageComponents.clear();
+		this.disposeMessageComponents();
 		this.localMessages.length = 0;
 		for (const lease of this.extensionOverlayLeases) lease.close();
 		this.extensionOverlayLeases.clear();
@@ -18426,6 +19402,11 @@ var TuiApp = class TuiApp {
 			this.rebuildMessages();
 			return { consume: true };
 		}
+		if (matchesKey(data, "ctrl+v")) {
+			if (this.events.onClipboardPaste === void 0) return { consume: false };
+			this.events.onClipboardPaste();
+			return { consume: true };
+		}
 		if (matchesKey(data, "ctrl+t")) {
 			this.toggleTodoPanel();
 			return { consume: true };
@@ -18644,10 +19625,14 @@ var TuiApp = class TuiApp {
 			this.externalEditorInFlight = false;
 		}
 	}
-	/** Record a submitted line into the editor history and the persistence mirror. */
+	/** Record a submitted line into the editor history and the persistence
+	* mirror. The host may REFUSE via `shouldRememberInput` (e.g. a
+	* multimodal draft whose placeholders die with their drafts — recalling
+	* it would re-send dead placeholders as plain text; review finding). */
 	rememberInput(text) {
 		const trimmed = text.trim();
 		if (trimmed === "") return;
+		if (this.events.shouldRememberInput?.(text) === false) return;
 		this.editor.addToHistory(trimmed);
 		if (this.inputHistory[0] === trimmed) return;
 		this.inputHistory.unshift(trimmed);
@@ -18928,7 +19913,8 @@ var TuiApp = class TuiApp {
 			const height = component.render(width).length + (index < blocks.length - 1 ? 1 : 0);
 			rows.push({
 				message,
-				height
+				height,
+				attachments: this.attachmentRangesOf(component, width)
 			});
 			if (index < blocks.length - 1) this.messagesView.addChild(new Spacer());
 		});
@@ -18962,13 +19948,86 @@ var TuiApp = class TuiApp {
 		this.reconcileWorkingRow();
 		this.requestRender();
 	}
-	/**
-	* Show or hide the busy indicator on the row directly above the editor
-	* border: while a turn is streaming or a tool is running (the runner
-	* derives it from turn/start and turn/end). A compaction in flight keeps
-	* the row live under its own label (see {@link setCompacting}).
-	*/
-	setWorking(active) {
+	/** The per-attachment click regions inside one message component: the row
+	* span (message-relative) of every COLLAPSIBLE `ImageThumbnail` child —
+	* the host wires a `collapsedRef` only for user/assistant message
+	* attachments. Tool-card images (no collapsedRef) stay inside their
+	* card's own click surface: their rows advance the counter but never
+	* enter a collapse range, so a click there still folds/unfolds the card
+	* instead of being swallowed by an inert attachment toggle. Every other
+	* child's height still advances the row counter, so the spans line up
+	* with the rendered layout.
+	*
+	* The ordinal among COLLAPSIBLE thumbnails IS the occurrence's image
+	* index: renderUserBlocks / renderBlockSequence create a collapsible
+	* thumbnail for EVERY image block of the message in content order, so
+	* the nth thumbnail ↔ the nth image block — the same index the host's
+	* collapsedRef getter reads. */
+	attachmentRangesOf(component, width) {
+		if (!(component instanceof Container)) return [];
+		const ranges = [];
+		let row = 0;
+		let imageIndex = 0;
+		for (const child of component.children) {
+			const height = child.render(width).length;
+			if (child instanceof ImageThumbnail && child.collapsible) {
+				ranges.push({
+					imageIndex,
+					start: row,
+					end: row + height
+				});
+				imageIndex += 1;
+			}
+			row += height;
+		}
+		return ranges;
+	}
+	/** Re-measure the message row map (heights + attachment spans) from the
+	* cached components — called before a fullscreen click hit-test so a
+	* thumbnail that just finished loading (1 row → image rows) never shifts
+	* the hit map. Cached renders make this cheap (reference-stable lines). */
+	refreshMessageRows() {
+		const width = this.terminal.columns;
+		const boundary = this.expandBoundary();
+		const blocks = [...this.messages.filter((message) => !(message.kind === "thinking" && this.hideThinking)), ...this.localMessages];
+		const rows = [];
+		blocks.forEach((message, index) => {
+			const component = this.componentForMessage(message, boundary);
+			const height = component.render(width).length + (index < blocks.length - 1 ? 1 : 0);
+			rows.push({
+				message,
+				height,
+				attachments: this.attachmentRangesOf(component, width)
+			});
+		});
+		this.messageRows = rows;
+	}
+	/** The live collapse flag for ONE image-block occurrence (message object
+	* + image index within its content). Read at render time — a fullscreen
+	* click only repaints. */
+	occurrenceCollapsedRef(message, imageIndex) {
+		return () => this.collapsedOccurrences.get(message)?.has(imageIndex) ?? false;
+	}
+	/** Toggle ONE image occurrence's display (fullscreen click). The info
+	* bar stays constant — only that image's rows collapse/expand; a
+	* repeated attachment elsewhere in the transcript is untouched. */
+	toggleAttachmentCollapsed(message, imageIndex) {
+		let indices = this.collapsedOccurrences.get(message);
+		if (indices === void 0) {
+			indices = /* @__PURE__ */ new Set();
+			this.collapsedOccurrences.set(message, indices);
+		}
+		if (indices.has(imageIndex)) indices.delete(imageIndex);
+		else indices.add(imageIndex);
+		this.rebuildMessages();
+	}
+	/**
+	* Show or hide the busy indicator on the row directly above the editor
+	* border: while a turn is streaming or a tool is running (the runner
+	* derives it from turn/start and turn/end). A compaction in flight keeps
+	* the row live under its own label (see {@link setCompacting}).
+	*/
+	setWorking(active) {
 		this.workingActive = active;
 		this.reconcileWorkingRow();
 		this.requestRender();
@@ -19062,9 +20121,15 @@ var TuiApp = class TuiApp {
 		const welcomeHeight = this.welcomeCard.render(width).length;
 		const messageRow = rowInScroll + scrollTop - welcomeHeight;
 		if (messageRow < 0) return;
+		this.refreshMessageRows();
 		let row = 0;
 		for (const entry of this.messageRows) {
 			if (messageRow < row + entry.height) {
+				const inMessage = messageRow - row;
+				for (const attachment of entry.attachments) if (inMessage >= attachment.start && inMessage < attachment.end) {
+					this.toggleAttachmentCollapsed(entry.message, attachment.imageIndex);
+					return;
+				}
 				this.toggleMessageExpanded(entry.message);
 				return;
 			}
@@ -19082,6 +20147,19 @@ var TuiApp = class TuiApp {
 	* session switch must not leak the old session's click toggles). */
 	clearSessionOverrides() {
 		this.expandedOverride.clear();
+		this.collapsedOccurrences.clear();
+		this.disposeMessageComponents();
+	}
+	/** Dispose every cached message component, then clear the cache. The
+	* component dispose is idempotent (thumbnails release their loader
+	* subscription once). */
+	disposeMessageComponents() {
+		for (const entry of this.messageComponents.values()) {
+			const component = entry.component;
+			if (component?.dispose !== void 0) try {
+				component.dispose();
+			} catch {}
+		}
 		this.messageComponents.clear();
 	}
 	/** Show or clear plan mode: header + footer badges and a warning-tinted editor border. */
@@ -19144,6 +20222,23 @@ var TuiApp = class TuiApp {
 		this.requestRender();
 	}
 	/**
+	* Insert text at the editor cursor — the image-placeholder insertion
+	* path (`/image`, Ctrl+V). A replacement editor without cursor insertion
+	* falls back to appending at the end of the draft; the host editor
+	* inserts at the cursor (fork `Editor.insertTextAtCursor`).
+	*/
+	insertIntoEditor(text) {
+		if (this.viewerMode !== void 0) {
+			this.draftBeforeViewer = (this.draftBeforeViewer ?? this.seatEditor().getText()) + text;
+			return;
+		}
+		const editor = this.seatEditor();
+		if (editor.insertTextAtCursor !== void 0) editor.insertTextAtCursor(text);
+		else editor.setText(editor.getText() + text);
+		this.editorSeatHolder.notifyChanged();
+		this.requestRender();
+	}
+	/**
 	* Enter or leave the read-only subagent viewer. While viewing, the
 	* editor bar is covered by a placeholder (the real draft is preserved
 	* and restored on exit), the editor border switches to the accent color,
@@ -19897,6 +20992,7 @@ var TuiApp = class TuiApp {
 					col: remaining
 				});
 			},
+			insertTextAtCursor: (text) => editor.insertTextAtCursor(text),
 			handleInput: (data) => editor.handleInput(data),
 			runWithoutChange: (task) => {
 				const onChange = editor.onChange;
@@ -20056,6 +21152,10 @@ var TuiApp = class TuiApp {
 		}
 		const rendererRevisionChanged = this.renderers !== void 0 && entry.rendererRevision !== this.renderers.snapshot().revision;
 		if (entry.boundary !== boundary || entry.themeRev !== this.themeRevision || entry.expanded !== expanded || rendererRevisionChanged || this.componentStale(entry, message)) {
+			const previous = entry.component;
+			if (previous?.dispose !== void 0) try {
+				previous.dispose();
+			} catch {}
 			const rebuilt = this.buildMessage(message, boundary, expanded);
 			entry.component = rebuilt.component;
 			entry.boundary = rebuilt.boundary;
@@ -20096,6 +21196,7 @@ var TuiApp = class TuiApp {
 			case "thinking":
 			case "system":
 				entry.text = message.text;
+				entry.content = message.kind === "user" || message.kind === "assistant" ? message.content : void 0;
 				entry.running = message.kind === "thinking" ? message.running : void 0;
 				entry.label = message.kind === "system" ? message.label : void 0;
 				entry.summary = message.kind === "system" ? message.summary : void 0;
@@ -20107,6 +21208,7 @@ var TuiApp = class TuiApp {
 				entry.meta = message.meta;
 				entry.members = message.members;
 				entry.error = message.error;
+				entry.resultBlocks = message.resultBlocks;
 				break;
 			case "summary": break;
 			case "compaction":
@@ -20121,10 +21223,10 @@ var TuiApp = class TuiApp {
 	componentStale(entry, message) {
 		switch (message.kind) {
 			case "user":
-			case "assistant": return entry.text !== message.text;
+			case "assistant": return entry.text !== message.text || entry.content !== message.content;
 			case "thinking": return entry.text !== message.text || entry.running !== message.running;
 			case "system": return entry.text !== message.text || entry.label !== message.label || entry.summary !== message.summary;
-			case "tool": return entry.status !== message.status || entry.args !== message.args || entry.result !== message.result || entry.meta !== message.meta || entry.members !== message.members || entry.error !== message.error;
+			case "tool": return entry.status !== message.status || entry.args !== message.args || entry.result !== message.result || entry.meta !== message.meta || entry.members !== message.members || entry.error !== message.error || entry.resultBlocks !== message.resultBlocks;
 			case "summary": return false;
 			case "compaction": return entry.text !== message.text || entry.items !== message.items || entry.tokens !== message.tokens || entry.running !== message.running || entry.errorText !== message.error;
 		}
@@ -20136,9 +21238,61 @@ var TuiApp = class TuiApp {
 	* renderer, so a throwing renderer is invoked exactly once per build
 	* and the host fallback is single-path).
 	*/
+	/**
+	* Render a message's content blocks IN ORDER (plan §15.2): text blocks
+	* fold into one text component per run, image blocks render as inline
+	* thumbnails between them — `[text, image, text]` stays `text → image →
+	* text` on screen. Other block kinds (reasoning/tool-call) are skipped
+	* exactly like the flat `textWithImageMarkers` path. Only reached when
+	* the loader and theme are wired.
+	*/
+	renderBlockSequence(content, makeText, message) {
+		if (this.imageLoader === void 0 || this.imageTheme === void 0) return makeText(textWithImageMarkers(content));
+		const container = new Container();
+		let buffer = "";
+		const flush = () => {
+			if (buffer !== "") {
+				container.addChild(makeText(buffer));
+				buffer = "";
+			}
+		};
+		let imageIndex = 0;
+		for (const block of content) if (block.type === "text") buffer += block.text;
+		else if (block.type === "image") {
+			flush();
+			container.addChild(new ImageThumbnail(block.attachment, this.imageLoader, this.imageTheme, this.occurrenceCollapsedRef(message, imageIndex)));
+			imageIndex += 1;
+		}
+		flush();
+		return container;
+	}
+	/**
+	* A user message with images: ONE bubble whose text keeps an inline
+	* `🖼️ name` placeholder at every image's ORIGINAL position — the user's
+	* own words then read like the draft they submitted (`这张图是啥 🖼️
+	* shot.png`), instead of a bubble with the image silently moved to its
+	* own row. The thumbnails follow as attachment rows in block order; the
+	* bubble marker carries the position, the thumbnail carries the picture.
+	*/
+	renderUserBlocks(content, message) {
+		const container = new Container();
+		container.addChild(new UserBubbleComponent(new Text(textWithImageMarkers(content), 0, 0), `${color.roleUser("❯")} `, color.roleUserBg));
+		let imageIndex = 0;
+		for (const block of content) if (block.type === "image") {
+			container.addChild(new ImageThumbnail(block.attachment, this.imageLoader, this.imageTheme, this.occurrenceCollapsedRef(message, imageIndex)));
+			imageIndex += 1;
+		}
+		return container;
+	}
 	renderMessage(message, boundary) {
-		if (message.kind === "user") return new BulletedComponent(new Text(message.text, 0, 0), `${color.roleUser("❯")} `);
-		if (message.kind === "assistant") return new BulletedComponent(new Markdown(message.text, 0, 0, markdownTheme), `${color.primary("🐋")}  `);
+		if (message.kind === "user") {
+			if (message.content !== void 0 && this.imageLoader !== void 0 && this.imageTheme !== void 0) return this.renderUserBlocks(message.content, message);
+			return new UserBubbleComponent(new Text(message.text, 0, 0), `${color.roleUser("❯")} `, color.roleUserBg);
+		}
+		if (message.kind === "assistant") {
+			if (message.content !== void 0 && this.imageLoader !== void 0 && this.imageTheme !== void 0) return this.renderBlockSequence(message.content, (text) => new BulletedComponent(new Markdown(text, 0, 0, markdownTheme), `${color.primary("🐋")}  `), message);
+			return new BulletedComponent(new Markdown(message.text, 0, 0, markdownTheme), `${color.primary("🐋")}  `);
+		}
 		if (message.kind === "thinking") {
 			if (message.turn >= boundary || this.expandedOverride.get(message) === true) return new Text(color.textDimItalic(`🐳  ${message.text}`), 0, 0);
 			const lines = message.text.split("\n").filter((line) => line !== "");
@@ -20164,14 +21318,17 @@ var TuiApp = class TuiApp {
 				const emoji = message.emoji ?? "📎";
 				if (expanded) {
 					row.addChild(new Text(color.textMuted(`${emoji}  Context injection ${message.label}`), 0, 0));
-					row.addChild(new Text(color.textDim(message.text), 0, 0));
+					const body = systemContextBody(message.text);
+					if (body === void 0) row.addChild(new Text(color.textDim(message.text), 0, 0));
+					else for (const line of body) row.addChild(new Text(color.textDim(line), 0, 0));
 				} else {
-					const summary = message.summary === void 0 ? "" : ` — ${message.summary}`;
+					const summary = message.summary === void 0 ? skillFoldedPreview(message.text) : ` — ${message.summary}`;
 					row.addChild(new Text(truncateToWidth(color.textMuted(`${emoji}  Context injection ${message.label}${summary} (ctrl+o to expand)`), this.terminal.columns, "…"), 0, 0));
 				}
 				return row;
 			}
-			return new Text(expanded ? `${color.textMuted("§")} ${color.textDim(message.text)}` : color.textMuted(`§ ${truncateToWidth(preview(message.text, 2), Math.max(1, this.terminal.columns - 22), "…")} (ctrl+o to expand)`), 0, 0);
+			const unwrapped = systemContextBody(message.text)?.join("\n") ?? message.text;
+			return new Text(expanded ? `${color.textMuted("§")} ${color.textDim(unwrapped)}` : color.textMuted(`§ ${truncateToWidth(preview(unwrapped, 2), Math.max(1, this.terminal.columns - 22), "…")} (ctrl+o to expand)`), 0, 0);
 		}
 		if (message.kind === "summary") return new Text(color.textDim(message.text), 0, 0);
 		if (message.kind === "compaction") {
@@ -20205,6 +21362,9 @@ var TuiApp = class TuiApp {
 			const foldedCall = header.summary === "" ? foldedCallPreview(message.name, message.args) : "";
 			let resultPreview;
 			if (message.name === "read") resultPreview = readFoldedPreview(message.result);
+			else if (message.name === "write") resultPreview = writeFoldedPreview(message.result);
+			else if (message.name === "skill") resultPreview = skillFoldedPreview(message.result);
+			else if (message.name === "read_image") resultPreview = imageFoldedPreview(message.result);
 			else if (message.name === "ask_user_question") {
 				const summary = message.error === void 0 ? askAnswersSummary(message.result) : void 0;
 				resultPreview = summary === void 0 ? "" : ` — ${summary}`;
@@ -20214,7 +21374,8 @@ var TuiApp = class TuiApp {
 			} else if (FOLDED_JSON_RESULT_TOOLS.has(message.name)) {
 				const summary = foldedResultSummaryFor(message.name, message.result);
 				resultPreview = summary === void 0 || summary === "" ? "" : ` — ${summary}`;
-			} else resultPreview = message.result === "" ? "" : ` — ${preview(message.result, 3)}`;
+			} else if (XML_ENVELOPE_RESULT_TOOLS.has(message.name) && message.result.trimStart().startsWith("<")) resultPreview = "";
+			else resultPreview = message.result === "" ? "" : ` — ${preview(message.result, 3)}`;
 			const callHead = foldedCall === "" ? "" : foldedCall;
 			const headWithPreview = `${head}${callHead}${resultPreview}`;
 			if (callPreview?.kind === "bash" && callPreview.command !== "") {
@@ -20402,7 +21563,7 @@ var TuiApp = class TuiApp {
 					this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
 					if (callView.rawInput !== void 0) for (const line of genericRawInputLines(message.name, callView.rawInput)) card.addChild(new Text(color.textDim(line), 0, 0));
 					for (const block of callView.content ?? []) if (block.type === "text") card.addChild(new Text(color.textDim(block.text), 0, 0));
-					else card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
+					else card.addChild(new Text(color.textDim(this.blockDisplayText(block)), 0, 0));
 					return;
 				}
 			}
@@ -20475,8 +21636,25 @@ var TuiApp = class TuiApp {
 			case "generic": {
 				const content = resultView.content ?? [];
 				if (content.length > 0) {
-					for (const block of content) if (block.type === "text") card.addChild(new Text(color.textDim(block.text), 0, 0));
-					else card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
+					if (content.some((block) => block.type === "image") && this.imageLoader !== void 0 && this.imageTheme !== void 0) {
+						let buffer = "";
+						const flush = () => {
+							if (buffer !== "") {
+								card.addChild(new Text(color.textDim(buffer), 0, 0));
+								buffer = "";
+							}
+						};
+						for (const block of content) if (block.type === "text") buffer += block.text;
+						else if (block.type === "image") {
+							flush();
+							card.addChild(new ImageThumbnail(block.attachment, this.imageLoader, this.imageTheme));
+						} else {
+							flush();
+							card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
+						}
+						flush();
+					} else for (const block of content) if (block.type === "text") card.addChild(new Text(color.textDim(block.text), 0, 0));
+					else card.addChild(new Text(color.textDim(this.blockDisplayText(block)), 0, 0));
 					return;
 				}
 				break;
@@ -20504,19 +21682,87 @@ var TuiApp = class TuiApp {
 				});
 				return;
 			}
+			if (message.status === "ok") return;
+		}
+		if (message.name === "skill") {
+			const envelope = parseSkillEnvelope(message.result);
+			if (envelope !== void 0) {
+				card.addChild(new Text(color.textMuted(`  skill: ${envelope.name}`), 0, 0));
+				for (const line of envelope.instructions.split("\n")) card.addChild(new Text(color.textDim(line), 0, 0));
+				return;
+			}
+			if (message.status === "ok") return;
+		}
+		if (message.name === "read_image") {
+			const envelope = parseImageEnvelope(message.result);
+			if (envelope !== void 0) {
+				card.addChild(new Text(color.textDim(`  ${envelope.summary}`), 0, 0));
+				card.addChild(new Text(color.textMuted(`  path: ${relativizeToCwd(envelope.path, this.workspaceRoot)}`), 0, 0));
+				this.renderResultImageBlocks(card, message.resultBlocks);
+				return;
+			}
+			if (message.status === "ok") {
+				this.renderResultImageBlocks(card, message.resultBlocks);
+				return;
+			}
+		}
+		if (message.name === "write") {
+			const envelope = parseWriteEnvelope(message.result);
+			if (envelope !== void 0) {
+				card.addChild(new Text(color.textDim(`  ${envelope.verb} ${relativizeToCwd(envelope.path, this.workspaceRoot)}`), 0, 0));
+				return;
+			}
+			if (message.status === "ok") return;
 		}
 		if (isDiffResult(message.name, message.result)) for (const line of renderDiffLines(message.result)) card.addChild(new Text(line, 0, 0));
 		else {
 			this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
 			const blocks = message.resultBlocks ?? [];
-			const lines = blocks.length > 0 ? resultTextLines(blocks, message.status === "error" ? {
-				name: "error",
-				code: "tool"
-			} : void 0) : [message.result];
-			for (const line of lines) card.addChild(new Text(color.textDim(line), 0, 0));
+			if (blocks.some((block) => block.type === "image") && this.imageLoader !== void 0 && this.imageTheme !== void 0) {
+				let buffer = "";
+				const flush = () => {
+					if (buffer !== "") {
+						card.addChild(new Text(color.textDim(buffer), 0, 0));
+						buffer = "";
+					}
+				};
+				for (const block of blocks) if (block.type === "text") buffer += block.text;
+				else if (block.type === "image") {
+					flush();
+					card.addChild(new ImageThumbnail(block.attachment, this.imageLoader, this.imageTheme));
+				} else {
+					flush();
+					card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
+				}
+				flush();
+			} else {
+				const lines = blocks.length > 0 ? resultTextLines(blocks, message.status === "error" ? {
+					name: "error",
+					code: "tool"
+				} : void 0) : [message.result];
+				for (const line of lines) card.addChild(new Text(color.textDim(line), 0, 0));
+			}
 		}
 	}
 	/**
+	* Display form for a non-text block WITHOUT the image pipeline: image
+	* blocks project to a compact placeholder — never a JSON dump (the
+	* read_image envelope rule, review finding); everything else keeps the
+	* legacy pretty-JSON form.
+	*/
+	blockDisplayText(block) {
+		if (block.type === "image") return "[image]";
+		return JSON.stringify(block, null, 2);
+	}
+	/** Append the result's IMAGE blocks as thumbnails (any tool card that
+	* returns images but has its own summary path — read_image today, MCP
+	* image results and screenshot tools next). No-op without the pipeline
+	* or without image blocks. */
+	renderResultImageBlocks(card, blocks) {
+		if (blocks === void 0 || this.imageLoader === void 0 || this.imageTheme === void 0) return;
+		for (const block of blocks) if (block.type === "image") card.addChild(new ImageThumbnail(block.attachment, this.imageLoader, this.imageTheme));
+	}
+	/**
 	* Fill a tool card with a diff body: LCS-aligned clustered lines, capped
 	* at {@link DIFF_PREVIEW_LINES} in the default recent-turn view and full
 	* when the card was explicitly expanded (kimi parity).
@@ -20857,7 +22103,7 @@ var TuiApp = class TuiApp {
 		const shownNotices = noticeRows.slice(0, TuiApp.MAX_NOTICE_ROWS);
 		for (const item of userRows) {
 			const truncated = truncateToWidth(item.text.replace(/\s+/g, " ").trim(), Math.max(1, width - visibleWidth("❯ ")), "…");
-			lines.push(`${color.accent("❯")} ${truncated}`);
+			lines.push(`${color.roleUser("❯")} ${truncated}`);
 		}
 		for (const item of shownNotices) {
 			const truncated = truncateToWidth(item.text.replace(/\s+/g, " ").trim(), Math.max(1, width - visibleWidth("⏳ ")), "…");
@@ -20901,7 +22147,7 @@ var TuiApp = class TuiApp {
 	submitDraft(forceQueue = false) {
 		if (this.disposed) return;
 		const text = this.getDraft();
-		if (text.trim() === "") return;
+		if (text.trim() === "" && this.events.isImageDraft?.() !== true) return;
 		this.rememberInput(text);
 		this.clearNotify();
 		if (this.viewerMode === void 0) {
@@ -24675,6 +25921,500 @@ function createDiag(options = {}) {
 	};
 }
 //#endregion
+//#region src/image/admission.ts
+/** Total encoded bytes of the referenced images (preflight input). */
+function imageSegmentsBytes(segments) {
+	let total = 0;
+	for (const segment of segments) if (segment.type === "image") total += segment.image.byteLength;
+	return total;
+}
+/**
+* Build the ordered `ContentBlock[]` for one draft (plan §11): every text
+* segment becomes a text block, every image segment an image block backed by
+* the durable refs (index-aligned with the image segments in order). Empty
+* text segments were already dropped by the placeholder expansion.
+* @param segments - the expanded draft segments.
+* @param refs - durable refs in image-segment order.
+*/
+function buildContentBlocks(segments, refs) {
+	const blocks = [];
+	let refIndex = 0;
+	for (const segment of segments) {
+		if (segment.type === "text") {
+			if (segment.text !== "") blocks.push({
+				type: "text",
+				text: segment.text
+			});
+			continue;
+		}
+		const ref = refs[refIndex];
+		if (ref === void 0) throw new ImageAdmissionError("An image draft could not be admitted (reference mismatch).");
+		refIndex += 1;
+		blocks.push({
+			type: "image",
+			attachment: ref
+		});
+	}
+	return blocks;
+}
+/**
+* Admit every staged image of a draft (plan §10.2): one batched
+* `saveImages()` keeps input/ref ordering and avoids half-success semantics.
+* Count/aggregate preflights come from the LIVE `imageLimits`; the harness
+* re-validates bytes at admission — the TUI never duplicates normalization.
+* RECALLED images (pulled back from the queue) are ALREADY durable: their
+* ref is reused as-is and they are excluded from the save batch — the
+* harness object is content-addressed, so re-submitting the same ref never
+* duplicates storage (dequeue recall, review finding 3).
+* @param segments - the expanded draft segments.
+* @param attachments - the live `ctx.attachments` service.
+* @returns the admitted blocks and refs.
+*/
+async function admitDraftImages(segments, attachments) {
+	const images = segments.filter((segment) => segment.type === "image");
+	if (images.length === 0) return {
+		blocks: buildContentBlocks(segments, []),
+		refs: []
+	};
+	const limits = attachments.imageLimits;
+	if (images.length > limits.maxImagesPerMessage) throw new ImageAdmissionError(`Too many images: ${images.length} attached, the current limit is ${limits.maxImagesPerMessage} per message.`);
+	const aggregate = imageSegmentsBytes(images);
+	if (aggregate > limits.maxMessageImageBytes) throw new ImageAdmissionError(`Images total ${aggregate} bytes; the current aggregate limit is ${limits.maxMessageImageBytes} bytes.`);
+	const refs = new Array(images.length);
+	const toSave = [];
+	images.forEach((segment, index) => {
+		const recalled = segment.image.recalledRef;
+		if (recalled !== void 0) refs[index] = recalled;
+		else toSave.push({
+			input: {
+				data: segment.image.bytes,
+				mediaType: segment.image.mediaType,
+				...segment.image.name !== void 0 ? { name: segment.image.name } : {}
+			},
+			index
+		});
+	});
+	if (toSave.length > 0) {
+		const saved = await attachments.saveImages(toSave.map((entry) => entry.input));
+		if (saved.length !== toSave.length) throw new ImageAdmissionError(`The attachment service returned ${saved.length} references for ${toSave.length} images.`);
+		toSave.forEach((entry, savedIndex) => {
+			refs[entry.index] = saved[savedIndex];
+		});
+	}
+	return {
+		blocks: buildContentBlocks(segments, refs),
+		refs
+	};
+}
+//#endregion
+//#region src/image/capability.ts
+/**
+* Model image-capability gating (plan M5, §12).
+*
+* The decision comes from the CURRENT live provider/model via
+* `ctx.llm.resolveModelInfo()` — never a cached agent-startup model, because
+* the TUI supports runtime model switching (/model). Semantics:
+* - `inputModalities` ABSENT (undefined): capability unknown — do NOT
+*   reject client-side; the harness admission remains the authority;
+* - explicitly present WITHOUT `'image'`: a declared text-only model —
+*   reject with an actionable error, never silently drop images (§12).
+* @module @xmoon76/dsh-pi-tui/image/capability
+*/
+/**
+* Whether a resolved model can accept image input: unknown metadata is
+* treated as capable (the harness still re-checks at admission).
+*/
+function modelSupportsImages(info) {
+	if (info.inputModalities === void 0) return true;
+	return info.inputModalities.includes("image");
+}
+/**
+* Gate one submission against the CURRENT model's image capability.
+* @param llm - the live `ctx.llm` service (structural).
+* @param provider - the current provider route id.
+* @param model - the current model id.
+* @throws ModelImageUnsupportedError for a declared text-only model;
+*   `resolveModelInfo` failures propagate (the submission path surfaces
+*   them as actionable notices).
+*/
+async function assertModelSupportsImages(llm, provider, model) {
+	if (!modelSupportsImages(await llm.resolveModelInfo(provider, model))) throw new ModelImageUnsupportedError(provider, model);
+}
+//#endregion
+//#region src/image/placeholder.ts
+/** The canonical editor placeholder for one draft image. */
+function formatImagePlaceholder(id, width, height) {
+	return `[image #${id} (${width}×${height})]`;
+}
+/**
+* Expand the draft text into ordered segments: every canonical placeholder
+* whose draft is still staged becomes an image segment, everything else
+* stays text. Adjacent text segments are merged and empty text segments are
+* dropped, so a submission can map the segments one-to-one onto
+* `ContentBlock`s without re-normalizing whitespace (§6.2 items 4-5).
+* @param text - the editor draft.
+* @param store - the live draft store (structural; only `values()` is read).
+* @returns the segments in original order.
+*/
+function expandImagePlaceholders(text, store) {
+	const candidates = store.values().map((image) => ({
+		image,
+		placeholder: image.placeholder
+	}));
+	if (candidates.length === 0) return text === "" ? [] : [{
+		type: "text",
+		text
+	}];
+	const segments = [];
+	let cursor = 0;
+	while (cursor < text.length) {
+		let bestIndex = -1;
+		let best;
+		for (const candidate of candidates) {
+			const index = text.indexOf(candidate.placeholder, cursor);
+			if (index !== -1 && (best === void 0 || index < bestIndex)) {
+				bestIndex = index;
+				best = candidate.image;
+			}
+		}
+		if (best === void 0) break;
+		if (bestIndex > cursor) segments.push({
+			type: "text",
+			text: text.slice(cursor, bestIndex)
+		});
+		segments.push({
+			type: "image",
+			image: best
+		});
+		cursor = bestIndex + best.placeholder.length;
+	}
+	if (cursor < text.length) segments.push({
+		type: "text",
+		text: text.slice(cursor)
+	});
+	const merged = [];
+	for (const segment of segments) {
+		const previous = merged[merged.length - 1];
+		if (segment.type === "text" && segment.text === "") continue;
+		if (segment.type === "text" && previous !== void 0 && previous.type === "text") merged[merged.length - 1] = {
+			type: "text",
+			text: previous.text + segment.text
+		};
+		else merged.push(segment);
+	}
+	return merged;
+}
+//#endregion
+//#region src/image/submit.ts
+/**
+* Draft → UserMessage preparation for every agent-bound path (plan M6,
+* §13): followup, steer and queue all receive the SAME prepared message, so
+* no path can silently drop an `ImageBlock` (queue messages are durable
+* `UserMessage`s in the agent inbox — the queue never re-derives images
+* from drafts, §13.3).
+*
+* The pipeline: expand placeholders → (image present) model capability gate
+* → batched `saveImages()` → ordered ContentBlocks → `createUserMessage`.
+* A text-only draft keeps the exact legacy path (single text block, no
+* service calls), so the no-image fast path is unchanged.
+* @module @xmoon76/dsh-pi-tui/image/submit
+*/
+/** Whether the draft text references any staged image (the image-only
+* prompt gate shared by every submit path). */
+function draftHasImages(text, store) {
+	return expandImagePlaceholders(text, store).some((segment) => segment.type === "image");
+}
+/**
+* Remove ONLY the drafts a submission actually consumed (plan §14): the
+* image ids referenced by the submitted text. Never a wholesale clear — a
+* concurrent /image or Ctrl+V intake racing a submission keeps its newly
+* staged draft (round-5 finding 1).
+*/
+function consumeDraftImages(text, store) {
+	for (const segment of expandImagePlaceholders(text, store)) if (segment.type === "image") store.remove(segment.image.id);
+}
+/**
+* Drop every draft the CURRENT editor text no longer references (review
+* finding 2): deleting a placeholder (or Ctrl+C clearing the editor) leaves
+* the staged bytes in the store until capacity runs out — 16 stale
+* attachments then block the next /image with "Too many staged images".
+* Called BEFORE a new attach (the editor text at that moment is the truth
+* of what is still wanted). DRAFTS PINNED BY AN IN-FLIGHT SUBMISSION are
+* kept — the editor is cleared before dispatch, so an attach must never
+* delete the images a pending prepareUserMessage is about to admit
+* (review finding 1).
+*/
+function pruneUnreferencedDrafts(text, store) {
+	const referenced = /* @__PURE__ */ new Set();
+	for (const segment of expandImagePlaceholders(text, store)) if (segment.type === "image") referenced.add(segment.image.id);
+	for (const image of store.values()) if (!referenced.has(image.id) && !store.isPinned(image.id)) store.remove(image.id);
+}
+/**
+* Prepare the immutable `UserMessage` for one submission.
+* @param text - the editor draft text.
+* @param store - the live draft store.
+* @param deps - the service surface.
+* @returns the frozen user message.
+* @throws ImageAdmissionError when the deployment has no attachment service
+*   but the draft references images; capability/admission errors otherwise.
+*/
+async function prepareUserMessage(text, store, deps) {
+	const segments = expandImagePlaceholders(text, store);
+	if (!segments.some((segment) => segment.type === "image")) return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: { kind: "user" }
+	});
+	if (deps.attachments === void 0) throw new ImageAdmissionError("Image attachments are unavailable in this deployment.");
+	const current = deps.currentModel();
+	if (deps.llm !== void 0 && current !== void 0) await assertModelSupportsImages(deps.llm, current.provider, current.model);
+	const admitted = await admitDraftImages(segments, deps.attachments);
+	return createUserMessage({
+		content: [...admitted.blocks],
+		source: { kind: "user" }
+	});
+}
+//#endregion
+//#region src/image/intake.ts
+/**
+* Image intake: file → validated draft bytes (plan M2, §7-§8).
+*
+* The intake is split into PURE functions (magic-byte sniffing, lightweight
+* header-only dimension parsing, limits preflight) and one IO function
+* (`readImageFile`: resolve → stat → read → sniff → parse → preflight).
+* The pure half is fully unit-testable without a filesystem; the IO half
+* stays narrow so the /image command handler and the headless tests can
+* drive it with real files.
+*
+* Design rules from the plan:
+* - extension is NEVER the MIME authority (magic bytes only, §7.2);
+* - stat BEFORE readFile so an over-limit file never enters memory (§7.3);
+* - only regular files are accepted (symlinks resolve to their target,
+*   §7.1);
+* - the harness's `ctx.attachments.imageLimits` is the ONLY limit source —
+*   nothing here hardcodes a deployment default (§21);
+* - metadata parsing is header-only; no image decoder is imported (§8).
+* @module @xmoon76/dsh-pi-tui/image/intake
+*/
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const JPEG_SIGNATURE = [
+	255,
+	216,
+	255
+];
+/** True when `bytes` starts with every byte of `signature`. */
+function startsWith(bytes, signature) {
+	if (bytes.length < signature.length) return false;
+	for (let index = 0; index < signature.length; index += 1) if (bytes[index] !== signature[index]) return false;
+	return true;
+}
+/** Detect the raster media type from magic bytes only. */
+function sniffMediaType(bytes) {
+	if (startsWith(bytes, PNG_SIGNATURE)) return "image/png";
+	if (startsWith(bytes, JPEG_SIGNATURE)) return "image/jpeg";
+	if (bytes.length >= 6) {
+		const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]);
+		if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
+	}
+	if (bytes.length >= 12) {
+		const riff = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+		const webp = String.fromCharCode(bytes[8], bytes[9], bytes[10], bytes[11]);
+		if (riff === "RIFF" && webp === "WEBP") return "image/webp";
+	}
+}
+function readUInt16BE(bytes, offset) {
+	return bytes[offset] << 8 | bytes[offset + 1];
+}
+function readUInt16LE(bytes, offset) {
+	return bytes[offset] | bytes[offset + 1] << 8;
+}
+function readUInt32BE(bytes, offset) {
+	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+/** PNG: IHDR at offset 8; width/height are big-endian u32 at 16/20. */
+function pngDimensions(bytes) {
+	if (bytes.length < 24) return void 0;
+	if (String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]) !== "IHDR") return void 0;
+	return {
+		width: readUInt32BE(bytes, 16),
+		height: readUInt32BE(bytes, 20)
+	};
+}
+/**
+* JPEG dimensions from the SOFn marker scan (SOF0-15, excluding the
+* arithmetic/table markers C4/C8/CC). Height precedes width in the frame
+* header, both big-endian.
+*/
+function jpegDimensions(bytes) {
+	if (bytes.length < 4) return void 0;
+	let offset = 2;
+	while (offset + 9 <= bytes.length) {
+		if (bytes[offset] !== 255) {
+			offset += 1;
+			continue;
+		}
+		let marker = bytes[offset + 1];
+		if (marker === 255) {
+			offset += 1;
+			continue;
+		}
+		if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1) {
+			offset += 2;
+			continue;
+		}
+		const length = readUInt16BE(bytes, offset + 2);
+		if (length < 2) return void 0;
+		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+			if (length < 8 || offset + 2 + length > bytes.length) return void 0;
+			return {
+				height: readUInt16BE(bytes, offset + 5),
+				width: readUInt16BE(bytes, offset + 7)
+			};
+		}
+		offset += 2 + length;
+	}
+}
+/** GIF logical screen descriptor: little-endian width/height at 6/8. */
+function gifDimensions(bytes) {
+	if (bytes.length < 10) return void 0;
+	return {
+		width: readUInt16LE(bytes, 6),
+		height: readUInt16LE(bytes, 8)
+	};
+}
+/** WebP dimensions for the VP8 (lossy) / VP8L (lossless) / VP8X (extended)
+* chunk variants (the same offsets the vendored pi-tui fork parses). */
+function webpDimensions(bytes) {
+	if (bytes.length < 30) return void 0;
+	const chunk = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+	if (chunk === "VP8 ") return {
+		width: readUInt16LE(bytes, 26) & 16383,
+		height: readUInt16LE(bytes, 28) & 16383
+	};
+	if (chunk === "VP8L") {
+		if (bytes.length < 25) return void 0;
+		const bits = bytes[21] | bytes[22] << 8 | bytes[23] << 16 | bytes[24] << 24;
+		return {
+			width: (bits & 16383) + 1,
+			height: (bits >>> 14 & 16383) + 1
+		};
+	}
+	if (chunk === "VP8X") return {
+		width: (bytes[24] | bytes[25] << 8 | bytes[26] << 16) + 1,
+		height: (bytes[27] | bytes[28] << 8 | bytes[29] << 16) + 1
+	};
+}
+/**
+* Parse raster metadata from raw bytes: magic-byte MIME detection plus
+* header-only dimension parsing. Returns undefined for non-images,
+* truncated/corrupt headers, or impossible dimensions (<= 0 or non-finite
+* — round-2 finding 7; the harness re-validates at admission).
+*/
+function parseImageMetadata(bytes) {
+	const mediaType = sniffMediaType(bytes);
+	if (mediaType === void 0) return void 0;
+	const parsed = mediaType === "image/png" ? pngDimensions(bytes) : mediaType === "image/jpeg" ? jpegDimensions(bytes) : mediaType === "image/gif" ? gifDimensions(bytes) : webpDimensions(bytes);
+	if (parsed === void 0) return void 0;
+	if (!(parsed.width > 0) || !(parsed.height > 0) || !Number.isFinite(parsed.width) || !Number.isFinite(parsed.height)) return;
+	return {
+		mediaType,
+		width: parsed.width,
+		height: parsed.height
+	};
+}
+/**
+* Preflight one parsed image against the deployment's attachment limits.
+* Throws the actionable intake errors; the harness re-checks at admission.
+* @param meta - sniffed metadata.
+* @param byteLength - exact encoded byte length.
+* @param limits - the deployment image policy (or undefined = no preflight).
+*/
+function checkImageLimits(meta, byteLength, limits) {
+	if (limits === void 0) return;
+	if (!limits.mediaTypes.includes(meta.mediaType)) throw new UnsupportedImageTypeError(`The deployment does not accept ${meta.mediaType}.`);
+	if (byteLength > limits.maxImageBytes) throw new ImageTooLargeError(byteLength, limits.maxImageBytes);
+	if (meta.width * meta.height > limits.maxImagePixels) throw new ImageDimensionError(`Image is ${meta.width}×${meta.height} (${meta.width * meta.height} px); the pixel limit is ${limits.maxImagePixels} px.`);
+	if (meta.width > limits.maxImageDimension || meta.height > limits.maxImageDimension) throw new ImageDimensionError(`Image is ${meta.width}×${meta.height}; the dimension limit is ${limits.maxImageDimension} px per side.`);
+}
+/** Expand a leading `~` to the home directory (no other shell expansion). */
+function expandHome(raw) {
+	if (raw === "~") return homedir();
+	if (raw.startsWith("~/") || raw.startsWith("~\\")) return `${homedir()}${raw.slice(1)}`;
+	return raw;
+}
+/**
+* Resolve one path argument to a canonical regular-file path.
+* @param raw - the raw argument (already shell-word parsed).
+* @param cwd - the TUI working directory for relative paths.
+* @returns the canonical real path.
+* @throws ImageInputError when the target is missing, unreadable, or not a
+*   regular file (directory/FIFO/socket/device are rejected, §7.1). Error
+*   messages name the BASENAME only — full private paths are never logged
+*   (§21). ASYNC throughout (fs/promises) — the intake must never block the
+*   TUI event loop on slow disks or NFS (review finding).
+*/
+async function resolveImagePath(raw, cwd) {
+	const expanded = expandHome(raw);
+	const absolute = isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+	const label = basename(absolute);
+	let real;
+	try {
+		real = await realpath(absolute);
+	} catch (error) {
+		throw new ImageInputError(`Image file not found: ${label}`);
+	}
+	let stats;
+	try {
+		stats = await stat(real);
+	} catch (error) {
+		throw new ImageInputError(`Image file cannot be read: ${label}`);
+	}
+	if (!stats.isFile()) throw new ImageInputError(`Not a regular file: ${label}`);
+	return real;
+}
+/**
+* Read one image file end to end: resolve → stat → size preflight → read →
+* sniff → parse → dimension preflight. Throws the actionable errors from
+* errors.ts; the caller stages the result into the draft store. Fully
+* async — never blocks the TUI event loop (review finding).
+* @param rawPath - the command argument (shell-word parsed already).
+* @param cwd - the working directory for relative paths.
+* @param limits - the deployment image policy (undefined = the TUI safety
+*   cap applies instead of the attachment limit).
+* @param extraSafetyCap - an additional caller-side byte cap (e.g. the
+*   draft store's remaining resident budget); the smallest of all caps
+*   wins. Undefined = no extra cap.
+*/
+async function readImageFile(rawPath, cwd, limits, extraSafetyCap) {
+	const path = await resolveImagePath(rawPath, cwd);
+	const stats = await stat(path);
+	const sizeCap = Math.min(limits?.maxImageBytes ?? 67108864, extraSafetyCap ?? 67108864);
+	if (stats.size > sizeCap) throw new ImageTooLargeError(stats.size, sizeCap);
+	const bytes = new Uint8Array(await readFile(path));
+	const meta = parseImageMetadata(bytes);
+	if (meta === void 0) throw new UnsupportedImageTypeError();
+	checkImageLimits(meta, bytes.byteLength, limits);
+	return {
+		bytes,
+		mediaType: meta.mediaType,
+		width: meta.width,
+		height: meta.height,
+		name: basename(path),
+		path
+	};
+}
+//#endregion
 //#region src/model-menu.ts
 /**
 * In-place submenu components for `/model`: the model list and the
@@ -25885,17 +27625,19 @@ function readProviderOptions(ctx) {
 		settingsPath: ["providers", option.label]
 	});
 }
-/** Build the merged /login picker rows: reference targets keep their
-* configured/available/custom groups (the fork renders a non-interactive
-* header row per group), authorization targets get their own group, and the
-* Add New Platform action row is pinned last. Authorization row values
-* carry the AUTH_VALUE_PREFIX so they can never collide with a route. */
+/** Build the merged /login picker rows: reference targets (the API-key
+* path) keep their configured/available/custom groups, prefixed with the
+* `API key` category so the two credential planes are visible at a glance
+* (the fork renders a non-interactive header row per group); authorization
+* targets (the provider sign-in path) get their own group, and the Add New
+* Platform action row is pinned last. Authorization row values carry the
+* AUTH_VALUE_PREFIX so they can never collide with a route. */
 function mergedPickerRows(merged) {
 	const rows = [];
 	const groupLabels = {
-		configured: "configured",
-		available: "available · catalog",
-		custom: "custom",
+		configured: "API key · configured",
+		available: "API key · available",
+		custom: "API key · custom",
 		authorization: "sign in with provider"
 	};
 	for (const target of merged) if (target.kind === "reference") {
@@ -26185,7 +27927,7 @@ async function askAddProvider(ctx, app, signal, prefilledRoute) {
 	}
 	return {
 		kind: "ok",
-		text: key === "" ? `provider ${routeValue} added (no key; provider-native authentication)` : `${ref} set · provider ${routeValue} added`
+		text: key === "" ? `provider ${routeValue} added (no key; provider-native authentication)` : `API key ${ref} set · provider ${routeValue} added`
 	};
 }
 /**
@@ -26251,6 +27993,10 @@ function registerTuiCommands(runner, initial) {
 	};
 	/** The advertised names of the currently installed completion list. */
 	let claims = /* @__PURE__ */ new Set();
+	/** Slash commands whose single argument is a path: the fork's
+	* `getArgumentCompletions` extension point completes it against the LIVE
+	* session cwd (natural typing shows candidates, Tab accepts them). */
+	const PATH_ARGUMENT_COMMANDS = /* @__PURE__ */ new Set(["image"]);
 	/**
 	* Install one completion list (sorted, claims refreshed). The single
 	* synchronous seam every catalog commit funnels through.
@@ -26261,7 +28007,8 @@ function registerTuiCommands(runner, initial) {
 		app.setCommandCompletions(sorted.map((command) => ({
 			name: command.name,
 			description: command.description,
-			argumentHint: command.input?.hint
+			argumentHint: command.input?.hint,
+			...PATH_ARGUMENT_COMMANDS.has(command.name) ? { getArgumentCompletions: (argument) => suggestPathArgument(argument, runner.sessionCwd()) } : {}
 		})), runner.sessionCwd(), fdPath, extensionAutocomplete === void 0 ? void 0 : async (query) => {
 			const result = await extensionAutocomplete.suggest(query, (id, error) => {
 				recordExtensionError?.("autocomplete", id, error);
@@ -26751,17 +28498,17 @@ function registerTuiCommands(runner, initial) {
 			text: `skill "${name}" returned a malformed definition`
 		};
 		const line = args.trim() === "" ? "/" + skill.name : "/" + skill.name + " " + args.trimStart();
-		const userMessage = createUserMessage({
-			content: [{
-				type: "text",
-				text: line
-			}],
-			source: { kind: "user" }
-		});
+		const releasePin = runner.imageStore.pinReferenced(line);
+		let userMessage;
+		try {
+			userMessage = await runner.prepareDraftMessage(line);
+			agent.steer(userMessage);
+			consumeDraftImages(line, runner.imageStore);
+		} finally {
+			releasePin();
+		}
 		const hostSkillLoader = ctx.get("tools")?.get?.("skill", agent);
-		const hostLoadsSkillBody = hostSkillLoader !== void 0 && typeof hostSkillLoader.execute === "function";
-		agent.steer(userMessage);
-		if (!hostLoadsSkillBody) {
+		if (!(hostSkillLoader !== void 0 && typeof hostSkillLoader.execute === "function")) {
 			const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
 			const resourceBase = readResourceBase(skill.resourceBase);
 			agent.inject(createUserMessage({
@@ -27052,7 +28799,14 @@ function registerTuiCommands(runner, initial) {
 				setup: composition.setup
 			});
 			const error = await runner.swapTo(next);
-			if (error !== void 0) app.notify(error, "error");
+			if (error !== void 0) {
+				app.notify(error, "error");
+				return {
+					kind: "error",
+					text: error
+				};
+			}
+			runner.imageStore.clearUnpinned();
 			return {
 				kind: "success",
 				text: "started a fresh session"
@@ -27380,6 +29134,60 @@ function registerTuiCommands(runner, initial) {
 			};
 		}
 	});
+	commands.register({
+		name: "image",
+		description: "Attach an image file to the draft (tab completes the path; [image #N (W×H)] placeholder)",
+		input: { hint: "<path>" },
+		handler: (invocation) => {
+			const words = parseShellWords(invocation.rawInput);
+			if (words.length !== 1 || words[0] === "") return {
+				kind: "error",
+				text: "Usage: /image <path>"
+			};
+			const raw = words[0];
+			const intakeGeneration = runner.sessionGeneration;
+			const detach = (label, task) => {
+				runDetached(label, task, {
+					diag: runner.diag,
+					sessionId: () => runner.liveAgent?.session.id,
+					notify: (message) => app.notify(message, "error"),
+					recoverable: () => true
+				});
+			};
+			detach("image intake", () => {
+				runOwned("image intake", () => {
+					pruneUnreferencedDrafts(app.getDraft(), runner.imageStore);
+					return readImageFile(raw, runner.sessionCwd(), runner.imageLimits(), runner.imageStore.remainingBytes()).then((resolved) => {
+						if (runner.sessionGeneration !== intakeGeneration) {
+							app.notify("the session changed while reading the image — try again", "error");
+							return;
+						}
+						pruneUnreferencedDrafts(app.getDraft(), runner.imageStore);
+						const draft = runner.imageStore.add({
+							bytes: resolved.bytes,
+							mediaType: resolved.mediaType,
+							width: resolved.width,
+							height: resolved.height,
+							source: {
+								type: "path",
+								path: resolved.path
+							},
+							name: resolved.name
+						});
+						runner.insertIntoEditor(`${draft.placeholder} `);
+						app.notify(`attached ${draft.placeholder} — Enter to send`);
+					});
+				}, {
+					diag: runner.diag,
+					sessionId: () => runner.liveAgent?.session.id,
+					onError: (error) => {
+						app.notify(safeErrorMessage(error), "error");
+					}
+				});
+			});
+			return { kind: "success" };
+		}
+	});
 	commands.register({
 		name: "export",
 		description: "Export this session log (JSONL by default, `md` for a readable transcript)",
@@ -27448,7 +29256,14 @@ function registerTuiCommands(runner, initial) {
 				seed
 			});
 			const error = await runner.swapTo(next);
-			if (error !== void 0) app.notify(error, "error");
+			if (error !== void 0) {
+				app.notify(error, "error");
+				return {
+					kind: "error",
+					text: error
+				};
+			}
+			runner.imageStore.clearUnpinned();
 			return {
 				kind: "success",
 				text: `forked as ${next.agent.session.id}`
@@ -27492,7 +29307,7 @@ function registerTuiCommands(runner, initial) {
 	});
 	commands.register({
 		name: "login",
-		description: "Sign in — deepseek official or an llm-pi-ai provider route (API key or provider-native flow)",
+		description: "Sign in with a provider or set an API key — deepseek official or an llm-pi-ai provider route",
 		input: { hint: "[<route|env-var>]" },
 		handler: async (invocation) => {
 			const credentials = ctx.get("credentials");
@@ -27598,7 +29413,7 @@ function registerTuiCommands(runner, initial) {
 			try {
 				const key = (await app.askQuestions([{
 					id: "key",
-					question: `Paste the API key for ${label}:`,
+					question: `Enter the API key for ${label}:`,
 					masked: true
 				}]))[0]?.custom ?? "";
 				if (key === "") return {
@@ -27608,7 +29423,7 @@ function registerTuiCommands(runner, initial) {
 				await credentials.set(targetRef, key);
 				return {
 					kind: "success",
-					text: `${targetRef} set`
+					text: `API key ${targetRef} set`
 				};
 			} catch {
 				return {
@@ -27647,7 +29462,7 @@ function registerTuiCommands(runner, initial) {
 					await credentials.unset(resolved);
 					return {
 						kind: "success",
-						text: `${resolved} cleared`
+						text: `API key ${resolved} cleared`
 					};
 				}
 				const flow = flowForRoute(targets, arg.toLowerCase());
@@ -27693,7 +29508,7 @@ function registerTuiCommands(runner, initial) {
 			await credentials.unset(targetRef);
 			return {
 				kind: "success",
-				text: `${targetRef} cleared`
+				text: `API key ${targetRef} cleared`
 			};
 		}
 	});
@@ -27924,6 +29739,684 @@ function appendHistoryLine(file, text, lastContent) {
 	return true;
 }
 //#endregion
+//#region src/image/draft-store.ts
+/**
+* The per-TUI draft image registry (plan M1, §5.2).
+*
+* Holds staged clipboard/file bytes under numeric ids, mirroring kimi's
+* `ImageAttachmentStore` UX. The store is a MEMORY registry only: it never
+* writes durable attachments (that is `ctx.attachments.saveImages()`), and
+* `clear()` never touches anything the harness already accepted — a cleared
+* draft leaves durable refs unreachable-but-alive per harness retention
+* semantics (plan §14).
+*
+* Bounded (plan §21): a per-draft byte cap and an aggregate byte cap reject
+* new drafts before they are staged, so repeated `/image`/Ctrl+V pastes can
+* never pin unbounded memory in the TUI.
+* @module @xmoon76/dsh-pi-tui/image/draft-store
+*/
+/** In-memory draft registry. */
+var DraftImageStore = class {
+	nextId = 1;
+	images = /* @__PURE__ */ new Map();
+	bytesHeld = 0;
+	maxImages;
+	maxBytes;
+	/**
+	* In-flight submission reservations (review finding 1): ids referenced by
+	* a submission that STARTED but has not committed yet. The editor is
+	* cleared before dispatch, so an attach-time prune would otherwise delete
+	* the very drafts the in-flight prepareUserMessage still needs. A pinned
+	* draft survives pruning until its submission settles.
+	*/
+	pins = /* @__PURE__ */ new Map();
+	/**
+	* TUI-OWNED memory protection, NOT an attachment limit: the caps bound
+	* what the TUI stages in RAM before submission (review finding). The
+	* harness's `imageLimits` (20 images / 200 MiB per message by default)
+	* is a SEPARATE policy enforced at admission; a draft rejected here can
+	* still be valid for the backend once submitted in smaller batches.
+	* @param maxImages - entry cap (default 16).
+	* @param maxBytes - aggregate encoded-byte cap (default 64 MiB). */
+	constructor(maxImages = 16, maxBytes = 67108864) {
+		this.maxImages = maxImages;
+		this.maxBytes = maxBytes;
+	}
+	/** Stage one image and return its draft (ids increment from 1).
+	* @throws ImageTooLargeError when the aggregate RESIDENT cap would be
+	*   exceeded; ImageAdmissionError when the entry cap is reached. A
+	*   RECALLED input (`recalledRef` present) carries no local bytes: its
+	*   LOGICAL size (the durable ref's recorded bytes) counts toward the
+	*   message aggregate, but its RESIDENT size is 0 — the bytes live in
+	*   harness storage, so the TUI RAM budget never counts them (review
+	*   finding 3). */
+	add(input) {
+		if (this.images.size >= this.maxImages) throw new ImageAdmissionError(`Too many staged images: the draft holds ${this.images.size} (limit ${this.maxImages}). Send or remove one first.`);
+		const recalled = input.recalledRef;
+		const bytes = input.bytes ?? /* @__PURE__ */ new Uint8Array(0);
+		const logicalByteLength = recalled !== void 0 ? recalled.bytes : bytes.byteLength;
+		const residentBytes = bytes.byteLength;
+		if (this.bytesHeld + residentBytes > this.maxBytes) throw new ImageTooLargeError(residentBytes, this.maxBytes - this.bytesHeld);
+		const id = this.nextId++;
+		const image = {
+			id,
+			kind: "image",
+			source: recalled !== void 0 ? { type: "recalled" } : input.source ?? { type: "clipboard" },
+			bytes,
+			mediaType: input.mediaType,
+			width: input.width,
+			height: input.height,
+			byteLength: logicalByteLength,
+			...input.name !== void 0 ? { name: input.name } : {},
+			...recalled !== void 0 ? { recalledRef: recalled } : {},
+			placeholder: formatImagePlaceholder(id, input.width, input.height)
+		};
+		this.images.set(id, image);
+		this.bytesHeld += residentBytes;
+		return image;
+	}
+	/** The staged draft for an id, or undefined when unknown/removed. */
+	get(id) {
+		return this.images.get(id);
+	}
+	/** Remove one draft; returns whether it was staged. */
+	remove(id) {
+		const image = this.images.get(id);
+		if (image === void 0) return false;
+		this.bytesHeld -= image.bytes.byteLength;
+		return this.images.delete(id);
+	}
+	/** Drop every staged draft (submit, /clear, session switch, dispose). */
+	/** Drop every staged draft (TUI dispose / full teardown). */
+	clear() {
+		this.images.clear();
+		this.bytesHeld = 0;
+		this.pins.clear();
+	}
+	/**
+	* Drop every staged draft EXCEPT those reserved by an in-flight
+	* submission (session switch, /new, /fork — review finding): a stale
+	* submission that detects the switch still restores its editor text
+	* (mergeDraft), and that text's placeholders must keep their backing
+	* drafts until the submission's pin releases. Unpinned drafts go; the
+	* pin map survives (released pins become prunable normally).
+	*/
+	clearUnpinned() {
+		for (const [id, image] of this.images) {
+			if (this.isPinned(id)) continue;
+			this.bytesHeld -= image.bytes.byteLength;
+			this.images.delete(id);
+		}
+	}
+	/** All staged drafts in insertion order. */
+	values() {
+		return [...this.images.values()];
+	}
+	/** How many drafts are staged. */
+	size() {
+		return this.images.size;
+	}
+	/** Aggregate RESIDENT staged bytes (observability/tests; recalled
+	* images hold no local bytes and count 0). */
+	bytes() {
+		return this.bytesHeld;
+	}
+	/** The remaining RESIDENT byte budget (review finding: used as the
+	* intake's extra pre-read safety cap, so a file that could never fit the
+	* draft store is refused before any read). */
+	remainingBytes() {
+		return Math.max(0, this.maxBytes - this.bytesHeld);
+	}
+	/**
+	* Reserve every draft referenced by `text` for the duration of one
+	* in-flight submission (review finding 1): the editor is cleared before
+	* dispatch, so without a reservation an attach-time prune could delete
+	* the drafts the submission is about to admit. The returned release
+	* function MUST be called (idempotent; safe in finally).
+	* @param text - the submitted text (placeholders already expanded).
+	* @returns the release function.
+	*/
+	pinReferenced(text) {
+		const ids = [];
+		for (const segment of expandImagePlaceholders(text, this)) {
+			if (segment.type !== "image") continue;
+			const id = segment.image.id;
+			if (!this.images.has(id)) continue;
+			this.pins.set(id, (this.pins.get(id) ?? 0) + 1);
+			ids.push(id);
+		}
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			for (const id of ids) {
+				const count = this.pins.get(id);
+				if (count === void 0) continue;
+				if (count <= 1) this.pins.delete(id);
+				else this.pins.set(id, count - 1);
+			}
+		};
+	}
+	/** Whether a draft is reserved by an in-flight submission. */
+	isPinned(id) {
+		return (this.pins.get(id) ?? 0) > 0;
+	}
+};
+//#endregion
+//#region src/image/clipboard.ts
+/**
+* Clipboard image reading (plan M3, §9).
+*
+* The paste action probes the platform clipboard ONCE, then: an image
+* becomes a draft (placeholder into the editor); plain text keeps the
+* ordinary paste behavior; "clipboard has no image" is NOT an error (a
+* text Ctrl+V must never pop "No image found" — §20). The platform matrix
+* follows the plan: Wayland `wl-paste`, X11 `xclip`, WSL/macOS/Windows
+* PowerShell+AppKit PNG round-trips, graceful unsupported elsewhere.
+*
+* Every platform runs through an injected `RunCommand`, so CI exercises
+* the decision trees with mocks (plan §26) and real machines verify one
+* native path.
+* @module @xmoon76/dsh-pi-tui/image/clipboard
+*/
+/**
+* Whether a command is available on $PATH (review finding): a bare
+* `existsSync(command)` only checks the CURRENT directory, so normal
+* Wayland/X11 installations would look "helper missing". Walks the PATH
+* entries; empty entries fall back to the CWD like a real shell.
+* - a command containing a path separator resolves DIRECTLY (shell lookup
+*   semantics: `./wl-paste` never walks PATH);
+* - win32 PATH entries split on `;` ONLY — drive-letter colons (`C:\…`)
+*   survive (follow-up finding); POSIX splits on `:`.
+*/
+function commandOnPath(command, pathVar, platform) {
+	if (command.includes("/") || platform === "win32" && command.includes("\\")) return existsSync(command);
+	const separator = platform === "win32" ? ";" : ":";
+	const dirs = (pathVar ?? "").split(separator);
+	if (dirs.length === 0 || dirs.some((dir) => dir === "")) {
+		if (existsSync(command)) return true;
+	}
+	for (const dir of dirs) {
+		if (dir === "") continue;
+		try {
+			if (existsSync(join(dir, command))) return true;
+		} catch {}
+	}
+	return false;
+}
+/** WSL detection: the interop marker env or the kernel banner. */
+function isWsl(env) {
+	return env.env.WSL_DISTRO_NAME !== void 0 || env.env.WSL_INTEROP !== void 0 || env.env.WSLENV !== void 0;
+}
+/** Whether the termux environment is active. */
+function isTermux(env) {
+	return env.env.TERMUX_VERSION !== void 0 || env.env.PREFIX === "/data/data/com.termux/files/usr";
+}
+/** Wait-free bounded run helper for clipboard commands. */
+async function runWithTimeout(run, command, args, timeoutMs) {
+	const result = await run(command, args, { timeoutMs });
+	if (result.code !== 0 && result.stdout.length === 0) throw new ClipboardImageError(`clipboard command failed: ${command} (exit ${result.code})`);
+	return {
+		stdout: result.stdout,
+		code: result.code
+	};
+}
+/** Parse the bytes once a binary clipboard payload arrives. */
+function imageFromBytes(bytes) {
+	const meta = parseImageMetadata(bytes);
+	if (meta === void 0) return {
+		kind: "text",
+		text: ""
+	};
+	return {
+		kind: "image",
+		bytes,
+		mediaType: meta.mediaType,
+		width: meta.width,
+		height: meta.height
+	};
+}
+async function waylandProbe(run) {
+	const list = (await runWithTimeout(run, "wl-paste", ["--list-types"], 1500)).stdout.toString("utf8");
+	if (!/[iI]mage\//.test(list)) return {
+		kind: "text",
+		text: (await runWithTimeout(run, "wl-paste", [], 1500)).stdout.toString("utf8")
+	};
+	for (const mediaType of [
+		"image/png",
+		"image/jpeg",
+		"image/webp",
+		"image/gif"
+	]) {
+		if (!list.includes(mediaType)) continue;
+		const data = await runWithTimeout(run, "wl-paste", ["-t", mediaType], 2e3);
+		if (data.stdout.length === 0) continue;
+		return imageFromBytes(data.stdout);
+	}
+	const data = await runWithTimeout(run, "wl-paste", [], 2e3);
+	if (data.stdout.length === 0) return {
+		kind: "text",
+		text: ""
+	};
+	return imageFromBytes(data.stdout);
+}
+async function x11Probe(run) {
+	const list = (await runWithTimeout(run, "xclip", [
+		"-selection",
+		"clipboard",
+		"-t",
+		"TARGETS",
+		"-o"
+	], 1500)).stdout.toString("utf8");
+	if (!/[mM]age\//.test(list)) return {
+		kind: "text",
+		text: (await runWithTimeout(run, "xclip", [
+			"-selection",
+			"clipboard",
+			"-o"
+		], 1500)).stdout.toString("utf8")
+	};
+	for (const mediaType of [
+		"image/png",
+		"image/jpeg",
+		"image/webp",
+		"image/gif"
+	]) {
+		if (!list.includes(mediaType)) continue;
+		const data = await runWithTimeout(run, "xclip", [
+			"-selection",
+			"clipboard",
+			"-t",
+			mediaType,
+			"-o"
+		], 2e3);
+		if (data.stdout.length === 0) continue;
+		return imageFromBytes(data.stdout);
+	}
+	const data = await runWithTimeout(run, "xclip", [
+		"-selection",
+		"clipboard",
+		"-o"
+	], 2e3);
+	if (data.stdout.length === 0) return {
+		kind: "text",
+		text: ""
+	};
+	return imageFromBytes(data.stdout);
+}
+/** macOS: AppKit NSPasteboard PNG → temp file. */
+async function macosProbe(run) {
+	const file = join(tmpdir(), `dsh-clipboard-${randomUUID()}.png`);
+	const osascript = [
+		"use framework \"AppKit\"",
+		`set thePasteboard to current application's NSPasteboard's generalPasteboard()`,
+		`set theData to thePasteboard's dataForType:(current application's NSPasteboardTypePNG)`,
+		"if theData is missing value then return \"\"",
+		`set theFile to POSIX file "${file}"`,
+		"theData's writeToFile:theFile atomically:true",
+		"return \"ok\""
+	].join("\n");
+	try {
+		const result = await run("osascript", ["-e", osascript], { timeoutMs: 5e3 });
+		if (result.code !== 0) throw new ClipboardImageError(`osascript failed (exit ${result.code})`);
+		let bytes;
+		try {
+			bytes = new Uint8Array(readFileSync(file));
+		} catch {
+			return {
+				kind: "text",
+				text: (await run("osascript", ["-e", "the clipboard as text"], { timeoutMs: 3e3 })).stdout.toString("utf8")
+			};
+		}
+		return imageFromBytes(bytes);
+	} finally {
+		rmSync(file, { force: true });
+	}
+}
+/** Windows / WSL: PowerShell clipboard → temp PNG. Under WSL the Linux
+* temp path is converted with `wslpath -w` first — PowerShell cannot
+* address `/tmp/...` directly (review finding 5). */
+async function powershellProbe(run, wsl) {
+	const file = join(tmpdir(), `dsh-clipboard-${randomUUID()}.png`);
+	let target = file;
+	if (wsl) {
+		const converted = await run("wslpath", ["-w", file], { timeoutMs: 2e3 });
+		if (converted.code !== 0) throw new ClipboardImageError(`wslpath failed (exit ${converted.code})`);
+		target = converted.stdout.toString("utf8").trim();
+	}
+	const script = [
+		"Add-Type -AssemblyName System.Windows.Forms",
+		"$img = [System.Windows.Forms.Clipboard]::GetImage()",
+		"if ($null -eq $img) { exit 0 }",
+		`$img.Save('${target.replaceAll("'", "''")}')`
+	].join("; ");
+	try {
+		const result = await run("powershell.exe", [
+			"-NoProfile",
+			"-Command",
+			script
+		], { timeoutMs: 8e3 });
+		if (result.code !== 0) throw new ClipboardImageError(`powershell failed (exit ${result.code})`);
+		let bytes;
+		try {
+			bytes = new Uint8Array(readFileSync(file));
+		} catch {
+			return {
+				kind: "text",
+				text: (await run("powershell.exe", [
+					"-NoProfile",
+					"-Command",
+					"Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Clipboard]::GetText()"
+				], { timeoutMs: 3e3 })).stdout.toString("utf8")
+			};
+		}
+		return imageFromBytes(bytes);
+	} finally {
+		rmSync(file, { force: true });
+	}
+}
+/**
+* Probe the clipboard for an image. Never throws for "no image": plain
+* text and empty clipboards resolve to `{ kind: 'text' }`; platform
+* failures throw {@link ClipboardImageError} (a clipboard that DOES carry
+* an image but cannot be read must be distinguished from no image).
+*/
+async function readClipboardImage(run, env) {
+	if (isTermux(env)) return { kind: "unsupported" };
+	if (env.platform === "darwin") return macosProbe(run);
+	if (env.platform === "win32") return powershellProbe(run, false);
+	if (isWsl(env)) return powershellProbe(run, true);
+	if (env.env.WAYLAND_DISPLAY !== void 0 && env.exists("wl-paste")) return waylandProbe(run);
+	if (env.env.DISPLAY !== void 0 && env.exists("xclip")) return x11Probe(run);
+	return { kind: "unsupported" };
+}
+//#endregion
+//#region src/image/cache.ts
+/** Bounded LRU image cache. */
+var ImageCache = class {
+	entries = /* @__PURE__ */ new Map();
+	bytesHeld = 0;
+	maxEntries;
+	maxBytes;
+	constructor(maxEntries = 32, maxBytes = 67108864) {
+		this.maxEntries = maxEntries;
+		this.maxBytes = maxBytes;
+	}
+	/** The cached entry for an attachment id, or undefined. */
+	get(attachmentId) {
+		const entry = this.entries.get(attachmentId);
+		if (entry === void 0) return void 0;
+		this.entries.delete(attachmentId);
+		this.entries.set(attachmentId, entry);
+		return entry;
+	}
+	/** Store one entry, evicting least-recently-used entries past the caps. */
+	set(attachmentId, entry) {
+		const existing = this.entries.get(attachmentId);
+		if (existing !== void 0) this.bytesHeld -= entryBytes(existing);
+		this.entries.delete(attachmentId);
+		this.entries.set(attachmentId, entry);
+		this.bytesHeld += entryBytes(entry);
+		this.evict();
+	}
+	/** Whether the cache holds a ready entry for an attachment id. */
+	has(attachmentId) {
+		return this.entries.has(attachmentId);
+	}
+	/** Drop one attachment (transcript trim / explicit invalidation). */
+	delete(attachmentId) {
+		const entry = this.entries.get(attachmentId);
+		if (entry !== void 0) {
+			this.bytesHeld -= entryBytes(entry);
+			this.entries.delete(attachmentId);
+		}
+	}
+	/** Drop everything (session switch / TUI dispose). */
+	clear() {
+		this.entries.clear();
+		this.bytesHeld = 0;
+	}
+	/** Current entry count (observability/tests). */
+	size() {
+		return this.entries.size;
+	}
+	/** Current held bytes (observability/tests). */
+	bytes() {
+		return this.bytesHeld;
+	}
+	/** Enforce the caps from the NEWEST slot backwards. */
+	evict() {
+		while (this.entries.size > this.maxEntries || this.bytesHeld > this.maxBytes) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) return;
+			const entry = this.entries.get(oldest);
+			if (entry !== void 0) this.bytesHeld -= entryBytes(entry);
+			this.entries.delete(oldest);
+		}
+	}
+};
+function entryBytes(entry) {
+	return entry.state === "ready" ? entry.byteLength + Math.ceil(entry.byteLength * 1.33) : 0;
+}
+//#endregion
+//#region src/image/loader.ts
+/**
+* Durable image loading for the transcript (plan M8, §16).
+*
+* History images come ONLY from `ctx.attachments.readImage(ref)` — never
+* from the draft store (§16). The loader is the async bridge a render
+* component consults synchronously:
+*
+* - `get(ref)` returns the CURRENT state (idle/loading/ready/error) without
+*   awaiting — render methods cannot await (plan §16.1);
+* - `load(ref)` fires the underlying read ONCE per attachment id, deduping
+*   concurrent loads from multiple components (§16.2);
+* - subscribers are notified after every settle so components can
+*   invalidate and repaint with the resolved bytes.
+* @module @xmoon76/dsh-pi-tui/image/loader
+*/
+/** Cap on retained failure records (round-2 finding 3): failures are
+* diagnostic, never a growing leak on long transcripts. */
+const MAX_ERROR_ENTRIES = 64;
+/** The async image loader with concurrent-load dedupe + subscriber notify. */
+var ImageLoader = class {
+	cache;
+	inflight = /* @__PURE__ */ new Map();
+	errors = /* @__PURE__ */ new Map();
+	/** Per-attachment listeners: a settle notifies ONLY the attachments that
+	* care, so N thumbnails loading in parallel never invalidate each other
+	* (review finding 8 — no O(N²) repaint churn). */
+	listeners = /* @__PURE__ */ new Map();
+	read;
+	/**
+	* Invalidation generations (review finding 3): `invalidate(id)` bumps
+	* ONLY that attachment's local generation, so a settle of an unrelated
+	* in-flight read is never discarded. `clear()` bumps the GLOBAL
+	* generation AND resets the per-id map — every in-flight settle is stale
+	* after a session switch, including ones that had been locally
+	* invalidated before (a per-id override must never let a pre-clear read
+	* pass the global check; review finding: composite-single-number epochs
+	* were unsound).
+	*/
+	globalEpoch = 0;
+	perIdEpoch = /* @__PURE__ */ new Map();
+	/** The epoch one read must match at settle time (a binary snapshot). */
+	epochOf(id) {
+		return {
+			global: this.globalEpoch,
+			local: this.perIdEpoch.get(id) ?? 0
+		};
+	}
+	/** Whether a settle with the captured epoch is still current. */
+	epochCurrent(id, captured) {
+		return this.globalEpoch === captured.global && (this.perIdEpoch.get(id) ?? 0) === captured.local;
+	}
+	constructor(read, cache = new ImageCache()) {
+		this.read = read;
+		this.cache = cache;
+	}
+	/** The synchronous state view for one ref (never awaits). */
+	get(ref) {
+		const id = ref.attachmentId;
+		const cached = this.cache.get(id);
+		if (cached !== void 0) {
+			if (cached.state === "ready") return {
+				state: "ready",
+				bytes: cached.bytes,
+				base64: cached.base64
+			};
+			return {
+				state: "error",
+				error: cached.error
+			};
+		}
+		const failed = this.errors.get(id);
+		if (failed !== void 0) return {
+			state: "error",
+			error: failed
+		};
+		if (this.inflight.has(id)) return { state: "loading" };
+		return { state: "idle" };
+	}
+	/** Whether a ref is fully resolved (cache hit). */
+	isReady(ref) {
+		return this.cache.has(ref.attachmentId);
+	}
+	/**
+	* Fire the async load for a ref (no-op when already loading/ready). One
+	* underlying `readImage` per attachment id: concurrent callers share the
+	* in-flight promise. On settle, the cache/error maps update and every
+	* subscriber is notified.
+	*/
+	load(ref) {
+		const id = ref.attachmentId;
+		if (this.cache.has(id) || this.inflight.has(id)) return;
+		const epoch = this.epochOf(id);
+		const pending = Promise.resolve().then(() => this.read(ref)).then((stored) => {
+			if (!this.epochCurrent(id, epoch)) return stored;
+			const data = stored.data;
+			this.cache.set(id, {
+				state: "ready",
+				bytes: data,
+				base64: bytesToBase64(data),
+				byteLength: data.byteLength
+			});
+			this.errors.delete(id);
+			return stored;
+		}).catch((error) => {
+			if (!this.epochCurrent(id, epoch)) return { data: /* @__PURE__ */ new Uint8Array(0) };
+			this.recordError(id, error instanceof Error ? error : new ImageLoadError(String(error)));
+			return { data: /* @__PURE__ */ new Uint8Array(0) };
+		}).finally(() => {
+			this.inflight.delete(id);
+			this.notify(id);
+		});
+		this.inflight.set(id, pending);
+	}
+	/** Record one load failure, bounding the error map (round-2 finding 3). */
+	recordError(id, error) {
+		this.errors.set(id, error);
+		if (this.errors.size > MAX_ERROR_ENTRIES) {
+			const oldest = this.errors.keys().next().value;
+			if (oldest !== void 0) this.errors.delete(oldest);
+		}
+	}
+	/**
+	* Subscribe to one attachment's settles; returns the unsubscribe
+	* function. A settle notifies ONLY its attachment's listeners — N
+	* thumbnails loading in parallel never invalidate each other (review
+	* finding 8). `clear()` still broadcasts to every subscriber.
+	*/
+	subscribe(attachmentId, listener) {
+		let set = this.listeners.get(attachmentId);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(attachmentId, set);
+		}
+		set.add(listener);
+		return () => {
+			const owned = this.listeners.get(attachmentId);
+			if (owned === void 0) return;
+			owned.delete(listener);
+			if (owned.size === 0) this.listeners.delete(attachmentId);
+		};
+	}
+	/** Drop one attachment's cached state (transcript trim). In-flight reads
+	* for THIS attachment settle into the void (its per-id generation bumps);
+	* unrelated in-flight reads keep their generations and settle normally
+	* (review finding 3). */
+	invalidate(attachmentId) {
+		this.perIdEpoch.set(attachmentId, this.epochOf(attachmentId).local + 1);
+		this.cache.delete(attachmentId);
+		this.errors.delete(attachmentId);
+	}
+	/** Drop everything (session switch / dispose): the GLOBAL generation
+	* bumps AND the per-id map resets — a pre-clear local invalidation can
+	* never mask the global invalidation for a later settle (review
+	* finding), and the map cannot grow unboundedly. Every subscriber hears
+	* the global invalidation and repaints once. */
+	clear() {
+		this.globalEpoch += 1;
+		this.perIdEpoch.clear();
+		this.cache.clear();
+		this.errors.clear();
+		this.notifyAll();
+	}
+	/** Current cache size (observability/tests). */
+	cacheSize() {
+		return this.cache.size();
+	}
+	/** Current subscriber count (observability/tests). */
+	listenerCount() {
+		let total = 0;
+		for (const set of this.listeners.values()) total += set.size;
+		return total;
+	}
+	/** Notify the listeners of ONE attachment (settle fan-out). */
+	notify(attachmentId) {
+		const set = this.listeners.get(attachmentId);
+		if (set === void 0) return;
+		for (const listener of set) try {
+			listener();
+		} catch {}
+	}
+	/** Notify every subscriber (global invalidation). */
+	notifyAll() {
+		for (const set of this.listeners.values()) for (const listener of set) try {
+			listener();
+		} catch {}
+	}
+};
+/** Base64 of a byte buffer (the pi-tui Image component's input). */
+function bytesToBase64(bytes) {
+	let binary = "";
+	const chunk = 32768;
+	for (let index = 0; index < bytes.length; index += chunk) binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+	return btoa(binary);
+}
+//#endregion
+//#region src/image/submit-flow.ts
+/**
+* Run one pinned submission end to end. The reservation is established
+* FIRST (the caller must call this synchronously, before any await — the
+* editor was already cleared by the submit path); on failure the editor
+* is restored BEFORE the reservation releases; the release always runs.
+* @returns when the submission committed (or was aborted normally).
+* @throws the run failure after the restore (the caller's runOwned
+*   onError then notifies — never a second restore).
+*/
+async function runReservedSubmit(flow, text) {
+	const release = flow.reserve(text);
+	try {
+		await flow.run(text);
+	} catch (error) {
+		flow.restore(text);
+		throw error;
+	} finally {
+		release();
+	}
+}
+//#endregion
 //#region src/dsh-version.ts
 /**
 * The installed dsh (DeepSeek Harness CLI) version, resolved from the
@@ -28425,7 +30918,7 @@ async function steerAll(deps, text, options = {}) {
 		return "ok";
 	}
 	const draft = text.trim();
-	const messages = [...current, ...draft === "" ? [] : [deps.createDraft(draft)]];
+	const messages = [...current, ...draft === "" ? [] : [deps.createDraft(text)]];
 	for (const message of current) now.inbox.remove(message.id);
 	for (const message of messages) now.steer(message);
 	if (!forced) deps.notify(messages.length === 1 ? "steering 1 message" : `steering ${messages.length} messages`, "info");
@@ -29240,6 +31733,7 @@ const SESSIONLESS_COMMANDS = /* @__PURE__ */ new Set([
 	"exit",
 	"settings",
 	"help",
+	"image",
 	"login",
 	"logout",
 	"model",
@@ -29269,6 +31763,7 @@ const LOCAL_COMMANDS = /* @__PURE__ */ new Set([
 	"export",
 	"fork",
 	"help",
+	"image",
 	"kill",
 	"login",
 	"logout",
@@ -29290,6 +31785,23 @@ const LOCAL_COMMANDS = /* @__PURE__ */ new Set([
 	"yolo"
 ]);
 /**
+* Command semantics matrix (plan §19.3/M12): a LOCAL command line carrying a
+* staged image placeholder is REJECTED — local commands are pure UI
+* controls, never LLM prompts. AGENT-FACING input (plain prompts AND
+* per-skill slash invocations like `/grilling`) SUPPORTS images: the skill
+* wrapper builds its message through the same prepared-input path, so an
+* image-bearing skill line is a real multimodal prompt (review finding 4).
+* There is never a silent drop.
+* @param parsed - the parsed slash command, undefined for a plain prompt.
+* @param text - the submission text.
+* @param store - the live draft store.
+* @param isLocal - whether the command name is a LOCAL (TUI-owned/UI)
+*   command; skill names answer false.
+*/
+function commandRejectsImages(parsed, text, store, isLocal) {
+	return parsed !== void 0 && isLocal(parsed.name) && draftHasImages(text, store);
+}
+/**
 * The AUTHORITATIVE host-owned command catalog (P1-04): every command name
 * the TUI registers itself (registerTuiCommands in commands.ts) plus the
 * ownership sets (LOCAL_COMMANDS and SESSIONLESS_COMMANDS — /kill and
@@ -29318,12 +31830,38 @@ const HOST_COMMAND_CATALOG = /* @__PURE__ */ new Set([
 function shouldSteerOnEnter(parsed, running, busyEnter, forceQueue, isDynamicLocal) {
 	if (forceQueue) return false;
 	if (parsed !== void 0) {
+		if (parsed.name === "skill" && (parsed.rawInput?.trim() ?? "") !== "") return running && busyEnter === "steer";
 		if (LOCAL_COMMANDS.has(parsed.name)) return false;
 		if (isDynamicLocal !== void 0 && isDynamicLocal(parsed.name)) return false;
 	}
 	return running && busyEnter === "steer";
 }
 /**
+* Normalize an explicit `/skill <name> <args>` invocation to the skill's
+* own slash line `/<name> <args>` (review finding 2). The harness's
+* explicit skill gesture scans for `/<skill-name>` — it would extract
+* `skill` from a raw `/skill grilling ...` line and never inject the
+* grilling body. The command handler already performs this conversion
+* (`loadSkill` builds `'/' + skill.name + ' ' + args`); the busy-Enter
+* steer path must use the SAME normalized line so the body injects and
+* any image placeholders ride along.
+* @param text - the submitted line.
+* @returns the normalized `/<name> <args>` line, or undefined when the
+*   line is not an explicit skill invocation (plain prompt, other
+*   commands, or the bare `/skill` picker).
+*/
+function normalizeSkillInvocation(text) {
+	const parsed = parseCommand(text);
+	if (parsed?.name !== "skill") return void 0;
+	const raw = parsed.rawInput.trim();
+	if (raw === "") return void 0;
+	const match = /^([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/.exec(raw);
+	if (match === null) return void 0;
+	const name = match[1];
+	const args = match[2];
+	return args === void 0 || args.trim() === "" ? `/${name}` : `/${name} ${args.trimStart()}`;
+}
+/**
 * The advertised-claim miss decision (pure, exported for the headless
 * suite): a slash input whose name was advertised by the completion list at
 * submit time but that the REAL session's catalog lacks is CONSUMED with an
@@ -29490,6 +32028,20 @@ function subagentNoticeIsFailure(source) {
 *   skipped, and a newly-reported id is ADDED here so a re-render can never
 *   double-notify.
 */
+/**
+* The queue-pane display text of one message's content (review finding 5):
+* text blocks verbatim, image blocks as a compact `🖼️ name` summary (the
+* marker carries U+FE0F so fonts with an emoji face render it 2 cells wide
+* — the width math's expectation — and never overlap the name) — an
+* image-only queued message shows `🖼️ shot.png` instead of an empty row,
+* and a mixed message advertises its image. The queue row stays one line.
+*/
+function queueTextOf(content) {
+	const parts = [];
+	for (const block of content) if (block.type === "text") parts.push(block.text);
+	else if (block.type === "image") parts.push(`🖼️ ${block.attachment.name ?? "image"}`);
+	return parts.join(" ");
+}
 function foldQueueRows(messages, mode, notified) {
 	const rows = [];
 	const failures = [];
@@ -29504,7 +32056,7 @@ function foldQueueRows(messages, mode, notified) {
 		}
 		rows.push({
 			id: message.id,
-			text: textOf(message.content),
+			text: queueTextOf(message.content),
 			mode,
 			notice: !isUserQueueInput(source)
 		});
@@ -30247,7 +32799,9 @@ function apply(ctx, config) {
 					},
 					setup: composition.setup
 				});
-				return swapTo(next);
+				const error = await swapTo(next);
+				if (error === void 0) draftImages.clearUnpinned();
+				return error;
 			} catch (error) {
 				const message = safeErrorMessage(error);
 				ctx.logger.warn(`tui-runner: switch to ${sessionId} failed: ${message}`);
@@ -30626,11 +33180,65 @@ function apply(ctx, config) {
 		const failSubmission = (draft) => (error) => {
 			app.setEditorText(mergeDraft(app.getDraft(), draft));
 			const message = safeErrorMessage(error);
+			if (error instanceof ImageInputError) {
+				app.notify(message, "error");
+				return;
+			}
 			try {
 				ctx.logger.error(`tui-runner: session creation failed: ${message}`);
 			} catch {}
 			app.notify(`could not start a session: ${message}`, "error");
 		};
+		/**
+		* Restore the submitted text into the editor after a failed submission
+		* (review finding: the restore MUST run BEFORE the reservation pin
+		* releases — the restored placeholders must keep their backing drafts
+		* against concurrent attach-time prunes). Correctness side effect
+		* first; never throws.
+		*/
+		const restoreSubmissionDraft = (draft) => {
+			app.setEditorText(mergeDraft(app.getDraft(), draft));
+		};
+		/**
+		* Notify one submission failure WITHOUT restoring (the task's catch
+		* already restored; restoring twice would re-merge the draft). Image
+		* intake/admission/capability failures are THEIR OWN actionable errors
+		* ("Current model ... does not support image input") — wrapping them in
+		* "could not start a session" misleads when a session already exists.
+		* Diagnostics are owned by runOwned.
+		*/
+		const notifySubmissionFailure = (error) => {
+			const message = safeErrorMessage(error);
+			if (error instanceof ImageInputError) {
+				app.notify(message, "error");
+				return;
+			}
+			try {
+				ctx.logger.error(`tui-runner: submission failed: ${message}`);
+			} catch {}
+			const prefix = liveAgent === void 0 ? "could not start a session" : "submission failed";
+			app.notify(`${prefix}: ${message}`, "error");
+		};
+		/** The image submission surface (plan §13): the live attachment/llm
+		* services + the CURRENT provider/model, re-read at submit time (the
+		* TUI supports runtime model switching — never a startup snapshot). */
+		const submitDeps = {
+			attachments: ctx.get("attachments"),
+			llm: ctx.get("llm"),
+			currentModel: () => {
+				const current = selected.current;
+				if (current !== void 0) return {
+					provider: current.provider,
+					model: current.model
+				};
+				if (liveAgent === void 0) return void 0;
+				const { provider, model } = liveAgent.options;
+				return provider === void 0 || model === void 0 ? void 0 : {
+					provider,
+					model
+				};
+			}
+		};
 		/** The session-backed dispatch: create the session lazily (the first
 		* user input is the deferred trigger), guard against cross-process
 		* divergence, then execute a registered slash command or follow up. */
@@ -30638,80 +33246,109 @@ function apply(ctx, config) {
 			const parsedAtSubmit = parseCommand(text);
 			const extensionCommandId = parsedAtSubmit === void 0 ? void 0 : extensionService?.commands.idFor(parsedAtSubmit.name);
 			const wasAdvertised = parsedAtSubmit !== void 0 && wasAdvertisedClaim?.(parsedAtSubmit.name) === true;
-			runOwned("submit", () => ensureSession().then(async () => {
-				const agent = liveAgent;
-				if (agent === void 0) return;
-				const generation = sessionGeneration;
-				const verdict = await guardSend("submit", text);
-				if (verdict.kind === "blocked") {
-					const merged = mergeDraft(app.getDraft(), text);
-					app.setEditorText(merged);
-					app.notify(merged === text ? verdict.reason === "removed" ? GUARD_REMOVED_NOTIFY("submit") : verdict.reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("submit") : GUARD_BLOCKED_NOTIFY("submit") : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
-					return;
-				}
-				if (!sessionUnchanged({
-					agent,
-					generation
-				}, liveAgent, sessionGeneration)) {
-					const merged = mergeDraft(app.getDraft(), text);
-					app.setEditorText(merged);
-					app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
-					return;
-				}
-				if (verdict.kind === "forced") app.notify(GUARD_FORCED_NOTIFY, "error");
-				const commands = ctx.get("commands");
-				if (commands !== void 0) {
-					const parsed = parseCommand(text);
-					const toggled = parsed?.name === "plan" && parsed.rawInput.trim() === "" && foldPlanMode(agent.session.events ?? []) ? "/plan off" : text;
-					runOwned("command execution", () => commands.execute(agent, toggled, [], signal), {
-						diag,
-						sessionId: () => agent.session.id,
-						onResult: (execution) => {
-							if (extensionCommandId !== void 0 && execution !== void 0) extensionService?._clearRegistryError("command", extensionCommandId);
-							if (shouldConsumeAdvertisedMiss(execution, wasAdvertised)) {
-								app.notify(`/${parsedAtSubmit?.name ?? "?"} is not available in the created session`, "error");
-								return;
-							}
-							if (execution === void 0) {
-								if (sessionUnchanged({
-									agent,
-									generation
-								}, liveAgent, sessionGeneration)) agent.followup(createUserMessage({
-									content: [{
-										type: "text",
-										text
-									}],
-									source: { kind: "user" }
-								}));
-								else {
-									const merged = mergeDraft(app.getDraft(), text);
-									app.setEditorText(merged);
-									app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+			runOwned("submit", () => runReservedSubmit({
+				reserve: (t) => draftImages.pinReferenced(t),
+				run: async () => {
+					await ensureSession();
+					const agent = liveAgent;
+					if (agent === void 0) return;
+					const generation = sessionGeneration;
+					const verdict = await guardSend("submit", text);
+					if (verdict.kind === "blocked") {
+						const merged = mergeDraft(app.getDraft(), text);
+						app.setEditorText(merged);
+						app.notify(merged === text ? verdict.reason === "removed" ? GUARD_REMOVED_NOTIFY("submit") : verdict.reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("submit") : GUARD_BLOCKED_NOTIFY("submit") : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+						return;
+					}
+					if (!sessionUnchanged({
+						agent,
+						generation
+					}, liveAgent, sessionGeneration)) {
+						const merged = mergeDraft(app.getDraft(), text);
+						app.setEditorText(merged);
+						app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+						return;
+					}
+					if (verdict.kind === "forced") app.notify(GUARD_FORCED_NOTIFY, "error");
+					const commands = ctx.get("commands");
+					if (commands !== void 0) {
+						const parsed = parseCommand(text);
+						const toggled = parsed?.name === "plan" && parsed.rawInput.trim() === "" && foldPlanMode(agent.session.events ?? []) ? "/plan off" : text;
+						const fallbackPin = draftImages.pinReferenced(text);
+						runOwned("command execution", () => commands.execute(agent, toggled, [], signal), {
+							diag,
+							sessionId: () => agent.session.id,
+							onResult: (execution) => {
+								if (extensionCommandId !== void 0 && execution !== void 0) extensionService?._clearRegistryError("command", extensionCommandId);
+								if (shouldConsumeAdvertisedMiss(execution, wasAdvertised)) {
+									app.notify(`/${parsedAtSubmit?.name ?? "?"} is not available in the created session`, "error");
+									fallbackPin();
+									return;
 								}
+								if (execution === void 0) {
+									if (sessionUnchanged({
+										agent,
+										generation
+									}, liveAgent, sessionGeneration)) runOwned("image submit", () => runReservedSubmit({
+										reserve: () => fallbackPin,
+										run: async () => {
+											const message = await prepareUserMessage(text, draftImages, submitDeps);
+											if (!sessionUnchanged({
+												agent,
+												generation
+											}, liveAgent, sessionGeneration)) {
+												const merged = mergeDraft(app.getDraft(), text);
+												app.setEditorText(merged);
+												app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+												return;
+											}
+											agent.followup(message);
+											consumeDraftImages(text, draftImages);
+										},
+										restore: (t) => restoreSubmissionDraft(t)
+									}, text), {
+										diag,
+										sessionId: () => agent.session.id,
+										onError: notifySubmissionFailure
+									});
+									else {
+										fallbackPin();
+										const merged = mergeDraft(app.getDraft(), text);
+										app.setEditorText(merged);
+										app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+									}
+								} else fallbackPin();
+							},
+							onError: (error) => {
+								fallbackPin();
+								if (extensionCommandId !== void 0) extensionService?._recordRegistryError("command", extensionCommandId, error);
+								const message = safeErrorMessage(error);
+								try {
+									ctx.logger.error(`tui-runner: command execution failed: ${message}`);
+								} catch {}
+								app.notify(message, "error");
 							}
-						},
-						onError: (error) => {
-							if (extensionCommandId !== void 0) extensionService?._recordRegistryError("command", extensionCommandId, error);
-							const message = safeErrorMessage(error);
-							try {
-								ctx.logger.error(`tui-runner: command execution failed: ${message}`);
-							} catch {}
-							app.notify(message, "error");
-						}
-					});
-					return;
-				}
-				agent.followup(createUserMessage({
-					content: [{
-						type: "text",
-						text
-					}],
-					source: { kind: "user" }
-				}));
-			}), {
+						});
+						return;
+					}
+					const message = await prepareUserMessage(text, draftImages, submitDeps);
+					if (!sessionUnchanged({
+						agent,
+						generation
+					}, liveAgent, sessionGeneration)) {
+						const merged = mergeDraft(app.getDraft(), text);
+						app.setEditorText(merged);
+						app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+						return;
+					}
+					agent.followup(message);
+					consumeDraftImages(text, draftImages);
+				},
+				restore: (t) => restoreSubmissionDraft(t)
+			}, text), {
 				diag,
 				sessionId: () => liveAgent?.session.id,
-				onError: failSubmission(text)
+				onError: notifySubmissionFailure
 			});
 		};
 		/**
@@ -30778,45 +33415,45 @@ function apply(ctx, config) {
 			}
 			app.clearSettledLocalMessages();
 			if (onlyDraft) {
-				if (text.trim() === "") return;
+				if (text.trim() === "" && !draftHasImages(text, draftImages)) return;
 			} else if (liveAgent !== void 0) {
-				if ([...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].length === 0 && text.trim() === "") return;
-			} else if (text.trim() === "") return;
-			runOwned("steer", () => ensureSession().then(async () => {
-				if (liveAgent === void 0) return;
-				await steerAll({
-					currentAgent: () => liveAgent,
-					currentGeneration: () => sessionGeneration,
-					guard: { run: async (identity) => {
-						const verdict = await guardSend("save", identity);
-						if (verdict.kind === "blocked") return {
-							kind: "blocked",
-							reason: verdict.reason
-						};
-						return { kind: verdict.kind === "forced" ? "forced" : "ok" };
-					} },
-					notify: (message, kind) => app.notify(message, kind),
-					restoreDraft: (draft) => {
-						const merged = mergeDraft(app.getDraft(), draft);
-						app.setEditorText(merged);
-						return merged === draft;
-					},
-					createDraft: (draft) => createUserMessage({
-						content: [{
-							type: "text",
-							text: draft
-						}],
-						source: { kind: "user" }
-					}),
-					blockedNotice: (reason) => reason === "removed" ? GUARD_REMOVED_NOTIFY("save") : reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("save") : GUARD_BLOCKED_NOTIFY("save"),
-					forcedNotice: () => GUARD_FORCED_NOTIFY,
-					staleNotice: () => "the queue or session changed while sending — try again",
-					mergedNotice: () => "the draft changed while sending — review it before submitting again (the earlier text was preserved below)"
-				}, text, onlyDraft ? { onlyDraft: true } : void 0);
-			}), {
+				if ([...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].length === 0 && text.trim() === "" && !draftHasImages(text, draftImages)) return;
+			} else if (text.trim() === "" && !draftHasImages(text, draftImages)) return;
+			runOwned("steer", () => runReservedSubmit({
+				reserve: (t) => draftImages.pinReferenced(t),
+				run: async () => {
+					await ensureSession();
+					if (liveAgent === void 0) return;
+					const prepared = await prepareUserMessage(text, draftImages, submitDeps);
+					if (await steerAll({
+						currentAgent: () => liveAgent,
+						currentGeneration: () => sessionGeneration,
+						guard: { run: async (identity) => {
+							const verdict = await guardSend("save", identity);
+							if (verdict.kind === "blocked") return {
+								kind: "blocked",
+								reason: verdict.reason
+							};
+							return { kind: verdict.kind === "forced" ? "forced" : "ok" };
+						} },
+						notify: (message, kind) => app.notify(message, kind),
+						restoreDraft: (draft) => {
+							const merged = mergeDraft(app.getDraft(), draft);
+							app.setEditorText(merged);
+							return merged === draft;
+						},
+						createDraft: () => prepared,
+						blockedNotice: (reason) => reason === "removed" ? GUARD_REMOVED_NOTIFY("save") : reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("save") : GUARD_BLOCKED_NOTIFY("save"),
+						forcedNotice: () => GUARD_FORCED_NOTIFY,
+						staleNotice: () => "the queue or session changed while sending — try again",
+						mergedNotice: () => "the draft changed while sending — review it before submitting again (the earlier text was preserved below)"
+					}, text, onlyDraft ? { onlyDraft: true } : void 0) === "ok") consumeDraftImages(text, draftImages);
+				},
+				restore: (t) => restoreSubmissionDraft(t)
+			}, text), {
 				diag,
 				sessionId: () => liveAgent?.session.id,
-				onError: failSubmission(text)
+				onError: notifySubmissionFailure
 			});
 		};
 		/**
@@ -30846,7 +33483,7 @@ function apply(ctx, config) {
 			}
 			app.clearSettledLocalMessages();
 			const trimmed = text.trim();
-			if (trimmed !== "" && trimmed !== lastHistoryContent) {
+			if (trimmed !== "" && trimmed !== lastHistoryContent && !draftHasImages(text, draftImages)) {
 				const file = historyFilePath(dshHome(process.env), sessionCwd());
 				runDetached("input history write", () => {
 					appendHistoryLine(file, trimmed, lastHistoryContent);
@@ -30867,22 +33504,85 @@ function apply(ctx, config) {
 				return;
 			}
 			const parsed = parseCommand(text);
+			if (commandRejectsImages(parsed, text, draftImages, (name) => {
+				if (name === "skill" && (parsed?.rawInput.trim() ?? "") !== "") return false;
+				return LOCAL_COMMANDS.has(name) || (extensionService?.commands.isLocal(name, LOCAL_COMMANDS) ?? false);
+			})) {
+				app.setEditorText(mergeDraft(app.getDraft(), text));
+				app.notify("Images cannot be attached to a command.", "error");
+				return;
+			}
 			const isSessionless = parsed !== void 0 && (SESSIONLESS_COMMANDS.has(parsed.name) || (extensionService?.commands.isSessionless(parsed.name, SESSIONLESS_COMMANDS) ?? false));
 			if (parsed !== void 0 && liveAgent === void 0 && isSessionless) {
 				runLocalCommand(parsed, text);
 				return;
 			}
 			if (shouldSteerOnEnter(parsed, liveAgent?.status === "running", tuiSettings?.get().busyEnter, forceQueue, (name) => extensionService?.commands.isLocal(name, LOCAL_COMMANDS) ?? false)) {
-				steerNow(text, true);
+				steerNow(normalizeSkillInvocation(text) ?? text, true);
 				return;
 			}
 			dispatchViaSession(text);
 		};
 		extensionService = ctx.get(PI_TUI_EXTENSIONS_SERVICE);
 		if (extensionService !== void 0) extensionHost = new SurfaceHost(extensionService._ledger(), () => app.requestRender());
+		const imageLoader = new ImageLoader((ref) => {
+			const attachments = ctx.get("attachments");
+			if (attachments === void 0) throw new ImageLoadError("Image attachments are unavailable in this deployment.");
+			return attachments.readImage(ref);
+		});
+		/** The clipboard bridge (plan M3): a bounded execFile runner with a
+		* generous buffer (clipboard payloads can be multi-MB). */
+		const runClipboardCommand = (command, args, options) => new Promise((resolve) => {
+			execFile(command, args, {
+				timeout: options?.timeoutMs ?? 2e3,
+				maxBuffer: 67108864
+			}, (error, stdout, stderr) => {
+				const code = error === null ? 0 : typeof error.code === "number" ? error.code : 1;
+				resolve({
+					stdout: Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout),
+					stderr: Buffer.isBuffer(stderr) ? stderr : Buffer.from(stderr ?? ""),
+					code
+				});
+			});
+		});
+		const clipboardEnv = {
+			platform: process.platform,
+			env: process.env,
+			exists: (command) => commandOnPath(command, process.env.PATH, process.platform)
+		};
 		app = startProcessTui({
 			onSubmit: (text) => dispatchUserInput(text),
-			onQueueSubmit: (text) => dispatchUserInput(text, true),
+			isImageDraft: () => draftHasImages(app.getDraft(), draftImages),
+			shouldRememberInput: (text) => !draftHasImages(text, draftImages),
+			onClipboardPaste: () => {
+				const pasteGeneration = sessionGeneration;
+				runOwned("clipboard paste", () => readClipboardImage(runClipboardCommand, clipboardEnv).then((result) => {
+					if (sessionGeneration !== pasteGeneration) return;
+					if (result.kind === "image") {
+						pruneUnreferencedDrafts(app.getDraft(), draftImages);
+						const limits = ctx.get("attachments")?.imageLimits;
+						if (limits !== void 0) checkImageLimits({
+							mediaType: result.mediaType,
+							width: result.width,
+							height: result.height
+						}, result.bytes.byteLength, limits);
+						const draft = draftImages.add({
+							bytes: result.bytes,
+							mediaType: result.mediaType,
+							width: result.width,
+							height: result.height,
+							source: { type: "clipboard" }
+						});
+						app.insertIntoEditor(`${draft.placeholder} `);
+						app.notify(`attached ${draft.placeholder} — Enter to send`);
+					} else if (result.kind === "text" && result.text !== "") app.insertIntoEditor(result.text);
+				}), {
+					diag,
+					sessionId: () => liveAgent?.session.id,
+					onError: (error) => app.notify(safeErrorMessage(error), "error")
+				});
+			},
+			onQueueSubmit: (input) => dispatchUserInput(input, true),
 			runOwned: (label, task, options) => {
 				runOwned(label, task, {
 					...options,
@@ -31041,14 +33741,43 @@ function apply(ctx, config) {
 				if (liveAgent === void 0) return;
 				const queued = [...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].filter((message) => isUserQueueInput(message.source));
 				if (queued.length === 0) return;
+				let recalledText = "";
+				const staged = [];
+				try {
+					const lines = [];
+					for (const message of queued) {
+						const parts = [];
+						for (const block of message.content) if (block.type === "text") parts.push(block.text);
+						else if (block.type === "image") {
+							const attachment = block.attachment;
+							const draft = draftImages.add({
+								mediaType: attachment.mediaType,
+								width: attachment.width,
+								height: attachment.height,
+								...attachment.name !== void 0 ? { name: attachment.name } : {},
+								source: { type: "recalled" },
+								recalledRef: attachment
+							});
+							staged.push(draft.id);
+							parts.push(draft.placeholder);
+						}
+						lines.push(parts.join(""));
+					}
+					recalledText = lines.join("\n\n");
+				} catch (error) {
+					for (const id of staged) draftImages.remove(id);
+					app.notify(safeErrorMessage(error), "error");
+					return;
+				}
 				for (const message of queued) liveAgent.inbox.remove(message.id);
-				const queuedText = queued.map((message) => textOf(message.content)).join("\n\n");
 				const current = app.getDraft();
-				app.setDraft([queuedText, current].filter((part) => part.trim() !== "").join("\n\n"));
+				app.setDraft([recalledText, current].filter((part) => part.trim() !== "").join("\n\n"));
 				refreshQueue();
 			},
 			onOpenTasks: () => openTasksBrowser()
 		}, {
+			imageLoader,
+			imageTheme: { fallbackColor: color.textDim },
 			present,
 			workspaceRoot: cwd,
 			extensionHost,
@@ -31532,6 +34261,7 @@ function apply(ctx, config) {
 				diag.warn("skills/change subscription unavailable", { error: safeErrorMessage(error) });
 			}
 		};
+		const draftImages = new DraftImageStore();
 		const runner = {
 			ctx,
 			app,
@@ -31549,6 +34279,10 @@ function apply(ctx, config) {
 			agents,
 			sessions: { flush: (session) => sessions.flush(session) },
 			cwd,
+			imageStore: draftImages,
+			imageLimits: () => ctx.get("attachments")?.imageLimits,
+			insertIntoEditor: (text) => app.insertIntoEditor(text),
+			prepareDraftMessage: (text) => prepareUserMessage(text, draftImages, submitDeps),
 			get extensions() {
 				return extensionService === void 0 ? void 0 : {
 					commands: extensionService.commands,
@@ -31843,4 +34577,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { dshVersion as A, resumeCommand as C, subagentJobTranscriptId as D, shouldSteerOnEnter as E, PI_TUI_EXTENSIONS_SERVICE as F, API_VERSION as I, describeKey as L, apply$1 as M, inject$1 as N, subagentJobViewHint as O, name$1 as P, resolveInitialCatalog as S, shouldConsumeAdvertisedMiss as T, matchPendingSubagentCall as _, SessionLockRefusedError as a, recordedPreset as b, compactingFromLog as c, foldCompactionEvent as d, foldQueueRows as f, isUserQueueInput as g, isSubagentSettlementNotice as h, SESSIONLESS_COMMANDS as i, forkSeed as j, subagentNoticeIsFailure as k, composeAgent as l, isPlainExitPrompt as m, HOST_COMMAND_CATALOG as n, apply as o, inject as p, LOCAL_COMMANDS as r, busyAfterTurnBoundary as s, Config as t, dangerCommand as u, name as v, runningProfile as w, registerCredentialSurfaceRefresh as x, recomposeBlank as y };
+export { subagentJobViewHint as A, registerCredentialSurfaceRefresh as C, shouldConsumeAdvertisedMiss as D, runningProfile as E, inject$1 as F, name$1 as I, PI_TUI_EXTENSIONS_SERVICE as L, dshVersion as M, forkSeed as N, shouldSteerOnEnter as O, apply$1 as P, API_VERSION as R, recordedPreset as S, resumeCommand as T, isUserQueueInput as _, SessionLockRefusedError as a, normalizeSkillInvocation as b, commandRejectsImages as c, dangerCommand as d, foldCompactionEvent as f, isSubagentSettlementNotice as g, isPlainExitPrompt as h, SESSIONLESS_COMMANDS as i, subagentNoticeIsFailure as j, subagentJobTranscriptId as k, compactingFromLog as l, inject as m, HOST_COMMAND_CATALOG as n, apply as o, foldQueueRows as p, LOCAL_COMMANDS as r, busyAfterTurnBoundary as s, Config as t, composeAgent as u, matchPendingSubagentCall as v, resolveInitialCatalog as w, recomposeBlank as x, name as y, describeKey as z };