@oh-my-pi/pi-coding-agent 16.2.13 → 16.3.0

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

@@ -12,7 +12,7 @@
  */
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import { isZodSchema, zodToWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
-import { $env, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
+import { $env, isRecord, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
 import { reset as resetCapabilities } from "../../capability";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
@@ -41,8 +41,11 @@ import type {
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
 	RpcHostToolDefinition,
+	RpcHostToolResult,
+	RpcHostToolUpdate,
 	RpcHostUriCancelRequest,
 	RpcHostUriRequest,
+	RpcHostUriResult,
 	RpcResponse,
 	RpcSessionState,
 	RpcSubagentSubscriptionLevel,
@@ -91,7 +94,7 @@ export async function tryRunRpcSkillCommand(
 	if (!parsed) return false;
 	const skill = session.skills.find(candidate => candidate.name === parsed.name);
 	if (!skill) return false;
-	const built = await buildSkillPromptMessage(skill, parsed.args);
+	const built = await buildSkillPromptMessage(skill, parsed.args, "user");
 	await session.promptCustomMessage({
 		customType: SKILL_PROMPT_MESSAGE_TYPE,
 		content: built.message,
@@ -213,6 +216,158 @@ export function watchAndReportLocalOnlyPromptResult(input: {
 	});
 }
 
+/**
+ * Dependencies for {@link dispatchRpcInputFrame}. Provided by the RPC mode
+ * entrypoint; broken out so tests can drive the input loop with stubs.
+ */
+export interface RpcInputFrameDeps {
+	handleCommand: (command: RpcCommand) => Promise<RpcResponse>;
+	output: RpcOutput;
+	errorResponse: (id: string | undefined, command: string, message: string) => RpcResponse;
+	trackBackgroundTask?: (task: Promise<void>) => void;
+	pendingExtensionRequests: Map<string, PendingExtensionRequest>;
+	onHostToolResult: (frame: RpcHostToolResult) => void;
+	onHostToolUpdate: (frame: RpcHostToolUpdate) => void;
+	onHostUriResult: (frame: RpcHostUriResult) => void;
+}
+
+/**
+ * Structural guard for a well-formed extension UI response frame. Mirrors the
+ * shape declared in {@link RpcExtensionUIResponse} — a truthy record with
+ * `type === "extension_ui_response"` and a string `id`. Payload variants (value,
+ * confirmed, cancelled) are validated at the read site.
+ */
+function isRpcExtensionUIResponse(value: unknown): value is RpcExtensionUIResponse {
+	if (!isRecord(value)) return false;
+	return value.type === "extension_ui_response" && typeof value.id === "string";
+}
+
+/**
+ * Dispatch a single parsed frame from the RPC input stream.
+ *
+ * Bash commands are dispatched in the background so the caller (the stdin loop
+ * in {@link runRpcMode}) can keep reading subsequent frames while a shell
+ * command is still running. This lets a client send `abort_bash` (or any other
+ * command) while a long-running `bash` is in flight. Response correlation is
+ * preserved via each command's `id`; ordering across concurrent commands is
+ * not guaranteed and clients MUST match on `id`.
+ *
+ * @returns `undefined` when the frame was routed to a side-channel handler
+ *   (extension UI response, host tool/URI frames) or dispatched in the
+ *   background (`bash`). Otherwise a promise that resolves once the response
+ *   for the command has been emitted via `output`. Errors from `handleCommand`
+ *   on non-`bash` commands propagate; the caller is expected to wrap them.
+ */
+export function dispatchRpcInputFrame(parsed: unknown, deps: RpcInputFrameDeps): Promise<void> | undefined {
+	// Side-channel: extension UI responses resolve a pending dialog promise.
+	if (isRpcExtensionUIResponse(parsed)) {
+		const pending = deps.pendingExtensionRequests.get(parsed.id);
+		if (pending) pending.resolve(parsed);
+		return undefined;
+	}
+
+	if (isRpcHostToolResult(parsed)) {
+		deps.onHostToolResult(parsed);
+		return undefined;
+	}
+
+	if (isRpcHostToolUpdate(parsed)) {
+		deps.onHostToolUpdate(parsed);
+		return undefined;
+	}
+
+	if (isRpcHostUriResult(parsed)) {
+		deps.onHostUriResult(parsed);
+		return undefined;
+	}
+
+	// Regular RPC command. The transport contract states each remaining frame
+	// is an {@link RpcCommand}; `handleCommand`'s `default` arm surfaces
+	// unknown discriminants as an error response, so we do not shape-check
+	// the union here.
+	const command = parsed as RpcCommand;
+
+	// `bash` can run for a long time. Dispatch it in the background so a
+	// subsequent `abort_bash` frame can be read and handled without waiting
+	// for the shell command to finish on its own. The response is emitted
+	// when `handleCommand` resolves; clients correlate via `command.id`.
+	if (command.type === "bash") {
+		const task = (async () => {
+			try {
+				deps.output(await deps.handleCommand(command));
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				deps.output(deps.errorResponse(command.id, "bash", message));
+			}
+		})();
+		deps.trackBackgroundTask?.(task);
+		return undefined;
+	}
+
+	return (async () => {
+		deps.output(await deps.handleCommand(command));
+	})();
+}
+
+/**
+ * Coordinates deferred shutdown with in-flight background input tasks.
+ *
+ * `pi.shutdown()` from an extension only *requests* shutdown; the process must
+ * not exit while a background-dispatched command (`bash`, see
+ * {@link dispatchRpcInputFrame}) still owes the client a response frame. The
+ * coordinator tracks those tasks, re-checks the shutdown request whenever one
+ * settles (covering a shutdown requested mid-bash with no follow-up client
+ * frame), and drains every tracked task before invoking `performShutdown`.
+ * The shutdown sequence is latched so concurrent triggers (input loop and
+ * settling tasks) run it exactly once.
+ */
+export class RpcShutdownCoordinator {
+	#tasks = new Set<Promise<void>>();
+	#shutdown: Promise<void> | undefined;
+	readonly #isShutdownRequested: () => boolean;
+	readonly #performShutdown: () => Promise<void>;
+
+	constructor(options: { isShutdownRequested: () => boolean; performShutdown: () => Promise<void> }) {
+		this.#isShutdownRequested = options.isShutdownRequested;
+		this.#performShutdown = options.performShutdown;
+	}
+
+	/**
+	 * Track a background input task. When it settles it is untracked and the
+	 * shutdown request is re-checked, so a deferred shutdown fires even when
+	 * no further client frames arrive.
+	 */
+	track(task: Promise<void>): void {
+		this.#tasks.add(task);
+		void task.finally(() => {
+			this.#tasks.delete(task);
+			// Fire-and-forget: performShutdown ends the process. Rejections are
+			// not expected — hook errors are caught inside extensionRunner.emit,
+			// and background tasks catch their own dispatch errors.
+			void this.checkShutdownRequested();
+		});
+	}
+
+	/** Await every tracked task, including tasks tracked while draining. */
+	async drain(): Promise<void> {
+		while (this.#tasks.size > 0) {
+			await Promise.allSettled(Array.from(this.#tasks));
+		}
+	}
+
+	/**
+	 * If shutdown was requested, drain background tasks (so every owed
+	 * response frame is written) before running the shutdown sequence.
+	 */
+	checkShutdownRequested(): Promise<void> {
+		if (!this.#shutdown) {
+			if (!this.#isShutdownRequested()) return Promise.resolve();
+			this.#shutdown = this.drain().then(() => this.#performShutdown());
+		}
+		return this.#shutdown;
+	}
+}
+
 export type RpcSubagentResetRegistry = Pick<RpcSubagentRegistry, "clear">;
 
 export async function handleRpcSessionChange(
@@ -1096,61 +1251,57 @@ export async function runRpcMode(
 		}
 	};
 
-	/**
-	 * Check if shutdown was requested and perform shutdown if so.
-	 * Called after handling each command when waiting for the next command.
-	 */
-	async function checkShutdownRequested(): Promise<void> {
-		if (!shutdownState.requested) return;
-
-		if (session.extensionRunner?.hasHandlers("session_shutdown")) {
-			await session.extensionRunner.emit({ type: "session_shutdown" });
-		}
+	// Deferred shutdown (pi.shutdown() from an extension) must not kill the
+	// process while a background-dispatched bash still owes the client its
+	// response frame. The coordinator drains tracked tasks before exiting and
+	// re-checks the request as each task settles.
+	const shutdownCoordinator = new RpcShutdownCoordinator({
+		isShutdownRequested: () => shutdownState.requested,
+		performShutdown: async () => {
+			if (session.extensionRunner?.hasHandlers("session_shutdown")) {
+				await session.extensionRunner.emit({ type: "session_shutdown" });
+			}
+			process.exit(0);
+		},
+	});
 
-		process.exit(0);
-	}
+	const dispatchFrameDeps: RpcInputFrameDeps = {
+		handleCommand,
+		output,
+		errorResponse: error,
+		trackBackgroundTask: task => shutdownCoordinator.track(task),
+		pendingExtensionRequests,
+		onHostToolResult: frame => hostToolBridge.handleResult(frame),
+		onHostToolUpdate: frame => hostToolBridge.handleUpdate(frame),
+		onHostUriResult: frame => hostUriBridge.handleResult(frame),
+	};
 
-	// Listen for JSON input using Bun's stdin
+	// Listen for JSON input using Bun's stdin. Frame dispatch lives in
+	// dispatchRpcInputFrame so it can be exercised directly by tests; see the
+	// helper's docstring for the concurrency contract.
 	for await (const parsed of readJsonl(Bun.stdin.stream())) {
 		try {
-			// Handle extension UI responses
-			if ((parsed as RpcExtensionUIResponse).type === "extension_ui_response") {
-				const response = parsed as RpcExtensionUIResponse;
-				const pending = pendingExtensionRequests.get(response.id);
-				if (pending) {
-					pending.resolve(response);
-				}
-				continue;
+			const awaited = dispatchRpcInputFrame(parsed, dispatchFrameDeps);
+			if (awaited) {
+				await awaited;
+				// Check for deferred shutdown request (idle between commands).
+				// Background-dispatched bash frames skip this check so a later
+				// abort_bash can still be read; the coordinator re-checks when
+				// each tracked task settles, so a shutdown requested mid-bash
+				// fires once the response frame is written even if no further
+				// client frames arrive.
+				await shutdownCoordinator.checkShutdownRequested();
 			}
-
-			if (isRpcHostToolResult(parsed)) {
-				hostToolBridge.handleResult(parsed);
-				continue;
-			}
-
-			if (isRpcHostToolUpdate(parsed)) {
-				hostToolBridge.handleUpdate(parsed);
-				continue;
-			}
-
-			if (isRpcHostUriResult(parsed)) {
-				hostUriBridge.handleResult(parsed);
-				continue;
-			}
-
-			// Handle regular commands
-			const command = parsed as RpcCommand;
-			const response = await handleCommand(command);
-			output(response);
-
-			// Check for deferred shutdown request (idle between commands)
-			await checkShutdownRequested();
 		} catch (e: unknown) {
 			const message = e instanceof Error ? e.message : String(e);
 			output(error(undefined, "parse", `Failed to parse command: ${message}`));
 		}
 	}
 
+	// Background bash tasks may still owe response frames; drain them before
+	// tearing down (stdin EOF ends the frame stream, not in-flight work).
+	await shutdownCoordinator.drain();
+
 	// stdin closed — RPC client is gone, exit cleanly
 	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
 	hostUriBridge.clear("RPC client disconnected before host URI request completed");

package/src/modes/session-teardown.test.ts

@@ -0,0 +1,219 @@
+import { describe, expect, it } from "bun:test";
+import { postmortem } from "@oh-my-pi/pi-utils";
+import { createSessionTeardown } from "./session-teardown";
+
+/**
+ * Signal-safe session teardown contract (issue #4080). The callback body
+ * registered on `postmortem` for `SIGINT`/`SIGTERM`/`SIGHUP`/`uncaughtException`
+ * must persist the in-progress editor draft and emit the extension
+ * `session_shutdown` event (via `session.dispose()`) — the same steps the TUI
+ * Ctrl+C keypress path performs. Both paths funnel through
+ * `createSessionTeardown`, so exercising it directly proves the acceptance
+ * criteria hold regardless of the trigger.
+ */
+describe("createSessionTeardown", () => {
+	it("persists the draft, then disposes the session, in that order", async () => {
+		const order: string[] = [];
+		const saved: string[] = [];
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "unsent draft",
+			beginDispose: () => {
+				order.push("beginDispose");
+			},
+			saveDraft: async text => {
+				order.push("saveDraft");
+				saved.push(text);
+			},
+			disposeSession: async () => {
+				order.push("disposeSession");
+			},
+		});
+
+		await teardown();
+
+		expect(order).toEqual(["beginDispose", "saveDraft", "disposeSession"]);
+		expect(saved).toEqual(["unsent draft"]);
+	});
+
+	it("marks the session disposing before awaiting draft persistence", async () => {
+		const order: string[] = [];
+		const release = Promise.withResolvers<void>();
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => {
+				order.push("snapshot");
+				return "draft";
+			},
+			beginDispose: () => {
+				order.push("beginDispose");
+			},
+			saveDraft: async () => {
+				order.push("saveDraft:start");
+				await release.promise;
+				order.push("saveDraft:done");
+			},
+			disposeSession: async () => {
+				order.push("disposeSession");
+			},
+		});
+
+		const running = teardown();
+		expect(order).toEqual(["snapshot", "beginDispose", "saveDraft:start"]);
+		release.resolve();
+		await running;
+
+		expect(order).toEqual(["snapshot", "beginDispose", "saveDraft:start", "saveDraft:done", "disposeSession"]);
+	});
+
+	it("still disposes when saveDraft rejects — never leaves session_shutdown unemitted", async () => {
+		let disposed = false;
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "draft",
+			beginDispose: () => {},
+			saveDraft: async () => {
+				throw new Error("disk full");
+			},
+			disposeSession: async () => {
+				disposed = true;
+			},
+		});
+
+		await teardown();
+
+		expect(disposed).toBe(true);
+	});
+
+	it("passes the empty snapshot through so a stale sidecar is cleared on clean exit", async () => {
+		const seen: string[] = [];
+		const teardown = createSessionTeardown({
+			getDraftText: () => "",
+			beginDispose: () => {},
+			saveDraft: async text => {
+				seen.push(text);
+			},
+			disposeSession: async () => {},
+		});
+
+		await teardown();
+
+		expect(seen).toEqual([""]);
+	});
+
+	it("memoizes: concurrent and repeat calls run the teardown exactly once", async () => {
+		let getDraftCalls = 0;
+		let saveDraftCalls = 0;
+		let disposeCalls = 0;
+		const release = Promise.withResolvers<void>();
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => {
+				getDraftCalls++;
+				return `draft-${getDraftCalls}`;
+			},
+			beginDispose: () => {},
+			saveDraft: async () => {
+				saveDraftCalls++;
+			},
+			disposeSession: async () => {
+				disposeCalls++;
+				await release.promise;
+			},
+		});
+
+		// Kick off two concurrent invocations while the first is still awaiting
+		// disposeSession — this is exactly what happens if a SIGTERM arrives
+		// mid-`InteractiveMode.shutdown()`.
+		const first = teardown();
+		const second = teardown();
+		release.resolve();
+		await Promise.all([first, second]);
+
+		// A third call after settlement must still be a no-op.
+		await teardown();
+
+		expect(getDraftCalls).toBe(1);
+		expect(saveDraftCalls).toBe(1);
+		expect(disposeCalls).toBe(1);
+	});
+
+	it("snapshots the draft text at first call — later editor mutations do not leak in", async () => {
+		let editorText = "before";
+		let captured: string | undefined;
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => editorText,
+			beginDispose: () => {},
+			saveDraft: async text => {
+				captured = text;
+			},
+			disposeSession: async () => {},
+		});
+
+		const running = teardown();
+		editorText = "after"; // A late edit must not overwrite the persisted draft.
+		await running;
+
+		expect(captured).toBe("before");
+	});
+
+	it("forwards the postmortem reason into disposeSession so signal exits record the real trigger", async () => {
+		const received: Array<postmortem.Reason | undefined> = [];
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "",
+			beginDispose: () => {},
+			saveDraft: async () => {},
+			disposeSession: async reason => {
+				received.push(reason);
+			},
+		});
+
+		await teardown(postmortem.Reason.SIGTERM);
+
+		expect(received).toEqual([postmortem.Reason.SIGTERM]);
+	});
+
+	it("keypress path passes no reason — dispose falls back to a normal exit record", async () => {
+		const received: Array<postmortem.Reason | undefined> = [];
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "",
+			beginDispose: () => {},
+			saveDraft: async () => {},
+			disposeSession: async reason => {
+				received.push(reason);
+			},
+		});
+
+		await teardown();
+
+		expect(received).toEqual([undefined]);
+	});
+
+	it("first call's reason wins: a later caller with a different reason awaits the same promise", async () => {
+		const received: Array<postmortem.Reason | undefined> = [];
+		const release = Promise.withResolvers<void>();
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "",
+			beginDispose: () => {},
+			saveDraft: async () => {},
+			disposeSession: async reason => {
+				received.push(reason);
+				await release.promise;
+			},
+		});
+
+		// SIGTERM lands first; postmortem.quit(0)'s MANUAL pass arrives while the
+		// teardown is still draining — it must not restart the run or mutate the
+		// recorded reason.
+		const first = teardown(postmortem.Reason.SIGTERM);
+		const second = teardown(postmortem.Reason.MANUAL);
+		release.resolve();
+		await Promise.all([first, second]);
+
+		expect(received).toEqual([postmortem.Reason.SIGTERM]);
+	});
+});

package/src/modes/session-teardown.ts

@@ -0,0 +1,82 @@
+/**
+ * Signal-safe session teardown: persists the in-progress editor draft, then
+ * disposes the session (which emits `session_shutdown`, cancels the session's
+ * background async jobs, and closes the session manager). Shared by the TUI
+ * Ctrl+C/Ctrl+D/`/exit` keypress path in `InteractiveMode.shutdown()` and by
+ * the postmortem `SIGINT`/`SIGTERM`/`SIGHUP`/`uncaughtException` handlers so a
+ * real kernel signal executes the exact same teardown as a keypress exit.
+ *
+ * Extracted (rather than inlined into `InteractiveMode`) so the callback body
+ * is directly unit-testable without instantiating the full TUI stack.
+ */
+import { logger, type postmortem } from "@oh-my-pi/pi-utils";
+
+/** Dependencies the teardown captures at construction time. */
+export interface SessionTeardownDeps {
+	/** Snapshot the current editor text; called once, before disposal touches session state. */
+	getDraftText: () => string;
+	/**
+	 * Synchronously mark the session as disposing before any awaited teardown
+	 * work. This closes the async gap where deferred jobs could otherwise start
+	 * after a signal requested shutdown but before `disposeSession()` begins.
+	 */
+	beginDispose: () => void;
+	/**
+	 * Persist the snapshotted draft. Called even for an empty string so a
+	 * previously-persisted draft sidecar is cleared on a clean exit.
+	 */
+	saveDraft: (text: string) => Promise<void>;
+	/**
+	 * Dispose the session — emits `session_shutdown`, drains async jobs, closes
+	 * the manager. Receives the postmortem reason that triggered the teardown
+	 * (undefined on the keypress/`/exit` path) so `AgentSession.dispose()` can
+	 * persist the real exit reason instead of the generic `"dispose"`.
+	 */
+	disposeSession: (reason?: postmortem.Reason) => Promise<void>;
+}
+
+/**
+ * Idempotent teardown: concurrent/repeat invocations share one settled
+ * promise. The optional `reason` is the postmortem reason that triggered the
+ * teardown (`sigterm`, `sighup`, `uncaught_exception`, …); only the FIRST
+ * call's reason is used — later callers await the same settled promise.
+ */
+export type SessionTeardown = (reason?: postmortem.Reason) => Promise<void>;
+
+/**
+ * Build a promise-memoized teardown function. The first call snapshots the
+ * draft text, marks the session disposing synchronously, runs `saveDraft`
+ * (draft-loss protection for `--resume`), then `disposeSession`; subsequent
+ * calls await the same settled promise, so the keypress
+ * `InteractiveMode.shutdown()` path and the postmortem signal callback cannot
+ * double-emit `session_shutdown`, double-dispose the session's async-job
+ * manager, or race each other.
+ *
+ * The postmortem callback forwards its `Reason` so the persisted
+ * `session_exit` diagnostic carries the real trigger (`sigterm`, `sighup`,
+ * `uncaught_exception`, …) instead of the generic `"dispose"` that plain
+ * programmatic disposal records. First call wins: a signal arriving after a
+ * keypress-initiated teardown awaits the in-flight promise and its reason is
+ * dropped — by then the exit entry is already being written as a normal exit.
+ *
+ * `saveDraft` failures are logged but never abort the disposal chain — a
+ * draft-write error must not leak background bash/task jobs or skip the
+ * extension `session_shutdown` event.
+ */
+export function createSessionTeardown(deps: SessionTeardownDeps): SessionTeardown {
+	let pending: Promise<void> | undefined;
+	const run = async (reason?: postmortem.Reason): Promise<void> => {
+		const draftText = deps.getDraftText();
+		deps.beginDispose();
+		try {
+			await deps.saveDraft(draftText);
+		} catch (err) {
+			logger.warn("Failed to save session draft during teardown", { error: String(err) });
+		}
+		await deps.disposeSession(reason);
+	};
+	return (reason?: postmortem.Reason) => {
+		if (!pending) pending = run(reason);
+		return pending;
+	};
+}

package/src/modes/setup-wizard/scenes/theme.ts

@@ -256,7 +256,7 @@ class ThemeSceneController implements SetupSceneController {
 		} else {
 			this.host.ctx.settings.set("theme.dark", themeName);
 		}
-		await previewTheme(themeName);
+		await previewTheme(themeName, { ephemeral: false });
 	}
 
 	async #preview(value: string): Promise<void> {
@@ -270,7 +270,7 @@ class ThemeSceneController implements SetupSceneController {
 		let result: { success: boolean; error?: string } = { success: true };
 		if (value === "auto") {
 			await this.#applyPreviewPresentation(this.#originalSymbolPreset, this.#originalColorBlindMode);
-			enableAutoTheme();
+			enableAutoTheme({ ephemeral: true });
 		} else if (value === "colorblind") {
 			await this.#applyPreviewPresentation(this.#originalSymbolPreset, true);
 		} else if (value === "ansi") {

package/src/modes/skill-command.ts

@@ -1,5 +1,5 @@
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
-import { getSkillSlashCommandName, parseSkillInvocation } from "../extensibility/skills";
+import { buildSkillPromptMessage, getSkillSlashCommandName, parseSkillInvocation } from "../extensibility/skills";
 import { type CustomMessage, SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../session/messages";
 import type { InteractiveModeContext } from "./types";
 
@@ -49,32 +49,19 @@ export async function buildSkillCommandPrompt(
 ): Promise<BuiltSkillCommandPrompt | undefined> {
 	const parsed = parseSkillInvocation(text);
 	if (!parsed) return undefined;
-	const commandName = getSkillSlashCommandName({ name: parsed.name });
-	const skillPath = ctx.skillCommands.get(commandName);
-	if (!skillPath) return undefined;
+	const skill = ctx.skillCommands.get(getSkillSlashCommandName({ name: parsed.name }));
+	if (!skill) return undefined;
 
-	const content = await Bun.file(skillPath).text();
-	const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
-	const metaLines = [`Skill: ${skillPath}`];
-	if (parsed.args) {
-		metaLines.push(`User: ${parsed.args}`);
-	}
-	const message = `${body}\n\n---\n\n${metaLines.join("\n")}`;
-	const textBlock: TextContent = { type: "text", text: message };
-	const promptContent = images && images.length > 0 ? [textBlock, ...images] : message;
-	const details: SkillPromptDetails = {
-		name: parsed.name,
-		path: skillPath,
-		args: parsed.args || undefined,
-		lineCount: body ? body.split("\n").length : 0,
-	};
+	const built = await buildSkillPromptMessage(skill, parsed.args, "user");
+	const textBlock: TextContent = { type: "text", text: built.message };
+	const promptContent = images && images.length > 0 ? [textBlock, ...images] : built.message;
 
 	return {
 		message: {
 			customType: SKILL_PROMPT_MESSAGE_TYPE,
 			content: promptContent,
 			display: true,
-			details,
+			details: built.details,
 			attribution: "user",
 		},
 		options: { streamingBehavior, queueChipText: text },