@gajae-code/coding-agent 0.5.0 → 0.5.2

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

@@ -1,4 +1,5 @@
 import type { AgentTool } from "@gajae-code/agent-core";
+import { ThinkingLevel } from "@gajae-code/agent-core";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import { Snowflake } from "@gajae-code/utils";
 import type { ExtensionUIContext } from "../../../extensibility/extensions";
@@ -127,313 +128,332 @@ export async function dispatchRpcCommand(
 	const denied = preflight();
 	if (denied) return denied;
 
-	switch (command.type) {
-		case "prompt": {
-			session
-				.prompt(command.message, {
-					images: command.images,
-					streamingBehavior: command.streamingBehavior,
-				})
-				.catch(e => output(rpcError(id, "prompt", serializeRpcDispatchError(e))));
-			return reconcile() ?? rpcSuccess(id, "prompt");
-		}
-
-		case "steer": {
-			await session.steer(command.message, command.images);
-			return rpcSuccess(id, "steer");
-		}
-
-		case "follow_up": {
-			await session.followUp(command.message, command.images);
-			return rpcSuccess(id, "follow_up");
-		}
-
-		case "abort": {
-			await session.abort();
-			return rpcSuccess(id, "abort");
-		}
+	try {
+		switch (command.type) {
+			case "prompt": {
+				session
+					.prompt(command.message, {
+						images: command.images,
+						streamingBehavior: command.streamingBehavior,
+					})
+					.catch(e => output(rpcError(id, "prompt", serializeRpcDispatchError(e))));
+				return reconcile() ?? rpcSuccess(id, "prompt");
+			}
 
-		case "abort_and_prompt": {
-			await session.abort();
-			session
-				.prompt(command.message, { images: command.images })
-				.catch(e => output(rpcError(id, "abort_and_prompt", e.message)));
-			return rpcSuccess(id, "abort_and_prompt");
-		}
+			case "steer": {
+				await session.steer(command.message, command.images);
+				return rpcSuccess(id, "steer");
+			}
 
-		case "new_session": {
-			const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
-			const cancelled = !(await session.newSession(options));
-			return rpcSuccess(id, "new_session", { cancelled });
-		}
+			case "follow_up": {
+				await session.followUp(command.message, command.images);
+				return rpcSuccess(id, "follow_up");
+			}
 
-		case "get_state": {
-			const state: RpcSessionState = {
-				model: session.model,
-				thinkingLevel: session.thinkingLevel,
-				isStreaming: session.isStreaming,
-				isCompacting: session.isCompacting,
-				steeringMode: session.steeringMode,
-				followUpMode: session.followUpMode,
-				interruptMode: session.interruptMode,
-				sessionFile: session.sessionFile,
-				sessionId: session.sessionId,
-				sessionName: session.sessionName,
-				autoCompactionEnabled: session.autoCompactionEnabled,
-				messageCount: session.messages.length,
-				queuedMessageCount: session.queuedMessageCount,
-				todoPhases: session.getTodoPhases(),
-				contextUsage: session.getContextUsage(),
-			};
-			const include = new Set(command.include ?? []);
-			if (include.has("systemPrompt")) {
-				state.systemPrompt = session.systemPrompt;
-			}
-			if (include.has("tools") || include.has("dumpTools")) {
-				state.dumpTools = session.agent.state.tools.map(tool => ({
-					name: tool.name,
-					description: tool.description,
-					parameters: tool.parameters,
-				}));
+			case "abort": {
+				await session.abort();
+				return rpcSuccess(id, "abort");
 			}
-			return rpcSuccess(id, "get_state", state);
-		}
 
-		case "set_todos": {
-			session.setTodoPhases(command.phases);
-			return rpcSuccess(id, "set_todos", { todoPhases: session.getTodoPhases() });
-		}
+			case "abort_and_prompt": {
+				await session.abort();
+				session
+					.prompt(command.message, { images: command.images })
+					.catch(e => output(rpcError(id, "abort_and_prompt", e.message)));
+				return rpcSuccess(id, "abort_and_prompt");
+			}
 
-		case "set_host_tools": {
-			const tools = normalizeHostToolDefinitions(command.tools);
-			const rpcTools = hostToolRegistry.setTools(tools);
-			await session.refreshRpcHostTools(rpcTools);
-			return rpcSuccess(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
-		}
+			case "new_session": {
+				const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
+				const cancelled = !(await session.newSession(options));
+				return rpcSuccess(id, "new_session", { cancelled });
+			}
 
-		case "set_host_uri_schemes": {
-			try {
-				const schemes = hostUriRegistry.setSchemes(command.schemes);
-				return rpcSuccess(id, "set_host_uri_schemes", { schemes });
-			} catch (err) {
-				return rpcError(id, "set_host_uri_schemes", err instanceof Error ? err.message : String(err));
+			case "get_state": {
+				const state: RpcSessionState = {
+					model: session.model,
+					thinkingLevel: session.thinkingLevel,
+					isStreaming: session.isStreaming,
+					isCompacting: session.isCompacting,
+					steeringMode: session.steeringMode,
+					followUpMode: session.followUpMode,
+					interruptMode: session.interruptMode,
+					sessionFile: session.sessionFile,
+					sessionId: session.sessionId,
+					sessionName: session.sessionName,
+					autoCompactionEnabled: session.autoCompactionEnabled,
+					messageCount: session.messages.length,
+					queuedMessageCount: session.queuedMessageCount,
+					todoPhases: session.getTodoPhases(),
+					contextUsage: session.getContextUsage(),
+				};
+				const include = new Set(command.include ?? []);
+				if (include.has("systemPrompt")) {
+					state.systemPrompt = session.systemPrompt;
+				}
+				if (include.has("tools") || include.has("dumpTools")) {
+					state.dumpTools = session.agent.state.tools.map(tool => ({
+						name: tool.name,
+						description: tool.description,
+						parameters: tool.parameters,
+					}));
+				}
+				return rpcSuccess(id, "get_state", state);
 			}
-		}
 
-		case "set_model": {
-			const models = session.getAvailableModels();
-			const model = models.find(m => m.provider === command.provider && m.id === command.modelId);
-			if (!model) {
-				return rpcError(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
+			case "set_todos": {
+				session.setTodoPhases(command.phases);
+				return rpcSuccess(id, "set_todos", { todoPhases: session.getTodoPhases() });
 			}
-			await session.setModel(model);
-			return rpcSuccess(id, "set_model", model);
-		}
 
-		case "cycle_model": {
-			const result = await session.cycleModel();
-			if (!result) {
-				return rpcSuccess(id, "cycle_model", null);
+			case "set_host_tools": {
+				const tools = normalizeHostToolDefinitions(command.tools);
+				const rpcTools = hostToolRegistry.setTools(tools);
+				await session.refreshRpcHostTools(rpcTools);
+				return rpcSuccess(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
 			}
-			return rpcSuccess(id, "cycle_model", result);
-		}
 
-		case "get_available_models": {
-			const models = session.getAvailableModels();
-			return rpcSuccess(id, "get_available_models", { models });
-		}
+			case "set_host_uri_schemes": {
+				try {
+					const schemes = hostUriRegistry.setSchemes(command.schemes);
+					return rpcSuccess(id, "set_host_uri_schemes", { schemes });
+				} catch (err) {
+					return rpcError(id, "set_host_uri_schemes", err instanceof Error ? err.message : String(err));
+				}
+			}
 
-		case "set_thinking_level": {
-			session.setThinkingLevel(command.level);
-			return rpcSuccess(id, "set_thinking_level");
-		}
+			case "set_model": {
+				const models = session.getAvailableModels();
+				const model = models.find(m => m.provider === command.provider && m.id === command.modelId);
+				if (!model) {
+					return rpcError(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
+				}
+				await session.setModel(model);
+				return rpcSuccess(id, "set_model", model);
+			}
 
-		case "cycle_thinking_level": {
-			const level = session.cycleThinkingLevel();
-			if (!level) {
-				return rpcSuccess(id, "cycle_thinking_level", null);
+			case "cycle_model": {
+				const result = await session.cycleModel();
+				if (!result) {
+					return rpcSuccess(id, "cycle_model", null);
+				}
+				return rpcSuccess(id, "cycle_model", result);
 			}
-			return rpcSuccess(id, "cycle_thinking_level", { level });
-		}
 
-		case "set_steering_mode": {
-			session.setSteeringMode(command.mode);
-			return rpcSuccess(id, "set_steering_mode");
-		}
+			case "get_available_models": {
+				const models = session.getAvailableModels();
+				return rpcSuccess(id, "get_available_models", { models });
+			}
 
-		case "set_follow_up_mode": {
-			session.setFollowUpMode(command.mode);
-			return rpcSuccess(id, "set_follow_up_mode");
-		}
+			case "set_thinking_level": {
+				if (!(Object.values(ThinkingLevel) as string[]).includes(command.level as string)) {
+					return rpcError(id, "set_thinking_level", `Invalid thinking level: ${String(command.level)}`);
+				}
+				session.setThinkingLevel(command.level);
+				return rpcSuccess(id, "set_thinking_level");
+			}
 
-		case "set_interrupt_mode": {
-			session.setInterruptMode(command.mode);
-			return rpcSuccess(id, "set_interrupt_mode");
-		}
+			case "cycle_thinking_level": {
+				const level = session.cycleThinkingLevel();
+				if (!level) {
+					return rpcSuccess(id, "cycle_thinking_level", null);
+				}
+				return rpcSuccess(id, "cycle_thinking_level", { level });
+			}
 
-		case "compact": {
-			const result = await session.compact(command.customInstructions);
-			return rpcSuccess(id, "compact", result);
-		}
+			case "set_steering_mode": {
+				if ((command.mode as string) !== "all" && (command.mode as string) !== "one-at-a-time") {
+					return rpcError(id, "set_steering_mode", `Invalid steering mode: ${String(command.mode)}`);
+				}
+				session.setSteeringMode(command.mode);
+				return rpcSuccess(id, "set_steering_mode");
+			}
 
-		case "set_auto_compaction": {
-			session.setAutoCompactionEnabled(command.enabled);
-			return rpcSuccess(id, "set_auto_compaction");
-		}
+			case "set_follow_up_mode": {
+				if ((command.mode as string) !== "all" && (command.mode as string) !== "one-at-a-time") {
+					return rpcError(id, "set_follow_up_mode", `Invalid follow-up mode: ${String(command.mode)}`);
+				}
+				session.setFollowUpMode(command.mode);
+				return rpcSuccess(id, "set_follow_up_mode");
+			}
 
-		case "set_auto_retry": {
-			session.setAutoRetryEnabled(command.enabled);
-			return rpcSuccess(id, "set_auto_retry");
-		}
+			case "set_interrupt_mode": {
+				if ((command.mode as string) !== "immediate" && (command.mode as string) !== "wait") {
+					return rpcError(id, "set_interrupt_mode", `Invalid interrupt mode: ${String(command.mode)}`);
+				}
+				session.setInterruptMode(command.mode);
+				return rpcSuccess(id, "set_interrupt_mode");
+			}
 
-		case "abort_retry": {
-			session.abortRetry();
-			return rpcSuccess(id, "abort_retry");
-		}
+			case "compact": {
+				const result = await session.compact(command.customInstructions);
+				return rpcSuccess(id, "compact", result);
+			}
 
-		case "bash": {
-			const result = await session.executeBash(command.command);
-			return reconcile() ?? rpcSuccess(id, "bash", result);
-		}
+			case "set_auto_compaction": {
+				session.setAutoCompactionEnabled(command.enabled);
+				return rpcSuccess(id, "set_auto_compaction");
+			}
 
-		case "abort_bash": {
-			session.abortBash();
-			return rpcSuccess(id, "abort_bash");
-		}
+			case "set_auto_retry": {
+				session.setAutoRetryEnabled(command.enabled);
+				return rpcSuccess(id, "set_auto_retry");
+			}
 
-		case "get_session_stats": {
-			const stats = session.getSessionStats();
-			return rpcSuccess(id, "get_session_stats", stats);
-		}
+			case "abort_retry": {
+				session.abortRetry();
+				return rpcSuccess(id, "abort_retry");
+			}
 
-		case "export_html": {
-			const path = await session.exportToHtml(command.outputPath);
-			return rpcSuccess(id, "export_html", { path });
-		}
+			case "bash": {
+				const result = await session.executeBash(command.command);
+				return reconcile() ?? rpcSuccess(id, "bash", result);
+			}
 
-		case "switch_session": {
-			const cancelled = !(await session.switchSession(command.sessionPath));
-			return rpcSuccess(id, "switch_session", { cancelled });
-		}
+			case "abort_bash": {
+				session.abortBash();
+				return rpcSuccess(id, "abort_bash");
+			}
 
-		case "branch": {
-			const result = await session.branch(command.entryId);
-			return rpcSuccess(id, "branch", { text: result.selectedText, cancelled: result.cancelled });
-		}
+			case "get_session_stats": {
+				const stats = session.getSessionStats();
+				return rpcSuccess(id, "get_session_stats", stats);
+			}
 
-		case "get_branch_messages": {
-			const messages = session.getUserMessagesForBranching();
-			return rpcSuccess(id, "get_branch_messages", { messages });
-		}
+			case "export_html": {
+				const path = await session.exportToHtml(command.outputPath);
+				return rpcSuccess(id, "export_html", { path });
+			}
 
-		case "get_last_assistant_text": {
-			const text = session.getLastAssistantText();
-			return rpcSuccess(id, "get_last_assistant_text", { text });
-		}
+			case "switch_session": {
+				const cancelled = !(await session.switchSession(command.sessionPath));
+				return rpcSuccess(id, "switch_session", { cancelled });
+			}
 
-		case "set_session_name": {
-			const name = command.name.trim();
-			if (!name) {
-				return rpcError(id, "set_session_name", "Session name cannot be empty");
+			case "branch": {
+				const result = await session.branch(command.entryId);
+				return rpcSuccess(id, "branch", { text: result.selectedText, cancelled: result.cancelled });
 			}
-			const applied = await session.setSessionName(name, "user");
-			if (!applied) {
-				return rpcError(id, "set_session_name", "Session name cannot be empty");
+
+			case "get_branch_messages": {
+				const messages = session.getUserMessagesForBranching();
+				return rpcSuccess(id, "get_branch_messages", { messages });
 			}
-			return rpcSuccess(id, "set_session_name");
-		}
 
-		case "handoff": {
-			const result = await session.handoff(command.customInstructions);
-			return rpcSuccess(id, "handoff", result ? { savedPath: result.savedPath } : null);
-		}
+			case "get_last_assistant_text": {
+				const text = session.getLastAssistantText();
+				return rpcSuccess(id, "get_last_assistant_text", { text });
+			}
 
-		case "get_messages": {
-			return rpcSuccess(id, "get_messages", { messages: session.messages });
-		}
+			case "set_session_name": {
+				const name = command.name.trim();
+				if (!name) {
+					return rpcError(id, "set_session_name", "Session name cannot be empty");
+				}
+				const applied = await session.setSessionName(name, "user");
+				if (!applied) {
+					return rpcError(id, "set_session_name", "Session name cannot be empty");
+				}
+				return rpcSuccess(id, "set_session_name");
+			}
 
-		case "get_login_providers": {
-			const providers = getOAuthProviders().map(provider => ({
-				id: provider.id,
-				name: provider.name,
-				available: provider.available,
-				authenticated: session.modelRegistry.authStorage.hasAuth(provider.id),
-			}));
-			return rpcSuccess(id, "get_login_providers", { providers });
-		}
+			case "handoff": {
+				const result = await session.handoff(command.customInstructions);
+				return rpcSuccess(id, "handoff", result ? { savedPath: result.savedPath } : null);
+			}
 
-		case "login": {
-			const knownProvider = getOAuthProviders().find(p => p.id === command.providerId);
-			if (!knownProvider) {
-				return rpcError(id, "login", `Unknown OAuth provider: ${command.providerId}`);
-			}
-			const uiCtx = createUiContext();
-			let authEmitted = false;
-			try {
-				await session.modelRegistry.authStorage.login(command.providerId, {
-					onAuth: info => {
-						authEmitted = true;
-						output({
-							type: "extension_ui_request",
-							id: Snowflake.next() as string,
-							method: "open_url",
-							url: info.url,
-							instructions: info.instructions,
-						} as RpcExtensionUIRequest);
-					},
-					onProgress: message => {
-						uiCtx.notify(message, "info");
-					},
-					onPrompt: () => {
-						if (!authEmitted) {
-							return Promise.reject(
-								new Error(
-									`Provider '${command.providerId}' requires interactive prompts ` +
-										"which are not supported in RPC mode. Use the terminal UI to log in.",
-								),
-							);
-						}
-						return new Promise<string>(() => {});
-					},
-				});
-				await session.modelRegistry.refresh();
-				return rpcSuccess(id, "login", { providerId: command.providerId });
-			} catch (err: unknown) {
-				return rpcError(id, "login", err instanceof Error ? err.message : String(err));
+			case "get_messages": {
+				// Fast-lane read: snapshot the live array so a concurrent ordered
+				// turn/compaction mutating session.messages in place cannot make this
+				// response serialize a half-rewritten array (#606, issue 13).
+				return rpcSuccess(id, "get_messages", { messages: [...session.messages] });
 			}
-		}
 
-		case "negotiate_unattended": {
-			if (!unattendedControlPlane) {
-				return rpcError(id, "negotiate_unattended", "unattended mode is not available on this session");
+			case "get_login_providers": {
+				const providers = getOAuthProviders().map(provider => ({
+					id: provider.id,
+					name: provider.name,
+					available: provider.available,
+					authenticated: session.modelRegistry.authStorage.hasAuth(provider.id),
+				}));
+				return rpcSuccess(id, "get_login_providers", { providers });
 			}
-			try {
-				const accepted = unattendedControlPlane.negotiate(command.declaration);
-				return rpcSuccess(id, "negotiate_unattended", accepted);
-			} catch (err) {
-				return typedError("negotiate_unattended", err);
+
+			case "login": {
+				const knownProvider = getOAuthProviders().find(p => p.id === command.providerId);
+				if (!knownProvider) {
+					return rpcError(id, "login", `Unknown OAuth provider: ${command.providerId}`);
+				}
+				const uiCtx = createUiContext();
+				let authEmitted = false;
+				try {
+					await session.modelRegistry.authStorage.login(command.providerId, {
+						onAuth: info => {
+							authEmitted = true;
+							output({
+								type: "extension_ui_request",
+								id: Snowflake.next() as string,
+								method: "open_url",
+								url: info.url,
+								instructions: info.instructions,
+							} as RpcExtensionUIRequest);
+						},
+						onProgress: message => {
+							uiCtx.notify(message, "info");
+						},
+						onPrompt: () => {
+							if (!authEmitted) {
+								return Promise.reject(
+									new Error(
+										`Provider '${command.providerId}' requires interactive prompts ` +
+											"which are not supported in RPC mode. Use the terminal UI to log in.",
+									),
+								);
+							}
+							return new Promise<string>(() => {});
+						},
+					});
+					await session.modelRegistry.refresh();
+					return rpcSuccess(id, "login", { providerId: command.providerId });
+				} catch (err: unknown) {
+					return rpcError(id, "login", err instanceof Error ? err.message : String(err));
+				}
 			}
-		}
 
-		case "workflow_gate_response": {
-			if (!unattendedControlPlane) {
-				return rpcError(id, "workflow_gate_response", "workflow gates are not available on this session");
+			case "negotiate_unattended": {
+				if (!unattendedControlPlane) {
+					return rpcError(id, "negotiate_unattended", "unattended mode is not available on this session");
+				}
+				try {
+					const accepted = unattendedControlPlane.negotiate(command.declaration);
+					return rpcSuccess(id, "negotiate_unattended", accepted);
+				} catch (err) {
+					return typedError("negotiate_unattended", err);
+				}
 			}
-			try {
-				const resolution = await unattendedControlPlane.resolveGate({
-					gate_id: command.gate_id,
-					answer: command.answer,
-					idempotency_key: command.idempotency_key,
-				});
-				return rpcSuccess(id, "workflow_gate_response", resolution);
-			} catch (err) {
-				return typedError("workflow_gate_response", err);
+
+			case "workflow_gate_response": {
+				if (!unattendedControlPlane) {
+					return rpcError(id, "workflow_gate_response", "workflow gates are not available on this session");
+				}
+				try {
+					const resolution = await unattendedControlPlane.resolveGate({
+						gate_id: command.gate_id,
+						answer: command.answer,
+						idempotency_key: command.idempotency_key,
+					});
+					return rpcSuccess(id, "workflow_gate_response", resolution);
+				} catch (err) {
+					return typedError("workflow_gate_response", err);
+				}
 			}
-		}
 
-		default: {
-			const unknownCommand = command as { type: string };
-			return rpcError(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+			default: {
+				const unknownCommand = command as { type: string };
+				return rpcError(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+			}
 		}
+	} catch (err) {
+		return rpcError(id, command.type, serializeRpcDispatchError(err));
 	}
 }

package/src/modes/shared/agent-wire/deep-interview-gate.ts

@@ -17,12 +17,26 @@ import type { OpenGateInput } from "./workflow-gate-broker";
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
 export const GATE_OTHER_OPTION = "Other (type your own)";
 
+/** Optional structured deep-interview round metadata supplied by the agent. */
+export interface AskGateDeepInterviewState {
+	round_id?: string;
+	round: number;
+	component: string;
+	dimension: string;
+	ambiguity: number;
+}
+
 export interface AskGateQuestion {
 	id: string;
 	question: string;
 	options: Array<{ label: string }>;
 	multi?: boolean;
 	recommended?: number;
+	/**
+	 * Structured round metadata. When present it is the authoritative source for gate
+	 * `stage_state`; when absent, the question text is regex-parsed as a fallback.
+	 */
+	deepInterview?: AskGateDeepInterviewState;
 }
 
 export interface AskGateResult {
@@ -130,6 +144,19 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 	};
 }
 
+/** Build `stage_state` round metadata from the structured param (authoritative when present). */
+function structuredDeepInterviewState(meta: AskGateDeepInterviewState): Record<string, unknown> {
+	const state: Record<string, unknown> = {
+		deep_interview_metadata: true,
+		round: meta.round,
+		component: meta.component,
+		dimension: meta.dimension,
+		ambiguity: meta.ambiguity,
+	};
+	if (meta.round_id !== undefined) state.round_id = meta.round_id;
+	return state;
+}
+
 /** Build the `workflow_gate` open-input for one deep-interview question. */
 export function questionToGate(question: AskGateQuestion): OpenGateInput {
 	const labels = question.options.map(o => o.label);
@@ -151,7 +178,9 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 				multi: question.multi ?? false,
 				options: labels,
 				other_option: GATE_OTHER_OPTION,
-				...deepInterviewQuestionState(question.question),
+				...(question.deepInterview
+					? structuredDeepInterviewState(question.deepInterview)
+					: deepInterviewQuestionState(question.question)),
 			},
 		},
 	};