@gajae-code/coding-agent 0.4.2 → 0.4.3

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/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";

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

@@ -0,0 +1,147 @@
+/**
+ * Canonical agent-wire contract: the single transport-neutral source of truth
+ * for AgentSession events and bounded owner observations.
+ *
+ * Two distinct consumer-facing shapes, deliberately NOT collapsed into one:
+ * - `AgentWireEventPayload`: rich, full `AgentSessionEvent` for renderers
+ *   (ACP SDK notifications, RPC/Bridge event frames).
+ * - `AgentWireOwnerObservation`: bounded/redacted owner evidence for control
+ *   planes (Harness). Never carries assistant text, message deltas, raw tool
+ *   args, raw command output, raw tool results, answers, or oversize strings.
+ *
+ * The exhaustive `AGENT_SESSION_EVENT_TYPE_REGISTRY` lives here so that adding
+ * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
+ * conformance tests can assert fixture coverage equals the registry exactly.
+ */
+import type { AgentSessionEvent } from "../../../session/agent-session";
+
+/** Wire protocol version. Bump on breaking envelope/semantic changes. */
+export const AGENT_WIRE_PROTOCOL_VERSION = 2 as const;
+export type AgentWireProtocolVersion = typeof AGENT_WIRE_PROTOCOL_VERSION;
+
+/** The discriminant of every `AgentSessionEvent` the agent can emit. */
+export type AgentWireEventType = AgentSessionEvent["type"];
+
+/**
+ * Compile-time exhaustive registry of every `AgentSessionEvent` variant. The
+ * `Record<AgentWireEventType, true>` shape forces every member to be present:
+ * a new union variant is a type error until added here, and a removed variant
+ * is a type error until deleted.
+ */
+const AGENT_SESSION_EVENT_TYPE_REGISTRY: Record<AgentWireEventType, true> = {
+	agent_start: true,
+	agent_end: true,
+	turn_start: true,
+	turn_end: true,
+	message_start: true,
+	message_update: true,
+	message_end: true,
+	tool_execution_start: true,
+	tool_execution_update: true,
+	tool_execution_end: true,
+	auto_compaction_start: true,
+	auto_compaction_end: true,
+	auto_retry_start: true,
+	auto_retry_end: true,
+	retry_fallback_applied: true,
+	retry_fallback_succeeded: true,
+	ttsr_triggered: true,
+	todo_reminder: true,
+	todo_auto_clear: true,
+	irc_message: true,
+	notice: true,
+	thinking_level_changed: true,
+	goal_updated: true,
+};
+
+/** Every agent-session event type, derived from the exhaustive registry. */
+export const AGENT_WIRE_EVENT_TYPES: readonly AgentWireEventType[] = Object.keys(
+	AGENT_SESSION_EVENT_TYPE_REGISTRY,
+) as AgentWireEventType[];
+
+/**
+ * Rich event payload. Carries the full `AgentSessionEvent` so renderers (ACP,
+ * RPC, Bridge) can present message content, tool args/results, todo state, etc.
+ */
+export interface AgentWireEventPayload {
+	event_type: AgentWireEventType;
+	event: AgentSessionEvent;
+}
+
+/**
+ * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
+ * the Harness `ObservedSignal` set; the Harness type aliases this in a later
+ * step so there is a single source of truth.
+ */
+export type AgentWireObservedSignal =
+	| "SessionStart"
+	| "prompt-accepted"
+	| "tool-call"
+	| "test-running"
+	| "commit-created"
+	| "completed"
+	| "error"
+	| "streaming"
+	| "idle";
+
+export type AgentWireSeverity = "info" | "warn" | "critical";
+
+/**
+ * Bounded, redacted owner observation. Evidence may include ids, names,
+ * categories, statuses, cursors, timestamps, short codes, and bounded short
+ * messages ONLY. It must never carry assistant text, message deltas, raw tool
+ * args, raw command output, raw tool result content, answers, or oversize
+ * strings.
+ */
+export interface AgentWireOwnerObservation {
+	/** Set when this observation derives from an `AgentSessionEvent`. */
+	eventType?: AgentWireEventType;
+	/** Set when this observation derives from a non-event wire frame. */
+	frameType?: string;
+	/** Owner event kind (e.g. `rpc_tool_started`). */
+	kind: string;
+	/** Bounded observed signal, or null when the frame carries no signal. */
+	signal: AgentWireObservedSignal | null;
+	/** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
+	evidence: Record<string, unknown>;
+	/** Severity for the emitted event. */
+	severity: AgentWireSeverity;
+	/** Never-drop observations: must be enqueued in order, never coalesced away. */
+	semantic: boolean;
+	/** Coalescing key for high-frequency non-semantic frames; null otherwise. */
+	coalesceKey: string | null;
+}
+
+/** Top-level frame categories carried over any agent-wire transport. */
+export type AgentWireFrameType =
+	| "ready"
+	| "event"
+	| "response"
+	| "ui_request"
+	| "permission_request"
+	| "host_tool_call"
+	| "host_uri_request"
+	| "reset"
+	| "workflow_gate"
+	| "error";
+
+/**
+ * Universal frame envelope. Every frame on every transport carries these
+ * fields so clients can order (`seq`), resume (`seq` cursor), and correlate
+ * request/response pairs (`correlation_id`).
+ */
+export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = AgentWireFrameType, TPayload = unknown> {
+	protocol_version: AgentWireProtocolVersion;
+	session_id: string;
+	/** Monotonic per-session sequence number, starting at 1. */
+	seq: number;
+	/** Unique id for this frame. */
+	frame_id: string;
+	/** Ties a request frame to its response frame, when applicable. */
+	correlation_id?: string;
+	type: TType;
+	payload: TPayload;
+}
+
+/** An `AgentSessionEvent` serialized into a versioned wire frame. */
+export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;

package/src/modes/shared/agent-wire/event-envelope.ts

@@ -1,19 +1,23 @@
 /**
- * Serialize `AgentSessionEvent`s into versioned bridge wire frames.
+ * Serialize `AgentSessionEvent`s into versioned agent-wire frames.
  *
  * The mapping is intentionally exhaustive: `agentSessionEventType` switches over
  * every variant of the event union and calls `assertNever` in the default arm,
  * so a newly added event variant fails to compile until it is handled here.
+ *
+ * The canonical sequencer + frame builders live here; the historical `Bridge*`
+ * names are retained as thin aliases for callers that have not yet migrated.
  */
 import { randomUUID } from "node:crypto";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 import {
-	type AgentSessionEventType,
-	BRIDGE_PROTOCOL_VERSION,
-	type BridgeEventFrame,
-	type BridgeFrameEnvelope,
-	type BridgeFrameType,
-} from "./protocol";
+	AGENT_WIRE_PROTOCOL_VERSION,
+	type AgentWireEventFrame,
+	type AgentWireEventPayload,
+	type AgentWireEventType,
+	type AgentWireFrameEnvelope,
+	type AgentWireFrameType,
+} from "./event-contract";
 
 function assertNever(value: never): never {
 	throw new Error(`Unhandled AgentSessionEvent variant: ${JSON.stringify(value)}`);
@@ -24,7 +28,7 @@ function assertNever(value: never): never {
  *
  * Exhaustive over the union; adding a variant without a case is a type error.
  */
-export function agentSessionEventType(event: AgentSessionEvent): AgentSessionEventType {
+export function agentSessionEventType(event: AgentSessionEvent): AgentWireEventType {
 	switch (event.type) {
 		case "agent_start":
 		case "agent_end":
@@ -59,7 +63,7 @@ export function agentSessionEventType(event: AgentSessionEvent): AgentSessionEve
  * Per-session monotonic frame builder. One instance per active session; `seq`
  * starts at 1 and increments per frame so clients can order and resume.
  */
-export class BridgeFrameSequencer {
+export class AgentWireFrameSequencer {
 	readonly #sessionId: string;
 	#seq = 0;
 
@@ -78,14 +82,14 @@ export class BridgeFrameSequencer {
 	}
 
 	/** Build the next envelope of the given type with a fresh seq + frame id. */
-	next<TType extends BridgeFrameType, TPayload>(
+	next<TType extends AgentWireFrameType, TPayload>(
 		type: TType,
 		payload: TPayload,
 		correlationId?: string,
-	): BridgeFrameEnvelope<TType, TPayload> {
+	): AgentWireFrameEnvelope<TType, TPayload> {
 		this.#seq += 1;
-		const frame: BridgeFrameEnvelope<TType, TPayload> = {
-			protocol_version: BRIDGE_PROTOCOL_VERSION,
+		const frame: AgentWireFrameEnvelope<TType, TPayload> = {
+			protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
 			session_id: this.#sessionId,
 			seq: this.#seq,
 			frame_id: randomUUID(),
@@ -99,14 +103,29 @@ export class BridgeFrameSequencer {
 	}
 }
 
-/** Serialize a single `AgentSessionEvent` into an `event` wire frame. */
-export function toBridgeEventFrame(event: AgentSessionEvent, sequencer: BridgeFrameSequencer): BridgeEventFrame {
+/** Back-compat alias for {@link AgentWireFrameSequencer}. */
+export const BridgeFrameSequencer = AgentWireFrameSequencer;
+export type BridgeFrameSequencer = AgentWireFrameSequencer;
+
+/** Serialize a single `AgentSessionEvent` into a canonical `event` wire frame. */
+export function toAgentWireEventFrame(
+	event: AgentSessionEvent,
+	sequencer: AgentWireFrameSequencer,
+): AgentWireEventFrame {
 	return sequencer.next("event", {
 		event_type: agentSessionEventType(event),
 		event,
 	});
 }
 
+/** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
+export function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload {
+	return { event_type: agentSessionEventType(event), event };
+}
+
+/** Back-compat alias for {@link toAgentWireEventFrame}. */
+export const toBridgeEventFrame = toAgentWireEventFrame;
+
 /**
  * Serialize a `workflow_gate` event into a sequenced wire frame (#321). The
  * gate_id is stamped as the correlation id so the answer (posted to the
@@ -115,7 +134,7 @@ export function toBridgeEventFrame(event: AgentSessionEvent, sequencer: BridgeFr
  */
 export function toBridgeWorkflowGateFrame(
 	gate: import("../../rpc/rpc-types").RpcWorkflowGate,
-	sequencer: BridgeFrameSequencer,
+	sequencer: AgentWireFrameSequencer,
 ): import("./protocol").BridgeWorkflowGateFrame {
 	return sequencer.next("workflow_gate", gate, gate.gate_id);
 }