@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/memories/index.ts

@@ -388,7 +388,7 @@ async function runPhase2(options: {
 		const phase2Model = await resolveMemoryModel({
 			modelRegistry,
 			session,
-			fallbackRole: "smol",
+			fallbackRole: "default",
 		});
 		if (!phase2Model) {
 			markPhase2FailureWithFallback(db, {

package/src/modes/acp/acp-agent.ts

@@ -72,10 +72,11 @@ import {
 } from "../../session/session-manager";
 import { ACP_BUILTIN_SLASH_COMMANDS, executeAcpBuiltinSlashCommand } from "../../slash-commands/acp-builtins";
 import { parseThinkingLevel } from "../../thinking";
+import { toAgentWireEventPayload } from "../shared/agent-wire/event-envelope";
 import { createAcpClientBridge } from "./acp-client-bridge";
 import {
 	buildToolCallStartUpdate,
-	mapAgentSessionEventToAcpSessionUpdates,
+	mapAgentWireEventPayloadToAcpSessionUpdates,
 	normalizeReplayToolArguments,
 } from "./acp-event-mapper";
 import { ACP_TERMINAL_AUTH_FLAG } from "./terminal-auth";
@@ -1128,12 +1129,16 @@ export class AcpAgent implements Agent {
 		}
 
 		this.#prepareLiveAssistantMessage(record, event);
-		for (const notification of mapAgentSessionEventToAcpSessionUpdates(event, record.session.sessionId, {
-			getMessageId: message => this.#getLiveMessageId(record, message),
-			getMessageProgress: message => this.#getLiveMessageProgress(record, message),
-			getToolArgs: toolCallId => record.toolArgsById.get(toolCallId),
-			cwd: record.session.sessionManager.getCwd(),
-		})) {
+		for (const notification of mapAgentWireEventPayloadToAcpSessionUpdates(
+			toAgentWireEventPayload(event),
+			record.session.sessionId,
+			{
+				getMessageId: message => this.#getLiveMessageId(record, message),
+				getMessageProgress: message => this.#getLiveMessageProgress(record, message),
+				getToolArgs: toolCallId => record.toolArgsById.get(toolCallId),
+				cwd: record.session.sessionManager.getCwd(),
+			},
+		)) {
 			await this.#connection.sessionUpdate(notification);
 		}
 		if (event.type === "tool_execution_end") {
@@ -1887,14 +1892,17 @@ export class AcpAgent implements Agent {
 				errorMessage: message.errorMessage,
 			},
 		};
-		const notifications = mapAgentSessionEventToAcpSessionUpdates(endEvent, sessionId, {
+		const notifications = mapAgentWireEventPayloadToAcpSessionUpdates(toAgentWireEventPayload(endEvent), sessionId, {
 			cwd,
 			getToolArgs: toolCallId => (toolCallId === message.toolCallId ? options.toolArgs : undefined),
 		});
 		if (options.includeStart === false) {
 			return notifications;
 		}
-		return [...mapAgentSessionEventToAcpSessionUpdates(startEvent, sessionId, { cwd }), ...notifications];
+		return [
+			...mapAgentWireEventPayloadToAcpSessionUpdates(toAgentWireEventPayload(startEvent), sessionId, { cwd }),
+			...notifications,
+		];
 	}
 
 	#buildReplayToolArgs(details: unknown): { path?: string } {

package/src/modes/acp/acp-event-mapper.ts

@@ -9,6 +9,7 @@ import type {
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { resolveToCwd } from "../../tools/path-utils";
 import type { TodoStatus } from "../../tools/todo-write";
+import type { AgentWireEventPayload } from "../shared/agent-wire/event-contract";
 
 interface MessageProgress {
 	textEmitted: boolean;
@@ -145,6 +146,14 @@ export function mapToolKind(toolName: string): ToolKind {
 	}
 }
 
+export function mapAgentWireEventPayloadToAcpSessionUpdates(
+	payload: AgentWireEventPayload,
+	sessionId: string,
+	options: AcpEventMapperOptions = {},
+): SessionNotification[] {
+	return mapAgentSessionEventToAcpSessionUpdates(payload.event, sessionId, options);
+}
+
 export function mapAgentSessionEventToAcpSessionUpdates(
 	event: AgentSessionEvent,
 	sessionId: string,
@@ -221,11 +230,34 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "todo_auto_clear":
 			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries: [] })];
-		default:
+		// These event types are intentionally not represented as ACP session updates.
+		case "agent_start":
+		case "agent_end":
+		case "turn_start":
+		case "turn_end":
+		case "message_start":
+		case "auto_compaction_start":
+		case "auto_compaction_end":
+		case "auto_retry_start":
+		case "auto_retry_end":
+		case "retry_fallback_applied":
+		case "retry_fallback_succeeded":
+		case "ttsr_triggered":
+		case "irc_message":
+		case "notice":
+		case "thinking_level_changed":
+		case "goal_updated":
 			return [];
+		default:
+			return assertNeverAcp(event);
 	}
 }
 
+function assertNeverAcp(event: never): SessionNotification[] {
+	void (event as AgentSessionEvent);
+	return [];
+}
+
 function mapAssistantMessageUpdate(
 	event: Extract<AgentSessionEvent, { type: "message_update" }>,
 	sessionId: string,

package/src/modes/components/custom-editor.ts

@@ -51,6 +51,13 @@ type PastePendingClearReason = "timeout" | "queue-limit";
  */
 export class CustomEditor extends Editor {
 	onEscape?: () => void;
+	/**
+	 * Optional high-priority interrupt consumer. Invoked when the interrupt key
+	 * is pressed, before `onEscape`. Returning `true` consumes the keystroke.
+	 * Used so a transient UI (e.g. the btw panel) stays dismissable even while
+	 * another controller has temporarily installed its own `onEscape` handler.
+	 */
+	onInterruptPriority?: () => boolean;
 	shouldBypassAutocompleteOnEscape?: () => boolean;
 	onClear?: () => void;
 	onExit?: () => void;
@@ -285,10 +292,19 @@ export class CustomEditor extends Editor {
 
 		// Intercept configured interrupt shortcut.
 		// Default behavior keeps autocomplete dismissal, but parent can prioritize global interrupt handling.
-		if (this.#matchesAction(data, "app.interrupt") && this.onEscape) {
+		if (this.#matchesAction(data, "app.interrupt")) {
 			if (!this.isShowingAutocomplete() || this.shouldBypassAutocompleteOnEscape?.()) {
-				this.onEscape();
-				return;
+				// A priority interrupt consumer (e.g. an open btw panel) must win over any
+				// transient onEscape handler other controllers install (auto-compaction,
+				// auto-retry, manual compaction, etc.) so dismissal stays wired regardless
+				// of which handler currently owns onEscape.
+				if (this.onInterruptPriority?.()) {
+					return;
+				}
+				if (this.onEscape) {
+					this.onEscape();
+					return;
+				}
 			}
 		}
 

package/src/modes/components/hook-selector.ts

@@ -4,6 +4,7 @@
  */
 import {
 	Container,
+	Editor,
 	Markdown,
 	matchesKey,
 	padding,
@@ -16,8 +17,13 @@ import {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@gajae-code/tui";
-import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import { matchesAppExternalEditor, matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
+import { getEditorTheme, getMarkdownTheme, theme } from "../../modes/theme/theme";
+import {
+	matchesAppExternalEditor,
+	matchesAppInterrupt,
+	matchesSelectCancel,
+} from "../../modes/utils/keybinding-matchers";
+import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { CountdownTimer } from "./countdown-timer";
 import { DynamicBorder } from "./dynamic-border";
 
@@ -56,6 +62,17 @@ export interface HookSelectorOptions {
 	 */
 	wrapFocused?: boolean;
 	scrollTitleRows?: number;
+	/**
+	 * Inline free-text entry for the option with this label (e.g. the ask
+	 * tool's "Other (type your own)"). Selecting it keeps the title and option
+	 * list on screen and opens a prompt-style editor below the list instead of
+	 * replacing the whole selector. Enter submits via `onSubmit`; Escape
+	 * returns to option selection.
+	 */
+	customInput?: {
+		optionLabel: string;
+		onSubmit: (text: string) => void;
+	};
 }
 
 class OutlinedList extends Container {
@@ -297,6 +314,12 @@ export class HookSelectorComponent extends Container {
 	#wrapFocused: boolean;
 	#outline: boolean;
 	#scrollTitleRows: number | undefined;
+	#customInput: { optionLabel: string; onSubmit: (text: string) => void } | undefined;
+	#inputArea: Container;
+	#inlineEditor: Editor | undefined;
+	#helpTextComponent: Text;
+	#baseHelpText: string;
+	#tui: TUI | undefined;
 	constructor(
 		title: string,
 		options: string[],
@@ -317,6 +340,8 @@ export class HookSelectorComponent extends Container {
 		this.#onExternalEditorCallback = opts?.onExternalEditor;
 		this.#wrapFocused = opts?.wrapFocused === true;
 		this.#outline = opts?.outline === true;
+		this.#customInput = opts?.customInput;
+		this.#tui = opts?.tui;
 
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
@@ -364,9 +389,12 @@ export class HookSelectorComponent extends Container {
 			this.#listContainer = new Container();
 			this.addChild(this.#listContainer);
 		}
+		this.#inputArea = new Container();
+		this.addChild(this.#inputArea);
 		this.addChild(new Spacer(1));
-		const controlsHint = opts?.helpText ?? "up/down navigate  enter select  esc cancel";
-		this.addChild(new Text(theme.fg("dim", controlsHint), 1, 0));
+		this.#baseHelpText = opts?.helpText ?? "up/down navigate  enter select  esc cancel";
+		this.#helpTextComponent = new Text(theme.fg("dim", this.#baseHelpText), 1, 0);
+		this.addChild(this.#helpTextComponent);
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 
@@ -432,6 +460,10 @@ export class HookSelectorComponent extends Container {
 			this.#scrollableTitle?.scrollBy(this.#scrollTitleRows);
 			return;
 		}
+		if (this.#inlineEditor) {
+			this.#handleInputModeKey(keyData, this.#inlineEditor);
+			return;
+		}
 		if (matchesKey(keyData, "up") || keyData === "k") {
 			this.#selectedIndex = Math.max(0, this.#selectedIndex - 1);
 			this.#updateList();
@@ -440,7 +472,12 @@ export class HookSelectorComponent extends Container {
 			this.#updateList();
 		} else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selected = this.#options[this.#selectedIndex];
-			if (selected) this.#onSelectCallback(selected);
+			if (!selected) return;
+			if (this.#customInput && selected === this.#customInput.optionLabel) {
+				this.#enterInputMode();
+				return;
+			}
+			this.#onSelectCallback(selected);
 		} else if (matchesKey(keyData, "left")) {
 			this.#onLeftCallback?.();
 		} else if (matchesKey(keyData, "right")) {
@@ -452,6 +489,73 @@ export class HookSelectorComponent extends Container {
 		}
 	}
 
+	/** Keys while the inline custom-input editor is open below the option list. */
+	#handleInputModeKey(keyData: string, editor: Editor): void {
+		// Escape backs out to option selection instead of cancelling the dialog,
+		// so a stray Esc never throws away the question context.
+		if (matchesKey(keyData, "escape") || matchesAppInterrupt(keyData)) {
+			this.#exitInputMode();
+			return;
+		}
+		if (matchesAppExternalEditor(keyData)) {
+			void this.#openExternalEditor(editor);
+			return;
+		}
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return")) {
+			this.#customInput?.onSubmit(editor.getText());
+			return;
+		}
+		editor.handleInput(keyData);
+	}
+
+	#enterInputMode(): void {
+		if (this.#inlineEditor) return;
+		// Stop the auto-select countdown for good: the user is actively typing,
+		// matching the old behavior where the separate editor had no timeout.
+		if (this.#countdown) {
+			this.#countdown.dispose();
+			this.#countdown = undefined;
+			this.#titleComponent.setText(this.#baseTitle);
+		}
+		const editor = new Editor(getEditorTheme());
+		editor.setBorderVisible(false);
+		editor.setPromptGutter("> ");
+		editor.disableSubmit = true;
+		this.#inlineEditor = editor;
+		this.#inputArea.addChild(new Spacer(1));
+		this.#inputArea.addChild(editor);
+		const scrollHint = this.#scrollTitleRows === undefined ? "" : "  wheel/PgUp/PgDn scroll question";
+		this.#helpTextComponent.setText(
+			theme.fg("dim", `enter submit  esc back to options  ctrl+g external editor${scrollHint}`),
+		);
+		this.invalidate();
+	}
+
+	#exitInputMode(): void {
+		if (!this.#inlineEditor) return;
+		this.#inlineEditor = undefined;
+		this.#inputArea.clear();
+		this.#helpTextComponent.setText(theme.fg("dim", this.#baseHelpText));
+		this.invalidate();
+	}
+
+	async #openExternalEditor(editor: Editor): Promise<void> {
+		const editorCmd = getEditorCommand();
+		if (!editorCmd || !this.#tui) return;
+
+		const currentText = editor.getExpandedText();
+		try {
+			this.#tui.stop();
+			const result = await openInEditor(editorCmd, currentText);
+			if (result !== null) {
+				editor.setText(result);
+			}
+		} finally {
+			this.#tui.start();
+			this.#tui.requestRender(true);
+		}
+	}
+
 	dispose(): void {
 		this.#countdown?.dispose();
 	}

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

@@ -29,6 +29,7 @@ const HOOK_SELECTOR_MOUSE_REPORTING_ENABLE = "\x1b[?1006h\x1b[?1000h";
 const HOOK_SELECTOR_MOUSE_REPORTING_DISABLE = "\x1b[?1000l\x1b[?1006l";
 const HOOK_SELECTOR_CHROME_ROWS = 7;
 const HOOK_SELECTOR_OUTLINE_ROWS = 2;
+const HOOK_SELECTOR_INLINE_INPUT_ROWS = 2;
 
 export class ExtensionUiController {
 	#extensionTerminalInputUnsubscribers = new Set<() => void>();
@@ -601,8 +602,11 @@ export class ExtensionUiController {
 		const maxVisible =
 			requestedTitleRows === undefined ? baseMaxVisible : Math.min(15, Math.max(3, scrollOptionRows + 1));
 		const listChromeRows = dialogOptions?.outline === true ? HOOK_SELECTOR_OUTLINE_ROWS : 0;
+		// Reserve rows for the inline custom-input editor so opening it doesn't
+		// push the scrollable title past the viewport into terminal scrollback.
+		const inlineInputRows = dialogOptions?.customInput ? HOOK_SELECTOR_INLINE_INPUT_ROWS : 0;
 		const availableTitleRows =
-			this.ctx.ui.terminal.rows - scrollOptionRows - listChromeRows - HOOK_SELECTOR_CHROME_ROWS;
+			this.ctx.ui.terminal.rows - scrollOptionRows - listChromeRows - inlineInputRows - HOOK_SELECTOR_CHROME_ROWS;
 		const scrollTitleRows =
 			requestedTitleRows === undefined ? undefined : Math.max(1, Math.min(requestedTitleRows, availableTitleRows));
 		if (scrollTitleRows !== undefined) {
@@ -645,6 +649,17 @@ export class ExtensionUiController {
 				wrapFocused: dialogOptions?.wrapFocused,
 				scrollTitleRows,
 				maxVisible,
+				customInput: dialogOptions?.customInput
+					? {
+							optionLabel: dialogOptions.customInput.optionLabel,
+							onSubmit: text => {
+								const optionLabel = dialogOptions.customInput?.optionLabel;
+								this.hideHookSelector();
+								dialogOptions.customInput?.onSubmit(text);
+								finish(optionLabel);
+							},
+						}
+					: undefined,
 			},
 		);
 		this.ctx.editorContainer.clear();

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

@@ -64,6 +64,11 @@ export class InputController {
 					this.ctx.autoCompactionEscapeHandler ||
 					this.ctx.retryEscapeHandler,
 			);
+		// An open btw panel must stay dismissable with Esc even while another
+		// controller (auto-compaction, auto-retry, manual compaction, etc.) has
+		// temporarily replaced editor.onEscape. This priority hook is never
+		// swapped out, so it always wins for the interrupt key.
+		this.ctx.editor.onInterruptPriority = () => (this.ctx.hasActiveBtw() ? this.ctx.handleBtwEscape() : false);
 		this.ctx.editor.onEscape = () => {
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
@@ -289,11 +294,12 @@ export class InputController {
 				text = slashResult;
 			}
 
-			// Handle skill commands (/skill:name [args]). Enter ⇒ steer (matches the
-			// free-text Enter semantics applied a few lines below at the streaming
-			// branch). Ctrl+Enter routes through `handleFollowUp` and dispatches the
-			// same helper with `"followUp"`.
-			if (await this.#invokeSkillCommand(text, "steer")) {
+			// Handle skill commands (/skill:name [args]). While streaming, Enter
+			// honors `busyPromptMode`: "steer" interrupts the active turn, "queue"
+			// runs after it completes (matches the free-text Enter semantics applied
+			// a few lines below at the streaming branch). Ctrl+Enter always routes
+			// through `handleFollowUp` and dispatches the same helper with `"followUp"`.
+			if (await this.#invokeSkillCommand(text, this.#busyStreamingBehavior())) {
 				return;
 			}
 
@@ -344,7 +350,9 @@ export class InputController {
 				return;
 			}
 
-			// If streaming, use prompt() with steer behavior
+			// If streaming, use prompt() with the busy-prompt behavior the user
+			// selected: "steer" interrupts the active turn, "queue" defers the
+			// prompt to run after the active turn completes (in submission order).
 			// This handles extension commands (execute immediately), prompt template expansion, and queueing
 			if (this.ctx.session.isStreaming) {
 				this.ctx.editor.addToHistory(text);
@@ -355,9 +363,10 @@ export class InputController {
 				// (a user-role `message_start` event) leaves any draft the user has
 				// typed since queuing intact. Same protection as #783, applied to
 				// the streaming/queue path.
+				const streamingBehavior = this.#busyStreamingBehavior();
 				await this.ctx.withLocalSubmission(
 					text,
-					() => this.ctx.session.prompt(text, { streamingBehavior: "steer", images }),
+					() => this.ctx.session.prompt(text, { streamingBehavior, images }),
 					{ imageCount: images?.length ?? 0 },
 				);
 				this.ctx.updatePendingMessagesDisplay();
@@ -450,6 +459,17 @@ export class InputController {
 		}
 	}
 
+	/**
+	 * Resolve how a prompt submitted while the agent is busy should be delivered.
+	 * Driven by the `busyPromptMode` setting and kept distinct from the
+	 * follow-up keybinding: "steer" interrupts the active turn, "queue" defers
+	 * the prompt to the follow-up queue so it runs after the active turn
+	 * completes (in submission order). Only consulted while streaming.
+	 */
+	#busyStreamingBehavior(): "steer" | "followUp" {
+		return this.ctx.settings.get("busyPromptMode") === "queue" ? "followUp" : "steer";
+	}
+
 	/**
 	 * Dispatch skill slash invocation(s) (`/skill:<name>`) through custom messages
 	 * using the supplied `streamingBehavior`. Returns true if the text was a

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

@@ -506,7 +506,13 @@ export class SelectorController {
 				}
 				break;
 			case "providers.image":
-				if (value === "auto" || value === "openai" || value === "gemini" || value === "openrouter") {
+				if (
+					value === "auto" ||
+					value === "openai" ||
+					value === "gemini" ||
+					value === "openrouter" ||
+					value === "antigravity"
+				) {
 					setPreferredImageProvider(value);
 				}
 				break;

package/src/modes/interactive-mode.ts

@@ -1156,7 +1156,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#updateGoalModeStatus();
 			return;
 		}
-		const pendingGoal = goalEnabled ? await consumePendingGoalModeRequest(this.sessionManager.getCwd()) : null;
+		const pendingGoal = goalEnabled
+			? await consumePendingGoalModeRequest(this.sessionManager.getCwd(), this.sessionManager.getSessionId())
+			: null;
 		if (pendingGoal) {
 			await this.#enterGoalMode({ objective: pendingGoal.objective, silent: true });
 			this.#scheduleGoalContinuation();

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

@@ -150,6 +150,18 @@ function isRpcWorkflowGate(value: unknown): value is RpcWorkflowGate {
 	);
 }
 
+/**
+ * Unwrap a canonical agent-wire `event` frame `{ type:"event", payload:{ event_type, event } }`
+ * to its inner `AgentSessionEvent`. Returns null for any frame that is not a
+ * canonical event frame (session events are only delivered wrapped).
+ */
+function unwrapAgentWireEventFrame(value: unknown): unknown {
+	if (isRecord(value) && value.type === "event" && isRecord(value.payload)) {
+		return value.payload.event;
+	}
+	return null;
+}
+
 function normalizeToolResult<TDetails>(result: RpcClientToolResult<TDetails>): AgentToolResult<TDetails> {
 	if (typeof result === "string") {
 		return {
@@ -763,11 +775,12 @@ export class RpcClient {
 			return;
 		}
 
-		if (!isAgentEvent(data)) return;
+		// Canonical agent-wire event frame: { type:"event", payload:{ event_type, event } }.
+		const event = unwrapAgentWireEventFrame(data);
+		if (!isAgentEvent(event)) return;
 
-		// Otherwise it's an event
 		for (const listener of this.#eventListeners) {
-			listener(data);
+			listener(event);
 		}
 	}
 

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 { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
+import { AgentWireFrameSequencer, toAgentWireEventFrame } from "../shared/agent-wire/event-envelope";
 import { rpcError as error } from "../shared/agent-wire/responses";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
 import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
@@ -471,9 +472,11 @@ export async function runRpcMode(
 		uiContext: rpcUiContext,
 	});
 
-	// Output all agent events as JSON
+	// Output all agent events as canonical agent-wire `event` frames (docs/rpc.md):
+	// { type:"event", protocol_version, session_id, seq, frame_id, payload:{ event_type, event } }.
+	const eventSequencer = new AgentWireFrameSequencer(session.sessionId);
 	session.subscribe(event => {
-		output(event);
+		output(toAgentWireEventFrame(event, eventSequencer));
 	});
 
 	// Handle a single command through the shared agent-wire dispatcher so RPC

package/src/modes/shared/agent-wire/command-contract.ts

@@ -0,0 +1,18 @@
+/**
+ * Canonical command-surface boundary for the agent-wire adapters.
+ *
+ * RPC and Bridge SHARE the JSONL `RpcCommand` grammar and dispatch it through
+ * the single `dispatchRpcCommand` entry in `command-dispatch.ts`. This module
+ * re-exports that command surface so the shared contract has one documented home.
+ *
+ * ACP does NOT use `RpcCommand`. It keeps its richer `@agentclientprotocol/sdk`
+ * command surface (fork/resume/elicitation/session-mode/session-model) and only
+ * shares the lower session/event layer (`AgentWireEventPayload`). ACP must never
+ * import `dispatchRpcCommand`.
+ *
+ * Event semantics are intentionally elsewhere: `event-contract.ts` owns the event
+ * types + registry and `event-observation.ts` owns the single semantic mapping.
+ */
+export type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
+export { dispatchRpcCommand, type RpcCommandDispatchContext } from "./command-dispatch";
+export { isRpcCommandType, RPC_COMMAND_TYPES, type RpcCommandType } from "./scopes";