@gajae-code/coding-agent 0.10.2 → 0.11.1

package/src/modes/acp/acp-client-bridge.ts

@@ -21,27 +21,9 @@ import type {
 	ClientBridgePermissionToolCall,
 	ClientBridgeTerminalHandle,
 } from "../../session/client-bridge";
+import { resolveAcpPermissionMode } from "./permission-mode";
 
-type AcpPermissionMode = "auto" | "prompt" | "always-allow";
-
-const ACP_PERMISSION_MODE_ENV = "GJC_ACP_PERMISSION_MODE";
-
-function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
-	if (value === "auto" || value === "prompt" || value === "always-allow") return value;
-	return "prompt";
-}
-
-/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
-function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined): AcpPermissionMode {
-	const meta = clientCapabilities?._meta;
-	if (typeof meta === "object" && meta !== null) {
-		const gjc = (meta as { gjc?: unknown }).gjc;
-		if (typeof gjc === "object" && gjc !== null && "permissionHandling" in gjc) {
-			return parseAcpPermissionMode((gjc as { permissionHandling?: unknown }).permissionHandling);
-		}
-	}
-	return parseAcpPermissionMode(process.env[ACP_PERMISSION_MODE_ENV]);
-}
+export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 
 export function createAcpClientBridge(
 	connection: AgentSideConnection,

package/src/modes/acp/acp-event-mapper.ts

@@ -232,6 +232,24 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "todo_auto_clear":
 			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries: [] })];
+		case "model_fallback_switched":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						gjcModelFallbackSwitched: true,
+						gjcModelFallbackEventId: event.eventId,
+						gjcModelFallbackFrom: event.from,
+						gjcModelFallbackTo: event.to,
+						gjcModelFallbackReason: event.reason,
+						gjcModelFallbackRole: event.role,
+						gjcModelFallbackScope: event.scope,
+						gjcModelFallbackActiveIndex: event.activeIndex,
+						gjcModelFallbackChainLength: event.chainLength,
+						gjcModelFallbackAttemptsUsed: event.attemptsUsed,
+					},
+				}),
+			];
 		// These event types are intentionally not represented as ACP session updates.
 		case "agent_start":
 		case "agent_end":
@@ -278,8 +296,6 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "auto_retry_start":
 		case "auto_retry_end":
-		case "retry_fallback_applied":
-		case "retry_fallback_succeeded":
 		case "ttsr_triggered":
 		case "irc_message":
 		case "subagent_steer_message":

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

@@ -1,50 +1,22 @@
 import * as stream from "node:stream";
 import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
-import type { AgentSession } from "../../session/agent-session";
 import { AcpAgent } from "./acp-agent";
+import type { AcpStartupOptions } from "./startup-options";
 
-export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-
-export interface AcpConnectionHandle {
-	connection: AgentSideConnection;
-	agent: AcpAgent;
-}
-
-export function createAcpConnection(
-	transport: Stream,
-	createSession: AcpSessionFactory,
-	initialSession?: AgentSession,
-): AgentSideConnection {
-	return createAcpConnectionWithAgent(transport, createSession, initialSession).connection;
+export interface AcpModeOptions {
+	agentDir?: string;
+	startupOptions?: AcpStartupOptions;
 }
 
-/**
- * Create an ACP connection and return both the {@link AgentSideConnection} and the
- * underlying {@link AcpAgent}. Callers that need to await agent shutdown (terminal
- * delete/dispose work) after transport closure should use this instead of
- * {@link createAcpConnection}.
- */
-export function createAcpConnectionWithAgent(
-	transport: Stream,
-	createSession: AcpSessionFactory,
-	initialSession?: AgentSession,
-): AcpConnectionHandle {
-	let agent: AcpAgent | undefined;
-	const connection = new AgentSideConnection(conn => {
-		agent = new AcpAgent(conn, createSession, initialSession);
-		return agent;
-	}, transport);
-	return { connection, agent: agent! };
+export function createAcpConnection(transport: Stream, options: AcpModeOptions = {}): AgentSideConnection {
+	return new AgentSideConnection(conn => new AcpAgent(conn, options), transport);
 }
 
-export async function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never> {
+export async function runAcpMode(options: AcpModeOptions = {}): Promise<never> {
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);
-	const { connection, agent } = createAcpConnectionWithAgent(transport, createSession, initialSession);
+	const connection = createAcpConnection(transport, options);
 	await connection.closed;
-	// Await connection-local terminal work (active deletes, disposal) so
-	// `process.exit` never kills in-flight deletion/cleanup.
-	await agent.shutdownPromise;
 	process.exit(0);
 }

package/src/modes/acp/permission-mode.ts

@@ -0,0 +1,25 @@
+import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+
+export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+
+const ACP_PERMISSION_MODE_ENV = "GJC_ACP_PERMISSION_MODE";
+
+function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
+	if (value === "auto" || value === "prompt" || value === "always-allow") return value;
+	return "prompt";
+}
+
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+export function resolveAcpPermissionMode(
+	clientCapabilities: ClientCapabilities | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): AcpPermissionMode {
+	const meta = clientCapabilities?._meta;
+	if (typeof meta === "object" && meta !== null) {
+		const gjc = (meta as { gjc?: unknown }).gjc;
+		if (typeof gjc === "object" && gjc !== null && "permissionHandling" in gjc) {
+			return parseAcpPermissionMode((gjc as { permissionHandling?: unknown }).permissionHandling);
+		}
+	}
+	return parseAcpPermissionMode(env[ACP_PERMISSION_MODE_ENV]);
+}

package/src/modes/acp/startup-options.ts

@@ -0,0 +1,6 @@
+/** Startup settings that ACP can apply through the canonical SDK control surface. */
+export interface AcpStartupOptions {
+	modelId?: string;
+	modelPreset?: string;
+	thinkingLevel?: string;
+}

package/src/modes/components/agent-dashboard.ts

@@ -40,6 +40,7 @@ import {
 	resolveConfiguredModelPatterns,
 	resolveModelOverride,
 } from "../../config/model-resolver";
+import { type ModelSelectorValue, selectorHead } from "../../config/model-selector-value";
 import { Settings } from "../../config/settings";
 import agentCreationArchitectPrompt from "../../prompts/system/agent-creation-architect.md" with { type: "text" };
 import agentCreationUserPrompt from "../../prompts/system/agent-creation-user.md" with { type: "text" };
@@ -84,6 +85,35 @@ interface AgentDashboardModelContext {
 	defaultModelPattern?: string;
 }
 
+export function resolveAgentCreationModel(
+	modelPatterns: string[],
+	modelRegistry: ModelRegistry,
+	settings: Settings | undefined,
+) {
+	const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	if (model) return model;
+	if (modelPatterns.length > 0) {
+		throw new Error(`Configured model selector(s) did not resolve: ${modelPatterns.join(", ")}.`);
+	}
+
+	const fallbackModel = modelRegistry.getAvailable()[0];
+	if (!fallbackModel) {
+		throw new Error("No available model to generate agent specification.");
+	}
+	return fallbackModel;
+}
+
+export function updateAgentModelOverride(
+	overrides: Record<string, ModelSelectorValue>,
+	agentName: string,
+	rawValue: string,
+): Record<string, ModelSelectorValue> {
+	const value = rawValue.trim();
+	if (value) return { ...overrides, [agentName]: value };
+	const { [agentName]: _, ...remainingOverrides } = overrides;
+	return remainingOverrides;
+}
+
 const SOURCE_ORDER: Record<AgentSource, number> = {
 	project: 0,
 	user: 1,
@@ -370,7 +400,7 @@ export class AgentDashboard extends Container {
 				.map(agent => ({
 					...agent,
 					disabled: disabled.has(agent.name),
-					overrideModel: overrides[agent.name]?.trim() || undefined,
+					overrideModel: selectorHead(overrides[agent.name])?.trim() || undefined,
 				}));
 
 			this.#tabs = this.#buildTabs(this.#allAgents);
@@ -465,16 +495,10 @@ export class AgentDashboard extends Container {
 		this.#settingsManager.set("task.disabledAgents", disabled);
 	}
 
-	#persistModelOverrides(): void {
+	#persistModelOverride(agentName: string, rawValue: string): void {
 		if (!this.#settingsManager) return;
-		const overrides: Record<string, string> = {};
-		for (const agent of this.#allAgents) {
-			const value = agent.overrideModel?.trim();
-			if (value) {
-				overrides[agent.name] = value;
-			}
-		}
-		this.#settingsManager.set("task.agentModelOverrides", overrides);
+		const overrides = this.#settingsManager.get("task.agentModelOverrides");
+		this.#settingsManager.set("task.agentModelOverrides", updateAgentModelOverride(overrides, agentName, rawValue));
 	}
 
 	#toggleSelectedAgent(): void {
@@ -506,7 +530,7 @@ export class AgentDashboard extends Container {
 		if (!selected) return;
 		const value = rawValue.trim();
 		selected.overrideModel = value || undefined;
-		this.#persistModelOverrides();
+		this.#persistModelOverride(selected.name, value);
 		this.#editingAgentName = null;
 		this.#editInput = null;
 		this.#applyFilters();
@@ -587,12 +611,7 @@ export class AgentDashboard extends Container {
 				settings?.getModelRole("default"),
 			settings,
 		);
-		const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
-		const fallbackModel = modelRegistry.getAvailable()[0];
-		const selectedModel = model ?? fallbackModel;
-		if (!selectedModel) {
-			throw new Error("No available model to generate agent specification.");
-		}
+		const selectedModel = resolveAgentCreationModel(modelPatterns, modelRegistry, settings);
 
 		const systemPrompt = prompt.render(agentCreationArchitectPrompt, { TASK_TOOL_NAME: "task" });
 		const userPrompt = prompt.render(agentCreationUserPrompt, { request: description });
@@ -605,6 +624,7 @@ export class AgentDashboard extends Container {
 			model: selectedModel,
 			systemPrompt: [systemPrompt],
 			hasUI: false,
+			notificationHostModeSupported: false,
 			enableLsp: false,
 			enableMCP: false,
 			disableExtensionDiscovery: true,

package/src/modes/components/model-selector.ts

@@ -25,9 +25,11 @@ import {
 } from "../../config/model-registry";
 import {
 	formatModelSelectorValue,
+	resolveConfiguredModelPatterns,
 	resolveModelRoleValue,
 	type ScopedModelSelection,
 } from "../../config/model-resolver";
+import { type ModelSelectorValue, normalizeModelSelectorValue, selectorHead } from "../../config/model-selector-value";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import type { Settings } from "../../config/settings";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
@@ -227,9 +229,8 @@ function profileRequiredProviders(profile: ModelProfileDefinition): string[] {
 	return [...new Set(profile.requiredProviders)].sort((a, b) => a.localeCompare(b));
 }
 
-function isInheritedRoleSelector(value: string | undefined): boolean {
-	const normalized = value?.trim();
-	return !normalized || normalized === "default" || normalized === "pi/default";
+function isInheritedRoleSelector(value: string): boolean {
+	return value === "default" || value === "pi/default";
 }
 
 function getDefaultAliasThinkingLevel(value: string | undefined): ThinkingLevel | undefined {
@@ -245,28 +246,35 @@ function getSelectorProvider(selector: string): string | undefined {
 
 function deriveRequiredProviders(modelMapping: ModelProfileConfig["model_mapping"]): string[] {
 	const providers = new Set<string>();
-	for (const selector of Object.values(modelMapping)) {
-		const provider = getSelectorProvider(selector);
-		if (provider) providers.add(provider);
+	for (const selectorValue of Object.values(modelMapping)) {
+		for (const selector of normalizeModelSelectorValue(selectorValue)) {
+			const provider = getSelectorProvider(selector);
+			if (provider) providers.add(provider);
+		}
 	}
 	return [...providers].sort((a, b) => a.localeCompare(b));
 }
 
-function sameStringRecord(
-	left: Readonly<Record<string, string | undefined>>,
-	right: Readonly<Record<string, string | undefined>>,
+function sameModelSelectorRecord(
+	left: Readonly<Record<string, ModelSelectorValue | undefined>>,
+	right: Readonly<Record<string, ModelSelectorValue | undefined>>,
 ): boolean {
 	const leftEntries = Object.entries(left)
-		.filter((entry): entry is [string, string] => entry[1] !== undefined)
+		.filter((entry): entry is [string, ModelSelectorValue] => entry[1] !== undefined)
 		.sort(([a], [b]) => a.localeCompare(b));
 	const rightEntries = Object.entries(right)
-		.filter((entry): entry is [string, string] => entry[1] !== undefined)
+		.filter((entry): entry is [string, ModelSelectorValue] => entry[1] !== undefined)
 		.sort(([a], [b]) => a.localeCompare(b));
 	if (leftEntries.length !== rightEntries.length) return false;
 	for (let i = 0; i < leftEntries.length; i++) {
 		const leftEntry = leftEntries[i];
 		const rightEntry = rightEntries[i];
-		if (!leftEntry || !rightEntry || leftEntry[0] !== rightEntry[0] || leftEntry[1] !== rightEntry[1]) {
+		if (
+			!leftEntry ||
+			!rightEntry ||
+			leftEntry[0] !== rightEntry[0] ||
+			!sameStringArray(normalizeModelSelectorValue(leftEntry[1]), normalizeModelSelectorValue(rightEntry[1]))
+		) {
 			return false;
 		}
 	}
@@ -318,6 +326,7 @@ export class ModelSelectorComponent extends Container {
 	#currentModel?: Model;
 	#currentThinkingLevel?: ThinkingLevel;
 	#activeModelProfile?: string;
+	#configuredDefaultChain?: readonly string[];
 	#isFastForProvider: (provider?: string) => boolean = () => false;
 	#isFastForSubagentProvider: (provider?: string) => boolean = () => false;
 	#isCurrentModelFastModeActive: () => boolean = () => false;
@@ -359,6 +368,7 @@ export class ModelSelectorComponent extends Container {
 			isCurrentModelFastModeActive?: () => boolean;
 			currentThinkingLevel?: ThinkingLevel;
 			activeModelProfile?: string;
+			configuredDefaultChain?: readonly string[];
 		},
 	) {
 		super();
@@ -374,6 +384,7 @@ export class ModelSelectorComponent extends Container {
 		this.#currentModel = _currentModel;
 		this.#currentThinkingLevel = options?.currentThinkingLevel;
 		this.#activeModelProfile = options?.activeModelProfile;
+		this.#configuredDefaultChain = options?.configuredDefaultChain;
 		this.#isFastForProvider = options?.isFastForProvider ?? (() => false);
 		this.#isFastForSubagentProvider = options?.isFastForSubagentProvider ?? (() => false);
 		// Current-model EFFECTIVE fast state. Defaults to intent for the current
@@ -451,6 +462,24 @@ export class ModelSelectorComponent extends Container {
 		});
 	}
 
+	#isActiveDefaultFallback(): boolean {
+		if (!this.#currentModel) return false;
+		const configuredChain =
+			this.#configuredDefaultChain ?? normalizeModelSelectorValue(this.#settings.getModelRole("default"));
+		if (configuredChain.length < 2) return false;
+
+		const allModels = this.#modelRegistry.getAll();
+		const matchPreferences = { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() };
+		return configuredChain.slice(1).some(selector => {
+			const resolved = resolveModelRoleValue(selector, allModels, {
+				settings: this.#settings,
+				matchPreferences,
+				modelRegistry: this.#modelRegistry,
+			});
+			return resolved.model !== undefined && modelsAreEqual(resolved.model, this.#currentModel);
+		});
+	}
+
 	#loadRoleModels(): void {
 		const allModels = this.#modelRegistry.getAll();
 		const matchPreferences = { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() };
@@ -476,7 +505,12 @@ export class ModelSelectorComponent extends Container {
 				};
 			}
 		}
-		if (this.#activeModelProfile && this.#currentModel) {
+		if (
+			((this.#configuredDefaultChain?.length ?? 0) > 0 ||
+				this.#activeModelProfile ||
+				this.#isActiveDefaultFallback()) &&
+			this.#currentModel
+		) {
 			this.#roles.default = {
 				model: this.#currentModel,
 				thinkingLevel: this.#currentThinkingLevel ?? ThinkingLevel.Inherit,
@@ -835,33 +869,57 @@ export class ModelSelectorComponent extends Container {
 		return formatModelSelectorValue(`${this.#currentModel.provider}/${this.#currentModel.id}`, thinkingLevel);
 	}
 
-	#resolveProfileModelSelector(value: string | undefined): string | undefined {
-		const normalized = value?.trim();
-		if (isInheritedRoleSelector(normalized)) return undefined;
+	#resolveProfileModelSelector(value: ModelSelectorValue | undefined): string | string[] | undefined {
+		const resolvedSelectors: string[] = [];
+		for (const configuredSelector of normalizeModelSelectorValue(value)) {
+			if (isInheritedRoleSelector(configuredSelector)) continue;
+			const selectors = resolveConfiguredModelPatterns(configuredSelector, this.#settings);
+			for (const selector of selectors.length > 0 ? selectors : [configuredSelector]) {
+				const resolved = resolveModelRoleValue(selector, this.#modelRegistry.getAll(), {
+					settings: this.#settings,
+					matchPreferences: { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() },
+					modelRegistry: this.#modelRegistry,
+				});
+				if (resolved.model) {
+					resolvedSelectors.push(
+						formatModelSelectorValue(`${resolved.model.provider}/${resolved.model.id}`, resolved.thinkingLevel),
+					);
+					continue;
+				}
 
-		const resolved = resolveModelRoleValue(normalized, this.#modelRegistry.getAll(), {
-			settings: this.#settings,
-			matchPreferences: { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() },
-			modelRegistry: this.#modelRegistry,
-		});
-		if (resolved.model) {
-			return formatModelSelectorValue(`${resolved.model.provider}/${resolved.model.id}`, resolved.thinkingLevel);
-		}
+				const inheritedDefaultThinkingLevel = getDefaultAliasThinkingLevel(selector);
+				if (inheritedDefaultThinkingLevel) {
+					const currentSelector = this.#formatCurrentModelSelector(inheritedDefaultThinkingLevel);
+					if (currentSelector) resolvedSelectors.push(currentSelector);
+					continue;
+				}
 
-		const inheritedDefaultThinkingLevel = getDefaultAliasThinkingLevel(normalized);
-		if (inheritedDefaultThinkingLevel) return this.#formatCurrentModelSelector(inheritedDefaultThinkingLevel);
-		return undefined;
+				// Preserve unresolved chain members verbatim instead of silently
+				// truncating configured fallback tails.
+				resolvedSelectors.push(selector);
+			}
+		}
+		if (resolvedSelectors.length === 0) return undefined;
+		return resolvedSelectors.length === 1 ? resolvedSelectors[0] : resolvedSelectors;
 	}
 
 	#buildCustomModelProfileSnapshot(): ModelProfileConfig {
 		const modelMapping: ModelProfileConfig["model_mapping"] = {};
-		const currentModelSelector = this.#formatCurrentModelSelector();
-		if (currentModelSelector) {
-			modelMapping.default = currentModelSelector;
+		// Prefer the session's configured default chain so fallback tails are
+		// never dropped from the snapshot; the live model only replaces the head.
+		if (this.#configuredDefaultChain && this.#configuredDefaultChain.length > 0) {
+			const head = this.#formatCurrentModelSelector() ?? this.#configuredDefaultChain[0]!;
+			const tail = this.#configuredDefaultChain.slice(1);
+			modelMapping.default = tail.length > 0 ? [head, ...tail] : head;
 		} else {
-			const defaultRole = this.#settings.getModelRole("default");
-			const defaultSelector = this.#resolveProfileModelSelector(defaultRole);
-			if (defaultSelector) modelMapping.default = defaultSelector;
+			const currentModelSelector = this.#formatCurrentModelSelector();
+			if (currentModelSelector) {
+				modelMapping.default = currentModelSelector;
+			} else {
+				const defaultRole = this.#settings.getModelRole("default");
+				const defaultSelector = this.#resolveProfileModelSelector(defaultRole);
+				if (defaultSelector) modelMapping.default = defaultSelector;
+			}
 		}
 
 		const agentOverrides = this.#settings.get("task.agentModelOverrides");
@@ -880,7 +938,7 @@ export class ModelSelectorComponent extends Container {
 	#findDuplicateGeneratedProfile(snapshot: ModelProfileConfig): ModelProfileDefinition | undefined {
 		for (const profile of this.#modelRegistry.getModelProfiles?.().values() ?? []) {
 			if (
-				sameStringRecord(profile.modelMapping, snapshot.model_mapping) &&
+				sameModelSelectorRecord(profile.modelMapping, snapshot.model_mapping) &&
 				sameStringArray(profile.requiredProviders, snapshot.required_providers)
 			) {
 				return profile;
@@ -1148,7 +1206,7 @@ export class ModelSelectorComponent extends Container {
 			});
 			const label = GJC_MODEL_ASSIGNMENT_TARGETS[role].tag ?? role.toUpperCase();
 			this.#listContainer.addChild(
-				new Text(`  ${label}: ${formatClampedModelSelector(selector, resolved.model)}`, 0, 0),
+				new Text(`  ${label}: ${formatClampedModelSelector(selectorHead(selector) ?? "", resolved.model)}`, 0, 0),
 			);
 		}
 		this.#listContainer.addChild(new Spacer(1));