@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/src/modes/interactive-mode.ts

@@ -118,12 +118,14 @@ import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInpu
 import { UiHelpers } from "./utils/ui-helpers";
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
-const DEFAULT_COMPOSER_PLACEHOLDER = "Type your message...";
+const COMPOSER_NEWLINE_HINT = process.platform === "win32" ? "Alt+Enter/Ctrl+J" : "Shift+Enter/Ctrl+J";
+export const DEFAULT_COMPOSER_PLACEHOLDER = `Type your message... ${COMPOSER_NEWLINE_HINT}: New line · Ctrl+C: Clear · Ctrl+R: Search history · Shift+Tab: Reasoning`;
+const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
 const FRIENDLY_KEY_PARTS: Record<string, string> = {
 	alt: "Alt",
-	cmd: "Command",
-	command: "Command",
-	ctrl: "Control",
+	cmd: "Cmd",
+	command: "Cmd",
+	ctrl: "Ctrl",
 	enter: "Enter",
 	meta: process.platform === "darwin" ? "Command" : "Meta",
 	option: "Option",
@@ -133,7 +135,7 @@ const FRIENDLY_KEY_PARTS: Record<string, string> = {
 function formatShortcutForPlaceholder(key: string): string {
 	return key
 		.split("+")
-		.map(part => FRIENDLY_KEY_PARTS[part.toLowerCase()] ?? part)
+		.map(part => FRIENDLY_KEY_PARTS[part.toLowerCase()] ?? (part.length === 1 ? part.toUpperCase() : part))
 		.join("+");
 }
 
@@ -162,6 +164,7 @@ function configureDefaultComposerChrome(editor: CustomEditor): void {
 	editor.setInputPrefix(getDefaultInputPrefix());
 	editor.setPlaceholder(DEFAULT_COMPOSER_PLACEHOLDER);
 	editor.setPaddingX(1);
+	editor.setRightGutterWidth(1);
 	editor.setTopBorder(undefined);
 }
 
@@ -328,6 +331,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined = undefined;
 	locallySubmittedUserSignatures: Set<string> = new Set();
+	optimisticInjectedSignatures: Map<string, number> = new Map();
 	#pendingSubmittedInput: SubmittedUserInput | undefined;
 	#pendingSubmissionDispose: (() => void) | undefined;
 	lastSigintTime = 0;
@@ -444,7 +448,6 @@ export class InteractiveMode implements InteractiveModeContext {
 			logger.warn("History storage unavailable", { error: String(error) });
 		}
 		this.hookWidgetContainerAbove = new Container();
-		this.hookWidgetContainerAbove.addChild(new Spacer(1));
 		this.hookWidgetContainerBelow = new Container();
 		this.editorContainer = new Container();
 		this.editorContainer.addChild(this.editor);
@@ -532,13 +535,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 
 		if (!startupQuiet) {
-			const getWelcomeReservedBottomRows = (width: number): number =>
-				[
-					this.statusLine,
-					this.hookWidgetContainerAbove,
-					this.editorContainer,
-					this.hookWidgetContainerBelow,
-				].reduce((rows, component) => rows + component.render(width).length, 0);
+			const getWelcomeReservedBottomRows = (width: number): number => this.#getWelcomeReservedRows(width);
 
 			// Add welcome header
 			this.#welcomeComponent = new WelcomeComponent(
@@ -941,11 +938,37 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	#getComposerPlaceholder(): string {
 		if (!this.#isPromptDeliveryBusy()) return DEFAULT_COMPOSER_PLACEHOLDER;
-		const enterAction = this.settings.get("busyPromptMode") === "steer" ? "Steering" : "Message Queueing";
+		const enterAction = this.settings.get("busyPromptMode") === "steer" ? "Steer" : "Queue";
 		const parts = [`Enter: ${enterAction}`];
 		const queueKey = this.#getMessageQueueShortcut();
-		if (queueKey) parts.push(`${formatShortcutForPlaceholder(queueKey)}: Message Queueing`);
-		return `${DEFAULT_COMPOSER_PLACEHOLDER} ${parts.join(" · ")}`;
+		if (queueKey) parts.push(`${formatShortcutForPlaceholder(queueKey)}: Queue`);
+		return `${DEFAULT_COMPOSER_PLACEHOLDER} · ${parts.join(" · ")}`;
+	}
+
+	#getWelcomeReservedRows(width: number): number {
+		const transientRows = [
+			this.chatContainer,
+			this.pendingMessagesContainer,
+			this.statusContainer,
+			this.todoContainer,
+			this.btwContainer,
+		].reduce((rows, container) => rows + this.#renderShortContainerRowsForWelcomeReservation(width, container), 0);
+
+		const pinnedRows = [
+			this.statusLine,
+			this.hookWidgetContainerAbove,
+			this.editorContainer,
+			this.hookWidgetContainerBelow,
+		].reduce((rows, component) => rows + component.render(width).length, 0);
+
+		return transientRows + pinnedRows;
+	}
+
+	#renderShortContainerRowsForWelcomeReservation(width: number, container: Container): number {
+		if (container.children.length === 0 || container.children.length > WELCOME_RESERVED_CONTAINER_CHILD_LIMIT) {
+			return 0;
+		}
+		return container.render(width).length;
 	}
 
 	updateEditorChrome(): void {
@@ -1352,6 +1375,12 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 
+		// Leaving plan mode invalidates the plan-mode steering and standing
+		// resolve handler that the in-flight turn may still be acting on. Abort
+		// before clearing that state so the model cannot continue from stale
+		// plan-mode context and retry `resolve` against a retired handler.
+		await this.session.abort({ timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS });
+
 		const previousTools = this.#planModePreviousTools;
 		if (previousTools && previousTools.length > 0) {
 			await this.session.setActiveToolsByName(previousTools);
@@ -1689,6 +1718,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			planContent,
 			finalPlanFilePath: options.finalPlanFilePath,
 			contextPreserved: options.preserveContext === true,
+			tools: this.session.getActiveToolNames(),
 		});
 		await this.session.prompt(planModePrompt, { synthetic: true });
 	}
@@ -2180,6 +2210,7 @@ export class InteractiveMode implements InteractiveModeContext {
 				message => renderWorkingMessage(message, this.#getWorkingMessageAccent()),
 				this.#defaultWorkingMessage,
 				getSymbolTheme().spinnerFrames,
+				{ timeDependentColor: true },
 			);
 			this.statusContainer.addChild(this.loadingAnimation);
 		}
@@ -2337,6 +2368,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleClearCommand();
 	}
 
+	handleContextClearCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
+		return this.#commandController.handleContextClearCommand();
+	}
+
 	handleDropCommand(): Promise<void> {
 		this.#prepareSessionSwitch();
 		return this.#commandController.handleDropCommand();
@@ -2526,6 +2562,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showModelSelector(options);
 	}
 
+	showEffortSelector(): void {
+		this.#selectorController.showEffortSelector();
+	}
+
 	showProviderOnboarding(): void {
 		this.#selectorController.showProviderOnboarding();
 	}

package/src/modes/print-mode.ts

@@ -5,7 +5,7 @@
  * - `skc -p "prompt"` - text output
  * - `skc --mode json "prompt"` - JSON event stream
  */
-import type { AssistantMessage, ImageContent } from "@sayknow-cli/ai";
+import { type AssistantMessage, type ImageContent, isContextOverflow } from "@sayknow-cli/ai";
 import { logger, sanitizeText } from "@sayknow-cli/utils";
 import type { AgentSession } from "../session/agent-session";
 import { isSilentAbort } from "../session/messages";
@@ -31,6 +31,33 @@ export interface PrintModeOptions {
 	suppressProcessExit?: boolean;
 }
 
+/**
+ * Exit code used when a non-interactive **text-mode** run (`skc -p`) terminates
+ * because the model context window is exhausted and automatic compaction could
+ * not bring the request under the limit. Distinct from the generic failure code
+ * (1) so text-mode callers can detect context exhaustion specifically instead of
+ * parsing the raw provider error string.
+ *
+ * Scope: text-mode final-response path only. JSON mode (`--mode json`) streams
+ * events from the subscription and does not run this terminal-error branch, so
+ * it is intentionally NOT covered by this exit code.
+ */
+export const CONTEXT_OVERFLOW_EXIT_CODE = 2;
+
+/**
+ * Build an actionable stderr diagnostic for a terminal context-overflow error in
+ * text mode. The raw provider message is preserved (appended) for debugging, but
+ * the leading guidance explains what happened and what the operator can do —
+ * tailored to whether auto-compaction was even enabled.
+ */
+function formatContextOverflowError(message: AssistantMessage, autoCompactionEnabled: boolean): string {
+	const providerDetail = message.errorMessage ? ` (provider error: ${sanitizeText(message.errorMessage)})` : "";
+	const guidance = autoCompactionEnabled
+		? "Context window exhausted: automatic compaction ran but could not reduce the request below the model's context limit. Reduce the input size (smaller file reads / tool output), raise the compaction threshold, or switch to a larger-context model."
+		: "Context window exhausted and automatic compaction is disabled. Enable it (compaction.enabled=true with a non-off compaction.strategy) so SKC can compact and continue, reduce the input size, or switch to a larger-context model.";
+	return `${guidance}${providerDetail}`;
+}
+
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.
@@ -88,15 +115,27 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
 				!isSilentAbort(assistantMsg.errorMessage)
 			) {
-				const errorLine = sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				// Context-overflow is an expected, recoverable-in-principle condition — not
+				// an opaque crash. Auto-compaction has already run inside session.prompt();
+				// if we still land here the request could not be made to fit. In this
+				// text-mode final-response path, surface an actionable diagnostic and a
+				// distinct exit code so text-mode (`skc -p`) callers can detect context
+				// exhaustion instead of parsing the raw provider error string. (JSON mode
+				// does not reach this branch and is intentionally out of scope.)
+				const isOverflow =
+					assistantMsg.stopReason === "error" && isContextOverflow(assistantMsg, session.model?.contextWindow);
+				const errorLine = isOverflow
+					? formatContextOverflowError(assistantMsg, session.autoCompactionEnabled)
+					: sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				const exitCode = isOverflow ? CONTEXT_OVERFLOW_EXIT_CODE : 1;
 				const flushed = process.stderr.write(`${errorLine}\n`);
 				// When the caller owns finalization (RLM autonomous), return instead of
 				// exiting so its cleanup runs; the caller surfaces a non-zero exit itself.
 				if (!options.suppressProcessExit) {
 					if (flushed) {
-						process.exit(1);
+						process.exit(exitCode);
 					} else {
-						process.stderr.once("drain", () => process.exit(1));
+						process.stderr.once("drain", () => process.exit(exitCode));
 					}
 				}
 			}

package/src/modes/prompt-action-autocomplete.ts

@@ -1,5 +1,12 @@
-import type { AutocompleteItem, AutocompleteProvider, SlashCommand } from "@sayknow-cli/tui";
-import { CombinedAutocompleteProvider, getKeybindings, getSlashCommandMatchRank } from "@sayknow-cli/tui";
+import {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	CombinedAutocompleteProvider,
+	extractSlashCommandTokenPrefix,
+	getKeybindings,
+	getSlashCommandMatchRank,
+	type SlashCommand,
+} from "@sayknow-cli/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import { formatKeyHints } from "../config/keybindings";
 import { isSettingsInitialized, settings } from "../config/settings";
@@ -147,6 +154,10 @@ function sortSlashCommandSuggestions(
 	return { ...suggestions, items };
 }
 
+function isRootPathSuggestionResult(suggestions: { items: AutocompleteItem[]; prefix: string } | null): boolean {
+	return suggestions?.prefix.startsWith("/") === true && suggestions.items.some(item => item.value.startsWith("/"));
+}
+
 function withoutSkillCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
 ): { items: AutocompleteItem[]; prefix: string } | null {
@@ -168,18 +179,9 @@ function getPromptActionPrefix(textBeforeCursor: string): string | null {
 }
 
 function getSlashTokenPrefix(textBeforeCursor: string): string | null {
-	const slashIndex = textBeforeCursor.lastIndexOf("/");
-	if (slashIndex === -1) return null;
-	const beforeSlash = textBeforeCursor.slice(0, slashIndex);
-	if (beforeSlash && !/\s$/.test(beforeSlash)) return null;
-	const token = textBeforeCursor.slice(slashIndex);
-	if (/[\s]/.test(token)) return null;
-	return token;
+	return extractSlashCommandTokenPrefix(textBeforeCursor);
 }
 
-function isLeadingSlashToken(textBeforeCursor: string, slashPrefix: string): boolean {
-	return textBeforeCursor.trimStart() === slashPrefix;
-}
 export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
@@ -226,14 +228,13 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 
 		const slashPrefix = getSlashTokenPrefix(textBeforeCursor);
 		if (slashPrefix) {
-			const isLeading = isLeadingSlashToken(textBeforeCursor, slashPrefix);
-			const baseSuggestions = isLeading
-				? withoutSkillCommandSuggestions(await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol))
-				: null;
-			const skillCommandSuggestions =
-				isLeading || slashPrefix.startsWith("/skill")
-					? this.#getSkillCommandSuggestions(textBeforeCursor, { includeEmpty: isLeading })
-					: null;
+			const baseSuggestions = withoutSkillCommandSuggestions(
+				await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol),
+			);
+			if (isRootPathSuggestionResult(baseSuggestions)) return baseSuggestions;
+			const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor, {
+				includeEmpty: false,
+			});
 			return sortSlashCommandSuggestions(
 				mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
 				this.#commands,

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

@@ -22,8 +22,13 @@ import type { AgentSession } from "../../session/agent-session";
 import { workflowGatePath } from "../../skc-runtime/session-layout";
 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 {
+	AgentWireCompactEventEncoder,
+	AgentWireFrameSequencer,
+	toAgentWireCompactEventFrame,
+	toAgentWireEventFrame,
+} from "../shared/agent-wire/event-envelope";
+import { rpcError as error, rpcSuccess } from "../shared/agent-wire/responses";
 import { registerRpcSession, unregisterRpcSession } from "../shared/agent-wire/session-registry";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
 import { modelSupportsTokenCostMetrics, UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
@@ -168,15 +173,9 @@ function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "e
 	return "info";
 }
 
-export class RpcListenRefusedError extends Error {
-	constructor(socketPath: string) {
-		super(
-			`RPC --listen refused: a live server is already listening on ${socketPath}. ` +
-				"Stop it first or choose a different --listen path.",
-		);
-		this.name = "RpcListenRefusedError";
-	}
-}
+// Thrown by prepareRpcSocketPath when the --listen path has a live owner;
+// re-exported here because main.ts catches it at the RPC launch boundary.
+export { RpcListenRefusedError } from "./rpc-socket-security";
 
 /**
  * Probe whether a unix-domain socket path has a live server accepting
@@ -297,6 +296,7 @@ export async function runRpcMode(
 		output({ type: "ready" });
 	}
 	const emitRpcTitles = shouldEmitRpcTitles();
+	const rpcCapabilities = { compactMessageUpdate: false };
 	const decodeError = (err: unknown): string => (err instanceof Error ? err.message : String(err));
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
@@ -636,8 +636,13 @@ export async function runRpcMode(
 	// 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);
+	const compactEventEncoder = new AgentWireCompactEventEncoder(eventSequencer);
 	session.subscribe(event => {
-		output(toAgentWireEventFrame(event, eventSequencer));
+		output(
+			rpcCapabilities.compactMessageUpdate
+				? toAgentWireCompactEventFrame(event, compactEventEncoder)
+				: toAgentWireEventFrame(event, eventSequencer),
+		);
 	});
 
 	// Handle a single command through the shared agent-wire dispatcher so RPC
@@ -710,6 +715,21 @@ export async function runRpcMode(
 				hostUriBridge.handleResult(parsed);
 				return;
 			}
+			if ((parsed as RpcCommand).type === "set_capabilities") {
+				// RPC has no startup handshake; clients negotiate optional event-shape capabilities
+				// with this explicit command. Defaults remain legacy/full-frame until accepted here.
+				const command = parsed as Extract<RpcCommand, { type: "set_capabilities" }>;
+				const requested = Array.isArray(command.capabilities) ? command.capabilities : [];
+				const acceptedCapabilities = requested.filter(capability => capability === "compact_message_update");
+				rpcCapabilities.compactMessageUpdate = acceptedCapabilities.includes("compact_message_update");
+				output(
+					rpcSuccess(command.id, "set_capabilities", {
+						acceptedCapabilities,
+						unsupported: requested.filter(capability => capability !== "compact_message_update"),
+					}),
+				);
+				return;
+			}
 			// Ordered commands run through a serial chain to preserve causal order; the
 			// reader never blocks, so cancellation commands stay responsive even while a
 			// long command is in flight (issue 13).

package/src/modes/rpc/rpc-socket-security.ts

@@ -9,6 +9,18 @@ export class RpcSocketSecurityError extends Error {
 	}
 }
 
+// The launch boundary in main.ts catches exactly this class to turn a
+// duplicate --listen into a clean stderr diagnostic + non-zero exit (issue 19).
+export class RpcListenRefusedError extends Error {
+	constructor(socketPath: string) {
+		super(
+			`RPC --listen refused: a live server is already listening on ${socketPath}. ` +
+				"Stop it first or choose a different --listen path.",
+		);
+		this.name = "RpcListenRefusedError";
+	}
+}
+
 const unsafeBits = 0o077;
 
 function currentUid(): number | undefined {
@@ -53,7 +65,7 @@ export async function prepareRpcSocketPath(socketPath: string): Promise<void> {
 	if (!existing.isSocket()) throw new RpcSocketSecurityError(`RPC socket path is not a socket: ${socketPath}`);
 	assertPrivateMode(existing.mode, socketPath);
 	if (await probeUnixSocketAlive(socketPath)) {
-		throw new RpcSocketSecurityError(`RPC socket path is live: ${socketPath}`);
+		throw new RpcListenRefusedError(socketPath);
 	}
 	await fs.unlink(socketPath);
 }

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

@@ -13,6 +13,7 @@ import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
 
 export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
+export type RpcCapability = "compact_message_update";
 
 // ============================================================================
 // RPC Commands (stdin)
@@ -33,6 +34,7 @@ export type RpcCommand =
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
 	| { id?: string; type: "get_pending_workflow_gates" }
+	| { id?: string; type: "set_capabilities"; capabilities: RpcCapability[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -140,6 +142,13 @@ export type RpcResponse =
 			success: true;
 			data: { gates: RpcWorkflowGate[] };
 	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "set_capabilities";
+			success: true;
+			data: { acceptedCapabilities: RpcCapability[]; unsupported: string[] };
+	  }
 
 	// Model
 	| {

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

@@ -130,6 +130,10 @@ export function isRpcCommand(value: unknown): value is RpcCommand {
 			return Array.isArray(value.tools) && value.tools.every(hostToolDefinition);
 		case "set_host_uri_schemes":
 			return Array.isArray(value.schemes) && value.schemes.every(hostUriScheme);
+		case "set_capabilities":
+			return (
+				Array.isArray(value.capabilities) && value.capabilities.every(capability => typeof capability === "string")
+			);
 		case "set_model":
 			return stringField(value, "provider") && stringField(value, "modelId");
 		case "set_thinking_level":

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

@@ -13,6 +13,8 @@
  * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
  * conformance tests can assert fixture coverage equals the registry exactly.
  */
+
+import type { AssistantMessageEvent } from "@sayknow-cli/ai";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
@@ -68,6 +70,25 @@ export interface AgentWireEventPayload {
 	event_type: AgentWireEventType;
 	event: AgentSessionEvent;
 }
+export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent
+	? TEvent extends { type: string }
+		? Omit<TEvent, "partial" | "message" | "error">
+		: never
+	: never;
+
+export interface AgentWireCompactMessageUpdatePayload {
+	event_type: "message_update";
+	/** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+	compact: true;
+	message_id: string | null;
+	content_index: number | null;
+	assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
+	/** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
+	checkpoint_message?: Extract<AgentSessionEvent, { type: "message_update" }>["message"];
+	checkpoint_reason?: "periodic";
+}
+
+export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
 
 /**
  * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
@@ -146,3 +167,4 @@ export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = Agent
 
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
 export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
+export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

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

@@ -12,6 +12,9 @@ import { randomUUID } from "node:crypto";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 import {
 	AGENT_WIRE_PROTOCOL_VERSION,
+	type AgentWireCompactAssistantMessageEvent,
+	type AgentWireCompactEventFrame,
+	type AgentWireCompactMessageUpdatePayload,
 	type AgentWireEventFrame,
 	type AgentWireEventPayload,
 	type AgentWireEventType,
@@ -19,6 +22,26 @@ import {
 	type AgentWireFrameType,
 } from "./event-contract";
 
+export const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
+
+function recordObject(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+function messageIdOf(message: unknown): string | null {
+	const id = recordObject(message)?.id;
+	return typeof id === "string" ? id : null;
+}
+
+function contentIndexOf(assistantMessageEvent: unknown): number | null {
+	const contentIndex = recordObject(assistantMessageEvent)?.contentIndex;
+	return typeof contentIndex === "number" && Number.isInteger(contentIndex) ? contentIndex : null;
+}
+
+function snapshotMessage<T>(message: T): T {
+	return structuredClone(message);
+}
+
 function assertNever(value: never): never {
 	throw new Error(`Unhandled AgentSessionEvent variant: ${JSON.stringify(value)}`);
 }
@@ -123,6 +146,65 @@ export function toAgentWireEventFrame(
 export function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload {
 	return { event_type: agentSessionEventType(event), event };
 }
+export function sanitizeAssistantMessageEventForCompact(
+	assistantMessageEvent: Extract<AgentSessionEvent, { type: "message_update" }>["assistantMessageEvent"],
+): AgentWireCompactAssistantMessageEvent {
+	const {
+		partial: _partial,
+		message: _message,
+		error: _error,
+		...deltaOnly
+	} = assistantMessageEvent as Record<string, unknown>;
+	return deltaOnly as AgentWireCompactAssistantMessageEvent;
+}
+
+export interface AgentWireCompactMessageUpdateOptions {
+	checkpointInterval?: number;
+}
+
+/**
+ * Stateful compact event serializer for opt-in RPC clients.
+ *
+ * Only `message_update` changes shape: it carries the immutable provider delta
+ * plus message/content identifiers, with periodic full-message checkpoints that
+ * are cloned synchronously before the caller returns to the event loop. All other
+ * event variants remain canonical full event frames so legacy bridge/RPC behavior
+ * and terminal `message_end` reconstruction are unchanged.
+ */
+export class AgentWireCompactEventEncoder {
+	readonly #sequencer: AgentWireFrameSequencer;
+	readonly #checkpointInterval: number;
+	#messageUpdateCount = 0;
+
+	constructor(sequencer: AgentWireFrameSequencer, options: AgentWireCompactMessageUpdateOptions = {}) {
+		this.#sequencer = sequencer;
+		this.#checkpointInterval = options.checkpointInterval ?? AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL;
+	}
+
+	frame(event: AgentSessionEvent): AgentWireCompactEventFrame {
+		if (event.type !== "message_update") return toAgentWireEventFrame(event, this.#sequencer);
+		this.#messageUpdateCount += 1;
+		const payload: AgentWireCompactMessageUpdatePayload = {
+			event_type: "message_update",
+			compact: true,
+			message_id: messageIdOf(event.message),
+			content_index: contentIndexOf(event.assistantMessageEvent),
+			assistantMessageEvent: sanitizeAssistantMessageEventForCompact(event.assistantMessageEvent),
+		};
+		if (this.#checkpointInterval > 0 && this.#messageUpdateCount % this.#checkpointInterval === 0) {
+			payload.checkpoint_message = snapshotMessage(event.message);
+			payload.checkpoint_reason = "periodic";
+		}
+		return this.#sequencer.next("event", payload);
+	}
+}
+
+export function toAgentWireCompactEventFrame(
+	event: AgentSessionEvent,
+	encoder: AgentWireCompactEventEncoder,
+): AgentWireCompactEventFrame {
+	return encoder.frame(event);
+}
 
 /** Back-compat alias for {@link toAgentWireEventFrame}. */
 export const toBridgeEventFrame = toAgentWireEventFrame;

package/src/modes/shared/agent-wire/scopes.ts

@@ -47,6 +47,7 @@ const RPC_COMMAND_SCOPE_REGISTRY: Record<RpcCommandType, BridgeCommandScope> = {
 	set_host_tools: "host_tools",
 	set_host_uri_schemes: "host_uri",
 	get_pending_workflow_gates: "message:read",
+	set_capabilities: "control",
 	set_model: "model",
 	cycle_model: "model",
 	get_available_models: "model",

package/src/modes/types.ts

@@ -116,6 +116,7 @@ export interface InteractiveModeContext {
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined;
 	locallySubmittedUserSignatures: Set<string>;
+	optimisticInjectedSignatures: Map<string, number>;
 	lastSigintTime: number;
 	lastEscapeTime: number;
 	lastComposerClearEscapeTime: number;
@@ -216,6 +217,7 @@ export interface InteractiveModeContext {
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
+	handleContextClearCommand(): Promise<void>;
 	handleDropCommand(): Promise<void>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
@@ -243,6 +245,7 @@ export interface InteractiveModeContext {
 	showExtensionsDashboard(): void;
 	showAgentsDashboard(): void;
 	showModelSelector(options?: { temporaryOnly?: boolean }): void;
+	showEffortSelector(): void;
 	showProviderOnboarding(): void;
 	showPluginSelector(mode?: "install" | "uninstall"): void;
 	showUserMessageSelector(): void;

package/src/modes/utils/hotkeys-markdown.ts

@@ -23,6 +23,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"|-----|--------|",
 		"| `Enter` | Send / queue while busy |",
 		`| \`${appKey(bindings, "app.message.queue")}\` | Queue message for next turn |`,
+		`| \`${appKey(bindings, "app.message.dequeue")}\` | Select queued message to edit |`,
 		"| `Shift+Enter` / `Ctrl+J` | New line |",
 		"| `Ctrl+W` / `Option+Backspace` | Delete word backwards |",
 		"| `Ctrl+U` | Delete to start of line |",