@oh-my-pi/pi-coding-agent 15.11.0 → 15.11.2

package/src/modes/controllers/streaming-reveal.ts

@@ -163,7 +163,7 @@ export class StreamingRevealController {
 		this.#hideThinkingBlock = this.#getHideThinkingBlock();
 		this.#smoothStreaming = this.#getSmoothStreaming();
 		if (!this.#smoothStreaming) {
-			component.updateContent(message);
+			component.updateContent(message, { transient: true });
 			return;
 		}
 		const total = this.#visibleUnits(message);
@@ -171,10 +171,12 @@ export class StreamingRevealController {
 			// A tool call is a transcript-order boundary: finish any leading
 			// assistant text before EventController renders the separate tool card.
 			this.#revealed = total;
-			component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf));
+			component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
+				transient: true,
+			});
 			return;
 		}
-		this.#renderCurrent(total);
+		this.#renderCurrent();
 		this.#syncTimer(total);
 	}
 
@@ -182,7 +184,7 @@ export class StreamingRevealController {
 		this.#target = message;
 		if (!this.#component) return;
 		if (!this.#smoothStreaming) {
-			this.#component.updateContent(message);
+			this.#component.updateContent(message, { transient: true });
 			return;
 		}
 		const total = this.#visibleUnits(message);
@@ -193,13 +195,16 @@ export class StreamingRevealController {
 			this.#stopTimer();
 			this.#component.updateContent(
 				buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf),
+				{
+					transient: true,
+				},
 			);
 			return;
 		}
 		if (this.#revealed > total) {
 			this.#revealed = total;
 		}
-		this.#renderCurrent(total);
+		this.#renderCurrent();
 		this.#syncTimer(total);
 	}
 
@@ -225,11 +230,14 @@ export class StreamingRevealController {
 		return total;
 	}
 
-	#renderCurrent(total = this.#target ? this.#visibleUnits(this.#target) : 0): void {
+	#renderCurrent(): void {
 		if (!this.#target || !this.#component) return;
+		// Every controller render is an in-flight streaming snapshot, even when
+		// smooth reveal has temporarily caught up to the current target. The
+		// message_end handler performs the only stable non-transient render.
 		this.#component.updateContent(
 			buildDisplayMessage(this.#target, this.#revealed, this.#hideThinkingBlock, this.#countOf),
-			{ transient: this.#revealed < total },
+			{ transient: true },
 		);
 	}
 
@@ -269,7 +277,7 @@ export class StreamingRevealController {
 		}
 		this.#revealed = Math.min(total, this.#revealed + nextStep(total - this.#revealed));
 		component.updateContent(buildDisplayMessage(target, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
-			transient: this.#revealed < total,
+			transient: true,
 		});
 		this.#requestRender();
 		if (this.#revealed >= total) {

package/src/modes/controllers/tool-args-reveal.ts

@@ -0,0 +1,174 @@
+import { parseStreamingJson } from "@oh-my-pi/pi-ai/utils/json-parse";
+import { nextStep, STREAMING_REVEAL_FRAME_MS } from "./streaming-reveal";
+
+/** Minimal component surface the reveal pushes frames into. */
+type ToolArgsRevealComponent = {
+	updateArgs(args: unknown, toolCallId?: string): void;
+};
+
+type ToolArgsRevealControllerOptions = {
+	getSmoothStreaming(): boolean;
+	requestRender(): void;
+};
+
+type RevealEntry = {
+	component: ToolArgsRevealComponent | undefined;
+	/** Latest raw streamed argument text (JSON for function tools, raw text for custom tools). */
+	target: string;
+	/** Revealed UTF-16 code units of `target`. */
+	revealed: number;
+	/** Custom-tool raw input: display args are `{ input: prefix }`, never parsed as JSON. */
+	rawInput: boolean;
+};
+
+/** Clamp a slice end into `text`, never splitting a surrogate pair: a prefix
+ *  ending on a high surrogate would feed a lone surrogate into the parsed
+ *  preview args (providers decode UTF-8 incrementally, so the raw stream
+ *  itself never contains one). */
+function clampSliceEnd(text: string, end: number): number {
+	if (end <= 0) return 0;
+	if (end >= text.length) return text.length;
+	const code = text.charCodeAt(end - 1);
+	return code >= 0xd800 && code <= 0xdbff ? end + 1 : end;
+}
+
+/** Display args for a revealed raw-stream prefix. Function-tool prefixes are
+ *  re-parsed with the same streaming-tolerant parser providers use, so every
+ *  frame is a state the provider itself could have produced; custom tools
+ *  mirror the provider's `{ input }` shape. `__partialJson` carries the
+ *  matching raw prefix for renderers that read it directly (bash env preview,
+ *  edit strategies). */
+function buildDisplayArgs(prefix: string, rawInput: boolean): Record<string, unknown> {
+	const base: Record<string, unknown> = rawInput ? { input: prefix } : parseStreamingJson(prefix);
+	return { ...base, __partialJson: prefix };
+}
+
+/**
+ * Paces streamed tool-call arguments the same way StreamingRevealController
+ * paces assistant text: providers that deliver `partialJson` in large batches
+ * (or throttle their partial parses) would otherwise make write/edit/bash
+ * streaming previews jump in chunks. Each pending tool call reveals its raw
+ * argument stream at the shared 30fps cadence with the same adaptive
+ * catch-up step, re-parsing the revealed prefix per frame.
+ *
+ * Reveal units are UTF-16 code units of the raw stream, not graphemes —
+ * the prefix goes through a JSON parser rather than straight to the screen,
+ * so only surrogate-pair integrity matters (see {@link clampSliceEnd}).
+ */
+export class ToolArgsRevealController {
+	readonly #getSmoothStreaming: () => boolean;
+	readonly #requestRender: () => void;
+	readonly #entries = new Map<string, RevealEntry>();
+	#timer: NodeJS.Timeout | undefined;
+
+	constructor(options: ToolArgsRevealControllerOptions) {
+		this.#getSmoothStreaming = options.getSmoothStreaming;
+		this.#requestRender = options.requestRender;
+	}
+
+	/**
+	 * Record the latest streamed argument text for a tool call and return the
+	 * args to render right now. With smoothing disabled the full target passes
+	 * through in the caller's legacy shape (`{ ...args, __partialJson }`).
+	 */
+	setTarget(
+		id: string,
+		partialJson: string,
+		rawInput: boolean,
+		fullArgs: Record<string, unknown>,
+	): Record<string, unknown> {
+		if (!this.#getSmoothStreaming()) {
+			// Toggle may flip mid-call: drop any live entry so ticks stop.
+			this.#entries.delete(id);
+			return { ...fullArgs, __partialJson: partialJson };
+		}
+		let entry = this.#entries.get(id);
+		if (!entry) {
+			entry = { component: undefined, target: partialJson, revealed: 0, rawInput };
+			this.#entries.set(id, entry);
+		} else {
+			// Streams only append; a non-prefix target means a rewind — snap into range.
+			if (!partialJson.startsWith(entry.target)) {
+				entry.revealed = Math.min(entry.revealed, partialJson.length);
+			}
+			entry.target = partialJson;
+		}
+		entry.revealed = clampSliceEnd(entry.target, entry.revealed);
+		this.#syncTimer();
+		return buildDisplayArgs(entry.target.slice(0, entry.revealed), entry.rawInput);
+	}
+
+	/** Attach the component future ticks push frames into. */
+	bind(id: string, component: ToolArgsRevealComponent): void {
+		const entry = this.#entries.get(id);
+		if (entry) entry.component = component;
+	}
+
+	/** Final arguments arrived (the JSON closed): drop the reveal so the
+	 *  caller's final-args render wins immediately, mirroring how assistant
+	 *  text snaps to the full message at message_end. */
+	finish(id: string): void {
+		this.#entries.delete(id);
+		if (this.#entries.size === 0) this.#stopTimer();
+	}
+
+	/** Snap every live entry to its full received stream and clear. Used at
+	 *  message_end (abort/error mid-stream) so sealed components freeze showing
+	 *  everything that arrived rather than a mid-reveal prefix. */
+	flushAll(): void {
+		for (const [id, entry] of this.#entries) {
+			if (entry.component && entry.revealed < entry.target.length) {
+				entry.component.updateArgs(buildDisplayArgs(entry.target, entry.rawInput), id);
+			}
+		}
+		this.#entries.clear();
+		this.#stopTimer();
+	}
+
+	/** Clear without pushing (teardown). */
+	stop(): void {
+		this.#entries.clear();
+		this.#stopTimer();
+	}
+
+	#syncTimer(): void {
+		for (const entry of this.#entries.values()) {
+			if (entry.revealed < entry.target.length) {
+				this.#startTimer();
+				return;
+			}
+		}
+		this.#stopTimer();
+	}
+
+	#startTimer(): void {
+		if (this.#timer) return;
+		this.#timer = setInterval(() => {
+			this.#tick();
+		}, STREAMING_REVEAL_FRAME_MS);
+		this.#timer.unref?.();
+	}
+
+	#stopTimer(): void {
+		if (!this.#timer) return;
+		clearInterval(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#tick(): void {
+		let advanced = false;
+		for (const [id, entry] of this.#entries) {
+			const backlog = entry.target.length - entry.revealed;
+			if (backlog <= 0 || !entry.component) continue;
+			entry.revealed = clampSliceEnd(entry.target, entry.revealed + nextStep(backlog));
+			entry.component.updateArgs(buildDisplayArgs(entry.target.slice(0, entry.revealed), entry.rawInput), id);
+			advanced = true;
+		}
+		if (advanced) {
+			this.#requestRender();
+		} else {
+			// Every entry caught up (or unbound); setTarget restarts on growth.
+			this.#stopTimer();
+		}
+	}
+}

package/src/modes/interactive-mode.ts

@@ -496,8 +496,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	playWelcomeIntro(): void {
-		this.#welcomeComponent?.playIntro(() => this.ui.requestRender());
+		const welcome = this.#welcomeComponent;
+		// Component-scoped: the intro only mutates the welcome box's own rows,
+		// so a resumed long transcript is not re-walked per animation frame.
+		welcome?.playIntro(() => this.ui.requestComponentRender(welcome));
 	}
+
 	async init(options: InteractiveModeInitOptions = {}): Promise<void> {
 		if (this.isInitialized) return;
 
@@ -1050,6 +1054,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			separator: settings.get("statusLine.separator"),
 			showHookStatus: settings.get("statusLine.showHookStatus"),
 			sessionAccent: settings.get("statusLine.sessionAccent"),
+			transparent: settings.get("statusLine.transparent"),
 			segmentOptions: settings.get("statusLine.segmentOptions"),
 		});
 	}
@@ -1780,6 +1785,7 @@ export class InteractiveMode implements InteractiveModeContext {
 				onPick: choice => finish(choice),
 				onCancel: () => finish(undefined),
 				onExternalEditor: dialogOptions?.onExternalEditor,
+				onAnnotationExternalEditor: (draft, commit) => void this.#openPlanAnnotationInExternalEditor(draft, commit),
 				onPlanEdited: dialogOptions?.onPlanEdited,
 				onFeedbackChange: dialogOptions?.onFeedbackChange,
 			},
@@ -1894,6 +1900,37 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
+	async #openPlanAnnotationInExternalEditor(draft: string, commit: (text: string | null) => void): Promise<void> {
+		const editorCmd = getEditorCommand();
+		if (!editorCmd) {
+			this.showWarning("No editor configured. Set $VISUAL or $EDITOR environment variable.");
+			return;
+		}
+
+		let ttyHandle: fs.FileHandle | null = null;
+		try {
+			ttyHandle = await this.#openEditorTerminalHandle();
+			this.ui.stop();
+
+			const stdio: [number | "inherit", number | "inherit", number | "inherit"] = ttyHandle
+				? [ttyHandle.fd, ttyHandle.fd, ttyHandle.fd]
+				: ["inherit", "inherit", "inherit"];
+
+			const result = await openInEditor(editorCmd, draft, { extension: ".md", stdio });
+			if (result !== null) {
+				commit(result);
+			}
+		} catch (error) {
+			this.showWarning(`Failed to open external editor: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			if (ttyHandle) {
+				await ttyHandle.close();
+			}
+			this.ui.start();
+			this.ui.requestRender(true);
+		}
+	}
+
 	async #applyPlanExecutionModel(entry: ResolvedRoleModel | undefined): Promise<void> {
 		if (!entry) return;
 		try {
@@ -3036,7 +3073,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#voiceAnimationInterval = setInterval(() => {
 			this.#voiceHue = (this.#voiceHue + 8) % 360;
 			this.#updateMicIcon();
-			this.ui.requestRender();
+			// Component-scoped: the hue sweep only recolors the editor's cursor
+			// glyph, so the transcript subtree is reused per animation frame.
+			this.ui.requestComponentRender(this.editor);
 		}, 60);
 	}
 

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

@@ -13,6 +13,8 @@ import type { FileSink } from "bun";
 import type { BashResult } from "../../exec/bash-executor";
 import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
 import type {
+	RpcAvailableCommandsUpdateFrame,
+	RpcAvailableSlashCommand,
 	RpcCommand,
 	RpcExtensionUIRequest,
 	RpcHandoffResult,
@@ -63,6 +65,7 @@ export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
 export type RpcSubagentLifecycleListener = (payload: RpcSubagentLifecycleFrame["payload"]) => void;
 export type RpcSubagentProgressListener = (payload: RpcSubagentProgressFrame["payload"]) => void;
 export type RpcSubagentEventListener = (payload: RpcSubagentEventFrame["payload"]) => void;
+export type RpcAvailableCommandsUpdateListener = (commands: RpcAvailableSlashCommand[]) => void;
 
 export interface RpcClientToolContext<TDetails = unknown> {
 	toolCallId: string;
@@ -161,6 +164,11 @@ function isRpcSubagentEventFrame(value: unknown): value is RpcSubagentEventFrame
 	return value.type === "subagent_event" && isRecord(value.payload);
 }
 
+function isRpcAvailableCommandsUpdateFrame(value: unknown): value is RpcAvailableCommandsUpdateFrame {
+	if (!isRecord(value)) return false;
+	return value.type === "available_commands_update" && Array.isArray(value.commands);
+}
+
 function isRpcHostToolCallRequest(value: unknown): value is RpcHostToolCallRequest {
 	if (!isRecord(value)) return false;
 	return (
@@ -202,6 +210,7 @@ export class RpcClient {
 	#subagentLifecycleListeners = new Set<RpcSubagentLifecycleListener>();
 	#subagentProgressListeners = new Set<RpcSubagentProgressListener>();
 	#subagentEventListeners = new Set<RpcSubagentEventListener>();
+	#availableCommandsUpdateListeners = new Set<RpcAvailableCommandsUpdateListener>();
 	#pendingRequests: Map<string, { resolve: (response: RpcResponse) => void; reject: (error: Error) => void }> =
 		new Map();
 	#customTools: RpcClientCustomTool[] = [];
@@ -377,6 +386,14 @@ export class RpcClient {
 		return () => this.#subagentEventListeners.delete(listener);
 	}
 
+	/**
+	 * Subscribe to slash-command availability updates emitted by the RPC server.
+	 */
+	onAvailableCommandsUpdate(listener: RpcAvailableCommandsUpdateListener): () => void {
+		this.#availableCommandsUpdateListeners.add(listener);
+		return () => this.#availableCommandsUpdateListeners.delete(listener);
+	}
+
 	/**
 	 * Get collected stderr output (useful for debugging).
 	 */
@@ -511,6 +528,14 @@ export class RpcClient {
 		return this.#getData<{ models: ModelInfo[] }>(response).models;
 	}
 
+	/**
+	 * Get list of available slash commands.
+	 */
+	async getAvailableCommands(): Promise<RpcAvailableSlashCommand[]> {
+		const response = await this.#send({ type: "get_available_commands" });
+		return this.#getData<{ commands: RpcAvailableSlashCommand[] }>(response).commands;
+	}
+
 	/**
 	 * Set thinking level.
 	 */
@@ -825,6 +850,13 @@ export class RpcClient {
 			return;
 		}
 
+		if (isRpcAvailableCommandsUpdateFrame(data)) {
+			for (const listener of this.#availableCommandsUpdateListeners) {
+				listener(data.commands);
+			}
+			return;
+		}
+
 		if (!isAgentSessionEvent(data)) return;
 
 		for (const listener of this.#sessionEventListeners) {

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

@@ -12,6 +12,8 @@
  */
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import { $env, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
+import { reset as resetCapabilities } from "../../capability";
+import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
 	type ExtensionUIContext,
 	type ExtensionUIDialogOptions,
@@ -19,8 +21,13 @@ import {
 	type ExtensionWidgetOptions,
 	getExtensionUISelectOptionLabel,
 } from "../../extensibility/extensions";
+import { buildSkillPromptMessage } from "../../extensibility/skills";
+import { loadSlashCommands } from "../../extensibility/slash-commands";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
+import { SKILL_PROMPT_MESSAGE_TYPE } from "../../session/messages";
+import { executeAcpBuiltinSlashCommand } from "../../slash-commands/acp-builtins";
+import { buildAvailableSlashCommands } from "../../slash-commands/available-commands";
 import type { EventBus } from "../../utils/event-bus";
 import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
@@ -70,6 +77,28 @@ export type RpcSessionChangeResult =
 	| { type: "branch"; data: { text: string; cancelled: boolean } };
 
 export type RpcSessionChangeSession = Pick<AgentSession, "newSession" | "switchSession" | "branch">;
+
+export type RpcSkillCommandSession = Pick<AgentSession, "promptCustomMessage" | "skills" | "skillsSettings">;
+
+export async function tryRunRpcSkillCommand(session: RpcSkillCommandSession, text: string): Promise<boolean> {
+	if (!text.startsWith("/skill:")) return false;
+	if (!session.skillsSettings?.enableSkillCommands) return false;
+	const spaceIndex = text.indexOf(" ");
+	const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+	const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+	const skillName = commandName.slice("skill:".length);
+	const skill = session.skills.find(candidate => candidate.name === skillName);
+	if (!skill) return false;
+	const built = await buildSkillPromptMessage(skill, args);
+	await session.promptCustomMessage({
+		customType: SKILL_PROMPT_MESSAGE_TYPE,
+		content: built.message,
+		display: true,
+		details: built.details,
+		attribution: "user",
+	});
+	return true;
+}
 export type RpcSubagentResetRegistry = Pick<RpcSubagentRegistry, "clear">;
 
 export async function handleRpcSessionChange(
@@ -511,6 +540,24 @@ export async function runRpcMode(
 		output(event);
 	});
 
+	const getAvailableCommands = async () => buildAvailableSlashCommands(session);
+	const reloadPluginState = async () => {
+		const cwd = session.sessionManager.getCwd();
+		const projectPath = await resolveActiveProjectRegistryPath(cwd);
+		clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
+		resetCapabilities();
+		session.setSlashCommands(await loadSlashCommands({ cwd }));
+		await session.refreshSshTool({ activateIfAvailable: true });
+		await emitAvailableCommandsUpdate();
+	};
+	const emitAvailableCommandsUpdate = async () => {
+		output({ type: "available_commands_update", commands: await getAvailableCommands() });
+	};
+	session.subscribeCommandMetadataChanged(() => {
+		void emitAvailableCommandsUpdate();
+	});
+	await emitAvailableCommandsUpdate();
+
 	// Handle a single command
 	const handleCommand = async (command: RpcCommand): Promise<RpcResponse> => {
 		const id = command.id;
@@ -521,6 +568,33 @@ export async function runRpcMode(
 			// =================================================================
 
 			case "prompt": {
+				if (await tryRunRpcSkillCommand(session, command.message)) {
+					return success(id, "prompt");
+				}
+				const builtinResult = await executeAcpBuiltinSlashCommand(command.message, {
+					session,
+					sessionManager: session.sessionManager,
+					settings: session.settings,
+					cwd: session.sessionManager.getCwd(),
+					output: text => output({ type: "command_output", text }),
+					refreshCommands: emitAvailableCommandsUpdate,
+					reloadPlugins: reloadPluginState,
+					notifyTitleChanged: async () => {
+						output({ type: "session_info_update", title: session.sessionName, sessionId: session.sessionId });
+					},
+					notifyConfigChanged: async () => {
+						output({ type: "config_update", model: session.model, thinkingLevel: session.thinkingLevel });
+					},
+				});
+				if (builtinResult !== false) {
+					if ("prompt" in builtinResult) {
+						session
+							.prompt(builtinResult.prompt, { images: command.images })
+							.catch(e => output(error(id, "prompt", e.message)));
+					}
+					return success(id, "prompt");
+				}
+
 				// Don't await - events will stream
 				// Extension commands are executed immediately, file prompt templates are expanded
 				// If streaming and streamingBehavior specified, queues via steer/followUp
@@ -556,8 +630,11 @@ export async function runRpcMode(
 				return success(id, "abort_and_prompt");
 			}
 
-			case "new_session": {
+			case "new_session":
+			case "switch_session":
+			case "branch": {
 				const result = await handleRpcSessionChange(session, command, subagentRegistry);
+				if (!result.data.cancelled) await emitAvailableCommandsUpdate();
 				return success(id, result.type, result.data);
 			}
 
@@ -592,6 +669,10 @@ export async function runRpcMode(
 				return success(id, "get_state", state);
 			}
 
+			case "get_available_commands": {
+				return success(id, "get_available_commands", { commands: await getAvailableCommands() });
+			}
+
 			case "set_todos": {
 				session.setTodoPhases(command.phases);
 				return success(id, "set_todos", { todoPhases: session.getTodoPhases() });
@@ -770,12 +851,6 @@ export async function runRpcMode(
 				return success(id, "export_html", { path });
 			}
 
-			case "switch_session":
-			case "branch": {
-				const result = await handleRpcSessionChange(session, command, subagentRegistry);
-				return success(id, result.type, result.data);
-			}
-
 			case "get_branch_messages": {
 				const messages = session.getUserMessagesForBranching();
 				return success(id, "get_branch_messages", { messages });

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

@@ -11,6 +11,7 @@ import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
 import type { FileEntry } from "../../session/session-manager";
+import type { AvailableSlashCommandSource } from "../../slash-commands/available-commands";
 import type {
 	AgentProgress,
 	SubagentEventPayload,
@@ -34,6 +35,7 @@ export type RpcCommand =
 
 	// State
 	| { id?: string; type: "get_state" }
+	| { id?: string; type: "get_available_commands" }
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
@@ -110,6 +112,20 @@ export interface RpcSessionState {
 	contextUsage?: ContextUsage;
 }
 
+export interface RpcAvailableSlashCommand {
+	name: string;
+	aliases?: string[];
+	description?: string;
+	input?: { hint?: string };
+	subcommands?: Array<{ name: string; description?: string; usage?: string }>;
+	source: AvailableSlashCommandSource;
+}
+
+export interface RpcAvailableCommandsUpdateFrame {
+	type: "available_commands_update";
+	commands: RpcAvailableSlashCommand[];
+}
+
 export interface RpcHandoffResult {
 	savedPath?: string;
 }
@@ -156,6 +172,13 @@ export type RpcResponse =
 
 	// State
 	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_available_commands";
+			success: true;
+			data: { commands: RpcAvailableSlashCommand[] };
+	  }
 	| { id?: string; type: "response"; command: "set_todos"; success: true; data: { todoPhases: TodoPhase[] } }
 	| { id?: string; type: "response"; command: "set_host_tools"; success: true; data: { toolNames: string[] } }
 	| { id?: string; type: "response"; command: "set_host_uri_schemes"; success: true; data: { schemes: string[] } }

package/src/modes/theme/theme.ts

@@ -108,6 +108,7 @@ export type SymbolKey =
 	| "icon.time"
 	| "icon.pi"
 	| "icon.agents"
+	| "icon.job"
 	| "icon.cache"
 	| "icon.input"
 	| "icon.output"
@@ -304,6 +305,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"icon.time": "⏱",
 	"icon.pi": "π",
 	"icon.agents": "👥",
+	"icon.job": "⚙",
 	"icon.cache": "💾",
 	"icon.input": "⤵",
 	"icon.output": "⤴",
@@ -567,6 +569,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"icon.pi": "\ue22c",
 	// pick:  | alt: 
 	"icon.agents": "\uf0c0",
+	// pick:  (nf-fa-gear) | alt:  ⚙
+	"icon.job": "\uf013",
 	// pick:  | alt:  
 	"icon.cache": "\uf1c0",
 	// pick:  | alt:  →
@@ -796,6 +800,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"icon.time": "t:",
 	"icon.pi": "pi",
 	"icon.agents": "AG",
+	"icon.job": "bg",
 	"icon.cache": "cache",
 	"icon.input": "in:",
 	"icon.output": "out:",
@@ -1678,6 +1683,7 @@ export class Theme {
 			time: this.#symbols["icon.time"],
 			pi: this.#symbols["icon.pi"],
 			agents: this.#symbols["icon.agents"],
+			job: this.#symbols["icon.job"],
 			cache: this.#symbols["icon.cache"],
 			input: this.#symbols["icon.input"],
 			output: this.#symbols["icon.output"],
@@ -2559,10 +2565,10 @@ 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) {
+function highlightCached(code: string, validLang: string | undefined, highlightTheme: Theme): string | null {
+	if (highlightCacheTheme !== highlightTheme) {
 		highlightCache.clear();
-		highlightCacheTheme = theme;
+		highlightCacheTheme = highlightTheme;
 	}
 	const key = `${validLang ?? ""}\x00${code}`;
 	const hit = highlightCache.get(key);
@@ -2571,7 +2577,7 @@ function highlightCached(code: string, validLang: string | undefined): string |
 	}
 	let highlighted: string;
 	try {
-		highlighted = nativeHighlightCode(code, validLang, getHighlightColors(theme));
+		highlighted = nativeHighlightCode(code, validLang, getHighlightColors(highlightTheme));
 	} catch {
 		return null;
 	}
@@ -2583,9 +2589,9 @@ function highlightCached(code: string, validLang: string | undefined): string |
  * Highlight code with syntax coloring based on file extension or language.
  * Returns array of highlighted lines.
  */
-export function highlightCode(code: string, lang?: string): string[] {
+export function highlightCode(code: string, lang?: string, highlightTheme: Theme = theme): string[] {
 	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-	const highlighted = highlightCached(code, validLang);
+	const highlighted = highlightCached(code, validLang, highlightTheme);
 	// 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");
@@ -2633,7 +2639,7 @@ export function getMarkdownTheme(): MarkdownTheme {
 		resolveMermaidAscii,
 		highlightCode: (code: string, lang?: string): string[] => {
 			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-			const highlighted = highlightCached(code, validLang);
+			const highlighted = highlightCached(code, validLang, theme);
 			if (highlighted !== null) return highlighted.split("\n");
 			return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
 		},