@gajae-code/coding-agent 0.9.6 → 0.10.0

package/src/modes/interactive-mode.ts

@@ -81,9 +81,11 @@ import type { BashExecutionComponent } from "./components/bash-execution";
 import { CustomEditor } from "./components/custom-editor";
 import { DynamicBorder } from "./components/dynamic-border";
 import type { EvalExecutionComponent } from "./components/eval-execution";
+import { GajaePetWidget, type PetMode } from "./components/gajae-pet-widget";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
+import { IrcSplitViewComponent } from "./components/irc-sidebar";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import {
@@ -99,6 +101,7 @@ import { InputController } from "./controllers/input-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import { IrcObservationLedger } from "./irc-observation-ledger";
 import { JobsObserver } from "./jobs-observer";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
@@ -114,13 +117,42 @@ import {
 	onThemeChange,
 	theme,
 } from "./theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
-import { addChatChild, UiHelpers } from "./utils/ui-helpers";
+import type {
+	CompactionQueuedMessage,
+	InteractiveModeContext,
+	IrcArrivalSnapshot,
+	SubmittedUserInput,
+	TodoItem,
+	TodoPhase,
+	TranscriptRebuildPolicy,
+} from "./types";
+import type { ParsedIrcMessage } from "./utils/irc-message";
+import { addChatChild, prepareTranscriptRebuild, UiHelpers } from "./utils/ui-helpers";
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
 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 IRC_SIDEBAR_TOGGLE_SHADOWING_ACTIONS: readonly AppKeybinding[] = [
+	"app.plan.toggle",
+	"app.session.new",
+	"app.session.tree",
+	"app.session.fork",
+	"app.session.resume",
+	"app.message.followUp",
+	"app.stt.toggle",
+	"app.clipboard.copyLine",
+	"app.session.observe",
+	"app.jobs.open",
+	"app.tool.backgroundFold",
+];
+
+export function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number {
+	return chatContainer.children.length === 0 || chatContainer.children.length > WELCOME_RESERVED_CONTAINER_CHILD_LIMIT
+		? 0
+		: chatContainer.render(width).length;
+}
 const FRIENDLY_KEY_PARTS: Record<string, string> = {
 	alt: "Alt",
 	cmd: "Cmd",
@@ -280,6 +312,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	keybindings: KeybindingsManager;
 	agent: Agent;
 	historyStorage?: HistoryStorage;
+	readonly ircLedger = new IrcObservationLedger();
 
 	ui: TUI;
 	chatContainer: Container;
@@ -291,6 +324,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
 	hookWidgetContainerBelow: Container;
+	petFloorContainer: Container = new Container();
+	petWidget: GajaePetWidget | undefined;
 	statusLine: StatusLineComponent;
 
 	isInitialized = false;
@@ -387,6 +422,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
+	#ircSplitView: IrcSplitViewComponent;
+	#ircSidebarAvailable = false;
+	#ircSidebarRequestedVisible = false;
 
 	constructor(
 		session: AgentSession,
@@ -423,6 +461,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui = new TUI(new ProcessTerminal(), settings.get("showHardwareCursor"));
 		this.ui.setClearOnShrink(settings.get("clearOnShrink"));
 		this.chatContainer = new Container();
+		this.#ircSplitView = new IrcSplitViewComponent(this.chatContainer, this.ircLedger, () => theme);
 		this.pendingMessagesContainer = new Container();
 		this.statusContainer = new Container();
 		this.todoContainer = new Container();
@@ -442,6 +481,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#syncEditorMaxHeight();
 			this.updateEditorChrome();
 			this.editor.invalidate();
+			this.#invalidateIrcSidebarRender();
 			this.ui.requestResizeRender();
 		};
 		process.stdout.on("resize", this.#resizeHandler);
@@ -561,7 +601,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#welcomeComponent.playIntro(() => this.ui.requestRender());
 		}
 
-		this.ui.addChild(this.chatContainer);
+		this.ui.addChild(this.#ircSplitView);
+		this.ui.setViewportAnchorComponent(this.#ircSplitView);
+
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
 		this.ui.addChild(this.todoContainer);
@@ -569,9 +611,12 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.statusLine); // Main status rail + hook statuses; composer chrome is rendered by the editor.
 		this.ui.addChild(this.hookWidgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
+		this.ui.addChild(this.petFloorContainer);
 		this.ui.addChild(this.hookWidgetContainerBelow);
 		this.ui.setBottomPinnedComponent(this.statusLine);
 		this.ui.setFocus(this.editor);
+		this.petWidget = this.#createPetWidget(this.editor);
+		this.petWidget.setMode(settings.get("pet.mode"));
 
 		this.#inputController.setupKeyHandlers();
 		this.#inputController.setupEditorSubmitHandler();
@@ -609,6 +654,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.updateEditorChrome();
 		this.#syncEditorMaxHeight();
 		this.isInitialized = true;
+		this.#syncIrcSidebarAvailabilityFromSettings();
 		this.ui.requestRender(true);
 
 		// GitHub star reminder (interactive-only). Register the decline-driven
@@ -874,7 +920,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		if (!submission.customType) {
 			this.pendingImages = submission.images ? [...submission.images] : [];
-			this.rebuildChatFromMessages();
+			this.rebuildChatFromMessages("reconcile-same-transcript");
 			this.editor.setText(submission.text);
 		}
 		this.updateEditorChrome();
@@ -950,8 +996,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	#getWelcomeReservedRows(width: number): number {
+		const transcriptRows = getWelcomeTranscriptReservedRows(this.chatContainer, width);
+
 		const transientRows = [
-			this.chatContainer,
 			this.pendingMessagesContainer,
 			this.statusContainer,
 			this.todoContainer,
@@ -965,7 +1012,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.hookWidgetContainerBelow,
 		].reduce((rows, component) => rows + component.render(width).length, 0);
 
-		return transientRows + pinnedRows;
+		return transcriptRows + transientRows + pinnedRows;
 	}
 
 	#renderShortContainerRowsForWelcomeReservation(width: number, container: Container): number {
@@ -1017,7 +1064,42 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.editor.setTopBorder(undefined);
 	}
 
-	rebuildChatFromMessages(): void {
+	setPetMode(mode: PetMode): void {
+		this.petWidget?.setMode(mode);
+		settings.set("pet.mode", mode);
+		this.ui.requestRender();
+	}
+
+	previewPetMode(mode: PetMode): void {
+		this.petWidget?.previewMode(mode);
+		this.ui.requestRender();
+	}
+
+	restoreComposer(): void {
+		if (this.petWidget) {
+			this.petWidget.remountComposer();
+		} else {
+			this.editorContainer.clear();
+			this.editorContainer.addChild(this.editor);
+		}
+		this.ui.setFocus(this.editor);
+	}
+
+	#createPetWidget(editor: CustomEditor): GajaePetWidget {
+		return new GajaePetWidget({
+			ui: this.ui,
+			editor,
+			editorContainer: this.editorContainer,
+			floorContainer: this.petFloorContainer,
+			isWorking: () => this.loadingAnimation !== undefined,
+			getComposerBottomOffset: () =>
+				this.petFloorContainer.render(this.ui.terminal.columns).length +
+				this.hookWidgetContainerBelow.render(this.ui.terminal.columns).length,
+		});
+	}
+
+	rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void {
+		prepareTranscriptRebuild(this.ui, policy);
 		this.chatContainer.clear();
 		const context = this.session.buildDisplaySessionContext();
 		this.renderSessionContext(context);
@@ -1992,6 +2074,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	stop(): void {
+		this.petWidget?.dispose();
+		this.petWidget = undefined;
 		if (this.loadingAnimation) {
 			this.loadingAnimation.stop();
 			this.loadingAnimation = undefined;
@@ -2123,11 +2207,17 @@ export class InteractiveMode implements InteractiveModeContext {
 		nextEditor.setText(previousText);
 		previousEditor.dispose();
 
+		const petMode = this.petWidget?.mode ?? settings.get("pet.mode");
+		this.petWidget?.dispose();
+
 		this.editorContainer.clear();
 		this.editor = nextEditor;
 		this.editorContainer.addChild(nextEditor);
 		this.ui.setFocus(nextEditor);
 
+		this.petWidget = this.#createPetWidget(nextEditor);
+		this.petWidget.setMode(petMode);
+
 		this.#inputController.setupKeyHandlers();
 		this.#inputController.setupEditorSubmitHandler();
 
@@ -2284,13 +2374,32 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#uiHelpers.addMessageToChat(message, options);
 	}
 
+	addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[] {
+		return this.#uiHelpers.addLiveIrcObservationToChat(message, arrival);
+	}
+	removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined {
+		return this.#uiHelpers.removeRenderedIrcInlineComponents(observationId);
+	}
+	resetRenderedIrcInlineComponents(): readonly (readonly Component[])[] {
+		return this.#uiHelpers.resetRenderedIrcInlineComponents();
+	}
+
 	renderSessionContext(
 		sessionContext: SessionContext,
 		options?: { updateFooter?: boolean; populateHistory?: boolean },
 	): void {
 		this.#uiHelpers.renderSessionContext(sessionContext, options);
+		this.#eventController.reconcileIrcExpiryTimers(this.#uiHelpers.getRenderedIrcInlineComponents());
 	}
 
+	rebuildInitialMessages(
+		policy: TranscriptRebuildPolicy,
+		prebuiltContext?: SessionContext,
+		options?: { preserveExistingChat?: boolean },
+	): void {
+		prepareTranscriptRebuild(this.ui, policy);
+		this.#uiHelpers.renderInitialMessages(prebuiltContext, options);
+	}
 	renderInitialMessages(prebuiltContext?: SessionContext, options?: { preserveExistingChat?: boolean }): void {
 		this.#uiHelpers.renderInitialMessages(prebuiltContext, options);
 	}
@@ -2303,6 +2412,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#uiHelpers.findLastAssistantMessage();
 	}
 
+	getAssistantViewportAnchorId(message: AssistantMessage): string {
+		return this.#uiHelpers.assistantViewportAnchorId(message);
+	}
+
 	extractAssistantText(message: AssistantMessage): string {
 		return this.#uiHelpers.extractAssistantText(message);
 	}
@@ -2553,6 +2666,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showThemeSelector();
 	}
 
+	showPetSelector(): void {
+		this.#selectorController.showPetSelector();
+	}
+
 	showHistorySearch(): void {
 		this.#selectorController.showHistorySearch();
 	}
@@ -2668,6 +2785,65 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#inputController.setToolsExpanded(expanded);
 	}
 
+	#resolveEffectiveIrcSidebarToggleKey(): string | null {
+		for (const key of this.keybindings.getKeys("app.irc.sidebar.toggle")) {
+			if (this.editor.hasActionKey(key)) continue;
+			const shadowed = IRC_SIDEBAR_TOGGLE_SHADOWING_ACTIONS.some(action =>
+				this.keybindings.getKeys(action).includes(key),
+			);
+			if (!shadowed) return key;
+		}
+		return null;
+	}
+
+	captureIrcArrivalSnapshot(): IrcArrivalSnapshot {
+		return {
+			panelVisible: this.#ircSplitView.effectiveSidebarVisible(this.ui.terminal.columns),
+			panelRequestedVisible: this.#ircSidebarRequestedVisible,
+			sidebarAvailable: this.#ircSidebarAvailable,
+			resolvedToggleKey: this.#resolveEffectiveIrcSidebarToggleKey(),
+		};
+	}
+	toggleIrcSidebar(): void {
+		if (
+			!this.#ircSidebarAvailable ||
+			this.settings.get("irc.enabled") !== true ||
+			this.settings.get("irc.sidebar.enabled") !== true
+		)
+			return;
+		this.#ircSidebarRequestedVisible = !this.#ircSidebarRequestedVisible;
+		this.#ircSplitView.setVisible(this.#ircSidebarRequestedVisible);
+		this.#invalidateIrcSidebarRender();
+		this.ui.requestRender();
+	}
+
+	applyIrcSidebarAvailability(enabled: boolean): void {
+		this.#ircSidebarAvailable = enabled;
+		this.#ircSplitView.setVisible(enabled && this.#ircSidebarRequestedVisible);
+		this.#invalidateIrcSidebarRender();
+		this.ui.requestRender();
+	}
+
+	#syncIrcSidebarAvailabilityFromSettings(): void {
+		this.applyIrcSidebarAvailability(
+			this.settings.get("irc.enabled") === true && this.settings.get("irc.sidebar.enabled") === true,
+		);
+	}
+
+	resetIrcSidebarSession(): void {
+		this.ircLedger.reset();
+		this.#eventController.resetIrcObservations();
+		this.#ircSidebarRequestedVisible = false;
+		this.#ircSplitView.setVisible(false);
+		this.#uiHelpers.resetIrcSidebarHint();
+		this.#syncIrcSidebarAvailabilityFromSettings();
+	}
+
+	#invalidateIrcSidebarRender(): void {
+		clearRenderCache();
+		this.#ircSplitView.invalidate();
+	}
+
 	toggleThinkingBlockVisibility(): void {
 		this.#inputController.toggleThinkingBlockVisibility();
 	}

package/src/modes/irc-observation-ledger.ts

@@ -0,0 +1,127 @@
+import * as crypto from "node:crypto";
+
+import type { ParsedIrcMessage } from "./utils/irc-message";
+
+type InlineMode = "persistent" | "ephemeral";
+
+const MAX_RECORDS = 10_000;
+const MAX_RETAINED_UTF8_BYTES = 16 * 1024 * 1024;
+const MAX_SEEN_IDENTITIES = 100_000;
+
+export type IrcObservationRecord = Readonly<
+	ParsedIrcMessage & {
+		mode: InlineMode;
+		observedAt: number;
+		sequence: number;
+		expiresAt?: number;
+		retainedUtf8Bytes: number;
+	}
+>;
+
+function measureRetainedUtf8Bytes(message: ParsedIrcMessage): number {
+	let bytes = 4;
+	for (const value of [message.observationId, message.from, message.to, message.text, message.kind]) {
+		bytes += Buffer.byteLength(value, "utf8");
+		if (bytes > MAX_RETAINED_UTF8_BYTES) return bytes;
+	}
+	return bytes;
+}
+
+function tombstoneIdentity(observationId: string): string {
+	const hash = crypto.createHash("sha256");
+	hash.update("gjc:irc:observation-id:utf16le:v1\0");
+	for (let offset = 0; offset < observationId.length; offset += 4_096) {
+		hash.update(Buffer.from(observationId.slice(offset, offset + 4_096), "utf16le"));
+	}
+	return hash.digest("hex");
+}
+
+/** Runtime-only IRC observations. This intentionally has no persistence layer. */
+export class IrcObservationLedger {
+	#records = new Map<string, IrcObservationRecord>();
+	#retainedUtf8Bytes = 0;
+	#nextSequence = 0;
+	#seenObservationIdentities = new Set<string>();
+	#identityCapacityExhausted = false;
+	#evictedObservationIds = new Set<string>();
+
+	#rememberObservationIdentity(observationId: string): boolean {
+		const identity = tombstoneIdentity(observationId);
+		if (this.#seenObservationIdentities.has(identity) || this.#identityCapacityExhausted) return false;
+		if (this.#seenObservationIdentities.size >= MAX_SEEN_IDENTITIES) {
+			this.#identityCapacityExhausted = true;
+			return false;
+		}
+		this.#seenObservationIdentities.add(identity);
+		return true;
+	}
+
+	#evict(observationId: string): void {
+		const record = this.#records.get(observationId);
+		if (!record) return;
+		this.#records.delete(observationId);
+		this.#retainedUtf8Bytes -= record.retainedUtf8Bytes;
+		this.#evictedObservationIds.add(observationId);
+	}
+
+	#enforceBounds(): void {
+		while (this.#records.size > MAX_RECORDS || this.#retainedUtf8Bytes > MAX_RETAINED_UTF8_BYTES) {
+			const oldestObservationId = this.#records.keys().next().value;
+			if (oldestObservationId === undefined) return;
+			this.#evict(oldestObservationId);
+		}
+	}
+
+	/** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
+	observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined {
+		const existing = this.#records.get(message.observationId);
+		if (existing) return existing;
+		if (!this.#rememberObservationIdentity(message.observationId)) return undefined;
+
+		const estimatedBytes = measureRetainedUtf8Bytes(message);
+		if (estimatedBytes > MAX_RETAINED_UTF8_BYTES) return undefined;
+
+		const observedAt = Date.now();
+		const mode: InlineMode = panelVisibleAtObservation ? "ephemeral" : "persistent";
+		const record: IrcObservationRecord = Object.freeze({
+			...message,
+			mode,
+			observedAt,
+			sequence: this.#nextSequence++,
+			...(mode === "ephemeral" ? { expiresAt: observedAt + 10_000 } : {}),
+			retainedUtf8Bytes: estimatedBytes,
+		});
+		this.#records.set(record.observationId, record);
+		this.#retainedUtf8Bytes += estimatedBytes;
+		this.#enforceBounds();
+		return this.#records.get(record.observationId);
+	}
+
+	getRecord(observationId: string): IrcObservationRecord | undefined {
+		return this.#records.get(observationId);
+	}
+
+	getSidebarRecords(): readonly IrcObservationRecord[] {
+		return [...this.#records.values()];
+	}
+
+	getInlineProjection(now: number): readonly IrcObservationRecord[] {
+		return [...this.#records.values()].filter(record => record.mode === "persistent" || now < record.expiresAt!);
+	}
+
+	/** Returns and clears IDs whose retained payload was released. */
+	drainEvictedObservationIds(): readonly string[] {
+		const observationIds = [...this.#evictedObservationIds];
+		this.#evictedObservationIds.clear();
+		return observationIds;
+	}
+
+	reset(): void {
+		for (const observationId of this.#records.keys()) {
+			this.#evictedObservationIds.add(observationId);
+		}
+		this.#records.clear();
+		this.#retainedUtf8Bytes = 0;
+		this.#nextSequence = 0;
+	}
+}

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

@@ -44,6 +44,8 @@ export interface AskGateQuestion {
 	deepInterview?: AskGateDeepInterviewState;
 	/** Override the emitted workflow gate address for non-deep-interview ask prompts. */
 	workflowGate?: AskGateWorkflowGateMeta;
+	allowEmpty?: boolean;
+	navigationLabel?: "Next" | "Done";
 }
 
 export interface AskGateResult {
@@ -119,7 +121,7 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 	const selectedBase: RpcJsonSchema = { type: "array", items: selectedItems, uniqueItems: true };
 	const selectedOnly: RpcJsonSchema = {
 		...selectedBase,
-		minItems: 1,
+		minItems: question.allowEmpty ? 0 : 1,
 		...(multi ? {} : { maxItems: 1 }),
 	};
 	const selectedWithOther: RpcJsonSchema = {
@@ -216,6 +218,8 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 				options: labels,
 				other_option: GATE_OTHER_OPTION,
 				clarification_action: "clarify",
+				allow_empty: question.allowEmpty === true,
+				navigation_label: question.navigationLabel,
 				...(question.deepInterview
 					? structuredDeepInterviewState(question.deepInterview)
 					: deepInterviewQuestionState(question.question)),
@@ -280,12 +284,21 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	}
 	const other = answer.other === true;
 	const totalPicks = deduped.length + (other ? 1 : 0);
-	if (totalPicks === 0) {
+	if (totalPicks === 0 && !question.allowEmpty) {
 		throw new DeepInterviewGateError(
 			"empty_selection",
 			"at least one option (or the free-text other) must be selected",
 		);
 	}
+	if (totalPicks === 0) {
+		return {
+			id: question.id,
+			question: question.question,
+			options: labels,
+			multi,
+			selectedOptions: [],
+		};
+	}
 	if (!multi && totalPicks > 1) {
 		throw new DeepInterviewGateError("multi_not_allowed", "this question accepts a single selection");
 	}
@@ -302,6 +315,36 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	};
 }
 
+/**
+ * Classify an accepted ask-domain gate answer independently of its transport.
+ * Schema-invalid and semantically invalid answers throw, so callers leave the
+ * durable gate pending rather than treating them as a non-committing answer.
+ */
+export function classifyAskGateDisposition(
+	gate: Pick<OpenGateInput, "context" | "options">,
+	answer: unknown,
+): "commit" | "resolve_without_commit" {
+	const state = gate.context?.stage_state;
+	if (typeof state !== "object" || state === null) return "commit";
+	const questionId = (state as Record<string, unknown>).question_id;
+	if (typeof questionId !== "string") return "commit";
+	const question: AskGateQuestion = {
+		id: questionId,
+		question: typeof gate.context?.prompt === "string" ? gate.context.prompt : questionId,
+		options: (gate.options ?? []).map(option => ({
+			label: typeof option.value === "string" ? option.value : option.label,
+		})),
+		multi: (state as Record<string, unknown>).multi === true,
+		allowEmpty: (state as Record<string, unknown>).allow_empty === true,
+	};
+	if (typeof answer === "object" && answer !== null && (answer as Record<string, unknown>).action === "clarify") {
+		gateAnswerToResult(question, answer);
+		return "resolve_without_commit";
+	}
+	const result = gateAnswerToResult(question, answer);
+	return result.selectedOptions.length === 0 && result.customInput === undefined ? "resolve_without_commit" : "commit";
+}
+
 /** Convenience: map a batch of ask questions to gate open-inputs. */
 export function questionsToGates(questions: AskGateQuestion[]): OpenGateInput[] {
 	return questions.map(questionToGate);