@gajae-code/coding-agent 0.11.3 → 0.11.4

package/src/gjc-runtime/state-runtime.ts

@@ -42,6 +42,7 @@ import {
 	SessionResolutionError,
 	writeSessionActivityMarker,
 } from "./session-resolution";
+import { classifyStateArgv, firstStateFlagValue, type StateAction, type StateArgvClassification } from "./state-argv";
 import { renderStateGraph, type StateGraphFormat } from "./state-graph";
 import { migrateAndPersistLegacyState, migrateWorkflowState } from "./state-migrations";
 import {
@@ -72,7 +73,7 @@ import {
 	writeGuardedWorkflowEnvelopeAtomic,
 } from "./state-writer";
 import { assertSafePathComponent, CommandError, flagValue, hasFlag, isPlainObject } from "./workflow-cli-common";
-import { getSkillManifest, isKnownWorkflowState, isValidTransition, typedArgsFor } from "./workflow-manifest";
+import { getSkillManifest, isKnownWorkflowState, isValidTransition } from "./workflow-manifest";
 
 /**
  * Native implementation of the `gjc state read|write|clear` command surface.
@@ -99,136 +100,9 @@ class StateCommandError extends CommandError {
 }
 
 const GRAPH_FORMATS = new Set(["ascii", "mermaid", "dot"]);
-const FLAGS_WITH_VALUES = new Set([
-	"--input",
-	"--mode",
-	"--session-id",
-	"--thread-id",
-	"--turn-id",
-	"--to",
-	"--skill",
-	"--format",
-	"--older-than",
-	"--status",
-	"--fields",
-	"--since",
-	"--limit",
-]);
-const ACTION_NAMES = new Set([
-	"read",
-	"write",
-	"clear",
-	"contract",
-	"handoff",
-	"graph",
-	"prune",
-	"gc",
-	"migrate",
-	"status",
-	"doctor",
-]);
-const BOOLEAN_FLAGS = new Set([
-	"--json",
-	"--replace",
-	"--hard",
-	"--dry-run",
-	"--migrate",
-	"--compact",
-	"--history",
-	"--force",
-]);
-const VERB_SPECIFIC_FLAGS = new Set([
-	"--skill",
-	"--format",
-	"--older-than",
-	"--status",
-	"--fields",
-	"--since",
-	"--limit",
-	"--history",
-]);
-
-function flagName(arg: string): string | undefined {
-	if (!arg.startsWith("--")) return undefined;
-	const equalsIndex = arg.indexOf("=");
-	return equalsIndex >= 0 ? arg.slice(0, equalsIndex) : arg;
-}
-
-function manifestFlagNames(action: ParsedInvocation["action"], positionalSkill: string | undefined): Set<string> {
-	const names = new Set<string>();
-	const skills =
-		positionalSkill && KNOWN_MODES.includes(positionalSkill)
-			? [positionalSkill as CanonicalGjcWorkflowSkill]
-			: CANONICAL_GJC_WORKFLOW_SKILLS;
-	for (const skill of skills) {
-		for (const arg of typedArgsFor(skill, action)) names.add(`--${arg.name}`);
-	}
-	return names;
-}
-
-function assertKnownFlags(args: readonly string[], parsed: ParsedInvocation): void {
-	const manifestFlags = manifestFlagNames(parsed.action, parsed.positionalSkill);
-	for (const arg of args) {
-		const flag = flagName(arg);
-		if (!flag) continue;
-		if (
-			FLAGS_WITH_VALUES.has(flag) ||
-			BOOLEAN_FLAGS.has(flag) ||
-			VERB_SPECIFIC_FLAGS.has(flag) ||
-			manifestFlags.has(flag)
-		) {
-			continue;
-		}
-		throw new StateCommandError(2, `unknown gjc state flag: ${flag}`);
-	}
-}
-
-interface ParsedInvocation {
-	action:
-		| "read"
-		| "write"
-		| "clear"
-		| "contract"
-		| "handoff"
-		| "graph"
-		| "prune"
-		| "gc"
-		| "migrate"
-		| "status"
-		| "doctor";
-	positionalSkill?: string;
-}
-
-function parsePositionalArgs(args: readonly string[]): ParsedInvocation {
-	let skipNext = false;
-	const positional: string[] = [];
-	for (const arg of args) {
-		if (skipNext) {
-			skipNext = false;
-			continue;
-		}
-		if (FLAGS_WITH_VALUES.has(arg)) {
-			skipNext = true;
-			continue;
-		}
-		if (!arg.startsWith("-")) positional.push(arg);
-	}
-	// Documented argv shapes:
-	//   gjc state read|write|clear|contract ...
-	//   gjc state <skill> read|write|contract ...
-	const first = positional[0];
-	const second = positional[1];
-	if (first && ACTION_NAMES.has(first)) {
-		return { action: first as ParsedInvocation["action"], positionalSkill: second };
-	}
-	if (first && second && ACTION_NAMES.has(second)) {
-		return { action: second as ParsedInvocation["action"], positionalSkill: first };
-	}
-	// `gjc state <skill>` alone defaults to read for that skill.
-	if (first && !second) {
-		return { action: "read", positionalSkill: first };
-	}
-	return { action: "read" };
+function assertKnownFlags(classification: StateArgvClassification): void {
+	const [unknownFlag] = classification.unknownFlags;
+	if (unknownFlag) throw new StateCommandError(2, `unknown gjc state flag: ${unknownFlag}`);
 }
 
 function isKnownMode(mode: string): mode is CanonicalGjcWorkflowSkill {
@@ -279,19 +153,16 @@ interface ResolvedSelectors {
 // `clear` resolves like a read (explicit -> payload -> env -> latest-activity marker)
 // per the spec: read/status/clear may fall back to the most-recent session. Commands
 // that create or mutate new state roots still require an explicit/env session id.
-const WRITE_SESSION_ACTIONS = new Set<ParsedInvocation["action"]>(["write", "handoff", "prune", "migrate"]);
+const WRITE_SESSION_ACTIONS = new Set<StateAction>(["write", "handoff", "prune", "migrate"]);
 
-async function resolveSelectors(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-	action: ParsedInvocation["action"],
-): Promise<ResolvedSelectors> {
-	const payload = await readInputJson(flagValue(args, "--input"), cwd);
+async function resolveSelectors(args: readonly string[], cwd: string, action: StateAction): Promise<ResolvedSelectors> {
+	const classification = classifyStateArgv(args);
+	const payload = await readInputJson(firstStateFlagValue(classification, "--input"), cwd);
 
+	const [modeCandidate, positionalCandidate] = classification.runtimeSelectorCandidates;
 	const candidates: Array<string | undefined> = [
-		flagValue(args, "--mode")?.trim() || undefined,
-		positionalSkill?.trim() || undefined,
+		modeCandidate?.value,
+		positionalCandidate?.value,
 		typeof payload?.mode === "string" ? (payload.mode as string).trim() || undefined : undefined,
 		typeof payload?.skill === "string" ? (payload.skill as string).trim() || undefined : undefined,
 	];
@@ -1232,12 +1103,8 @@ export async function readWorkflowStateJson(
 	return (await readJsonFile(modeStateFile(cwd, skill, session.gjcSessionId))) ?? {};
 }
 
-async function handleRead(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "read");
+async function handleRead(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "read");
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, selectors.gjcSessionId));
 	const fields = parseFieldsFlag(args);
 	if (mode) {
@@ -1276,12 +1143,8 @@ async function handleRead(
 	return { status: 0, stdout: `${JSON.stringify(existing ?? {}, null, 2)}\n` };
 }
 
-async function handleStatus(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "read");
+async function handleStatus(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "read");
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, selectors.gjcSessionId));
 	if (!mode) {
 		throw new StateCommandError(
@@ -1303,12 +1166,8 @@ async function handleStatus(
 	};
 }
 
-async function handleWrite(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "write");
+async function handleWrite(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "write");
 	const { gjcSessionId: sessionId, threadId, turnId, payload } = selectors;
 	if (!payload) throw new StateCommandError(2, "gjc state write requires --input '<json>'");
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, sessionId));
@@ -1465,12 +1324,8 @@ async function handleWrite(
 	);
 }
 
-async function handleClear(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "clear");
+async function handleClear(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "clear");
 	const { gjcSessionId: sessionId, threadId, turnId } = selectors;
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, sessionId));
 	if (!mode)
@@ -1631,12 +1486,8 @@ async function assertDeepInterviewHandoffReady(state: Record<string, unknown>):
  * the phase remains in `skill-active-state.json` until a chain call (or
  * explicit `clear`) demotes it.
  */
-async function handleHandoffUnlocked(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "handoff");
+async function handleHandoffUnlocked(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "handoff");
 	const { gjcSessionId: sessionId, threadId, turnId } = selectors;
 	const caller = selectors.mode ?? (await inferModeFromActiveState(cwd, sessionId));
 	if (!caller) {
@@ -1944,12 +1795,8 @@ async function handleHandoffUnlocked(
 	};
 }
 
-async function handleHandoff(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "handoff");
+async function handleHandoff(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "handoff");
 	// Serialize concurrent handoffs on a dedicated sentinel lock, NOT on the
 	// derived `skill-active-state.json` cache. The inner transaction
 	// (applyHandoffToActiveState / syncSkillActiveState -> rebuildActiveSnapshot)
@@ -1959,15 +1806,11 @@ async function handleHandoff(
 	// `{ cwd }` so the sentinel resolves against the handoff cwd rather than
 	// `process.cwd()`.
 	const handoffLock = path.join(sessionStateDir(cwd, selectors.gjcSessionId), "handoff");
-	return withWorkflowStateLock(handoffLock, async () => handleHandoffUnlocked(args, cwd, positionalSkill), { cwd });
+	return withWorkflowStateLock(handoffLock, async () => handleHandoffUnlocked(args, cwd), { cwd });
 }
 
-async function handleContract(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const { mode } = await resolveSelectors(args, cwd, positionalSkill, "read");
+async function handleContract(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const { mode } = await resolveSelectors(args, cwd, "read");
 	if (!mode) {
 		throw new StateCommandError(2, "gjc state contract requires --mode <skill>, positional <skill>, or input.skill");
 	}
@@ -2195,12 +2038,8 @@ async function handleGraph(
 	};
 }
 
-async function handlePrune(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "prune");
+async function handlePrune(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "prune");
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, selectors.gjcSessionId));
 	if (!mode) {
 		throw new StateCommandError(
@@ -2265,12 +2104,8 @@ async function handleGc(
 	return { status: 0, stdout: `${JSON.stringify(summary, null, 2)}\n` };
 }
 
-async function handleMigrate(
-	args: readonly string[],
-	cwd: string,
-	positionalSkill: string | undefined,
-): Promise<StateCommandResult> {
-	const selectors = await resolveSelectors(args, cwd, positionalSkill, "migrate");
+async function handleMigrate(args: readonly string[], cwd: string): Promise<StateCommandResult> {
+	const selectors = await resolveSelectors(args, cwd, "migrate");
 	const mode = selectors.mode ?? (await inferModeFromActiveState(cwd, selectors.gjcSessionId));
 	if (!mode) {
 		throw new StateCommandError(
@@ -2301,34 +2136,31 @@ async function handleMigrate(
 
 export async function runNativeStateCommand(args: string[], cwd = process.cwd()): Promise<StateCommandResult> {
 	try {
-		const parsed = parsePositionalArgs(args);
-		assertKnownFlags(args, parsed);
-		switch (parsed.action) {
+		const parsed = classifyStateArgv(args);
+		assertKnownFlags(parsed);
+		switch (parsed.effectiveAction) {
 			case "read":
-				if (hasFlag(args, "--migrate")) return await handleMigrate(args, cwd, parsed.positionalSkill);
-				return await handleRead(args, cwd, parsed.positionalSkill);
+				return await handleRead(args, cwd);
 			case "write":
-				return await handleWrite(args, cwd, parsed.positionalSkill);
+				return await handleWrite(args, cwd);
 			case "clear":
-				return await handleClear(args, cwd, parsed.positionalSkill);
+				return await handleClear(args, cwd);
 			case "contract":
-				return await handleContract(args, cwd, parsed.positionalSkill);
+				return await handleContract(args, cwd);
 			case "status":
-				return await handleStatus(args, cwd, parsed.positionalSkill);
+				return await handleStatus(args, cwd);
 			case "doctor":
 				return await handleDoctor(args, cwd, parsed.positionalSkill);
 			case "handoff":
-				return await handleHandoff(args, cwd, parsed.positionalSkill);
+				return await handleHandoff(args, cwd);
 			case "graph":
 				return await handleGraph(args, cwd, parsed.positionalSkill);
 			case "prune":
-				return await handlePrune(args, cwd, parsed.positionalSkill);
+				return await handlePrune(args, cwd);
 			case "gc":
 				return await handleGc(args, cwd, parsed.positionalSkill);
 			case "migrate":
-				return await handleMigrate(args, cwd, parsed.positionalSkill);
-			default:
-				return { status: 2, stderr: `Unknown gjc state command: ${parsed.action}\n` };
+				return await handleMigrate(args, cwd);
 		}
 	} catch (error) {
 		if (error instanceof CommandError) return { status: error.exitStatus, stderr: `${error.message}\n` };

package/src/modes/components/custom-editor.ts

@@ -59,9 +59,22 @@ const DEFAULT_ACTION_KEYS = Object.fromEntries(
 
 const PASTE_DECISION_TIMEOUT_MS = 5_000;
 const PENDING_PASTE_INPUT_MAX = 64;
+const PENDING_PASTE_INPUT_MAX_BYTES = 256 * 1024;
 
 type PastePendingClearReason = "timeout" | "queue-limit";
 
+export interface PasteTextContext {
+	readonly signal: AbortSignal;
+	/** Run one synchronous composer mutation only while this paste transaction is current. */
+	commit(commit: () => boolean): boolean;
+}
+
+interface PendingPasteDecision {
+	readonly controller: AbortController;
+	readonly pasteContent: string;
+	readonly remaining: string;
+}
+
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -94,9 +107,9 @@ export class CustomEditor extends Editor {
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
 	/** Called before bracketed paste content is inserted. Return true to consume it. */
-	onPasteText?: (text: string) => boolean | Promise<boolean>;
-	/** Called when async paste handling drops queued input instead of replaying it. */
-	onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
+	onPasteText?: (text: string, context: PasteTextContext) => boolean | Promise<boolean>;
+	/** Called when pending paste handling is cancelled after restoring queued input. */
+	onPastePendingInputCleared?: (reason: PastePendingClearReason, restoredInputCount: number) => void;
 	/** Called when the configured dequeue shortcut is pressed. */
 	onDequeue?: () => void;
 	/** Called when the configured queue shortcut is pressed. */
@@ -117,7 +130,9 @@ export class CustomEditor extends Editor {
 	#pasteDecisionPending = false;
 	#pasteDecisionToken = 0;
 	#pasteDecisionTimeout: NodeJS.Timeout | undefined;
+	#pendingPasteDecision: PendingPasteDecision | undefined;
 	#pendingPasteInput: string[] = [];
+	#pendingPasteInputBytes = 0;
 
 	setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void {
 		this.#actionKeys.set(action, [...keys]);
@@ -165,75 +180,127 @@ export class CustomEditor extends Editor {
 		}
 	}
 
-	#clearPendingPasteState(): number {
+	#resetPendingPasteState(abortReason?: Error): string[] {
 		this.#clearPasteDecisionTimeout();
+		if (abortReason) this.#pendingPasteDecision?.controller.abort(abortReason);
 		this.#pasteDecisionPending = false;
 		this.#pasteDecisionToken += 1;
-		const droppedInputCount = this.#pendingPasteInput.length;
+		this.#pendingPasteDecision = undefined;
+		const queuedInput = this.#pendingPasteInput;
 		this.#pendingPasteInput = [];
-		return droppedInputCount;
+		this.#pendingPasteInputBytes = 0;
+		return queuedInput;
+	}
+
+	#pendingPasteEventCount(): number {
+		return this.#pendingPasteInput.length + (this.#pendingPasteDecision?.remaining ? 1 : 0);
+	}
+
+	#restoreCancelledPaste(reason: PastePendingClearReason, overflowInput?: string): void {
+		const decision = this.#pendingPasteDecision;
+		const queuedInput = this.#resetPendingPasteState(new Error(`Paste handling cancelled: ${reason}`));
+		if (decision) {
+			super.handleInput(`\x1b[200~${decision.pasteContent}\x1b[201~`);
+			this.#drainPendingPasteInput(decision.remaining, queuedInput);
+			if (overflowInput !== undefined) this.handleInput(overflowInput);
+		}
+		this.onPastePendingInputCleared?.(
+			reason,
+			queuedInput.length + (decision?.remaining ? 1 : 0) + (overflowInput === undefined ? 0 : 1),
+		);
 	}
 
 	#startPasteDecisionTimeout(token: number): void {
 		this.#clearPasteDecisionTimeout();
 		this.#pasteDecisionTimeout = setTimeout(() => {
 			if (token !== this.#pasteDecisionToken) return;
-			const droppedInputCount = this.#clearPendingPasteState();
-			this.onPastePendingInputCleared?.("timeout", droppedInputCount);
+			this.#restoreCancelledPaste("timeout");
 		}, PASTE_DECISION_TIMEOUT_MS);
 		this.#pasteDecisionTimeout.unref?.();
 	}
 
 	dispose(): void {
-		this.#clearPendingPasteState();
+		this.#resetPendingPasteState(new Error("Editor disposed during paste handling"));
 		this.#pasteHandler = new BracketedPasteHandler();
 		super.dispose();
 	}
 
-	#drainPendingPasteInput(initialInput?: string): void {
+	#drainPendingPasteInput(initialInput: string | undefined, queuedInput: readonly string[]): void {
 		if (initialInput && initialInput.length > 0) {
 			this.handleInput(initialInput);
 		}
-		while (!this.#pasteDecisionPending) {
-			const nextInput = this.#pendingPasteInput.shift();
-			if (nextInput === undefined) break;
-			this.handleInput(nextInput);
+		for (const input of queuedInput) {
+			this.handleInput(input);
 		}
 	}
 
 	#handleBracketedPaste(pasteContent: string, remaining: string): void {
-		const applyPasteResult = (token: number, handled: boolean | undefined) => {
+		const remainingBytes = Buffer.byteLength(remaining);
+		if (remainingBytes > PENDING_PASTE_INPUT_MAX_BYTES) {
+			super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
+			if (remaining.length > 0) this.handleInput(remaining);
+			this.onPastePendingInputCleared?.("queue-limit", 1);
+			return;
+		}
+		const token = this.#pasteDecisionToken + 1;
+		const controller = new AbortController();
+		this.#pasteDecisionToken = token;
+		this.#pasteDecisionPending = true;
+		this.#pendingPasteDecision = { controller, pasteContent, remaining };
+		this.#pendingPasteInputBytes = remainingBytes;
+		let commitUsed = false;
+
+		const applyPasteResult = (handled: boolean | undefined) => {
 			if (token !== this.#pasteDecisionToken) return;
-			this.#clearPasteDecisionTimeout();
+			const queuedInput = this.#resetPendingPasteState();
 			if (!handled) {
 				super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
 			}
-			this.#pasteDecisionPending = false;
-			this.#drainPendingPasteInput(remaining);
+			this.#drainPendingPasteInput(remaining, queuedInput);
 		};
-		const pasteResult = this.onPasteText?.(pasteContent);
+
+		let pasteResult: boolean | Promise<boolean> | undefined;
+		try {
+			pasteResult = this.onPasteText?.(pasteContent, {
+				signal: controller.signal,
+				commit: commit => {
+					if (
+						commitUsed ||
+						token !== this.#pasteDecisionToken ||
+						!this.#pasteDecisionPending ||
+						controller.signal.aborted
+					) {
+						return false;
+					}
+					commitUsed = true;
+					return commit();
+				},
+			});
+		} catch {
+			applyPasteResult(false);
+			return;
+		}
 
 		if (pasteResult instanceof Promise) {
-			const token = this.#pasteDecisionToken + 1;
-			this.#pasteDecisionToken = token;
-			this.#pasteDecisionPending = true;
 			this.#startPasteDecisionTimeout(token);
-			void pasteResult.then(
-				handled => applyPasteResult(token, handled),
-				() => applyPasteResult(token, false),
-			);
+			void pasteResult.then(applyPasteResult, () => applyPasteResult(false));
 		} else {
-			applyPasteResult(this.#pasteDecisionToken, pasteResult);
+			applyPasteResult(pasteResult);
 		}
 	}
 
 	handleInput(data: string): void {
 		if (this.#pasteDecisionPending) {
-			this.#pendingPasteInput.push(data);
-			if (this.#pendingPasteInput.length > PENDING_PASTE_INPUT_MAX) {
-				const droppedInputCount = this.#clearPendingPasteState();
-				this.onPastePendingInputCleared?.("queue-limit", droppedInputCount);
+			const inputBytes = Buffer.byteLength(data);
+			if (
+				this.#pendingPasteEventCount() >= PENDING_PASTE_INPUT_MAX ||
+				this.#pendingPasteInputBytes + inputBytes > PENDING_PASTE_INPUT_MAX_BYTES
+			) {
+				this.#restoreCancelledPaste("queue-limit", data);
+				return;
 			}
+			this.#pendingPasteInput.push(data);
+			this.#pendingPasteInputBytes += inputBytes;
 			return;
 		}
 
@@ -245,8 +312,12 @@ export class CustomEditor extends Editor {
 		}
 
 		if (this.onPasteText) {
-			const paste = this.#pasteHandler.process(data);
+			const paste =
+				data === "\x1b" && !this.#pasteHandler.hasPendingFrame
+					? ({ handled: false } as const)
+					: this.#pasteHandler.process(data);
 			if (paste.handled) {
+				if (paste.leading.length > 0) this.handleInput(paste.leading);
 				if (paste.pasteContent !== undefined) {
 					this.onViewportFollowLive?.();
 					this.#handleBracketedPaste(paste.pasteContent, paste.remaining);

package/src/modes/components/custom-provider-wizard.ts

@@ -41,6 +41,7 @@ export class CustomProviderWizardComponent extends Container {
 		credential: "",
 		models: "",
 	};
+	#submitInFlight = false;
 	#onSubmit: (input: CustomProviderWizardSubmit) => void;
 	#onCancel: () => void;
 	#onRender: () => void;
@@ -294,7 +295,7 @@ export class CustomProviderWizardComponent extends Container {
 			this.#step = "credential";
 		} else if (this.#step === "confirm" || this.#step === "force-confirm") {
 			if (this.#selectedIndex === 0) {
-				this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+				this.#submit();
 				return;
 			}
 			this.#step = "models";
@@ -303,6 +304,30 @@ export class CustomProviderWizardComponent extends Container {
 		this.#onRender();
 	}
 
+	#submit(): void {
+		if (this.#submitInFlight) return;
+		this.#submitInFlight = true;
+		let submission: unknown;
+		try {
+			submission = this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+		} catch (error) {
+			this.#submitInFlight = false;
+			throw error;
+		}
+		if (!(submission instanceof Promise)) {
+			this.#submitInFlight = false;
+			return;
+		}
+		void submission.then(
+			() => {
+				this.#submitInFlight = false;
+			},
+			() => {
+				this.#submitInFlight = false;
+			},
+		);
+	}
+
 	#buildInput(force: boolean): CustomProviderWizardSubmit {
 		const input = {
 			compatibility: this.#state.compatibility,