@gajae-code/coding-agent 0.17.1 → 0.17.4

package/src/config/model-registry.ts

@@ -18,6 +18,7 @@ import {
 	getBundledModels,
 	getBundledProviders,
 	getEnvApiKey,
+	getMiniMaxThinkingMode,
 	googleAntigravityModelManagerOptions,
 	googleGeminiCliModelManagerOptions,
 	isCodexGpt56Tier,
@@ -43,6 +44,9 @@ import { fetchModelsDevPayload } from "@gajae-code/ai/provider-models/openai-com
 import { isDirectXaiReasoningEffortModel } from "@gajae-code/ai/providers/openai-completions-compat";
 import {
 	detectDiscoveredApiFamily,
+	isSafeCatalogModelId,
+	MODELS_LIST_REQUEST_TIMEOUT_MS,
+	readBoundedModelsJson,
 	resolveLoopbackOpenAIBaseUrl,
 } from "@gajae-code/ai/utils/discovery/openai-compatible";
 
@@ -143,6 +147,36 @@ function redactDiscoveryUrl(value: string | URL): string {
 	}
 }
 
+/**
+ * Scrub resolved credential material from a discovery failure before it is
+ * published to discovery state, cache provenance, or the logger. Mutates
+ * Error messages and stacks in place to preserve class/identity; wraps non-Errors.
+ */
+export function scrubDiscoveryError(error: unknown, secrets: ReadonlyArray<string | undefined>): unknown {
+	const redact = (text: string): string => {
+		let scrubbed = text;
+		for (const secret of secrets) {
+			if (secret) scrubbed = scrubbed.split(secret).join("[redacted]");
+		}
+		return scrubbed;
+	};
+	if (error instanceof Error) {
+		const seen = new Set<Error>();
+		const scrubError = (current: Error): void => {
+			if (seen.has(current)) return;
+			seen.add(current);
+			current.message = redact(current.message);
+			if (typeof current.stack === "string") current.stack = redact(current.stack);
+			if (current.cause instanceof Error) scrubError(current.cause);
+			else if (typeof current.cause === "string") current.cause = redact(current.cause);
+		};
+		scrubError(error);
+		return error;
+	}
+	if (typeof error === "string") return redact(error);
+	return error;
+}
+
 /** Whether a structured transport code proves that no listener accepted the connection. */
 function isConnectionRefusedDiscoveryCode(value: unknown): boolean {
 	if (typeof value === "string") {
@@ -280,6 +314,7 @@ export const GJC_MODEL_ASSIGNMENT_TARGETS: Record<GjcModelAssignmentTargetId, Gj
 
 export function requiresExplicitThinkingChoice(model: Model, role: GjcModelAssignmentTargetId | null): boolean {
 	if (!modelSupportsReasoningControl(model)) return false;
+	if (getMiniMaxThinkingMode(model) === "toggle") return true;
 	if (model.provider === "openai" || model.provider === "openai-codex" || isDirectXaiReasoningEffortModel(model))
 		return true;
 	if (role === null) return false;
@@ -740,13 +775,26 @@ function registryModelMetadataWithoutApiSpecificFields(model: Model<Api>): Parti
 	return metadata;
 }
 
-function registrySelectorResolvesToModel(selector: string, models: readonly Model<Api>[]): boolean {
-	if (models.some(model => model.id === selector || `${model.provider}/${model.id}` === selector)) return true;
-	const suffix = splitSelectorThinkingSuffix(selector);
-	const baseSelector = suffix.thinkingLevel === undefined ? selector : suffix.selector;
+export function registrySelectorResolvesToModel(selector: string, models: readonly Model<Api>[]): boolean {
+	const normalizedSelector = selector.trim().toLowerCase();
+	if (
+		models.some(
+			model =>
+				model.id.toLowerCase() === normalizedSelector ||
+				`${model.provider}/${model.id}`.toLowerCase() === normalizedSelector,
+		)
+	)
+		return true;
+	const suffix = splitSelectorThinkingSuffix(normalizedSelector);
+	const baseSelector = suffix.thinkingLevel === undefined ? normalizedSelector : suffix.selector;
 	const parsed = parseModelString(baseSelector);
-	if (parsed) return models.some(model => model.provider === parsed.provider && model.id === parsed.id);
-	return models.some(model => model.id === baseSelector || model.id.endsWith(`/${baseSelector}`));
+	if (parsed)
+		return models.some(
+			model => model.provider.toLowerCase() === parsed.provider && model.id.toLowerCase() === parsed.id,
+		);
+	return models.some(
+		model => model.id.toLowerCase() === baseSelector || model.id.toLowerCase().endsWith(`/${baseSelector}`),
+	);
 }
 
 function filterMaterializedRegistryProfiles(
@@ -3247,7 +3295,7 @@ export class ModelRegistry {
 			);
 			if (
 				evidence !== undefined &&
-				state?.status === "ok" &&
+				(state?.status === "ok" || state?.status === "empty") &&
 				discovery.fetched &&
 				currentAuthGeneration === evidence.authGeneration &&
 				currentEndpoint === evidence.endpoint
@@ -3285,8 +3333,8 @@ export class ModelRegistry {
 	}
 
 	#profileAvailabilityEvidenceFingerprint(): string {
-		return JSON.stringify(
-			[...this.#descriptorDiscoveryEvidence.entries()]
+		return JSON.stringify({
+			descriptor: [...this.#descriptorDiscoveryEvidence.entries()]
 				.sort(([left], [right]) => left.localeCompare(right))
 				.map(([provider, evidence]) => [
 					provider,
@@ -3298,7 +3346,15 @@ export class ModelRegistry {
 					[...evidence.modelIds].sort(),
 					evidence.profileModelIds === undefined ? undefined : [...evidence.profileModelIds].sort(),
 				]),
-		);
+			configured: [...this.#configuredDiscoveryEvidence.entries()]
+				.sort(([left], [right]) => left.localeCompare(right))
+				.map(([provider, evidence]) => [
+					provider,
+					evidence.authGeneration,
+					evidence.endpoint,
+					[...evidence.modelIds].sort(),
+				]),
+		});
 	}
 
 	#mergeDiscoveredModels(discovered: readonly Model<Api>[]): void {
@@ -3494,8 +3550,14 @@ export class ModelRegistry {
 						await this.#discoverModelsByProviderType(provider, apiKey),
 					);
 				} catch (error) {
-					discoveryFailureEvidence = error;
-					throw error;
+					// ONE credential-safe discovery error boundary: transport
+					// layers may echo request details (including the bearer)
+					// in failure text. Scrub resolved credential material
+					// before the error reaches discovery state, cache
+					// provenance, or the logger below.
+					const scrubbedError = scrubDiscoveryError(error, [apiKey, preflightApiKey]);
+					discoveryFailureEvidence = scrubbedError;
+					throw scrubbedError;
 				}
 			},
 			getEvidenceGeneration: provider => this.#getProviderEvidenceGeneration(provider.provider, preflightApiKey),
@@ -3567,24 +3629,35 @@ export class ModelRegistry {
 		};
 	}
 
-	#discoverModelsByProviderType(
+	async #discoverModelsByProviderType(
 		providerConfig: DiscoveryProviderConfig,
 		apiKey: string | undefined,
 	): Promise<Model<Api>[]> {
+		let models: Model<Api>[];
 		switch (providerConfig.discovery.type) {
 			case "ollama":
-				return this.#discoverOllamaModels(providerConfig, apiKey);
+				models = await this.#discoverOllamaModels(providerConfig, apiKey);
+				break;
 			case "llama.cpp":
-				return this.#discoverLlamaCppModels(providerConfig, apiKey);
+				models = await this.#discoverLlamaCppModels(providerConfig, apiKey);
+				break;
 			case "lm-studio":
 			case "omlx":
 			case "vllm":
 			case "sglang":
 			case "openai-models-list":
-				return this.#discoverOpenAIModelsList(providerConfig, apiKey);
+				models = await this.#discoverOpenAIModelsList(providerConfig, apiKey);
+				break;
 			case "models-dev":
-				return this.#discoverModelsDevProvider(providerConfig);
+				models = await this.#discoverModelsDevProvider(providerConfig);
+				break;
 		}
+		if (providerConfig.discovery.type === "openai-models-list" && models.length === 0) {
+			throw new Error(
+				`Model discovery for ${redactDiscoveryUrl(providerConfig.baseUrl ?? "")} returned no models; add --model <id> or fix the endpoint catalog.`,
+			);
+		}
+		return models;
 	}
 
 	async #discoverBuiltInProviderModels(
@@ -4220,7 +4293,7 @@ export class ModelRegistry {
 			...(providerConfig.discovery.type === "vllm" || providerConfig.discovery.type === "sglang"
 				? { redirect: "error" as const }
 				: {}),
-			signal: AbortSignal.timeout(hardenedLocalDiscovery ? 500 : 5_000),
+			signal: AbortSignal.timeout(hardenedLocalDiscovery ? 500 : MODELS_LIST_REQUEST_TIMEOUT_MS),
 		});
 		if (!response.ok) {
 			if (response.status === 401 || response.status === 403) {
@@ -4232,16 +4305,31 @@ export class ModelRegistry {
 			}
 			throw new Error(`HTTP ${response.status} from ${redactDiscoveryUrl(modelsUrl)}`);
 		}
-		const payload: unknown = await response.json();
+		// Shared 1MB bounded reader (same as the setup probe): a timeout
+		// bounds wall clock, not bytes buffered.
+		let payload: unknown;
+		try {
+			payload = await readBoundedModelsJson(response);
+		} catch {
+			throw new Error(`Malformed OpenAI models-list response from ${redactDiscoveryUrl(modelsUrl)}`);
+		}
 		if (!isRecord(payload) || !Array.isArray(payload.data)) {
 			throw new Error(`Malformed OpenAI models-list response from ${redactDiscoveryUrl(modelsUrl)}`);
 		}
 		const models = payload.data;
 		const discovered: Model<Api>[] = [];
 		for (const item of models) {
-			if (!isRecord(item) || typeof item.id !== "string" || !item.id.trim()) continue;
-			const id = item.id;
+			// Shared catalog admission: the setup probe applies the same
+			// check, so IDs that appear only between requests cannot enter
+			// the live catalog or cache unsanitized.
+			if (!isRecord(item) || !isSafeCatalogModelId(item.id)) continue;
+			const id = item.id.trim();
 			const referenceModel = resolveCustomModelReference(id);
+			// Names render directly in the model selector: apply the same
+			// text-safety admission, falling back to the reference name or
+			// the safe ID.
+			const rawName = typeof item.name === "string" ? item.name.trim() : "";
+			const name = rawName && isSafeCatalogModelId(rawName) ? rawName : (referenceModel?.name ?? id);
 			const discoveredMaxTokens = firstPositiveDiscoveryNumber(
 				item.max_completion_tokens,
 				item.max_tokens,
@@ -4251,7 +4339,7 @@ export class ModelRegistry {
 			discovered.push(
 				enrichModelThinking({
 					id,
-					name: typeof item.name === "string" ? item.name : (referenceModel?.name ?? id),
+					name,
 					api,
 					provider: providerConfig.provider,
 					baseUrl: requestBaseUrl,
@@ -4770,6 +4858,25 @@ export class ModelRegistry {
 		return [...this.#configuredProviderIds];
 	}
 
+	/**
+	 * Whether this registry can serve a provider id from any active source.
+	 *
+	 * Built-in providers are backed by the bundled AI catalog, configured
+	 * providers come from models.yml, and extension registrations are retained
+	 * in the runtime provider stores below. Runtime model/override state is
+	 * included for direct registrations that do not have an extension source id.
+	 */
+	isKnownProvider(provider: string): boolean {
+		return (
+			isKnownProvider(provider) ||
+			this.#configuredProviderIds.has(provider) ||
+			this.#runtimeProviderSourceByName.has(provider) ||
+			this.#runtimeModelOverlays.some(model => model.provider === provider) ||
+			this.#runtimeProviderApiKeys.has(provider) ||
+			this.#runtimeProviderOverrides.has(provider)
+		);
+	}
+
 	#isModelAvailable(model: Model<Api>, disabledProviders?: ReadonlySet<string>): boolean {
 		const disabled = disabledProviders ?? getDisabledProviderIdsFromSettings(this.#settings);
 		return (
@@ -5205,8 +5312,10 @@ export class ModelRegistry {
 	}
 
 	/**
-	 * Get only models that have auth configured.
-	 * This is a fast check that doesn't refresh OAuth tokens.
+	 * Get selectable models with auth configured.
+	 * This is a fast check that doesn't refresh OAuth tokens. A current,
+	 * authoritative live catalog also limits each provider to its enrolled ids;
+	 * bundled entries remain the fallback until that evidence exists.
 	 */
 	getAvailable(): Model<Api>[] {
 		this.#synchronizeEnvironmentCredentials();
@@ -5220,12 +5329,82 @@ export class ModelRegistry {
 		) {
 			return this.#availableModelsCache;
 		}
-		this.#availableModelsCache = this.#models.filter(model => this.#isModelAvailable(model, disabledProviders));
+		const authoritativeDiscoveryIds = new Map<string, ReadonlySet<string> | undefined>();
+		const bundledIdsByProvider = new Map<string, Set<string>>();
+		this.#availableModelsCache = this.#models.filter(model => {
+			if (!this.#isModelAvailable(model, disabledProviders)) return false;
+
+			let liveIds = authoritativeDiscoveryIds.get(model.provider);
+			if (!authoritativeDiscoveryIds.has(model.provider)) {
+				liveIds = this.#getAuthoritativeDiscoveredModelIds(model.provider);
+				authoritativeDiscoveryIds.set(model.provider, liveIds);
+			}
+			// Undefined means discovery has not run successfully for the current
+			// provider context. Keep the bundled catalog as the explicit fallback.
+			if (liveIds === undefined) return true;
+			if (this.#hasCustomModelOverlay(model.provider, model.id)) return true;
+
+			const activity = this.#providerActivity.get(model.provider);
+			if (!activity?.staticModelIds.has(model.id)) return liveIds.has(model.id);
+
+			let bundledIds = bundledIdsByProvider.get(model.provider);
+			if (!bundledIds) {
+				bundledIds = new Set(
+					(getBundledModels(model.provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[]).map(
+						candidate => candidate.id,
+					),
+				);
+				bundledIdsByProvider.set(model.provider, bundledIds);
+			}
+			return !bundledIds.has(model.id) || liveIds.has(model.id);
+		});
 		this.#availableModelsDisabledProviders = disabledProviderKey;
 		this.#availableModelsEnvFingerprint = envFingerprint;
 		return this.#availableModelsCache;
 	}
 
+	/**
+	 * Return the current live model ids only when discovery produced an
+	 * authoritative catalog for the provider and endpoint. An unavailable or
+	 * failed discovery returns undefined so callers retain the bundled fallback.
+	 */
+	#getAuthoritativeDiscoveredModelIds(provider: string): ReadonlySet<string> | undefined {
+		const descriptorEvidence = this.#descriptorDiscoveryEvidence.get(provider);
+		if (descriptorEvidence?.profileFresh && descriptorEvidence.profileModelIds !== undefined) {
+			try {
+				if (
+					descriptorEvidence.authGeneration === this.#getProviderEvidenceGeneration(provider) &&
+					descriptorEvidence.profileEndpoint ===
+						this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(provider) ?? "")
+				) {
+					return descriptorEvidence.profileModelIds;
+				}
+			} catch {
+				// A provider context that can no longer be verified must use its fallback.
+			}
+		}
+
+		const configuredEvidence = this.#configuredDiscoveryEvidence.get(provider);
+		if (!configuredEvidence) return undefined;
+		const discoveryState = this.#discoveryManager.getState(provider);
+		if (
+			discoveryState?.status !== "ok" &&
+			discoveryState?.status !== "cached" &&
+			discoveryState?.status !== "empty"
+		) {
+			return undefined;
+		}
+		try {
+			return configuredEvidence.authGeneration === this.#getProviderEvidenceGeneration(provider) &&
+				configuredEvidence.endpoint ===
+					this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(provider) ?? "")
+				? configuredEvidence.modelIds
+				: undefined;
+		} catch {
+			return undefined;
+		}
+	}
+
 	#synchronizeEnvironmentCredentials(): void {
 		// Runtime registrations own a provider while their credential is present.
 		// Refresh them first so a missing runtime env key can hand ownership back to

package/src/config/settings-schema.ts

@@ -369,6 +369,24 @@ const AUTOROUTING_PROVENANCE_JSON_SCHEMA: JsonSchemaObject = {
 	required: ["schema", "source", "declarationFingerprint", "tiersFingerprint"],
 };
 
+// SDK prompt deadline defaults. The `sdk.promptDeadlineMs` /
+// `sdk.promptMaxRuntimeMs` schema entries below and the SDK bus/host lease
+// fallbacks read these same constants, so a Settings lookup that misses — no
+// settings object, an unwritten key, a non-finite value — cannot arm a deadline
+// that disagrees with the declared default (#5583).
+export const DEFAULT_SDK_PROMPT_DEADLINE_MS = 3_600_000;
+export const DEFAULT_SDK_PROMPT_MAX_RUNTIME_MS = 21_600_000;
+
+/** Resolve a `sdk.promptDeadlineMs` lookup, falling back on any non-finite value. */
+export function resolveSdkPromptDeadlineMs(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_SDK_PROMPT_DEADLINE_MS;
+}
+
+/** Resolve a `sdk.promptMaxRuntimeMs` lookup, falling back on any non-finite value. */
+export function resolveSdkPromptMaxRuntimeMs(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_SDK_PROMPT_MAX_RUNTIME_MS;
+}
+
 export const SETTINGS_SCHEMA = {
 	// ────────────────────────────────────────────────────────────────────────
 	// General settings (no UI)
@@ -416,16 +434,22 @@ export const SETTINGS_SCHEMA = {
 	// SDK-owned prompt deadline. Hidden from the UI; ACP has no separate timeout.
 	"sdk.promptDeadlineMs": {
 		type: "number",
-		default: 3_600_000,
+		default: DEFAULT_SDK_PROMPT_DEADLINE_MS,
 		description: "SDK-owned prompt deadline; ACP has no separate timeout.",
 		validate: (value: number) => Number.isSafeInteger(value) && value >= 60_000 && value <= 86_400_000,
 	},
 	"sdk.promptMaxRuntimeMs": {
 		type: "number",
-		default: 21_600_000,
+		default: DEFAULT_SDK_PROMPT_MAX_RUNTIME_MS,
 		description: "Hard maximum runtime for an SDK prompt from acceptance, bounding progress-aware renewals.",
 		validate: (value: number) => Number.isSafeInteger(value) && value >= 60_000 && value <= 86_400_000,
 	},
+	"sdk.flushWorktreeOnDeadline": {
+		type: "boolean",
+		default: true,
+		description:
+			"Autosave uncommitted changes in the session's linked worktree by default as a WIP commit when a prompt deadline retires a prompt; primary checkouts require an explicit true opt-in.",
+	},
 	"sdk.masterOrphanGraceMs": {
 		type: "number",
 		default: 120_000,

package/src/coordinator-mcp/policy.ts

@@ -275,11 +275,16 @@ export async function assertCoordinatorSessionLocations(
 	]);
 	// Reauthorize both persisted locations independently. A managed worktree may
 	// differ from the requested cwd, but neither may escape the current roots.
-	if (
-		!roots.some(root => isInsideCanonicalRoot(canonicalCwd, root, platform)) ||
-		!roots.some(root => isInsideCanonicalRoot(canonicalWorkspace, root, platform))
-	)
-		throw new Error("coordinator_workdir_outside_allowed_roots");
+	const escaped: string[] = [];
+	if (!roots.some(root => isInsideCanonicalRoot(canonicalCwd, root, platform))) escaped.push(`cwd ${canonicalCwd}`);
+	if (!roots.some(root => isInsideCanonicalRoot(canonicalWorkspace, root, platform)))
+		escaped.push(`workspace ${canonicalWorkspace}`);
+	if (escaped.length > 0)
+		// The message stays exact because isSessionAuthorityError() in server.ts matches it
+		// verbatim; the escaping location rides in `cause` so a caller that logs can name it.
+		throw new Error("coordinator_workdir_outside_allowed_roots", {
+			cause: new Error(`outside allowed roots: ${escaped.join(", ")}`),
+		});
 }
 
 export async function assertCoordinatorArtifactPath(

package/src/coordinator-mcp/question-gate-codec.ts

@@ -184,6 +184,23 @@ export function buildCoordinatorAskAnswerSchema(
 	return {
 		title: "CoordinatorQuestionAnswerV1",
 		type: "object",
+		// `additionalProperties: false` is scoped by the SIBLING `properties` map, not by
+		// the `oneOf` branches: a standards-compliant validator evaluates the keyword
+		// against this node alone. Without this map every answer field was "additional",
+		// so selection, custom-answer, and clarification payloads were all rejected
+		// client-side before the server saw them (#5801). Each branch stays closed too,
+		// so the union still rejects field combinations this map alone would allow.
+		properties: {
+			selected: selectedBase,
+			other: { type: "boolean", description: "set true to provide a free-text answer in `custom`" },
+			custom: boundedAnswerText("free-text answer; required when `other` is true"),
+			action: {
+				type: "string",
+				enum: ["answer", "clarify"],
+				description: "set to `clarify` to ask about the choices without answering the round",
+			},
+			question: boundedAnswerText("clarification question; required when action is `clarify`"),
+		},
 		additionalProperties: false,
 		oneOf: [
 			{