@gajae-code/coding-agent 0.3.1 → 0.4.0

package/src/lsp/client.ts

@@ -61,6 +61,10 @@ function stopIdleChecker(): void {
 	}
 }
 
+export function isIdleCheckerActiveForTests(): boolean {
+	return idleCheckInterval !== null;
+}
+
 // =============================================================================
 // Client Capabilities
 // =============================================================================
@@ -919,6 +923,9 @@ export async function sendNotification(client: LspClient, method: string, params
  * Shutdown all LSP clients.
  */
 export async function shutdownAll(): Promise<void> {
+	stopIdleChecker();
+	clientLocks.clear();
+	fileOperationLocks.clear();
 	const clientsToShutdown = Array.from(clients.values());
 	clients.clear();
 	await Promise.allSettled(clientsToShutdown.map(client => shutdownClientInstance(client)));

package/src/main.ts

@@ -26,6 +26,7 @@ import { buildInitialMessage } from "./cli/initial-message";
 import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
+import { activateModelProfile } from "./config/model-profile-activation";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
@@ -194,11 +195,59 @@ export interface AcpSessionFactoryOptions {
 	sessionDir?: string;
 	authStorage: AuthStorage;
 	modelRegistry: ModelRegistry;
-	parsedArgs: Pick<Args, "apiKey">;
+	parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
 	rawArgs: string[];
 	createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
 }
 
+export async function applyStartupModelProfiles(args: {
+	session: AgentSession;
+	settings: Settings;
+	modelRegistry: ModelRegistry;
+	parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+	startupModel?: CreateAgentSessionOptions["model"];
+	startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+}): Promise<void> {
+	const applyProfile = async (profileName: string, persistDefault: boolean): Promise<void> => {
+		await activateModelProfile(
+			{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
+			{ persistDefault },
+		);
+	};
+
+	// Capture the explicitly-selected startup model BEFORE profile activation can
+	// override it. startupModel covers the eager path; session.model covers the
+	// deferred `--model <pattern>` path resolved inside createAgentSession.
+	const explicitModel = args.parsedArgs.model ? (args.startupModel ?? args.session.model) : undefined;
+
+	const defaultProfile = args.settings.get("modelProfile.default");
+	if (defaultProfile) {
+		await applyProfile(defaultProfile, false);
+	}
+	if (args.parsedArgs.mpreset) {
+		await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true);
+	}
+
+	// Explicit CLI --model/--thinking must win over any activated profile.
+	if (explicitModel) {
+		await args.session.setModelTemporary(explicitModel, args.startupThinkingLevel ?? args.parsedArgs.thinking);
+	} else if (args.parsedArgs.thinking && args.session.model) {
+		await args.session.setModelTemporary(args.session.model, args.parsedArgs.thinking);
+	}
+}
+
+export async function applyStartupModelProfilesOrExit(
+	args: Parameters<typeof applyStartupModelProfiles>[0],
+): Promise<void> {
+	try {
+		await applyStartupModelProfiles(args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`${chalk.red(`Error: ${message}`)}\n`);
+		process.exit(1);
+	}
+}
+
 /**
  * Build the per-`session/new` factory used by ACP mode.
  *
@@ -225,6 +274,14 @@ export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSess
 			hasUI: false,
 			enableMCP: false,
 		});
+		await applyStartupModelProfilesOrExit({
+			session: nextSession,
+			settings: nextSettings,
+			modelRegistry: args.modelRegistry,
+			parsedArgs: args.parsedArgs,
+			startupModel: args.baseOptions.model,
+			startupThinkingLevel: args.baseOptions.thinkingLevel,
+		});
 		if (args.parsedArgs.apiKey && !args.baseOptions.model && nextSession.model) {
 			args.authStorage.setRuntimeApiKey(nextSession.model.provider, args.parsedArgs.apiKey);
 		}
@@ -878,6 +935,15 @@ export async function runRootCommand(
 			authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
 		}
 
+		await applyStartupModelProfilesOrExit({
+			session,
+			settings: settingsInstance,
+			modelRegistry,
+			parsedArgs,
+			startupModel: sessionOptions.model,
+			startupThinkingLevel: sessionOptions.thinkingLevel,
+		});
+
 		if (modelFallbackMessage) {
 			notifs.push({ kind: "warn", message: modelFallbackMessage });
 		}

package/src/modes/acp/acp-agent.ts

@@ -50,6 +50,7 @@ import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../
 import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
 import { runExtensionCompact } from "../../extensibility/extensions/compact-handler";
 import { getSessionSlashCommands } from "../../extensibility/extensions/get-commands-handler";
+import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
 import {
 	buildSkillPromptMessage,
 	getSkillSlashCommandNames,
@@ -722,7 +723,18 @@ export class AcpAgent implements Agent {
 			for (let index = 0; index < invocations.length; index += 1) {
 				const invocation = invocations[index];
 				if (!invocation) continue;
-				const built = await buildSkillPromptMessage(invocation.skill, invocation.args);
+				const activationResult = await resolveSubskillActivationForSkillInvocation({
+					cwd: record.session.sessionManager.getCwd(),
+					sessionId: record.session.sessionId,
+					skillName: invocation.skill.name,
+					args: invocation.args,
+				});
+				const built = await buildSkillPromptMessage(invocation.skill, activationResult.cleanedArgs, {
+					subskillActivation: activationResult.activation,
+					subskillActivationSet: activationResult.activeSubskillsToPersist,
+					cwd: record.session.sessionManager.getCwd(),
+					sessionId: record.session.sessionId,
+				});
 				if (index === invocations.length - 1) {
 					await record.session.promptCustomMessage({
 						customType: SKILL_PROMPT_MESSAGE_TYPE,
@@ -757,7 +769,18 @@ export class AcpAgent implements Agent {
 		if (!skill || skill.hide === true) {
 			return false;
 		}
-		const built = await buildSkillPromptMessage(skill, args);
+		const activationResult = await resolveSubskillActivationForSkillInvocation({
+			cwd: record.session.sessionManager.getCwd(),
+			sessionId: record.session.sessionId,
+			skillName: skill.name,
+			args,
+		});
+		const built = await buildSkillPromptMessage(skill, activationResult.cleanedArgs, {
+			subskillActivation: activationResult.activation,
+			subskillActivationSet: activationResult.activeSubskillsToPersist,
+			cwd: record.session.sessionManager.getCwd(),
+			sessionId: record.session.sessionId,
+		});
 		await record.session.promptCustomMessage({
 			customType: SKILL_PROMPT_MESSAGE_TYPE,
 			content: built.message,

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

@@ -1,10 +1,15 @@
+import * as path from "node:path";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
 import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
-import type { RpcCommand, RpcResponse } from "../rpc/rpc-types";
+import type { RpcCommand, RpcResponse, RpcWorkflowGateResponse } from "../rpc/rpc-types";
 import { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
 import { isRpcCommand } from "../shared/agent-wire/command-validation";
-import { BridgeFrameSequencer, toBridgeEventFrame } from "../shared/agent-wire/event-envelope";
+import {
+	BridgeFrameSequencer,
+	toBridgeEventFrame,
+	toBridgeWorkflowGateFrame,
+} from "../shared/agent-wire/event-envelope";
 import type { BridgeCapability } from "../shared/agent-wire/handshake";
 import {
 	type BridgeHandshakeRequest,
@@ -23,6 +28,9 @@ import {
 } from "../shared/agent-wire/scopes";
 import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
 import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
+import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
+import { FileGateStore } from "../shared/agent-wire/workflow-gate-broker";
 import { assertSafeBridgeBind, isBridgeTokenAuthorized } from "./auth";
 import { type BridgePermissionRequestPayload, createBridgeClientBridge } from "./bridge-client-bridge";
 import { BridgeExtensionUIContext, type BridgeUiRequestPayload } from "./bridge-ui-context";
@@ -39,6 +47,7 @@ const SERVER_CAPABILITIES: readonly BridgeCapability[] = [
 	"ui.declarative",
 	"host_tools",
 	"host_uri",
+	"workflow_gate",
 ];
 
 const DEFAULT_BRIDGE_SCOPES: readonly BridgeCommandScope[] = ["prompt"];
@@ -71,6 +80,7 @@ const SERVER_FRAME_TYPES: readonly BridgeFrameType[] = [
 	"host_tool_call",
 	"host_uri_request",
 	"reset",
+	"workflow_gate",
 	"error",
 ];
 
@@ -86,6 +96,7 @@ interface BridgeFetchHandlerOptions {
 	hostToolBridge?: RpcHostToolBridge;
 	hostUriBridge?: RpcHostUriBridge;
 	endpointMatrix?: Partial<BridgeEndpointMatrix>;
+	unattendedControlPlane?: UnattendedSessionControlPlane;
 }
 
 interface BridgeIdempotencyRecord {
@@ -174,6 +185,15 @@ function bridgeHelpResponse(matrix: BridgeEndpointMatrix): Response {
 	});
 }
 
+function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "exceeded" | "aborted" | "info" {
+	if (event.includes("denied")) return "denied";
+	if (event.includes("exceeded")) return "exceeded";
+	if (event.includes("abort")) return "aborted";
+	if (event.includes("rejected") || event.includes("conflict")) return "rejected";
+	if (event.includes("accepted") || event.includes("negotiated") || event.includes("emitted")) return "accepted";
+	return "info";
+}
+
 function frameTypeForDispatchOutput(obj: RpcResponse | object): BridgeFrameType {
 	const type = typeof obj === "object" && obj !== null && "type" in obj ? (obj as { type?: unknown }).type : undefined;
 	if (type === "host_tool_call" || type === "host_tool_cancel") return "host_tool_call";
@@ -219,6 +239,24 @@ export function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (r
 			if (!isBridgeHandshakeRequest(payload)) {
 				return jsonResponse(400, { error: "invalid_request" });
 			}
+			let acceptedUnattended = options.unattendedControlPlane?.isUnattended() ? payload.unattended : undefined;
+			if (
+				acceptedUnattended === undefined &&
+				payload.unattended !== undefined &&
+				endpointMatrix.events &&
+				options.unattendedControlPlane
+			) {
+				try {
+					options.unattendedControlPlane.negotiate(payload.unattended);
+					acceptedUnattended = payload.unattended;
+				} catch (err) {
+					const error =
+						err instanceof Error && "code" in err
+							? { code: (err as { code: unknown }).code, message: err.message }
+							: { error: err instanceof Error ? err.message : String(err) };
+					return jsonResponse(403, error);
+				}
+			}
 			return jsonResponse(
 				200,
 				negotiateBridgeHandshake(payload, {
@@ -243,6 +281,7 @@ export function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (r
 							: "",
 					},
 					frameTypes: endpointMatrix.events ? SERVER_FRAME_TYPES : [],
+					acceptedUnattended,
 				}),
 			);
 		}
@@ -360,6 +399,36 @@ export function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (r
 			} catch {
 				return jsonResponse(400, { error: "invalid_json" });
 			}
+			if (
+				payload !== null &&
+				typeof payload === "object" &&
+				"gate_id" in payload &&
+				"answer" in payload &&
+				(correlationId === (payload as RpcWorkflowGateResponse).gate_id || correlationId.startsWith("wg_"))
+			) {
+				try {
+					const resolution = await options.unattendedControlPlane?.resolveGate({
+						gate_id: (payload as RpcWorkflowGateResponse).gate_id,
+						answer: (payload as RpcWorkflowGateResponse).answer,
+						idempotency_key: (payload as RpcWorkflowGateResponse).idempotency_key ?? idempotencyKey,
+					});
+					if (resolution) {
+						rememberIdempotencyResponse(options.idempotencyCache, idempotencyKey, {
+							route: url.pathname,
+							ownerToken,
+							body,
+							response: resolution,
+						});
+						return jsonResponse(200, resolution);
+					}
+				} catch (err) {
+					const error =
+						err instanceof Error && "code" in err
+							? { code: (err as { code: unknown }).code, message: err.message }
+							: { error: err instanceof Error ? err.message : String(err) };
+					return jsonResponse(409, error);
+				}
+			}
 			const permissionResult = options.permissionBroker?.respond(
 				correlationId,
 				ownerToken,
@@ -490,6 +559,57 @@ export async function runBridgeMode(
 	const hostToolBridge = new RpcHostToolBridge(output);
 	const hostUriBridge = new RpcHostUriBridge(output);
 	const idempotencyCache: BridgeIdempotencyCache = new Map();
+	const auditLog = new UnattendedAuditLog(defaultAuditPath(session.sessionId, session.sessionManager.getCwd()), {
+		redactAnswers: true,
+	});
+	const recordAudit = (event: { event: string; [key: string]: unknown }) => {
+		const payload =
+			typeof event.payload === "object" && event.payload !== null
+				? (event.payload as Record<string, unknown>)
+				: undefined;
+		const gateId =
+			typeof event.gate_id === "string"
+				? event.gate_id
+				: typeof payload?.gate_id === "string"
+					? payload.gate_id
+					: undefined;
+		auditLog.record({
+			run_id: session.sessionId,
+			session_id: session.sessionId,
+			actor: typeof event.actor === "string" ? event.actor : undefined,
+			event: event.event,
+			outcome: auditOutcomeFor(event.event),
+			dedupe_key: `${event.event}:${gateId ?? "run"}:${JSON.stringify(payload ?? event)}`,
+			gate_id: gateId,
+			stage: typeof event.stage === "string" ? (event.stage as never) : undefined,
+			kind: typeof event.kind === "string" ? (event.kind as never) : undefined,
+			scope: typeof payload?.scope === "string" ? payload.scope : undefined,
+			action: typeof payload?.action === "string" ? payload.action : undefined,
+			budget: event.event === "budget_exceeded" ? (payload as never) : undefined,
+			answer_hash: typeof event.answer_hash === "string" ? event.answer_hash : undefined,
+			error: payload && event.event.endsWith("denied") ? payload : undefined,
+		});
+	};
+	const gateStore = new FileGateStore(
+		path.join(session.sessionManager.getCwd(), ".gjc", "state", "workflow-gates", `${session.sessionId}.json`),
+	);
+	const unattendedControlPlane = new UnattendedSessionControlPlane({
+		runId: session.sessionId,
+		sessionId: session.sessionId,
+		emitFrame: gate => eventStream.publish(toBridgeWorkflowGateFrame(gate, sequencer)),
+		store: gateStore,
+		audit: recordAudit,
+		getUsageSnapshot: () => {
+			const stats = session.getSessionStats();
+			return { tokens: stats.tokens.total, costUsd: stats.cost };
+		},
+	});
+	session.setWorkflowGateEmitter(unattendedControlPlane);
+	unattendedControlPlane
+		.recover()
+		.catch(err =>
+			eventStream.publish(sequencer.next("error", { error: err instanceof Error ? err.message : String(err) })),
+		);
 
 	Bun.serve({
 		hostname,
@@ -505,6 +625,7 @@ export async function runBridgeMode(
 			hostToolBridge,
 			hostUriBridge,
 			commandScopes,
+			unattendedControlPlane,
 			commandDispatcher: command =>
 				dispatchRpcCommand(command, {
 					session,
@@ -512,6 +633,7 @@ export async function runBridgeMode(
 					hostToolRegistry: hostToolBridge,
 					hostUriRegistry: hostUriBridge,
 					createUiContext: () => uiContext,
+					unattendedControlPlane,
 				}),
 		}),
 	});

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

@@ -0,0 +1,318 @@
+import { Container, Input, matchesKey, Spacer, Text, TruncatedText } from "@gajae-code/tui";
+import type { ProviderCompatibility, ProviderSetupInput } from "../../setup/provider-onboarding";
+import { theme } from "../theme/theme";
+import { matchesAppInterrupt } from "../utils/keybinding-matchers";
+import { DynamicBorder } from "./dynamic-border";
+
+export type CustomProviderCredentialSource = "env" | "literal";
+
+type WizardStep =
+	| "compatibility"
+	| "provider-id"
+	| "base-url"
+	| "credential-source"
+	| "credential"
+	| "models"
+	| "confirm"
+	| "force-confirm";
+
+interface WizardState {
+	compatibility: ProviderCompatibility;
+	providerId: string;
+	baseUrl: string;
+	credentialSource: CustomProviderCredentialSource;
+	credential: string;
+	models: string;
+}
+
+export type CustomProviderWizardSubmit = ProviderSetupInput;
+
+export class CustomProviderWizardComponent extends Container {
+	#contentContainer: Container;
+	#input: Input | null = null;
+	#step: WizardStep = "compatibility";
+	#selectedIndex = 0;
+	#lastSubmitError: string | null = null;
+	#state: WizardState = {
+		compatibility: "openai",
+		providerId: "",
+		baseUrl: "",
+		credentialSource: "env",
+		credential: "",
+		models: "",
+	};
+	#onSubmit: (input: CustomProviderWizardSubmit) => void;
+	#onCancel: () => void;
+	#onRender: () => void;
+
+	constructor(
+		onSubmit: (input: CustomProviderWizardSubmit) => void,
+		onCancel: () => void,
+		onRender: () => void = () => {},
+	) {
+		super();
+		this.#onSubmit = onSubmit;
+		this.#onCancel = onCancel;
+		this.#onRender = onRender;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(new TruncatedText(theme.bold("Add custom provider")));
+		this.addChild(
+			new TruncatedText(theme.fg("muted", "  Configure an OpenAI- or Anthropic-compatible API provider."), 0, 0),
+		);
+		this.addChild(new Spacer(1));
+		this.#contentContainer = new Container();
+		this.addChild(this.#contentContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+		this.#renderStep();
+	}
+
+	setSubmitError(error: string): void {
+		this.#lastSubmitError = error;
+		if (error.includes("already exists")) {
+			this.#step = "force-confirm";
+			this.#selectedIndex = 1;
+		}
+		this.#renderStep();
+		this.#onRender();
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesAppInterrupt(keyData)) {
+			if (this.#step === "compatibility") {
+				this.#onCancel();
+				return;
+			}
+			this.#goBack();
+			return;
+		}
+
+		if (this.#input) {
+			if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+				this.#saveInputAndProceed();
+				return;
+			}
+			this.#input.handleInput(keyData);
+			return;
+		}
+
+		if (matchesKey(keyData, "up")) {
+			this.#moveSelection(-1);
+			return;
+		}
+		if (matchesKey(keyData, "down")) {
+			this.#moveSelection(1);
+			return;
+		}
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			this.#selectCurrentOption();
+		}
+	}
+
+	#renderStep(): void {
+		this.#contentContainer.clear();
+		this.#input = null;
+		switch (this.#step) {
+			case "compatibility":
+				this.#renderCompatibilityStep();
+				break;
+			case "provider-id":
+				this.#renderInputStep(
+					"Step 2: Provider id",
+					"Enter a provider id:",
+					this.#state.providerId,
+					"e.g. my-openai-proxy",
+				);
+				break;
+			case "base-url":
+				this.#renderInputStep(
+					"Step 3: Base URL",
+					"Enter the API base URL:",
+					this.#state.baseUrl,
+					"e.g. https://api.example.com/v1",
+				);
+				break;
+			case "credential-source":
+				this.#renderCredentialSourceStep();
+				break;
+			case "credential":
+				this.#renderInputStep(
+					"Step 5: Credential",
+					this.#state.credentialSource === "env"
+						? "Enter the API key environment variable name:"
+						: "Paste the API key:",
+					this.#state.credential,
+					this.#state.credentialSource === "env"
+						? "e.g. OPENAI_API_KEY"
+						: "The key will be stored in models.yml and redacted in output.",
+				);
+				break;
+			case "models":
+				this.#renderInputStep(
+					"Step 6: Model id(s)",
+					"Enter model ids, comma-separated:",
+					this.#state.models,
+					"e.g. gpt-5, claude-sonnet-4-5",
+				);
+				break;
+			case "confirm":
+				this.#renderConfirmStep(false);
+				break;
+			case "force-confirm":
+				this.#renderConfirmStep(true);
+				break;
+		}
+	}
+
+	#renderCompatibilityStep(): void {
+		this.#contentContainer.addChild(new Text(theme.fg("accent", "Step 1: Compatibility")));
+		this.#contentContainer.addChild(new Spacer(1));
+		const options: Array<{ value: ProviderCompatibility; label: string }> = [
+			{ value: "openai", label: "OpenAI-compatible" },
+			{ value: "anthropic", label: "Anthropic-compatible" },
+		];
+		for (let i = 0; i < options.length; i++) this.#addOption(i, options[i]?.label ?? "");
+		this.#addHelp("[↑↓ to navigate, Enter to select, Esc to cancel]");
+	}
+
+	#renderCredentialSourceStep(): void {
+		this.#contentContainer.addChild(new Text(theme.fg("accent", "Step 4: Credential source")));
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#addOption(0, "Environment variable");
+		this.#addOption(1, "Paste API key");
+		this.#addHelp("[↑↓ to navigate, Enter to select, Esc to go back]");
+	}
+
+	#renderInputStep(title: string, prompt: string, value: string, hint: string): void {
+		this.#contentContainer.addChild(new Text(theme.fg("accent", title)));
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#contentContainer.addChild(new Text(prompt, 0, 0));
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#input = new Input();
+		this.#input.setValue(value);
+		this.#contentContainer.addChild(this.#input);
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#addHelp(hint);
+		this.#addHelp("[Enter to continue, Esc to go back]");
+	}
+
+	#renderConfirmStep(force: boolean): void {
+		this.#contentContainer.addChild(
+			new Text(theme.fg("accent", force ? "Provider exists — replace it?" : "Confirm custom provider")),
+		);
+		this.#contentContainer.addChild(new Spacer(1));
+		if (this.#lastSubmitError) {
+			this.#contentContainer.addChild(new Text(theme.fg(force ? "warning" : "error", this.#lastSubmitError), 0, 0));
+			this.#contentContainer.addChild(new Spacer(1));
+		}
+		this.#contentContainer.addChild(new Text(`Compatibility: ${this.#state.compatibility}`, 0, 0));
+		this.#contentContainer.addChild(new Text(`Provider: ${this.#state.providerId}`, 0, 0));
+		this.#contentContainer.addChild(new Text(`Base URL: ${this.#state.baseUrl}`, 0, 0));
+		this.#contentContainer.addChild(
+			new Text(
+				`Credential: ${this.#state.credentialSource === "env" ? this.#state.credential : "pasted API key"}`,
+				0,
+				0,
+			),
+		);
+		this.#contentContainer.addChild(new Text(`Models: ${this.#state.models}`, 0, 0));
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#addOption(0, force ? "Replace existing provider" : "Add provider");
+		this.#addOption(1, "Go back");
+		this.#addHelp("[↑↓ to navigate, Enter to select, Esc to go back]");
+	}
+
+	#addOption(index: number, label: string): void {
+		const selected = index === this.#selectedIndex;
+		const prefix = selected ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
+		this.#contentContainer.addChild(new Text(`${prefix}${selected ? theme.fg("accent", label) : label}`, 0, 0));
+	}
+
+	#addHelp(text: string): void {
+		this.#contentContainer.addChild(new Text(theme.fg("muted", text), 0, 0));
+	}
+
+	#saveInputAndProceed(): void {
+		const value = this.#input?.getValue().trim() ?? "";
+		if (!value) return;
+		if (this.#step === "provider-id") {
+			this.#state.providerId = value;
+			this.#step = "base-url";
+		} else if (this.#step === "base-url") {
+			this.#state.baseUrl = value;
+			this.#step = "credential-source";
+			this.#selectedIndex = 0;
+		} else if (this.#step === "credential") {
+			this.#state.credential = value;
+			this.#step = "models";
+		} else if (this.#step === "models") {
+			this.#state.models = value;
+			this.#step = "confirm";
+			this.#selectedIndex = 0;
+			this.#lastSubmitError = null;
+		}
+		this.#renderStep();
+		this.#onRender();
+	}
+
+	#selectCurrentOption(): void {
+		if (this.#step === "compatibility") {
+			this.#state.compatibility = this.#selectedIndex === 0 ? "openai" : "anthropic";
+			this.#step = "provider-id";
+		} else if (this.#step === "credential-source") {
+			this.#state.credentialSource = this.#selectedIndex === 0 ? "env" : "literal";
+			this.#state.credential = "";
+			this.#step = "credential";
+		} else if (this.#step === "confirm" || this.#step === "force-confirm") {
+			if (this.#selectedIndex === 0) {
+				this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+				return;
+			}
+			this.#step = "models";
+		}
+		this.#renderStep();
+		this.#onRender();
+	}
+
+	#buildInput(force: boolean): CustomProviderWizardSubmit {
+		return {
+			compatibility: this.#state.compatibility,
+			providerId: this.#state.providerId,
+			baseUrl: this.#state.baseUrl,
+			apiKeyEnv: this.#state.credentialSource === "env" ? this.#state.credential : undefined,
+			apiKey: this.#state.credentialSource === "literal" ? this.#state.credential : undefined,
+			models: this.#state.models
+				.split(",")
+				.map(model => model.trim())
+				.filter(Boolean),
+			force,
+		};
+	}
+
+	#moveSelection(delta: number): void {
+		const maxIndex =
+			this.#step === "confirm" ||
+			this.#step === "force-confirm" ||
+			this.#step === "compatibility" ||
+			this.#step === "credential-source"
+				? 1
+				: 0;
+		this.#selectedIndex = (this.#selectedIndex + delta + maxIndex + 1) % (maxIndex + 1);
+		this.#renderStep();
+		this.#onRender();
+	}
+
+	#goBack(): void {
+		if (this.#step === "provider-id") this.#step = "compatibility";
+		else if (this.#step === "base-url") this.#step = "provider-id";
+		else if (this.#step === "credential-source") this.#step = "base-url";
+		else if (this.#step === "credential") this.#step = "credential-source";
+		else if (this.#step === "models") this.#step = "credential";
+		else if (this.#step === "confirm" || this.#step === "force-confirm") this.#step = "models";
+		this.#selectedIndex = 0;
+		this.#renderStep();
+		this.#onRender();
+	}
+}