@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

package/src/modes/interactive-mode.ts

@@ -96,6 +96,7 @@ import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
 import { CustomEditor } from "./components/custom-editor";
 import { DynamicBorder } from "./components/dynamic-border";
+import { ErrorBannerComponent } from "./components/error-banner";
 import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
@@ -264,6 +265,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	todoContainer: Container;
 	btwContainer: Container;
 	omfgContainer: Container;
+	errorBannerContainer: Container;
 	editor: CustomEditor;
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
@@ -288,6 +290,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
 	pendingImages: ImageContent[] = [];
+	pendingImageLinks: (string | undefined)[] = [];
 	compactionQueuedMessages: CompactionQueuedMessage[] = [];
 	pendingTools = new Map<string, ToolExecutionHandle>();
 	pendingBashComponents: BashExecutionComponent[] = [];
@@ -404,6 +407,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.todoContainer = new Container();
 		this.btwContainer = new Container();
 		this.omfgContainer = new Container();
+		this.errorBannerContainer = new Container();
 		this.editor = new CustomEditor(getEditorTheme());
 		this.editor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
 		this.editor.setAutocompleteMaxVisible(settings.get("autocompleteMaxVisible"));
@@ -565,6 +569,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.todoContainer);
 		this.ui.addChild(this.btwContainer);
 		this.ui.addChild(this.omfgContainer);
+		this.ui.addChild(this.errorBannerContainer);
 		this.ui.addChild(this.statusLine); // Only renders hook statuses (main status in editor border)
 		this.ui.addChild(this.hookWidgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
@@ -896,12 +901,14 @@ export class InteractiveMode implements InteractiveModeContext {
 	startPendingSubmission(input: {
 		text: string;
 		images?: ImageContent[];
+		imageLinks?: (string | undefined)[];
 		customType?: string;
 		display?: boolean;
 	}): SubmittedUserInput {
 		const submission: SubmittedUserInput = {
 			text: input.text,
 			images: input.images,
+			imageLinks: input.imageLinks,
 			customType: input.customType,
 			display: input.display,
 			cancelled: false,
@@ -913,22 +920,28 @@ export class InteractiveMode implements InteractiveModeContext {
 			const imageCount = submission.images?.length ?? 0;
 			this.optimisticUserMessageSignature = `${submission.text}\u0000${imageCount}`;
 			this.#pendingSubmissionDispose = this.recordLocalSubmission(submission.text, imageCount);
-			this.addMessageToChat({
-				role: "user",
-				content: [{ type: "text", text: submission.text }, ...(submission.images ?? [])],
-				attribution: "user",
-				timestamp: Date.now(),
-			});
+			this.addMessageToChat(
+				{
+					role: "user",
+					content: [{ type: "text", text: submission.text }, ...(submission.images ?? [])],
+					attribution: "user",
+					timestamp: Date.now(),
+				},
+				{ imageLinks: input.imageLinks },
+			);
 		} else {
 			this.optimisticUserMessageSignature = undefined;
 			this.#pendingSubmissionDispose = undefined;
 		}
 		this.editor.setText("");
-		// Reconciliation checkpoint: the rebuild below replays the whole transcript
-		// into native scrollback, so retire frozen block snapshots and let every
-		// block render its current state.
-		this.chatContainer.thaw();
-		this.ui.refreshNativeScrollbackIfDirty({ allowUnknownViewport: true });
+		this.editor.imageLinks = undefined;
+		// Reconciliation checkpoint: only retire frozen block snapshots after TUI
+		// proves the native viewport is at the tail and replays scrollback safely.
+		// Unknown host viewports stay frozen; thawing them would expose live rows
+		// over stale native history and can yank or duplicate when ED3 is unsafe.
+		if (this.ui.refreshNativeScrollbackIfDirty()) {
+			this.chatContainer.thaw();
+		}
 		this.ensureLoadingAnimation();
 		this.ui.requestRender();
 		return submission;
@@ -956,6 +969,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		if (!submission.customType) {
 			this.pendingImages = submission.images ? [...submission.images] : [];
+			this.pendingImageLinks = submission.imageLinks ? [...submission.imageLinks] : [];
+			this.editor.imageLinks = this.pendingImageLinks;
 			this.rebuildChatFromMessages();
 			this.editor.setText(submission.text);
 		}
@@ -2492,6 +2507,19 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#uiHelpers.showError(message);
 	}
 
+	showPinnedError(message: string): void {
+		if (this.isBackgrounded) return;
+		this.errorBannerContainer.clear();
+		this.errorBannerContainer.addChild(new ErrorBannerComponent(message));
+		this.ui.requestRender();
+	}
+
+	clearPinnedError(): void {
+		if (this.errorBannerContainer.children.length === 0) return;
+		this.errorBannerContainer.clear();
+		this.ui.requestRender();
+	}
+
 	showWarning(message: string): void {
 		this.#uiHelpers.showWarning(message);
 	}
@@ -2622,7 +2650,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#uiHelpers.isKnownSlashCommand(text);
 	}
 
-	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): Component[] {
+	addMessageToChat(
+		message: AgentMessage,
+		options?: { populateHistory?: boolean; imageLinks?: readonly (string | undefined)[] },
+	): Component[] {
 		return this.#uiHelpers.addMessageToChat(message, options);
 	}
 
@@ -2633,7 +2664,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#uiHelpers.renderSessionContext(sessionContext, options);
 	}
 
-	renderInitialMessages(prebuiltContext?: SessionContext, options?: { preserveExistingChat?: boolean }): void {
+	renderInitialMessages(
+		prebuiltContext?: SessionContext,
+		options?: { preserveExistingChat?: boolean; clearTerminalHistory?: boolean },
+	): void {
 		this.#uiHelpers.renderInitialMessages(prebuiltContext, options);
 	}
 
@@ -2666,10 +2700,6 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleShareCommand();
 	}
 
-	handleCopyCommand(sub?: string) {
-		return this.#commandController.handleCopyCommand(sub);
-	}
-
 	handleTodoCommand(args: string): Promise<void> {
 		return this.#todoCommandController.handleTodoCommand(args);
 	}
@@ -2706,6 +2736,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#btwController.dispose();
 		this.#omfgController.dispose();
 		this.#extensionUiController.clearExtensionTerminalInputListeners();
+		this.clearPinnedError();
 		this.#planReviewContainer = undefined;
 	}
 
@@ -2901,6 +2932,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showUserMessageSelector();
 	}
 
+	showCopySelector(): void {
+		this.#selectorController.showCopySelector();
+	}
+
 	showTreeSelector(): void {
 		this.#selectorController.showTreeSelector();
 	}

package/src/modes/theme/theme.ts

@@ -12,6 +12,7 @@ import {
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SymbolTheme } from "@oh-my-pi/pi-tui";
 import { adjustHsv, colorLuma, getCustomThemesDir, isEnoent, logger, relativeLuminance } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { LRUCache } from "lru-cache/raw";
 import * as z from "zod/v4";
 // Embed theme JSON files at build time
 import darkThemeJson from "./dark.json" with { type: "json" };
@@ -2429,17 +2430,54 @@ function getHighlightColors(t: Theme): NativeHighlightColors {
 	return cachedHighlightColors;
 }
 
+/**
+ * Memoized native syntax highlight. Returns the joined ANSI string, or `null`
+ * when the native tokenizer throws so callers can apply their own fallback.
+ *
+ * Keyed on `(lang, code)` and reset whenever the active `theme` instance
+ * changes — the ANSI colors are baked into the highlighted output, so a theme
+ * switch (which always reassigns `theme`) must invalidate every entry.
+ *
+ * Why this exists: animated tool blocks (eval/bash) repaint their box on every
+ * ~16ms border-shimmer frame, and markdown re-lexes on every streamed delta.
+ * Without memoization each frame re-tokenizes an unchanged code body through the
+ * Rust FFI — ~26ms for 100 lines, ~40ms for 150 — overrunning the 16ms frame
+ * budget and starving the spinner/render timers (the "TUI freeze").
+ */
+const HIGHLIGHT_CACHE_MAX = 256;
+const highlightCache = new LRUCache<string, string>({ max: HIGHLIGHT_CACHE_MAX });
+let highlightCacheTheme: Theme | undefined;
+
+function highlightCached(code: string, validLang: string | undefined): string | null {
+	if (highlightCacheTheme !== theme) {
+		highlightCache.clear();
+		highlightCacheTheme = theme;
+	}
+	const key = `${validLang ?? ""}\x00${code}`;
+	const hit = highlightCache.get(key);
+	if (hit !== undefined) {
+		return hit;
+	}
+	let highlighted: string;
+	try {
+		highlighted = nativeHighlightCode(code, validLang, getHighlightColors(theme));
+	} catch {
+		return null;
+	}
+	highlightCache.set(key, highlighted);
+	return highlighted;
+}
+
 /**
  * Highlight code with syntax coloring based on file extension or language.
  * Returns array of highlighted lines.
  */
 export function highlightCode(code: string, lang?: string): string[] {
 	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-	try {
-		return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
-	} catch {
-		return code.split("\n");
-	}
+	const highlighted = highlightCached(code, validLang);
+	// Always return a fresh array: callers (e.g. renderCodeCell) push extra lines
+	// onto the result, which would corrupt the cached string otherwise.
+	return (highlighted ?? code).split("\n");
 }
 
 export function getSymbolTheme(): SymbolTheme {
@@ -2484,11 +2522,9 @@ export function getMarkdownTheme(): MarkdownTheme {
 		resolveMermaidAscii,
 		highlightCode: (code: string, lang?: string): string[] => {
 			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-			try {
-				return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
-			} catch {
-				return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
-			}
+			const highlighted = highlightCached(code, validLang);
+			if (highlighted !== null) return highlighted.split("\n");
+			return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
 		},
 	};
 	cachedMarkdownTheme = markdownTheme;

package/src/modes/types.ts

@@ -40,6 +40,7 @@ export type CompactionQueuedMessage = {
 export type SubmittedUserInput = {
 	text: string;
 	images?: ImageContent[];
+	imageLinks?: (string | undefined)[];
 	customType?: string;
 	display?: boolean;
 	cancelled: boolean;
@@ -75,6 +76,7 @@ export interface InteractiveModeContext {
 	todoContainer: Container;
 	btwContainer: Container;
 	omfgContainer: Container;
+	errorBannerContainer: Container;
 	editor: CustomEditor;
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
@@ -106,6 +108,7 @@ export interface InteractiveModeContext {
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	pendingImages: ImageContent[];
+	pendingImageLinks: (string | undefined)[];
 	compactionQueuedMessages: CompactionQueuedMessage[];
 	pendingTools: Map<string, ToolExecutionHandle>;
 	pendingBashComponents: BashExecutionComponent[];
@@ -157,6 +160,8 @@ export interface InteractiveModeContext {
 	// UI helpers
 	showStatus(message: string, options?: { dim?: boolean }): void;
 	showError(message: string): void;
+	showPinnedError(message: string): void;
+	clearPinnedError(): void;
 	showWarning(message: string): void;
 	showNewVersionNotification(newVersion: string): void;
 	clearEditor(): void;
@@ -171,6 +176,7 @@ export interface InteractiveModeContext {
 	startPendingSubmission(input: {
 		text: string;
 		images?: ImageContent[];
+		imageLinks?: (string | undefined)[];
 		customType?: string;
 		display?: boolean;
 	}): SubmittedUserInput;
@@ -191,7 +197,10 @@ export interface InteractiveModeContext {
 	 */
 	withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: { imageCount?: number }): Promise<T>;
 	isKnownSlashCommand(text: string): boolean;
-	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): Component[];
+	addMessageToChat(
+		message: AgentMessage,
+		options?: { populateHistory?: boolean; imageLinks?: readonly (string | undefined)[] },
+	): Component[];
 	renderSessionContext(
 		sessionContext: SessionContext,
 		options?: { updateFooter?: boolean; populateHistory?: boolean },
@@ -213,7 +222,6 @@ export interface InteractiveModeContext {
 	// Command handling
 	handleExportCommand(text: string): Promise<void>;
 	handleShareCommand(): Promise<void>;
-	handleCopyCommand(sub?: string): void;
 	handleTodoCommand(args: string): Promise<void>;
 	handleSessionCommand(): Promise<void>;
 	handleJobsCommand(): Promise<void>;
@@ -254,6 +262,7 @@ export interface InteractiveModeContext {
 	showModelSelector(options?: { temporaryOnly?: boolean }): void;
 	showPluginSelector(mode?: "install" | "uninstall"): void;
 	showUserMessageSelector(): void;
+	showCopySelector(): void;
 	showTreeSelector(): void;
 	showSessionSelector(): void;
 	handleResumeSession(sessionPath: string): Promise<void>;

package/src/modes/utils/copy-targets.ts

@@ -0,0 +1,254 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ToolCall } from "@oh-my-pi/pi-ai";
+
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+	/** Info string after the opening fence (language id), trimmed. */
+	lang: string;
+	/** Block body with the trailing newline stripped. */
+	code: string;
+}
+
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+	kind: "bash" | "eval";
+	code: string;
+	/** Highlight language: "bash" for bash, "python"/"javascript" for eval. */
+	language: string;
+}
+
+/**
+ * A node in the `/copy` picker tree. Leaves carry `content` (placed on the
+ * clipboard) plus `copyMessage` (the status shown afterwards); groups carry
+ * `children` to drill into.
+ */
+export interface CopyTarget {
+	/** Stable identifier (e.g. "msg:1", "msg:1:code:0", "msg:1:all", "cmd:1"). */
+	id: string;
+	label: string;
+	/** Dim annotation: line/block counts, language, or tool name. */
+	hint?: string;
+	/** Full text rendered in the preview pane. */
+	preview: string;
+	/** Highlight language for code/command previews (undefined = plain/markdown). */
+	language?: string;
+	/** Leaf: text copied to the clipboard. */
+	content?: string;
+	/** Leaf: status message shown after copying. */
+	copyMessage?: string;
+	/** Group: nested targets to drill into. */
+	children?: CopyTarget[];
+}
+
+/** Minimal session surface needed to assemble copy targets (eases testing). */
+export interface CopySource {
+	readonly messages: readonly AgentMessage[];
+	getLastVisibleHandoffText(): string | undefined;
+}
+
+/** Cap on how many recent assistant messages the picker lists. */
+const MAX_MESSAGES = 50;
+
+const CODE_BLOCK_RE = /^```([^\n]*)\n([\s\S]*?)^```/gm;
+
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export function extractCodeBlocks(text: string): CodeBlock[] {
+	const blocks: CodeBlock[] = [];
+	for (const match of text.matchAll(CODE_BLOCK_RE)) {
+		blocks.push({ lang: match[1].trim(), code: match[2].replace(/\n$/, "") });
+	}
+	return blocks;
+}
+
+function extractEvalCode(args: unknown): { code: string; language: string } | undefined {
+	if (!args || typeof args !== "object") return undefined;
+	const cells = (args as { cells?: unknown }).cells;
+	if (!Array.isArray(cells)) return undefined;
+
+	const codeBlocks: string[] = [];
+	let language = "python";
+	let languageResolved = false;
+	for (const cell of cells) {
+		if (!cell || typeof cell !== "object") continue;
+		const code = (cell as { code?: unknown }).code;
+		if (typeof code !== "string" || code.length === 0) continue;
+		codeBlocks.push(code);
+		if (!languageResolved) {
+			language = (cell as { language?: unknown }).language === "js" ? "javascript" : "python";
+			languageResolved = true;
+		}
+	}
+
+	return codeBlocks.length > 0 ? { code: codeBlocks.join("\n\n"), language } : undefined;
+}
+
+function commandFromToolCall(tc: ToolCall): LastCommand | undefined {
+	if (tc.name === "bash" && typeof tc.arguments.command === "string") {
+		return { kind: "bash", code: tc.arguments.command, language: "bash" };
+	}
+	if (tc.name === "eval") {
+		const evalResult = extractEvalCode(tc.arguments);
+		if (evalResult) return { kind: "eval", code: evalResult.code, language: evalResult.language };
+	}
+	return undefined;
+}
+
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role !== "assistant") continue;
+		const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
+		for (let j = toolCalls.length - 1; j >= 0; j--) {
+			const command = commandFromToolCall(toolCalls[j]!);
+			if (command) return command;
+		}
+	}
+	return undefined;
+}
+
+/** Concatenated visible text of an assistant message, or undefined when empty. */
+function assistantText(msg: AgentMessage): string | undefined {
+	if (msg.role !== "assistant") return undefined;
+	let text = "";
+	for (const content of msg.content) {
+		if (content.type === "text") text += content.text;
+	}
+	return text.trim() || undefined;
+}
+
+function pluralLines(text: string): string {
+	const count = text.length === 0 ? 0 : text.split("\n").length;
+	return `${count} line${count === 1 ? "" : "s"}`;
+}
+
+function blockHint(block: CodeBlock): string {
+	const lines = pluralLines(block.code);
+	return block.lang ? `${block.lang} · ${lines}` : lines;
+}
+
+/** First non-empty line, whitespace-collapsed, used as a message label. */
+function firstLine(text: string): string {
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed) return trimmed.replace(/\s+/g, " ");
+	}
+	return text.trim().replace(/\s+/g, " ");
+}
+
+/** Build the target node for one assistant message: a leaf when it has no code
+ * blocks, otherwise a group exposing the full message, each block, and "all". */
+function messageTarget(text: string, rank: number): CopyTarget {
+	const id = `msg:${rank}`;
+	const label = firstLine(text);
+	const blocks = extractCodeBlocks(text);
+	const hint = blocks.length > 0 ? `${pluralLines(text)} · ${blocks.length} code` : pluralLines(text);
+	const messageCopy = rank === 1 ? "Copied last message to clipboard" : "Copied message to clipboard";
+
+	if (blocks.length === 0) {
+		return { id, label, hint, preview: text, content: text, copyMessage: messageCopy };
+	}
+
+	// The message node itself copies the full message; its code blocks are
+	// child copy targets you can expand into.
+	const children: CopyTarget[] = blocks.map((block, j) => ({
+		id: `${id}:code:${j}`,
+		label: `Block ${j + 1}`,
+		hint: blockHint(block),
+		preview: block.code,
+		language: block.lang || undefined,
+		content: block.code,
+		copyMessage: `Copied code block ${j + 1} to clipboard`,
+	}));
+	if (blocks.length > 1) {
+		const combined = blocks.map(b => b.code).join("\n\n");
+		children.push({
+			id: `${id}:all`,
+			label: `All ${blocks.length} blocks`,
+			hint: pluralLines(combined),
+			preview: combined,
+			content: combined,
+			copyMessage: `Copied ${blocks.length} code blocks to clipboard`,
+		});
+	}
+
+	return { id, label, hint, preview: text, content: text, copyMessage: messageCopy, children };
+}
+
+function commandTitle(command: LastCommand): string {
+	return command.kind === "bash" ? "Bash command" : "Eval code";
+}
+
+function commandTarget(command: LastCommand, rank: number): CopyTarget {
+	const title = commandTitle(command);
+	return {
+		id: `cmd:${rank}`,
+		label: firstLine(command.code) || title,
+		hint: `${command.kind} · ${pluralLines(command.code)}`,
+		preview: command.code,
+		language: command.language,
+		content: command.code,
+		copyMessage: `Copied ${command.kind === "bash" ? "bash command" : "eval code"} to clipboard`,
+	};
+}
+
+/**
+ * Assemble the unified `/copy` target tree: recent assistant messages
+ * (most recent first, each drillable into its code blocks), runnable command
+ * targets interleaved after the assistant message that issued them, and a
+ * fresh-handoff fallback when no assistant message exists yet.
+ */
+export function buildCopyTargets(source: CopySource): CopyTarget[] {
+	const targets: CopyTarget[] = [];
+	const pendingCommands: LastCommand[] = [];
+	let messageRank = 0;
+	let commandRank = 0;
+
+	const appendCommands = (commands: readonly LastCommand[]) => {
+		for (const command of commands) {
+			commandRank += 1;
+			targets.push(commandTarget(command, commandRank));
+		}
+	};
+
+	for (let i = source.messages.length - 1; i >= 0 && messageRank < MAX_MESSAGES; i--) {
+		const msg = source.messages[i];
+		if (msg.role !== "assistant") continue;
+
+		const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
+		const commands: LastCommand[] = [];
+		for (let j = toolCalls.length - 1; j >= 0; j--) {
+			const command = commandFromToolCall(toolCalls[j]!);
+			if (command) commands.push(command);
+		}
+
+		const text = assistantText(msg);
+		if (!text) {
+			pendingCommands.push(...commands);
+			continue;
+		}
+
+		messageRank += 1;
+		targets.push(messageTarget(text, messageRank));
+		appendCommands(pendingCommands);
+		appendCommands(commands);
+		pendingCommands.length = 0;
+	}
+
+	if (messageRank === 0) {
+		const handoff = source.getLastVisibleHandoffText();
+		if (handoff) {
+			targets.unshift({
+				id: "handoff",
+				label: "Handoff context",
+				hint: pluralLines(handoff),
+				preview: handoff,
+				content: handoff,
+				copyMessage: "Copied handoff context to clipboard",
+			});
+		}
+		appendCommands(pendingCommands);
+	}
+
+	return targets;
+}

package/src/modes/utils/ui-helpers.ts

@@ -18,6 +18,7 @@ import {
 import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { UserMessageComponent } from "../../modes/components/user-message";
+import { materializeImageReferenceLinksSync } from "../../modes/image-references";
 import { theme } from "../../modes/theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext } from "../../modes/types";
 import {
@@ -40,6 +41,18 @@ type QueuedMessages = {
 	followUp: string[];
 };
 
+function imageLinksForMessage(
+	message: Extract<AgentMessage, { role: "developer" | "user" }>,
+	putBlobSync: InteractiveModeContext["sessionManager"]["putBlobSync"],
+): (string | undefined)[] | undefined {
+	if (typeof message.content === "string") return undefined;
+	const images = message.content.filter(
+		(content): content is ImageContent =>
+			content.type === "image" && typeof content.data === "string" && typeof content.mimeType === "string",
+	);
+	return materializeImageReferenceLinksSync(images, putBlobSync);
+}
+
 export class UiHelpers {
 	constructor(private ctx: InteractiveModeContext) {}
 
@@ -84,7 +97,10 @@ export class UiHelpers {
 		this.ctx.ui.requestRender();
 	}
 
-	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): Component[] {
+	addMessageToChat(
+		message: AgentMessage,
+		options?: { populateHistory?: boolean; imageLinks?: readonly (string | undefined)[] },
+	): Component[] {
 		switch (message.role) {
 			case "bashExecution": {
 				const component = new BashExecutionComponent(message.command, this.ctx.ui, message.excludeFromContext);
@@ -253,7 +269,10 @@ export class UiHelpers {
 				const textContent = this.ctx.getUserMessageText(message);
 				if (textContent) {
 					const isSynthetic = message.role === "developer" ? true : (message.synthetic ?? false);
-					const userComponent = new UserMessageComponent(textContent, isSynthetic);
+					const imageLinks =
+						options?.imageLinks ??
+						imageLinksForMessage(message, this.ctx.sessionManager.putBlobSync.bind(this.ctx.sessionManager));
+					const userComponent = new UserMessageComponent(textContent, isSynthetic, imageLinks);
 					this.ctx.chatContainer.addChild(userComponent);
 					if (options?.populateHistory && message.role === "user" && !isSynthetic) {
 						this.ctx.editor.addToHistory(textContent);
@@ -513,6 +532,8 @@ export class UiHelpers {
 		}
 		this.ctx.editor.setText("");
 		this.ctx.pendingImages = [];
+		this.ctx.pendingImageLinks = [];
+		this.ctx.editor.imageLinks = undefined;
 		this.ctx.ui.requestRender();
 	}
 

package/src/prompts/ci-green-request.md

@@ -14,7 +14,7 @@ Do not stop after a single fix attempt.
 2. If any run fails, inspect failing job output and logs.
 3. Identify root cause and make minimal correct fix.
 4. Run local verification if it reduces chance of another failing push.
-5. Push the branch.
+{{#if headTag}}5. Push the branch and tag `{{headTag}}` atomically: `git push --atomic "{{remote}}" "{{branch}}" "+refs/tags/{{headTag}}"`.{{else}}5. Push the branch.{{/if}}
 6. Watch workflow runs for new HEAD commit again.
 7. Repeat until workflow runs for latest HEAD commit succeed.
 </procedure>
@@ -26,11 +26,13 @@ Do not stop after a single fix attempt.
 
 {{#if headTag}}
 <instruction>
-Once CI is green, ensure the final commit is tagged `{{headTag}}` and push that tag.
+Always push the branch and tag together atomically so the tag never points at an un-pushed or non-green commit:
+`git push --atomic "{{remote}}" "{{branch}}" "+refs/tags/{{headTag}}"`.
+The `--atomic` flag makes the branch and tag update succeed or fail as one ref transaction; `+refs/tags/{{headTag}}` force-moves the tag to the new HEAD. Do not push the branch first and retag later.
 </instruction>
 {{/if}}
 
 <critical>
 The task is complete only when the workflow runs for the latest HEAD commit succeed.
-{{#if headTag}}The final green commit must be tagged `{{headTag}}` and that tag must be pushed.{{/if}}
+{{#if headTag}}The latest HEAD commit must carry tag `{{headTag}}`, pushed atomically with the branch via `git push --atomic`.{{/if}}
 </critical>

package/src/prompts/system/project-prompt.md

@@ -3,6 +3,7 @@ PROJECT
 
 <workstation>
 {{#list environment prefix="- " join="\n"}}{{label}}: {{value}}{{/list}}
+{{#if model}}- Model: {{model}}{{/if}}
 </workstation>
 
 {{#if contextFiles.length}}

package/src/prompts/tools/ast-edit.md

@@ -14,7 +14,7 @@ Performs structural AST-aware rewrites via native ast-grep.
 </instruction>
 
 <output>
-- Replacement summary, per-file replacement counts, and change diffs as `¶src/foo.ts#0a`, `-12:before`, `+12:after` lines in hashline mode
+- Replacement summary, per-file replacement counts, and change diffs as `[src/foo.ts#1A2B]`, `-12:before`, `+12:after` lines in hashline mode
 - Parse issues when files cannot be processed
 </output>