@sayknow-cli/coding-agent 0.3.6 → 0.3.8

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";
@@ -29,6 +36,8 @@ interface PromptActionAutocompleteOptions {
 	copyCurrentLine: () => void;
 	copyPrompt: () => void;
 	pasteImage: () => void;
+	newSession: () => void;
+	showHelp: () => void;
 	scrollTmuxToPreviousUserInput: () => void;
 	undo: (prefix: string) => void;
 	moveCursorToMessageEnd: () => void;
@@ -101,6 +110,12 @@ function mergeAutocompleteSuggestions(
 
 	return { items, prefix: primary.prefix };
 }
+const ADVANCED_SLASH_COMMAND_PRIORITIES = new Map<string, number>([["grok-build-usage", -100]]);
+
+function getSlashCommandPriority(command: SlashCommand | undefined, item: AutocompleteItem): number {
+	if (command?.priority !== undefined) return command.priority;
+	return ADVANCED_SLASH_COMMAND_PRIORITIES.get(item.value) ?? 0;
+}
 
 function sortSlashCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
@@ -123,7 +138,7 @@ function sortSlashCommandSuggestions(
 				index,
 				commandIndex,
 				matchRank: getSlashCommandMatchRank(query, lowerName),
-				priority: command?.priority ?? 0,
+				priority: getSlashCommandPriority(command, item),
 				score: Math.max(nameScore, descScore),
 			};
 		})
@@ -139,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 {
@@ -160,13 +179,7 @@ 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);
 }
 
 export class PromptActionAutocompleteProvider implements AutocompleteProvider {
@@ -218,7 +231,10 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			const baseSuggestions = withoutSkillCommandSuggestions(
 				await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol),
 			);
-			const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor);
+			if (isRootPathSuggestionResult(baseSuggestions)) return baseSuggestions;
+			const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor, {
+				includeEmpty: false,
+			});
 			return sortSlashCommandSuggestions(
 				mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
 				this.#commands,
@@ -292,7 +308,7 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		const baseSuggestions = withoutSkillCommandSuggestions(
 			this.#baseProvider.trySyncSlashCompletion?.(textBeforeCursor) ?? null,
 		);
-		const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor);
+		const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor, { includeEmpty: false });
 		return sortSlashCommandSuggestions(
 			mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
 			this.#commands,
@@ -303,11 +319,14 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		return tryEmojiInlineReplace(textBeforeCursor);
 	}
 
-	#getSkillCommandSuggestions(textBeforeCursor: string): { items: AutocompleteItem[]; prefix: string } | null {
+	#getSkillCommandSuggestions(
+		textBeforeCursor: string,
+		options: { includeEmpty: boolean },
+	): { items: AutocompleteItem[]; prefix: string } | null {
 		const prefix = getSlashTokenPrefix(textBeforeCursor);
 		if (!prefix) return null;
 		const query = prefix.slice(1).toLowerCase();
-		if (query.length === 0) return null;
+		if (query.length === 0 && !options.includeEmpty) return null;
 		const normalizedQuery = query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query;
 		const exactNonSkillCommand = this.#commands.some(
 			command => command.name === query && !command.name.startsWith("skill:"),
@@ -358,6 +377,20 @@ export function createPromptActionAutocompleteProvider(
 ): PromptActionAutocompleteProvider {
 	const editorKeybindings = getKeybindings();
 	const actions: PromptActionDefinition[] = [
+		{
+			id: "new-session",
+			label: "Start new session",
+			description: formatKeyHints(options.keybindings.getKeys("app.session.new")) || "/new",
+			keywords: ["new", "session", "fresh", "clear", "start", "conversation"],
+			execute: options.newSession,
+		},
+		{
+			id: "help",
+			label: "Open command help",
+			description: "/help",
+			keywords: ["help", "commands", "command", "palette", "shortcuts", "beginner"],
+			execute: options.showHelp,
+		},
 		{
 			id: "copy-line",
 			label: "Copy current line",

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";
@@ -297,6 +302,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 +642,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 +721,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-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
 	| {
@@ -435,6 +444,7 @@ export interface RpcJsonSchema {
 	items?: RpcJsonSchema;
 	minLength?: number;
 	maxLength?: number;
+	pattern?: string;
 	minItems?: number;
 	maxItems?: number;
 	uniqueItems?: boolean;

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/deep-interview-gate.ts

@@ -11,7 +11,7 @@
  * the interactive select/editor UI) when an unattended controller + gate broker
  * are attached is wired with the transport in #321 and exercised by #323.
  */
-import type { RpcJsonSchema } from "../../rpc/rpc-types";
+import type { RpcJsonSchema, RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
 import type { OpenGateInput } from "./workflow-gate-broker";
 
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
@@ -26,6 +26,11 @@ export interface AskGateDeepInterviewState {
 	ambiguity: number;
 }
 
+export interface AskGateWorkflowGateMeta {
+	stage: RpcWorkflowStage;
+	kind: RpcWorkflowGateKind;
+}
+
 export interface AskGateQuestion {
 	id: string;
 	question: string;
@@ -37,6 +42,8 @@ export interface AskGateQuestion {
 	 * `stage_state`; when absent, the question text is regex-parsed as a fallback.
 	 */
 	deepInterview?: AskGateDeepInterviewState;
+	/** Override the emitted workflow gate address for non-deep-interview ask prompts. */
+	workflowGate?: AskGateWorkflowGateMeta;
 }
 
 export interface AskGateResult {
@@ -46,6 +53,7 @@ export interface AskGateResult {
 	multi: boolean;
 	selectedOptions: string[];
 	customInput?: string;
+	clarificationQuestion?: string;
 }
 
 /**
@@ -54,12 +62,15 @@ export interface AskGateResult {
  * `selected` are picked option labels; free text is conveyed by `other: true`
  * plus `custom`, encoded separately from `selected` so a real option whose label
  * happens to equal the display sentinel can never collide with the free-text path.
+ *
+ * `action: "clarify"` is a non-answer. It lets a Deep Interview user ask about
+ * the presented choices without advancing the round, scoring ambiguity, or
+ * recording selection state.
  */
-export interface DeepInterviewGateAnswer {
-	selected: string[];
-	other?: boolean;
-	custom?: string;
-}
+export type DeepInterviewGateAnswer =
+	| { selected: string[]; other?: false; custom?: undefined; action?: "answer" }
+	| { selected: string[]; other: true; custom: string; action?: "answer" }
+	| { action: "clarify"; question: string };
 
 export class DeepInterviewGateError extends Error {
 	constructor(
@@ -68,6 +79,7 @@ export class DeepInterviewGateError extends Error {
 			| "unknown_option"
 			| "multi_not_allowed"
 			| "missing_custom"
+			| "missing_clarification"
 			| "empty_selection"
 			| "duplicate_selection",
 		message: string,
@@ -119,14 +131,29 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 		properties: {
 			selected: selectedBase,
 			other: { type: "boolean", description: "set true to provide a free-text answer in `custom`" },
-			custom: { type: "string", minLength: 1, description: "free-text answer; required when `other` is true" },
+			custom: {
+				type: "string",
+				minLength: 1,
+				pattern: "\\S",
+				description: "free-text answer; required when `other` is true",
+			},
+			action: {
+				type: "string",
+				enum: ["answer", "clarify"],
+				description: "set to `clarify` to ask about the choices without answering the round",
+			},
+			question: {
+				type: "string",
+				minLength: 1,
+				pattern: "\\S",
+				description: "clarification question; required when action is `clarify`",
+			},
 		},
-		required: ["selected"],
 		additionalProperties: false,
 		anyOf: [
 			{
 				type: "object",
-				properties: { selected: selectedOnly, other: { const: false } },
+				properties: { selected: selectedOnly, other: { const: false }, action: { const: "answer" } },
 				required: ["selected"],
 				additionalProperties: false,
 			},
@@ -135,11 +162,21 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 				properties: {
 					selected: selectedWithOther,
 					other: { const: true },
-					custom: { type: "string", minLength: 1 },
+					custom: { type: "string", minLength: 1, pattern: "\\S" },
+					action: { const: "answer" },
 				},
 				required: ["selected", "other", "custom"],
 				additionalProperties: false,
 			},
+			{
+				type: "object",
+				properties: {
+					action: { const: "clarify" },
+					question: { type: "string", minLength: 1, pattern: "\\S" },
+				},
+				required: ["action", "question"],
+				additionalProperties: false,
+			},
 		],
 	};
 }
@@ -157,13 +194,13 @@ function structuredDeepInterviewState(meta: AskGateDeepInterviewState): Record<s
 	return state;
 }
 
-/** Build the `workflow_gate` open-input for one deep-interview question. */
+/** Build the `workflow_gate` open-input for one ask question. */
 export function questionToGate(question: AskGateQuestion): OpenGateInput {
 	const labels = question.options.map(o => o.label);
 	const schema = questionAnswerSchema(question, labels);
 	return {
-		stage: "deep-interview",
-		kind: "question",
+		stage: question.workflowGate?.stage ?? "deep-interview",
+		kind: question.workflowGate?.kind ?? "question",
 		schema,
 		options: question.options.map((o, i) => ({
 			value: o.label,
@@ -178,6 +215,7 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 				multi: question.multi ?? false,
 				options: labels,
 				other_option: GATE_OTHER_OPTION,
+				clarification_action: "clarify",
 				...(question.deepInterview
 					? structuredDeepInterviewState(question.deepInterview)
 					: deepInterviewQuestionState(question.question)),
@@ -188,8 +226,14 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 
 function isAnswer(value: unknown): value is DeepInterviewGateAnswer {
 	if (typeof value !== "object" || value === null) return false;
-	const v = value as DeepInterviewGateAnswer;
+	const v = value as Record<string, unknown>;
+	if (v.action === "clarify") {
+		return (
+			typeof v.question === "string" && v.selected === undefined && v.other === undefined && v.custom === undefined
+		);
+	}
 	return (
+		(v.action === undefined || v.action === "answer") &&
 		Array.isArray(v.selected) &&
 		v.selected.every(s => typeof s === "string") &&
 		(v.other === undefined || typeof v.other === "boolean") &&
@@ -207,11 +251,24 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	if (!isAnswer(answer)) {
 		throw new DeepInterviewGateError(
 			"invalid_answer_shape",
-			"answer must be { selected: string[]; other?: boolean; custom?: string }",
+			'answer must be an answer ({ selected: string[]; other?: boolean; custom?: string }) or clarification ({ action: "clarify"; question: string })',
 		);
 	}
 	const labels = question.options.map(o => o.label);
 	const multi = question.multi ?? false;
+	if (answer.action === "clarify") {
+		if (answer.question.trim() === "") {
+			throw new DeepInterviewGateError("missing_clarification", "clarification question is required");
+		}
+		return {
+			id: question.id,
+			question: question.question,
+			options: labels,
+			multi,
+			selectedOptions: [],
+			clarificationQuestion: answer.question,
+		};
+	}
 	const valid = new Set(labels);
 	for (const sel of answer.selected) {
 		if (!valid.has(sel)) throw new DeepInterviewGateError("unknown_option", `unknown option: ${sel}`);

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/shared/agent-wire/workflow-gate-schema.ts

@@ -25,6 +25,7 @@ const SUPPORTED_KEYWORDS = new Set<keyof RpcJsonSchema>([
 	"items",
 	"minLength",
 	"maxLength",
+	"pattern",
 	"minItems",
 	"maxItems",
 	"uniqueItems",
@@ -107,6 +108,17 @@ function walkSchema(schema: RpcJsonSchema, depth: number, path: string): void {
 			throw new WorkflowGateSchemaError(`${meta} at ${path} must be a string`);
 		}
 	}
+	if (schema.pattern !== undefined) {
+		if (typeof schema.pattern !== "string") {
+			throw new WorkflowGateSchemaError(`pattern at ${path} must be a string`);
+		}
+		try {
+			new RegExp(schema.pattern);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new WorkflowGateSchemaError(`pattern at ${path} must be a valid regular expression: ${message}`);
+		}
+	}
 	for (const limit of ["minLength", "maxLength", "minItems", "maxItems"] as const) {
 		const v = schema[limit];
 		if (v !== undefined && (typeof v !== "number" || !Number.isInteger(v) || v < 0)) {
@@ -242,6 +254,14 @@ function validateValue(schema: RpcJsonSchema, value: unknown, path: string, erro
 				expected: schema.maxLength,
 			});
 		}
+		if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+			errors.push({
+				path,
+				keyword: "pattern",
+				message: `does not match pattern ${schema.pattern}`,
+				expected: schema.pattern,
+			});
+		}
 	}
 	if (typeof value === "number") {
 		if (schema.minimum !== undefined && value < schema.minimum) {

package/src/modes/slash-command-visibility.ts

@@ -0,0 +1,9 @@
+const BEGINNER_HIDDEN_EXTENSION_COMMANDS = new Set(["grok-build-usage"]);
+
+export function shouldShowExtensionCommand(name: string, activeProvider: string | undefined): boolean {
+	if (!BEGINNER_HIDDEN_EXTENSION_COMMANDS.has(name)) return true;
+	if (name === "grok-build-usage") {
+		return activeProvider === "grok-build" || Boolean(process.env.GROK_CLI_OAUTH_TOKEN);
+	}
+	return true;
+}

package/src/modes/theme/theme.ts

@@ -188,7 +188,8 @@ export type SymbolKey =
 	| "tab.tools"
 	| "tab.memory"
 	| "tab.tasks"
-	| "tab.providers";
+	| "tab.providers"
+	| "tab.integrations";
 
 type SymbolMap = Record<SymbolKey, string>;
 
@@ -353,6 +354,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"tab.memory": "🧠",
 	"tab.tasks": "📦",
 	"tab.providers": "🌐",
+	"tab.integrations": "🔌",
 };
 
 const NERD_SYMBOLS: SymbolMap = {
@@ -612,6 +614,7 @@ const NERD_SYMBOLS: SymbolMap = {
 	"tab.memory": "󰧑",
 	"tab.tasks": "󰐱",
 	"tab.providers": "󰖟",
+	"tab.integrations": "󰚇",
 };
 
 const ASCII_SYMBOLS: SymbolMap = {
@@ -774,6 +777,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"tab.memory": "[Y]",
 	"tab.tasks": "[K]",
 	"tab.providers": "[P]",
+	"tab.integrations": "[+]",
 };
 
 const SYMBOL_PRESETS: Record<SymbolPreset, SymbolMap> = {