@oh-my-pi/pi-coding-agent 15.0.1 → 15.1.0

package/src/modes/components/status-line/segments.ts

@@ -2,7 +2,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
-import { formatDuration, formatNumber, getProjectDir, relativePathWithinRoot } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, getProjectDir, pathIsWithin, relativePathWithinRoot } from "@oh-my-pi/pi-utils";
 import { type ThemeColor, theme } from "../../../modes/theme/theme";
 import { shortenPath } from "../../../tools/render-utils";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
@@ -32,6 +32,33 @@ function normalizePremiumRequests(value: number): number {
 	return Math.round((value + Number.EPSILON) * 100) / 100;
 }
 
+const SCRATCH_ROOTS: readonly string[] = (() => {
+	const roots = new Set<string>([os.tmpdir(), path.join(os.homedir(), "tmp")]);
+	if (process.platform === "win32") {
+		const { TEMP, TMP, SystemRoot } = process.env;
+		if (TEMP) roots.add(TEMP);
+		if (TMP) roots.add(TMP);
+		if (SystemRoot) roots.add(path.join(SystemRoot, "Temp"));
+	} else {
+		roots.add("/tmp");
+		roots.add("/var/tmp");
+		if (process.platform === "darwin") {
+			roots.add("/private/tmp");
+			roots.add("/private/var/tmp");
+		}
+	}
+	return [...roots];
+})();
+
+function classifyProjectDir(pwd: string): { scratch: boolean; relative: string | null } {
+	for (const root of SCRATCH_ROOTS) {
+		if (pathIsWithin(root, pwd)) {
+			return { scratch: true, relative: relativePathWithinRoot(root, pwd) };
+		}
+	}
+	return { scratch: false, relative: null };
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Segment Implementations
 // ═══════════════════════════════════════════════════════════════════════════
@@ -150,10 +177,16 @@ const pathSegment: StatusLineSegment = {
 	render(ctx) {
 		const opts = ctx.options.path ?? {};
 
-		let pwd = getProjectDir();
+		const projectDir = getProjectDir();
+		const { scratch, relative } = classifyProjectDir(projectDir);
+		let pwd = projectDir;
 
 		if (opts.stripWorkPrefix !== false) {
-			pwd = stripDisplayRoot(pwd);
+			if (scratch) {
+				if (relative) pwd = relative;
+			} else {
+				pwd = stripDisplayRoot(pwd);
+			}
 		}
 		if (opts.abbreviate !== false) {
 			pwd = shortenPath(pwd);
@@ -166,7 +199,9 @@ const pathSegment: StatusLineSegment = {
 			pwd = `${ellipsis}${pwd.slice(-sliceLen)}`;
 		}
 
-		const content = withIcon(theme.icon.folder, pwd);
+		const showScratchIcon = scratch && opts.stripWorkPrefix !== false;
+		const icon = showScratchIcon ? theme.icon.scratchFolder : theme.icon.folder;
+		const content = withIcon(icon, pwd);
 		return { content: theme.fg("statusLinePath", content), visible: true };
 	},
 };

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

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { CompactionCancelledError, type CompactionOutcome } from "@oh-my-pi/pi-agent-core/compaction";
 import {
 	getEnvApiKey,
 	getProviderDetails,
@@ -37,7 +38,6 @@ import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
-import { CompactionCancelledError, type CompactionOutcome } from "../../session/compaction";
 import type { NewSessionOptions } from "../../session/session-manager";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
@@ -1175,8 +1175,29 @@ export class CommandController {
 			return;
 		}
 
+		if (this.ctx.loadingAnimation) {
+			this.ctx.loadingAnimation.stop();
+			this.ctx.loadingAnimation = undefined;
+		}
+		this.ctx.statusContainer.clear();
+
+		const originalOnEscape = this.ctx.editor.onEscape;
+		this.ctx.editor.onEscape = () => {
+			this.ctx.session.abortHandoff();
+		};
+
+		const handoffLoader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			"Generating handoff… (esc to cancel)",
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(handoffLoader);
+		this.ctx.ui.requestRender();
+
 		try {
-			// The agent will visibly generate the handoff document in chat
+			// Handoff generation runs as a oneshot request; the new session is shown after it completes.
 			const result = await this.ctx.session.handoff(customInstructions);
 
 			if (!result) {
@@ -1206,6 +1227,10 @@ export class CommandController {
 			} else {
 				this.ctx.showError(`Handoff failed: ${message}`);
 			}
+		} finally {
+			handoffLoader.stop();
+			this.ctx.statusContainer.clear();
+			this.ctx.editor.onEscape = originalOnEscape;
 		}
 		this.ctx.ui.requestRender();
 	}

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

@@ -1,4 +1,5 @@
 import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
+import { calculatePromptTokens } from "@oh-my-pi/pi-agent-core/compaction/compaction";
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import { type Component, Loader, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { settings } from "../../config/settings";
@@ -15,7 +16,6 @@ import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext, TodoPhase } from "../../modes/types";
 import type { PlanApprovalDetails } from "../../plan-mode/approved-plan";
 import type { AgentSessionEvent } from "../../session/agent-session";
-import { calculatePromptTokens } from "../../session/compaction/compaction";
 import { isSilentAbort, readPendingDisplayTag } from "../../session/messages";
 import type { ResolveToolDetails } from "../../tools/resolve";
 
@@ -719,9 +719,8 @@ export class EventController {
 
 	#scheduleIdleCompaction(): void {
 		this.#cancelIdleCompaction();
-		// Don't schedule while compaction/handoff is already running — the agent_end from a
-		// handoff agent turn still has the old session's bloated token counts, and scheduling
-		// here would fire after the session resets, trying to handoff an empty session.
+		// Don't schedule idle work while context maintenance is already running; the
+		// maintenance flow may reset the session before this timer fires.
 		if (this.ctx.session.isCompacting) return;
 
 		const idleSettings = settings.getGroup("compaction");

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

@@ -16,6 +16,7 @@ import type {
 	SendUserMessageHandler,
 	TerminalInputHandler,
 } from "../../extensibility/extensions";
+import { getSessionSlashCommands } from "../../extensibility/extensions/get-commands-handler";
 import { HookEditorComponent } from "../../modes/components/hook-editor";
 import { HookInputComponent } from "../../modes/components/hook-input";
 import { HookSelectorComponent } from "../../modes/components/hook-selector";
@@ -109,7 +110,7 @@ export class ExtensionUiController {
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
 			setThinkingLevel: level => this.ctx.session.setThinkingLevel(level),
-			getCommands: () => [],
+			getCommands: () => getSessionSlashCommands(this.ctx.session),
 			getSessionName: () => this.ctx.sessionManager.getSessionName(),
 			setSessionName: name => this.#updateSessionName(name),
 		};
@@ -349,7 +350,7 @@ export class ExtensionUiController {
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
 			setThinkingLevel: (level, persist) => this.ctx.session.setThinkingLevel(level, persist),
-			getCommands: () => [],
+			getCommands: () => getSessionSlashCommands(this.ctx.session),
 			getSessionName: () => this.ctx.sessionManager.getSessionName(),
 			setSessionName: name => this.#updateSessionName(name),
 		};

package/src/modes/interactive-mode.ts

@@ -5,6 +5,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type Agent, type AgentMessage, type AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { CompactionOutcome } from "@oh-my-pi/pi-agent-core/compaction";
 import {
 	type AssistantMessage,
 	type ImageContent,
@@ -46,7 +47,6 @@ import planModeCompactInstructionsPrompt from "../prompts/system/plan-mode-compa
 	type: "text",
 };
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
-import type { CompactionOutcome } from "../session/compaction";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import { getRecentSessions } from "../session/session-manager";

package/src/modes/rpc/host-tools.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import { Snowflake } from "@oh-my-pi/pi-utils";
-import type { Static, TSchema } from "@sinclair/typebox";
 import { applyToolProxy } from "../../extensibility/tool-proxy";
 import type { Theme } from "../../modes/theme/theme";
 import type {

package/src/modes/rpc/host-uris.ts

@@ -0,0 +1,235 @@
+import { Snowflake } from "@oh-my-pi/pi-utils";
+import { InternalUrlRouter } from "../../internal-urls";
+import type {
+	InternalResource,
+	InternalUrl,
+	ProtocolHandler,
+	ResolveContext,
+	WriteContext,
+} from "../../internal-urls/types";
+import type {
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
+	RpcHostUriResult,
+	RpcHostUriSchemeDefinition,
+} from "./rpc-types";
+
+type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
+
+type PendingUriRequest = {
+	operation: "read" | "write";
+	url: string;
+	resolve: (frame: RpcHostUriResult) => void;
+	reject: (error: Error) => void;
+};
+
+/** Type guard for inbound `host_uri_result` frames coming from the host. */
+export function isRpcHostUriResult(value: unknown): value is RpcHostUriResult {
+	if (!value || typeof value !== "object") return false;
+	const frame = value as { type?: unknown; id?: unknown };
+	return frame.type === "host_uri_result" && typeof frame.id === "string";
+}
+
+/**
+ * One handler instance per host-registered scheme. Delegates reads and (when
+ * the scheme was registered as writable) writes to the bridge, which serializes
+ * them over the RPC transport.
+ */
+class RpcHostUriProtocolHandler implements ProtocolHandler {
+	readonly scheme: string;
+	readonly immutable: boolean;
+	readonly write?: (url: InternalUrl, content: string, context?: WriteContext) => Promise<void>;
+	readonly #bridge: RpcHostUriBridge;
+
+	constructor(definition: RpcHostUriSchemeDefinition, bridge: RpcHostUriBridge) {
+		this.scheme = definition.scheme;
+		this.immutable = definition.immutable === true;
+		this.#bridge = bridge;
+		if (definition.writable === true) {
+			this.write = (url, content, context) => this.#bridge.requestWrite(this.scheme, url, content, context);
+		}
+	}
+
+	resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		return this.#bridge.requestRead(this.scheme, url, context);
+	}
+}
+
+/**
+ * Bidirectional bridge that lets the RPC host own a set of URI schemes.
+ *
+ * The host registers schemes via `set_host_uri_schemes`; the bridge installs
+ * a `RpcHostUriProtocolHandler` per scheme into the process-global
+ * {@link InternalUrlRouter}. Reads land on the read tool through the existing
+ * router; writes are intercepted by the write tool and dispatched through
+ * `requestWrite`.
+ */
+export class RpcHostUriBridge {
+	#output: RpcHostUriOutput;
+	#router: InternalUrlRouter;
+	#definitions = new Map<string, RpcHostUriSchemeDefinition>();
+	#pending = new Map<string, PendingUriRequest>();
+
+	constructor(output: RpcHostUriOutput, router: InternalUrlRouter = InternalUrlRouter.instance()) {
+		this.#output = output;
+		this.#router = router;
+	}
+
+	getSchemes(): string[] {
+		return Array.from(this.#definitions.keys());
+	}
+
+	/**
+	 * Replace the registered set of host URI schemes. Previously registered
+	 * schemes that no longer appear in the new set are unregistered from the
+	 * router; surviving and new schemes get fresh handler instances.
+	 */
+	setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[] {
+		const normalized = new Map<string, RpcHostUriSchemeDefinition>();
+		for (const raw of schemes) {
+			const scheme = typeof raw?.scheme === "string" ? raw.scheme.trim().toLowerCase() : "";
+			if (!scheme) {
+				throw new Error("Host URI scheme must be a non-empty string");
+			}
+			if (!/^[a-z][a-z0-9+.-]*$/.test(scheme)) {
+				throw new Error(`Host URI scheme contains invalid characters: ${raw.scheme}`);
+			}
+			normalized.set(scheme, {
+				scheme,
+				description: typeof raw.description === "string" ? raw.description : undefined,
+				writable: raw.writable === true,
+				immutable: raw.immutable === true,
+			});
+		}
+
+		for (const previous of this.#definitions.keys()) {
+			if (!normalized.has(previous)) {
+				this.#router.unregister(previous);
+			}
+		}
+		for (const definition of normalized.values()) {
+			this.#router.register(new RpcHostUriProtocolHandler(definition, this));
+		}
+		this.#definitions = normalized;
+		return Array.from(normalized.keys());
+	}
+
+	/**
+	 * Unregister every host scheme from the router and reject any in-flight
+	 * requests. Called on RPC shutdown to keep the global router clean for
+	 * subsequent sessions in the same process (used by tests).
+	 */
+	clear(message: string = "Host URI bridge shut down"): void {
+		for (const scheme of this.#definitions.keys()) {
+			this.#router.unregister(scheme);
+		}
+		this.#definitions.clear();
+		this.rejectAllPending(message);
+	}
+
+	/** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
+	handleResult(frame: RpcHostUriResult): boolean {
+		const pending = this.#pending.get(frame.id);
+		if (!pending) return false;
+		this.#pending.delete(frame.id);
+		pending.resolve(frame);
+		return true;
+	}
+
+	rejectAllPending(message: string): void {
+		const error = new Error(message);
+		const pending = Array.from(this.#pending.values());
+		this.#pending.clear();
+		for (const entry of pending) {
+			entry.reject(error);
+		}
+	}
+
+	async requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const result = await this.#dispatch("read", url.href, undefined, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI read failed for ${url.href}`);
+		}
+		const content = result.content ?? "";
+		const contentType = result.contentType ?? "text/plain";
+		const definition = this.#definitions.get(scheme);
+		return {
+			url: url.href,
+			content,
+			contentType,
+			size: Buffer.byteLength(content, "utf-8"),
+			notes: result.notes && result.notes.length > 0 ? [...result.notes] : undefined,
+			immutable: result.immutable ?? definition?.immutable === true,
+		};
+	}
+
+	async requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void> {
+		const result = await this.#dispatch("write", url.href, content, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI write failed for ${url.href}`);
+		}
+	}
+
+	#dispatch(
+		operation: "read" | "write",
+		url: string,
+		content: string | undefined,
+		signal: AbortSignal | undefined,
+	): Promise<RpcHostUriResult> {
+		if (signal?.aborted) {
+			return Promise.reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		}
+
+		const id = Snowflake.next() as string;
+		const { promise, resolve, reject } = Promise.withResolvers<RpcHostUriResult>();
+		let settled = false;
+
+		const cleanup = () => {
+			signal?.removeEventListener("abort", onAbort);
+			this.#pending.delete(id);
+		};
+
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			this.#output({
+				type: "host_uri_cancel",
+				id: Snowflake.next() as string,
+				targetId: id,
+			});
+			reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		};
+
+		signal?.addEventListener("abort", onAbort, { once: true });
+		this.#pending.set(id, {
+			operation,
+			url,
+			resolve: frame => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(frame);
+			},
+			reject: err => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(err);
+			},
+		});
+
+		const frame: RpcHostUriRequest = {
+			type: "host_uri_request",
+			id,
+			operation,
+			url,
+		};
+		if (operation === "write") {
+			frame.content = content ?? "";
+		}
+		this.#output(frame);
+
+		return promise;
+	}
+}

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

@@ -4,11 +4,11 @@
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
 import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import { isRecord, ptree, readJsonl } from "@oh-my-pi/pi-utils";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
-import type { CompactionResult } from "../../session/compaction";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,

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

@@ -21,6 +21,7 @@ import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
+import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -28,6 +29,8 @@ import type {
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
 	RpcHostToolDefinition,
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
 	RpcResponse,
 	RpcSessionState,
 } from "./rpc-types";
@@ -41,7 +44,14 @@ export type PendingExtensionRequest = {
 };
 
 type RpcOutput = (
-	obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | object,
+	obj:
+		| RpcResponse
+		| RpcExtensionUIRequest
+		| RpcHostToolCallRequest
+		| RpcHostToolCancelRequest
+		| RpcHostUriRequest
+		| RpcHostUriCancelRequest
+		| object,
 ) => void;
 
 function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[] {
@@ -188,6 +198,7 @@ export async function runRpcMode(
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
 	const hostToolBridge = new RpcHostToolBridge(output);
+	const hostUriBridge = new RpcHostUriBridge(output);
 
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
@@ -533,6 +544,15 @@ export async function runRpcMode(
 				return success(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
 			}
 
+			case "set_host_uri_schemes": {
+				try {
+					const schemes = hostUriBridge.setSchemes(command.schemes);
+					return success(id, "set_host_uri_schemes", { schemes });
+				} catch (err) {
+					return error(id, "set_host_uri_schemes", err instanceof Error ? err.message : String(err));
+				}
+			}
+
 			// =================================================================
 			// Model
 			// =================================================================
@@ -807,6 +827,11 @@ export async function runRpcMode(
 				continue;
 			}
 
+			if (isRpcHostUriResult(parsed)) {
+				hostUriBridge.handleResult(parsed);
+				continue;
+			}
+
 			// Handle regular commands
 			const command = parsed as RpcCommand;
 			const response = await handleCommand(command);
@@ -821,5 +846,6 @@ export async function runRpcMode(
 
 	// 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");
 	process.exit(0);
 }

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

@@ -5,11 +5,11 @@
  * Responses and events are emitted as JSON lines on stdout.
  */
 import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { SessionStats } from "../../session/agent-session";
-import type { CompactionResult } from "../../session/compaction";
 import type { TodoPhase } from "../../tools/todo-write";
 
 // ============================================================================
@@ -29,6 +29,7 @@ export type RpcCommand =
 	| { id?: string; type: "get_state" }
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
+	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -121,6 +122,7 @@ export type RpcResponse =
 	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
 	| { 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[] } }
 
 	// Model
 	| {
@@ -304,6 +306,61 @@ export interface RpcHostToolResult {
 	isError?: boolean;
 }
 
+// ============================================================================
+// Host URI Frames (bidirectional)
+// ============================================================================
+
+export interface RpcHostUriSchemeDefinition {
+	/** URL scheme without trailing `://` (e.g. `db`, `notion`). */
+	scheme: string;
+	/** Optional human-readable description for logs/diagnostics. */
+	description?: string;
+	/** When true, the write tool is allowed to dispatch writes to this scheme. */
+	writable?: boolean;
+	/** When true, downstream callers suppress hashline anchors for resolved content. */
+	immutable?: boolean;
+}
+
+export type RpcHostUriOperation = "read" | "write";
+
+/** Emitted by the RPC server when it needs the host to satisfy a URI operation. */
+export interface RpcHostUriRequest {
+	type: "host_uri_request";
+	id: string;
+	operation: RpcHostUriOperation;
+	url: string;
+	/** Present for write operations. */
+	content?: string;
+}
+
+/** Emitted by the RPC server when a pending URI request should be aborted. */
+export interface RpcHostUriCancelRequest {
+	type: "host_uri_cancel";
+	id: string;
+	targetId: string;
+}
+
+/** Sent by the host to complete a pending URI request. */
+export interface RpcHostUriResult {
+	type: "host_uri_result";
+	id: string;
+	/**
+	 * Required for successful `read` results. Ignored for `write` success.
+	 * Set on errors when a textual explanation accompanies `isError`.
+	 */
+	content?: string;
+	/** Defaults to `text/plain` when omitted. */
+	contentType?: "text/markdown" | "application/json" | "text/plain";
+	/** Optional resolution notes propagated to the read tool. */
+	notes?: string[];
+	/** Overrides the scheme-level `immutable` flag for this single resolution. */
+	immutable?: boolean;
+	/** When true, surface the result content as an error to the caller. */
+	isError?: boolean;
+	/** Optional error message; preferred over `content` for error surfacing. */
+	error?: string;
+}
+
 // ============================================================================
 // Extension UI Commands (stdin)
 // ============================================================================

package/src/modes/runtime-init.ts

@@ -7,6 +7,7 @@
  * caller-supplied hooks.
  */
 import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
+import { getSessionSlashCommands } from "../extensibility/extensions/get-commands-handler";
 import type { ExtensionError, ExtensionUIContext } from "../extensibility/extensions/types";
 import type { AgentSession } from "../session/agent-session";
 
@@ -59,7 +60,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			getActiveTools: () => session.getActiveToolNames(),
 			getAllTools: () => session.getAllToolNames(),
 			setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-			getCommands: () => [],
+			getCommands: () => getSessionSlashCommands(session),
 			setModel: model => runExtensionSetModel(session, model),
 			getThinkingLevel: () => session.thinkingLevel,
 			setThinkingLevel: level => session.setThinkingLevel(level),

package/src/modes/theme/defaults/dark-poimandres.json

@@ -133,6 +133,7 @@
       "icon.pause": "‖",
       "icon.loop": "↻",
       "icon.folder": "▸",
+      "icon.scratchFolder": "◌",
       "icon.pi": "π",
       "format.bullet": "◦",
       "md.bullet": "◦"

package/src/modes/theme/defaults/light-poimandres.json

@@ -133,6 +133,7 @@
       "icon.pause": "‖",
       "icon.loop": "↻",
       "icon.folder": "▸",
+      "icon.scratchFolder": "◌",
       "icon.pi": "π",
       "format.bullet": "◦",
       "md.bullet": "◦"