@oh-my-pi/pi-coding-agent 8.2.2 → 8.4.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [8.4.0] - 2026-01-25
+
+### Added
+- Added extension API to set working/loading messages during streaming
+- Added task worker propagation of context files, skills, and prompt templates
+- Added subagent option to skip Python preflight checks when Python tooling is unused
+- Model field now accepts string arrays for fallback model prioritization
+
+### Changed
+- Merged patch application warnings into edit tool diagnostics output
+- Cached Python prelude docs for subagent workers to avoid repeated warmups
+- Simplified image placeholders inserted on paste to match Claude-style markers
+
+### Fixed
+- Rewrote empty or corrupted session files to restore valid headers
+- Improved patch applicator ambiguity errors with match previews and overlap detection
+- Fixed Task tool agent model resolution to honor comma-separated model lists
+## [8.3.0] - 2026-01-25
+
+### Changed
+- Added request parameter tracking to LSP tool rendering for better diagnostics visibility
+- Added async diff computation and Kitty protocol support to tool execution rendering
+- Refactored patch applicator with improved fuzzy matching (7-pass sequence matching with Levenshtein distance) and indentation adjustment
+- Added inline rendering flag to bash and fetch tool renderers
+- Extracted constants for preview formatting to improve code maintainability
+- Exposed mergeCallAndResult and inline rendering options from tools to their wrappers
+- Added timeout validation and normalization for tool timeout parameters
+
+### Fixed
+- Fixed output block border rendering (bottom-right corner was missing)
+- Added background control parameter to output block rendering
 ## [8.2.2] - 2026-01-24
 
 ### Removed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.2.2",
+	"version": "8.4.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -75,11 +75,11 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.2.2",
-		"@oh-my-pi/pi-agent-core": "8.2.2",
-		"@oh-my-pi/pi-ai": "8.2.2",
-		"@oh-my-pi/pi-tui": "8.2.2",
-		"@oh-my-pi/pi-utils": "8.2.2",
+		"@oh-my-pi/omp-stats": "8.4.0",
+		"@oh-my-pi/pi-agent-core": "8.4.0",
+		"@oh-my-pi/pi-ai": "8.4.0",
+		"@oh-my-pi/pi-tui": "8.4.0",
+		"@oh-my-pi/pi-utils": "8.4.0",
 		"@openai/agents": "^0.4.3",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/config/model-registry.ts

@@ -19,12 +19,18 @@ import type { AuthStorage } from "../session/auth-storage";
 
 const Ajv = (AjvModule as any).default || AjvModule;
 
+const OpenRouterRoutingSchema = Type.Object({
+	only: Type.Optional(Type.Array(Type.String())),
+	order: Type.Optional(Type.Array(Type.String())),
+});
+
 // Schema for OpenAI compatibility settings
 const OpenAICompatSchema = Type.Object({
 	supportsStore: Type.Optional(Type.Boolean()),
 	supportsDeveloperRole: Type.Optional(Type.Boolean()),
 	supportsReasoningEffort: Type.Optional(Type.Boolean()),
 	maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+	openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
 });
 
 // Schema for custom model definition
@@ -36,6 +42,7 @@ const ModelDefinitionSchema = Type.Object({
 			Type.Literal("openai-completions"),
 			Type.Literal("openai-responses"),
 			Type.Literal("openai-codex-responses"),
+			Type.Literal("azure-openai-responses"),
 			Type.Literal("anthropic-messages"),
 			Type.Literal("google-generative-ai"),
 			Type.Literal("google-vertex"),
@@ -63,6 +70,7 @@ const ProviderConfigSchema = Type.Object({
 			Type.Literal("openai-completions"),
 			Type.Literal("openai-responses"),
 			Type.Literal("openai-codex-responses"),
+			Type.Literal("azure-openai-responses"),
 			Type.Literal("anthropic-messages"),
 			Type.Literal("google-generative-ai"),
 			Type.Literal("google-vertex"),

package/src/discovery/helpers.ts

@@ -156,13 +156,23 @@ export function parseArrayOrCSV(value: unknown): string[] | undefined {
 	return undefined;
 }
 
+/**
+ * Parse model field into a prioritized list.
+ */
+export function parseModelList(value: unknown): string[] | undefined {
+	const parsed = parseArrayOrCSV(value);
+	if (!parsed) return undefined;
+	const normalized = parsed.map(entry => entry.trim()).filter(Boolean);
+	return normalized.length > 0 ? normalized : undefined;
+}
+
 /** Parsed agent fields from frontmatter (excludes source/filePath/systemPrompt) */
 export interface ParsedAgentFields {
 	name: string;
 	description: string;
 	tools?: string[];
 	spawns?: string[] | "*";
-	model?: string;
+	model?: string[];
 	output?: unknown;
 	thinkingLevel?: ThinkingLevel;
 }
@@ -202,7 +212,7 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	}
 
 	const output = frontmatter.output !== undefined ? frontmatter.output : undefined;
-	const model = typeof frontmatter.model === "string" ? frontmatter.model : undefined;
+	const model = parseModelList(frontmatter.model);
 	const thinkingLevel = parseThinkingLevel(frontmatter);
 
 	return { name, description, tools, spawns, model, output, thinkingLevel };

package/src/extensibility/extensions/runner.ts

@@ -85,6 +85,7 @@ const noOpUIContext: ExtensionUIContext = {
 	input: async (_title, _placeholder, _dialogOptions) => undefined,
 	notify: () => {},
 	setStatus: () => {},
+	setWorkingMessage: () => {},
 	setWidget: () => {},
 	setFooter: () => {},
 	setHeader: () => {},

package/src/extensibility/extensions/types.ts

@@ -69,6 +69,9 @@ export interface ExtensionUIContext {
 	/** Set status text in the footer/status bar. Pass undefined to clear. */
 	setStatus(key: string, text: string | undefined): void;
 
+	/** Set the working/loading message shown during streaming. Call with no argument to restore default. */
+	setWorkingMessage(message?: string): void;
+
 	/** Set a widget to display above the editor. Accepts string array or component factory. */
 	setWidget(key: string, content: string[] | undefined): void;
 	setWidget(key: string, content: ((tui: TUI, theme: Theme) => Component & { dispose?(): void }) | undefined): void;

package/src/extensibility/extensions/wrapper.ts

@@ -79,6 +79,8 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 	parameters: TParameters;
 	renderCall?: AgentTool<TParameters, TDetails>["renderCall"];
 	renderResult?: AgentTool<TParameters, TDetails>["renderResult"];
+	mergeCallAndResult?: boolean;
+	inline?: boolean;
 
 	constructor(
 		private tool: AgentTool<TParameters, TDetails>,
@@ -90,6 +92,8 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		this.parameters = tool.parameters;
 		this.renderCall = tool.renderCall;
 		this.renderResult = tool.renderResult;
+		this.mergeCallAndResult = (tool as { mergeCallAndResult?: boolean }).mergeCallAndResult;
+		this.inline = (tool as { inline?: boolean }).inline;
 	}
 
 	async execute(

package/src/extensibility/hooks/tool-wrapper.ts

@@ -23,6 +23,8 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 	parameters: TParameters;
 	renderCall?: AgentTool<TParameters, TDetails>["renderCall"];
 	renderResult?: AgentTool<TParameters, TDetails>["renderResult"];
+	mergeCallAndResult?: boolean;
+	inline?: boolean;
 
 	constructor(
 		private tool: AgentTool<TParameters, TDetails>,
@@ -34,6 +36,8 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 		this.parameters = tool.parameters;
 		this.renderCall = tool.renderCall;
 		this.renderResult = tool.renderResult;
+		this.mergeCallAndResult = (tool as { mergeCallAndResult?: boolean }).mergeCallAndResult;
+		this.inline = (tool as { inline?: boolean }).inline;
 	}
 
 	async execute(

package/src/ipy/executor.ts

@@ -187,6 +187,10 @@ export function getPreludeDocs(): PreludeHelper[] {
 	return cachedPreludeDocs ?? [];
 }
 
+export function setPreludeDocsCache(docs: PreludeHelper[]): void {
+	cachedPreludeDocs = docs;
+}
+
 export function resetPreludeDocsCache(): void {
 	cachedPreludeDocs = null;
 }

package/src/lsp/index.ts

@@ -955,6 +955,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	public readonly parameters = lspSchema;
 	public readonly renderCall = renderCall;
 	public readonly renderResult = renderResult;
+	public readonly mergeCallAndResult = true;
+	public readonly inline = true;
 
 	private readonly session: ToolSession;
 
@@ -1011,7 +1013,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;
 			return {
 				content: [{ type: "text", text: output }],
-				details: { action, success: true },
+				details: { action, success: true, request: params },
 			};
 		}
 
@@ -1025,7 +1027,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 						text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
 					},
 				],
-				details: { action, success: true },
+				details: { action, success: true, request: params },
 			};
 		}
 
@@ -1636,13 +1638,13 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			return {
 				content: [{ type: "text", text: output }],
-				details: { serverName, action, success: true },
+				details: { serverName, action, success: true, request: params },
 			};
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			return {
 				content: [{ type: "text", text: `LSP error: ${errorMessage}` }],
-				details: { serverName, action, success: false },
+				details: { serverName, action, success: false, request: params },
 			};
 		}
 	}

package/src/lsp/render.ts

@@ -7,11 +7,18 @@
  * - Grouped references and symbols
  * - Collapsible/expandable views
  */
-import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
+import type { RenderResultOptions } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
-import { formatExpandHint, formatMoreItems, TRUNCATE_LENGTHS, truncate } from "../tools/render-utils";
+import {
+	formatExpandHint,
+	formatMoreItems,
+	formatStatusIcon,
+	shortenPath,
+	TRUNCATE_LENGTHS,
+	truncate,
+} from "../tools/render-utils";
 import { renderOutputBlock, renderStatusLine } from "../tui";
 import type { LspParams, LspToolDetails } from "./types";
 
@@ -23,15 +30,74 @@ import type { LspParams, LspToolDetails } from "./types";
  * Render the LSP tool call in the TUI.
  * Shows: "lsp <operation> <file/filecount>"
  */
-export function renderCall(args: unknown, theme: Theme): Text {
-	const p = args as LspParams & { file?: string; files?: string[] };
+export function renderCall(args: LspParams, theme: Theme): Text {
+	const actionLabel = (args.action ?? "request").replace(/_/g, " ");
+	const queryPreview = args.query ? truncate(args.query, TRUNCATE_LENGTHS.SHORT, theme.format.ellipsis) : undefined;
+	const replacementPreview = args.replacement
+		? truncate(args.replacement, TRUNCATE_LENGTHS.SHORT, theme.format.ellipsis)
+		: undefined;
+
+	let target: string | undefined;
+	let hasFileTarget = false;
+
+	if (args.file) {
+		target = shortenPath(args.file);
+		hasFileTarget = true;
+	} else if (args.files?.length === 1) {
+		target = shortenPath(args.files[0]);
+		hasFileTarget = true;
+	} else if (args.files?.length) {
+		target = `${args.files.length} files`;
+	}
+
+	if (hasFileTarget && args.line !== undefined) {
+		const col = args.column !== undefined ? `:${args.column}` : "";
+		target += `:${args.line}${col}`;
+		if (args.end_line !== undefined) {
+			const endCol = args.end_character !== undefined ? `:${args.end_character}` : "";
+			target += `-${args.end_line}${endCol}`;
+		}
+	} else if (!target && args.line !== undefined) {
+		const col = args.column !== undefined ? `:${args.column}` : "";
+		target = `line ${args.line}${col}`;
+		if (args.end_line !== undefined) {
+			const endCol = args.end_character !== undefined ? `:${args.end_character}` : "";
+			target += `-${args.end_line}${endCol}`;
+		}
+	}
+
 	const meta: string[] = [];
-	if (p.file) {
-		meta.push(p.file);
-	} else if (p.files?.length) {
-		meta.push(`${p.files.length} file(s)`);
+	if (queryPreview && target) meta.push(`query:${queryPreview}`);
+	if (args.new_name) meta.push(`new:${args.new_name}`);
+	if (replacementPreview) meta.push(`replace:${replacementPreview}`);
+	if (args.kind) meta.push(`kind:${args.kind}`);
+	if (args.apply !== undefined) meta.push(`apply:${args.apply ? "true" : "false"}`);
+	if (args.action_index !== undefined) meta.push(`action:${args.action_index}`);
+	if (args.include_declaration !== undefined) {
+		meta.push(`include_decl:${args.include_declaration ? "true" : "false"}`);
+	}
+	if (args.end_line !== undefined && args.line === undefined) {
+		const endCol = args.end_character !== undefined ? `:${args.end_character}` : "";
+		meta.push(`end:${args.end_line}${endCol}`);
+	}
+
+	const descriptionParts = [actionLabel];
+	if (target) {
+		descriptionParts.push(target);
+	} else if (queryPreview) {
+		descriptionParts.push(queryPreview);
 	}
-	const text = renderStatusLine({ icon: "pending", title: "LSP", description: p.action || "?", meta }, theme);
+
+	const text = renderStatusLine(
+		{
+			icon: "pending",
+			title: "LSP",
+			description: descriptionParts.join(" "),
+			meta,
+		},
+		theme,
+	);
+
 	return new Text(text, 0, 0);
 }
 
@@ -44,14 +110,15 @@ export function renderCall(args: unknown, theme: Theme): Text {
  * Detects hover, diagnostics, references, symbols, etc. and formats accordingly.
  */
 export function renderResult(
-	result: AgentToolResult<LspToolDetails>,
+	result: { content: Array<{ type: string; text?: string }>; details?: LspToolDetails; isError?: boolean },
 	options: RenderResultOptions,
 	theme: Theme,
 	args?: LspParams & { file?: string; files?: string[] },
 ): Component {
 	const content = result.content?.[0];
 	if (!content || content.type !== "text" || !("text" in content) || !content.text) {
-		const header = renderStatusLine({ icon: "warning", title: "LSP", description: "No result" }, theme);
+		const icon = formatStatusIcon("warning", theme, options.spinnerFrame);
+		const header = `${icon} LSP`;
 		return new Text([header, theme.fg("dim", "No result")].join("\n"), 0, 0);
 	}
 
@@ -94,22 +161,50 @@ export function renderResult(
 		}
 	}
 
-	const meta: string[] = [];
-	if (args?.action) meta.push(args.action);
-	if (args?.file) {
-		meta.push(args.file);
-	} else if (args?.files?.length) {
-		meta.push(`${args.files.length} file(s)`);
+	const request = args ?? result.details?.request;
+	const requestLines: string[] = [];
+	if (request?.file) {
+		requestLines.push(theme.fg("toolOutput", request.file));
+	} else if (request?.files?.length === 1) {
+		requestLines.push(theme.fg("toolOutput", request.files[0]));
+	} else if (request?.files?.length) {
+		requestLines.push(theme.fg("dim", `${request.files.length} file(s)`));
+	}
+	if (request?.line !== undefined) {
+		const col = request.column !== undefined ? `:${request.column}` : "";
+		requestLines.push(theme.fg("dim", `line ${request.line}${col}`));
 	}
-	const header = renderStatusLine({ icon: state, title: "LSP", description: label, meta }, theme);
+	if (request?.end_line !== undefined) {
+		const endCol = request.end_character !== undefined ? `:${request.end_character}` : "";
+		requestLines.push(theme.fg("dim", `end ${request.end_line}${endCol}`));
+	}
+	if (request?.query) requestLines.push(theme.fg("dim", `query: ${request.query}`));
+	if (request?.new_name) requestLines.push(theme.fg("dim", `new name: ${request.new_name}`));
+	if (request?.replacement) requestLines.push(theme.fg("dim", `replacement: ${request.replacement}`));
+	if (request?.kind) requestLines.push(theme.fg("dim", `kind: ${request.kind}`));
+	if (request?.apply !== undefined) requestLines.push(theme.fg("dim", `apply: ${request.apply ? "true" : "false"}`));
+	if (request?.action_index !== undefined) requestLines.push(theme.fg("dim", `action: ${request.action_index}`));
+	if (request?.include_declaration !== undefined) {
+		requestLines.push(theme.fg("dim", `include declaration: ${request.include_declaration ? "true" : "false"}`));
+	}
+
+	const actionLabel = (request?.action ?? result.details?.action ?? label.toLowerCase()).replace(/_/g, " ");
+	const status = options.isPartial ? "running" : result.isError ? "error" : "success";
+	const icon = formatStatusIcon(status, theme, options.spinnerFrame);
+	const header = `${icon} LSP ${actionLabel}`;
+
 	return {
 		render: (width: number) =>
 			renderOutputBlock(
 				{
 					header,
 					state,
-					sections: [{ label: theme.fg("toolTitle", label), lines: bodyLines }],
+					sections: [
+						...(requestLines.length > 0 ? [{ lines: requestLines }] : []),
+						{ label: theme.fg("toolTitle", "Response"), lines: bodyLines },
+					],
 					width,
+					applyBg: false,
 				},
 				theme,
 			),
@@ -612,4 +707,5 @@ export const lspToolRenderer = {
 	renderCall,
 	renderResult,
 	mergeCallAndResult: true,
+	inline: true,
 };

package/src/lsp/types.ts

@@ -53,6 +53,7 @@ export interface LspToolDetails {
 	serverName?: string;
 	action: string;
 	success: boolean;
+	request?: LspParams;
 }
 
 // =============================================================================

package/src/modes/components/tool-execution.ts

@@ -1,6 +1,7 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import {
 	Box,
+	type Component,
 	Container,
 	getCapabilities,
 	getImageDimensions,
@@ -11,6 +12,7 @@ import {
 	type TUI,
 } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { computeEditDiff, computePatchDiff, type EditDiffError, type EditDiffResult } from "../../patch";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
@@ -376,7 +378,8 @@ export class ToolExecutionComponent extends Container {
 			const tool = this.tool;
 			const mergeCallAndResult = Boolean((tool as { mergeCallAndResult?: boolean }).mergeCallAndResult);
 			// Custom tools use Box for flexible component rendering
-			this.contentBox.setBgFn(bgFn);
+			const inline = Boolean((tool as { inline?: boolean }).inline);
+			this.contentBox.setBgFn(inline ? undefined : bgFn);
 			this.contentBox.clear();
 
 			// Render call component
@@ -404,10 +407,17 @@ export class ToolExecutionComponent extends Container {
 			// Render result component if we have a result
 			if (this.result && tool.renderResult) {
 				try {
-					const resultComponent = tool.renderResult(
-						{ content: this.result.content as any, details: this.result.details },
+					const renderResult = tool.renderResult as (
+						result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
+						options: { expanded: boolean; isPartial: boolean; spinnerFrame?: number },
+						theme: Theme,
+						args?: unknown,
+					) => Component;
+					const resultComponent = renderResult(
+						{ content: this.result.content as any, details: this.result.details, isError: this.result.isError },
 						{ expanded: this.expanded, isPartial: this.isPartial, spinnerFrame: this.spinnerFrame },
 						theme,
+						this.args,
 					);
 					if (resultComponent) {
 						// Ensure component has invalidate() method for Component interface
@@ -542,10 +552,16 @@ export class ToolExecutionComponent extends Container {
 	}
 
 	/**
-	 * Build render context for tools that need extra state (bash, edit)
+	 * Build render context for tools that need extra state (bash, python, edit)
 	 */
 	private buildRenderContext(): Record<string, unknown> {
 		const context: Record<string, unknown> = {};
+		const normalizeTimeoutSeconds = (value: unknown, maxSeconds: number): number | undefined => {
+			if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+			let timeoutSec = value > 1000 ? value / 1000 : value;
+			timeoutSec = Math.max(1, Math.min(maxSeconds, timeoutSec));
+			return timeoutSec;
+		};
 
 		if (this.toolName === "bash" && this.result) {
 			// Pass raw output and expanded state - renderer handles width-aware truncation
@@ -553,13 +569,13 @@ export class ToolExecutionComponent extends Container {
 			context.output = output;
 			context.expanded = this.expanded;
 			context.previewLines = BASH_DEFAULT_PREVIEW_LINES;
-			context.timeout = typeof this.args?.timeout === "number" ? this.args.timeout : undefined;
+			context.timeout = normalizeTimeoutSeconds(this.args?.timeout, 3600);
 		} else if (this.toolName === "python" && this.result) {
 			const output = this.getTextOutput().trimEnd();
 			context.output = output;
 			context.expanded = this.expanded;
 			context.previewLines = PYTHON_DEFAULT_PREVIEW_LINES;
-			context.timeout = typeof this.args?.timeout === "number" ? this.args.timeout : undefined;
+			context.timeout = normalizeTimeoutSeconds(this.args?.timeout, 600);
 		} else if (this.toolName === "edit") {
 			// Edit needs diff preview and renderDiff function
 			context.editDiffPreview = this.editDiffPreview;

package/src/modes/controllers/event-controller.ts

@@ -68,6 +68,7 @@ export class EventController {
 					getSymbolTheme().spinnerFrames,
 				);
 				this.ctx.statusContainer.addChild(this.ctx.loadingAnimation);
+				this.ctx.applyPendingWorkingMessage();
 				this.ctx.ui.requestRender();
 				break;
 

package/src/modes/controllers/extension-ui-controller.ts

@@ -30,6 +30,7 @@ export class ExtensionUiController {
 			input: (title, placeholder, _dialogOptions) => this.showHookInput(title, placeholder),
 			notify: (message, type) => this.showHookNotify(message, type),
 			setStatus: (key, text) => this.setHookStatus(key, text),
+			setWorkingMessage: message => this.ctx.setWorkingMessage(message),
 			setWidget: (key, content) => this.setHookWidget(key, content),
 			setTitle: title => setTerminalTitle(title),
 			custom: (factory, _options) => this.showHookCustom(factory),
@@ -389,6 +390,7 @@ export class ExtensionUiController {
 			input: async (_title: string, _placeholder?: string, _dialogOptions?: unknown) => undefined,
 			notify: () => {},
 			setStatus: () => {},
+			setWorkingMessage: () => {},
 			setWidget: () => {},
 			setTitle: () => {},
 			custom: async () => undefined as never,

package/src/modes/controllers/input-controller.ts

@@ -541,9 +541,9 @@ export class InputController {
 					data: imageData.data,
 					mimeType: imageData.mimeType,
 				});
-				// Insert styled placeholder at cursor like Claude does
+				// Insert placeholder at cursor like Claude does
 				const imageNum = this.ctx.pendingImages.length;
-				const placeholder = theme.bold(theme.underline(`[Image #${imageNum}]`));
+				const placeholder = `[Image #${imageNum}]`;
 				this.ctx.editor.insertText(`${placeholder} `);
 				this.ctx.ui.requestRender();
 				return true;

package/src/modes/interactive-mode.ts

@@ -102,6 +102,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	public loadingAnimation: Loader | undefined = undefined;
 	public autoCompactionLoader: Loader | undefined = undefined;
 	public retryLoader: Loader | undefined = undefined;
+	private pendingWorkingMessage: string | undefined;
+	private readonly defaultWorkingMessage = `Working${theme.format.ellipsis} (esc to interrupt)`;
 	public autoCompactionEscapeHandler?: () => void;
 	public retryEscapeHandler?: () => void;
 	public unsubscribe?: () => void;
@@ -160,6 +162,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.statusContainer = new Container();
 		this.todoContainer = new Container();
 		this.editor = new CustomEditor(getEditorTheme());
+		this.editor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
 		this.editor.onAutocompleteCancel = () => {
 			this.ui.requestRender(true);
 		};
@@ -538,6 +541,33 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.uiHelpers.showWarning(message);
 	}
 
+	setWorkingMessage(message?: string): void {
+		if (message === undefined) {
+			this.pendingWorkingMessage = undefined;
+			if (this.loadingAnimation) {
+				this.loadingAnimation.setMessage(this.defaultWorkingMessage);
+			}
+			return;
+		}
+
+		if (this.loadingAnimation) {
+			this.loadingAnimation.setMessage(message);
+			return;
+		}
+
+		this.pendingWorkingMessage = message;
+	}
+
+	applyPendingWorkingMessage(): void {
+		if (this.pendingWorkingMessage === undefined) {
+			return;
+		}
+
+		const message = this.pendingWorkingMessage;
+		this.pendingWorkingMessage = undefined;
+		this.setWorkingMessage(message);
+	}
+
 	showNewVersionNotification(newVersion: string): void {
 		this.uiHelpers.showNewVersionNotification(newVersion);
 	}

package/src/modes/rpc/rpc-mode.ts

@@ -187,6 +187,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			} as RpcExtensionUIRequest);
 		}
 
+		setWorkingMessage(_message?: string): void {
+			// Not supported in RPC mode
+		}
+
 		setWidget(key: string, content: unknown): void {
 			// Only support string arrays in RPC mode - factory functions are ignored
 			if (content === undefined || Array.isArray(content)) {