@gajae-code/coding-agent 0.18.5 → 0.18.7

package/src/commands/sdk.ts

@@ -1,9 +1,15 @@
-import { createHash } from "node:crypto";
+import { type ChildProcess, spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
 import * as nodeFs from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { exactRemoveDirectoryTree, type NativeDirectoryTreeSnapshot, snapshotDirectoryTree } from "@gajae-code/natives";
+import {
+	exactRemoveDirectoryTree,
+	exactUnlinkDirect,
+	type NativeDirectoryTreeSnapshot,
+	snapshotDirectoryTree,
+} from "@gajae-code/natives";
 import { logger, postmortem } from "@gajae-code/utils";
 import { CliParseError, Command } from "@gajae-code/utils/cli";
 import type { Args as ParsedArgs } from "../cli/args";
@@ -23,6 +29,7 @@ import {
 	writeBrokerStartupExitRecordBounded,
 } from "../sdk/broker/broker-exit";
 import { readBrokerDiscovery } from "../sdk/broker/discovery";
+import { type EndpointFileRead, readEndpointFile } from "../sdk/broker/endpoint-authority";
 import {
 	emitBrokerStartupTestSignal,
 	reconcileBrokerGenerationForStartup,
@@ -42,6 +49,7 @@ import {
 	writeSessionLifecycleReady,
 } from "../sdk/broker/lifecycle";
 import { processIncarnation } from "../sdk/broker/process-incarnation";
+import { resolveSdkInternalSpawnCommand } from "../sdk/broker/runtime";
 import { writeBrokerStartupFailureMarker } from "../sdk/broker/startup-failure";
 import { runSdkStderrDrainer } from "../sdk/broker/stderr-drainer";
 import { renderSdkSearchTable, runSdkSearch, runSdkSessionCli } from "../sdk/cli";
@@ -651,6 +659,7 @@ export async function runSessionHost(
 	let startupComplete = false;
 	let readinessPublicationCleanupComplete = true;
 	let revokePendingReadinessMarker: (() => Promise<boolean>) | undefined;
+	let revokePublishedReadinessMarker: (() => Promise<boolean>) | undefined;
 	let readinessRevocation: Promise<boolean> | undefined;
 	let startupInterruption: SdkStartupFailure | undefined;
 	const interrupted = Promise.withResolvers<SdkStartupFailure>();
@@ -1265,20 +1274,76 @@ export async function runSessionHost(
 		return failureRollback;
 	};
 	const sessionEndpointPath = path.join(request.stateRoot, "sdk", `${request.sessionId}.json`);
-	const exitAfterSessionDisposal = async (reason?: "detached_idle"): Promise<void> => {
-		await disposeSession(reason);
+	const removeOwnedSessionEndpoint = async (): Promise<boolean> => {
+		try {
+			await fs.stat(sessionEndpointPath);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return true;
+			return false;
+		}
+		const endpoint: EndpointFileRead | undefined = await readEndpointFile(sessionEndpointPath);
+		if (!endpoint) return false;
+		let parsed: { pid?: unknown; sessionId?: unknown };
+		try {
+			parsed = JSON.parse(endpoint.source) as { pid?: unknown; sessionId?: unknown };
+		} catch {
+			return false;
+		}
+		if (parsed.pid !== process.pid || parsed.sessionId !== request.sessionId) {
+			return false;
+		}
+		const removal = (() => {
+			try {
+				return exactUnlinkDirect(sessionEndpointPath, {
+					dev: endpoint.dev,
+					ino: endpoint.ino,
+					nlink: endpoint.nlink,
+					size: endpoint.size,
+					mtimeNs: endpoint.mtimeNs,
+					quarantineName: `.gjc-delete-endpoint-${request.sessionId}-${randomUUID()}`,
+					sha256: createHash("sha256").update(endpoint.source).digest("hex"),
+					allowHardLink: true,
+				});
+			} catch (error) {
+				logger.warn("SDK host endpoint cleanup failed", { error: String(error) });
+				return undefined;
+			}
+		})();
+		if (!removal) return false;
+		return (
+			removal.ok ||
+			removal.code === "not_found" ||
+			(removal.code === "cleanup_pending" &&
+				removal.payloadDurable === true &&
+				!removal.retainedSuccessorPath &&
+				!removal.retainedUnknownPath)
+		);
+	};
+	let unregisterHostPostmortem: (() => void) | undefined;
+	let sessionDisposalExit: Promise<void> | undefined;
+	const exitAfterSessionDisposal = async (reason?: "detached_idle", exitProcess = true): Promise<void> => {
 		let failure: SdkStartupFailure | undefined;
+		let ownsEndpoint = false;
+		const endpointCleanup = (async (): Promise<boolean> => {
+			let complete = await removeOwnedSessionEndpoint();
+			for (let attempt = 0; !complete && attempt < 20; attempt += 1) {
+				await Bun.sleep(25);
+				complete = await removeOwnedSessionEndpoint();
+			}
+			return complete;
+		})();
+		let [endpointCleanupComplete, readinessRevoked] = await Promise.all([
+			endpointCleanup,
+			revokePublishedReadinessMarker?.() ?? Promise.resolve(true),
+		]);
+		await disposeSession(reason);
+		endpointCleanupComplete = await removeOwnedSessionEndpoint();
 		try {
 			const endpoint = JSON.parse(await fs.readFile(sessionEndpointPath, "utf8")) as {
 				pid?: unknown;
 				sessionId?: unknown;
 			};
-			if (endpoint.pid === process.pid && endpoint.sessionId === request.sessionId)
-				failure = {
-					phase: "startup",
-					reason: "failed",
-					message: `SDK host endpoint remained after graceful shutdown: ${request.sessionId}`,
-				};
+			ownsEndpoint = endpoint.pid === process.pid && endpoint.sessionId === request.sessionId;
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
 				failure = {
@@ -1286,27 +1351,57 @@ export async function runSessionHost(
 					reason: "failed",
 					message: `SDK host endpoint cleanup could not be verified: ${request.sessionId}`,
 				};
-			}
+			} else endpointCleanupComplete = true;
 		}
+		if (!ownsEndpoint && !failure && !readinessRevoked && revokePublishedReadinessMarker) {
+			failure = {
+				phase: "startup",
+				reason: "failed",
+				message: `SDK host readiness marker cleanup could not be verified: ${request.sessionId}`,
+			};
+		}
+		if (ownsEndpoint && !endpointCleanupComplete && !failure)
+			failure = {
+				phase: "startup",
+				reason: "failed",
+				message: `SDK host endpoint remained after graceful shutdown: ${request.sessionId}`,
+			};
 		if (failure) {
 			process.exitCode = 1;
 			process.stderr.write(`${failure.message}\n`);
 			await writeFailure(failure, rollback.result).catch(() => {});
 		}
-		process.exit(process.exitCode ?? 0);
+		unregisterHostPostmortem?.();
+		unregisterHostPostmortem = undefined;
+		if (exitProcess) process.exit(process.exitCode ?? 0);
 	};
 	let stopping = false;
+	const requestSessionStop = (reason?: "detached_idle", exitProcess = true): Promise<void> => {
+		if (stopping) return sessionDisposalExit ?? Promise.resolve();
+		stopping = true;
+		sessionDisposalExit = exitAfterSessionDisposal(reason, exitProcess);
+		return sessionDisposalExit;
+	};
 	const stop = (reason?: "detached_idle") => {
 		if (startupComplete) {
-			if (stopping) return;
-			stopping = true;
-			void exitAfterSessionDisposal(reason);
+			void requestSessionStop(reason);
 			return;
 		}
 		const failure = capability.normalizeFailure("startup", "failed", "SDK lifecycle host terminated.");
 		interruptStartup(failure);
 	};
-	const onReadySignal = (): void => stop();
+	const registerHostPostmortem = (): void => {
+		if (unregisterHostPostmortem) return;
+		unregisterHostPostmortem = postmortem.register("sdk-session-host:exit", async reason => {
+			if (reason !== postmortem.Reason.SIGTERM && reason !== postmortem.Reason.SIGINT) return;
+			// The postmortem signal authority defaults to 143/130; a session host
+			// signal is graceful and must preserve its cleanup result instead.
+			await requestSessionStop(undefined, false);
+			process.exitCode = 0;
+			process.exit(0);
+		});
+	};
+	registerHostPostmortem();
 
 	try {
 		const startupThinkingLevel = request.modelId ? parseModelString(request.modelId)?.thinkingLevel : undefined;
@@ -1354,6 +1449,7 @@ export async function runSessionHost(
 						effectMarker,
 						() => startupInterruption === undefined && now() < request.semanticReadyDeadlineAt,
 						revoke => {
+							revokePublishedReadinessMarker = revoke;
 							revokePendingReadinessMarker = revoke;
 							if (startupInterruption !== undefined) startReadinessRevocation(revoke);
 							else if (now() >= request.semanticReadyDeadlineAt) {
@@ -1388,8 +1484,6 @@ export async function runSessionHost(
 		revokePendingReadinessMarker = undefined;
 		readinessRevocation = undefined;
 		removeStartupSignalHandlers();
-		process.once("SIGTERM", onReadySignal);
-		process.once("SIGINT", onReadySignal);
 	} catch (error) {
 		if (error instanceof LifecycleReadinessCleanupError) constructionCleanupComplete = false;
 		const failure =
@@ -1402,8 +1496,6 @@ export async function runSessionHost(
 			await failAfterRollback(durableFailure);
 		} finally {
 			removeStartupSignalHandlers();
-			process.removeListener("SIGTERM", onReadySignal);
-			process.removeListener("SIGINT", onReadySignal);
 		}
 		throw error;
 	}
@@ -1441,6 +1533,7 @@ export async function runSessionHost(
 
 export type SdkInternalArgv =
 	| { action: "broker-internal"; agentDir: string }
+	| { action: "broker-trampoline-internal"; agentDir: string }
 	| { action: "session-host-internal" }
 	| { action: "stderr-drain-internal"; logPath: string; maxBytes: number };
 
@@ -1455,6 +1548,14 @@ export function parseSdkInternalArgv(argv: readonly string[]): SdkInternalArgv {
 		isSafeSdkInternalAgentDir(argv[2])
 	)
 		return { action: "broker-internal", agentDir: argv[2] };
+	if (
+		argv[0] === "broker-trampoline-internal" &&
+		argv.length === 3 &&
+		argv[1] === "--agent-dir" &&
+		typeof argv[2] === "string" &&
+		isSafeSdkInternalAgentDir(argv[2])
+	)
+		return { action: "broker-trampoline-internal", agentDir: argv[2] };
 	if (
 		argv[0] === "stderr-drain-internal" &&
 		argv.length === 5 &&
@@ -1494,6 +1595,7 @@ export default class Sdk extends Command {
 	async run(): Promise<void> {
 		if (
 			this.argv[0] !== "broker-internal" &&
+			this.argv[0] !== "broker-trampoline-internal" &&
 			this.argv[0] !== "session-host-internal" &&
 			this.argv[0] !== "stderr-drain-internal"
 		) {
@@ -1596,7 +1698,55 @@ export default class Sdk extends Command {
 		}
 
 		const internal = parseSdkInternalArgv(this.argv);
-		if (internal.action === "broker-internal") usePostmortemSignalExitAuthority();
+		if (internal.action === "broker-trampoline-internal") {
+			if (process.platform === "win32") throw new CliParseError("Broker trampoline is unavailable on Windows.");
+			const command = resolveSdkInternalSpawnCommand("broker-internal");
+			let child: ChildProcess;
+			try {
+				child = spawn(command.file, [...command.args, "--agent-dir", internal.agentDir], {
+					detached: true,
+					stdio: ["ignore", "ignore", "inherit"],
+					env: command.env,
+					...(command.kind === "bun-source" ? { cwd: command.cwd } : {}),
+				});
+			} catch (error) {
+				throw new Error("Broker trampoline could not start broker.", { cause: error });
+			}
+			let spawnError: Error | undefined;
+			child.once("error", error => {
+				spawnError = error;
+			});
+			if (child.pid === undefined) throw new Error("Broker trampoline could not start broker.");
+			const incarnation = processIncarnation(child.pid);
+			if (!incarnation) {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					// The child may already have exited; either way identity was not established.
+				}
+				throw new Error("Broker trampoline could not observe broker identity.");
+			}
+			if (spawnError) throw new Error("Broker trampoline could not start broker.", { cause: spawnError });
+			const stdoutWrite = Promise.withResolvers<void>();
+			process.stdout.write(`${child.pid}\t${incarnation}\n`, error => {
+				if (error) stdoutWrite.reject(error);
+				else stdoutWrite.resolve();
+			});
+			try {
+				await stdoutWrite.promise;
+			} catch (error) {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					// The child may already have exited; reporting failure remains authoritative.
+				}
+				throw error;
+			}
+			child.unref();
+			return;
+		}
+		if (internal.action === "broker-internal" || internal.action === "session-host-internal")
+			usePostmortemSignalExitAuthority();
 		if (internal.action === "session-host-internal") {
 			await runSessionHost();
 			return;

package/src/commands/update.ts

@@ -13,6 +13,20 @@ import {
 } from "../config/update-channel";
 import { initTheme } from "../modes/theme/theme";
 
+export async function runUpdateRecoveryCommand(
+	recover: () => Promise<void> = () => runManagedNotifyRecovery({}),
+): Promise<void> {
+	try {
+		await recover();
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		process.stderr.write(
+			`Post-update recovery failed: ${reason}. For each configured notification daemon (telegram, discord, or slack), manually run 'gjc daemon stop <kind> --force' and then 'gjc daemon reload <kind>', then run 'gjc notify recovery'.\n`,
+		);
+		process.exitCode = 1;
+	}
+}
+
 export default class Update extends Command {
 	static description = "Check for and install updates";
 
@@ -35,7 +49,7 @@ export default class Update extends Command {
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Update);
 		if (args.action === "update-recovery") {
-			await runManagedNotifyRecovery({});
+			await runUpdateRecoveryCommand();
 			return;
 		}
 		let channel: UpdateChannel | undefined;

package/src/config/file-lock.ts

@@ -610,7 +610,7 @@ async function classifyFileLockRemovalTransition(
 	if (!observation) return "active";
 	const info = parseLockInfoBytes(observation.bytes);
 	if (info) {
-		const stale = await staleLockSnapshot(transitionPath, 0, ownerHostId, previousOwnerHostIds);
+		const stale = await staleLockSnapshot(transitionPath, 0, ownerHostId, previousOwnerHostIds, undefined, true);
 		return stale.stale ? "abandoned" : "active";
 	}
 
@@ -698,6 +698,74 @@ async function adoptOrphanedFileLockRemovalTransition(lockPath: string, orphanAg
 	return false;
 }
 
+async function adoptAbandonedFileLockRemovalTransition(
+	lockPath: string,
+	ownerHostId?: string,
+	previousOwnerHostIds: readonly string[] = [],
+): Promise<boolean> {
+	const transitionPath = fileLockRemovalTransitionPath(lockPath);
+	const stale = await staleLockSnapshot(transitionPath, 0, ownerHostId, previousOwnerHostIds, undefined, true);
+	if (!stale.stale || !stale.identity) return false;
+	if (!(await isNativeExactRemovalUsable())) return false;
+
+	let captured: NativeDirectoryTreeResult;
+	try {
+		captured = nativeFileLockBindings().snapshotDirectoryTree(transitionPath);
+	} catch (error) {
+		if (isTransientReleaseError(error)) return false;
+		throw error;
+	}
+	if (!captured.ok || !captured.snapshot) return false;
+	const snapshot = captured.snapshot;
+	const root = snapshot.entries.find(entry => entry.relativePath === "");
+	const infoEntry = snapshot.entries.find(entry => entry.relativePath === "info");
+	if (
+		root?.kind !== "directory" ||
+		infoEntry?.kind !== "file" ||
+		snapshot.entries.some(
+			entry =>
+				entry.relativePath !== "" &&
+				entry.relativePath !== "info" &&
+				entry.kind !== "directory" &&
+				(entry.kind !== "file" || entry.size !== "0"),
+		)
+	)
+		return false;
+	const currentIdentity = await captureFileLockDirIdentity(transitionPath);
+	if (!currentIdentity || !sameStableFileLockIdentity(currentIdentity, stale.identity)) return false;
+	if (
+		!nativeFileLockInfoMatchesStableIdentity(snapshot.rootDev, snapshot.rootIno, infoEntry, stale.identity) ||
+		!nativeFileLockInfoMatchesContentEvidence(infoEntry, stale.identity)
+	)
+		return false;
+
+	let removal: NativeExactUnlinkResult;
+	try {
+		removal = nativeFileLockBindings().exactRemoveDirectoryTree(transitionPath, snapshot);
+	} catch (error) {
+		if (isTransientReleaseError(error)) return false;
+		throw error;
+	}
+	if (removal.ok === true) return removal.code === undefined && Object.keys(removal).every(key => key === "ok");
+	if (
+		removal.ok === false &&
+		removal.code === "cleanup_pending" &&
+		removal.payloadDurable === true &&
+		removal.detachedPath !== undefined &&
+		path.resolve(removal.detachedPath) === path.resolve(transitionPath) &&
+		removal.retainedSuccessorPath === undefined &&
+		removal.retainedPlaceholderPath === undefined &&
+		removal.retainedUnknownPath === undefined &&
+		Object.keys(removal).every(key => ["ok", "code", "payloadDurable", "detachedPath"].includes(key))
+	)
+		return await removeDetachedLockQuarantineOnDisk(transitionPath, snapshot.rootDev, snapshot.rootIno);
+	return (
+		removal.ok === false &&
+		removal.code === "not_found" &&
+		Object.keys(removal).every(key => key === "ok" || key === "code")
+	);
+}
+
 function sameFileLockTreeAfterPublication(
 	staged: NativeDirectoryTreeSnapshot,
 	published: NativeDirectoryTreeSnapshot,
@@ -1488,6 +1556,14 @@ async function staleLockSnapshot(
 	ownerHostId?: string,
 	previousOwnerHostIds: readonly string[] = [],
 	startTimeCache?: Map<string, string | null>,
+	// `.removing` transitions are internal cleanup state this codebase's own removal
+	// machinery produced, never a live holder's public identity: a hostless transition
+	// record predates host-id stamping and is reclaimable by local liveness proof alone,
+	// regardless of the acquirer's own host id. Active `<file>.lock` holders keep the
+	// stricter fail-closed rule (see `lockRecordIsForeignHost`) because that record can
+	// belong to a genuinely foreign process; only the two transition-specific callers
+	// below set this.
+	hostlessTransitionIsLocal = false,
 ): Promise<LockStaleSnapshot> {
 	// Capture the root and info inode BEFORE asking whether the owner is stale. A later
 	// snapshot alone would let a copied successor inherit the stale verdict's authority.
@@ -1521,7 +1597,8 @@ async function staleLockSnapshot(
 	// A host-qualified lock may only be reclaimed after proving that its owner is
 	// local. Foreign and malformed host-qualified records fail closed: PID values
 	// and clocks are not meaningful across hosts.
-	if (lockRecordIsForeignHost(info, ownerHostId, previousOwnerHostIds)) return { stale: false };
+	const foreignCheckHostId = hostlessTransitionIsLocal && info.owner_host_id === undefined ? undefined : ownerHostId;
+	if (lockRecordIsForeignHost(info, foreignCheckHostId, previousOwnerHostIds)) return { stale: false };
 	if (ownerIncarnationChanged(info, startTimeCache)) {
 		if (!judgedIdentity) return { stale: false };
 		let currentIdentity: GenericFileLockDirIdentity | null;
@@ -1752,6 +1829,18 @@ async function tryAcquireLock(
 			}
 			if (transitionState === "orphan_transition")
 				return { kind: "orphan_transition", path: fileLockRemovalTransitionPath(destinationPath) };
+			if (transitionState === "abandoned") {
+				if (await adoptAbandonedFileLockRemovalTransition(destinationPath, ownerHostId, previousOwnerHostIds)) {
+					transitionState = await classifyFileLockRemovalTransition(
+						destinationPath,
+						orphanTransitionAgeMs,
+						ownerHostId,
+						previousOwnerHostIds,
+					);
+				} else {
+					return null;
+				}
+			}
 			if (transitionState !== null) return null;
 			const staged = snapshotDirectoryTree(canonicalPendingPath);
 			if (!staged.ok || !staged.snapshot) {

package/src/config/model-profile-activation.ts

@@ -115,6 +115,7 @@ export interface PrepareModelProfileActivationOptions {
 			>
 		> & {
 			getError?: ModelRegistry["getError"];
+			authStorage?: ModelRegistry["authStorage"];
 		};
 	settings: Pick<Settings, "get" | "getGlobal" | "getOverride">;
 	profileName: string;
@@ -475,6 +476,53 @@ export class ModelProfileCredentialError extends Error {
 	}
 }
 
+interface SessionPinRegistry {
+	authStorage?: {
+		hasRuntimeApiKey(provider: string): boolean;
+		hasLiteralConfigApiKey(provider: string, owner?: object): boolean;
+		hasSessionCredentialUnavailable(provider: string, scopeId?: string): boolean;
+	};
+	getAuthStorageOwner?(): object;
+}
+
+/**
+ * Whether an unavailable session credential pin blocks `provider`.
+ *
+ * Mirrors `AuthStorage.getApiKey` precedence: a runtime `--api-key` override or a literal
+ * `models.yml` `apiKey` registered for this registry's owner is resolved before the
+ * unavailable-pin marker, so either one keeps the provider usable. An `apiKeyEnv` key does
+ * not: `getApiKey` prefers another stored api_key account over it, which would silently
+ * retarget the unavailable pin.
+ */
+export function isSessionCredentialPinBlocking(
+	registry: SessionPinRegistry,
+	provider: string,
+	sessionId: string | undefined,
+): boolean {
+	const authStorage = registry.authStorage;
+	if (!authStorage) return false;
+	if (authStorage.hasRuntimeApiKey(provider)) return false;
+	if (authStorage.hasLiteralConfigApiKey(provider, registry.getAuthStorageOwner?.())) return false;
+	return authStorage.hasSessionCredentialUnavailable(provider, sessionId);
+}
+
+async function getProfileProviderApiKey(
+	registry: PrepareModelProfileActivationOptions["modelRegistry"],
+	provider: string,
+	sessionId: string,
+	profileLabel: string,
+): Promise<string | undefined> {
+	const pinBlocking = () => isSessionCredentialPinBlocking(registry, provider, sessionId);
+	if (pinBlocking()) throw new ModelProfileCredentialError(profileLabel, [provider]);
+	try {
+		return await registry.getApiKeyForProvider(provider, sessionId);
+	} catch (error) {
+		// OAuth selection can invalidate a pin while the credential probe is running.
+		if (pinBlocking()) throw new ModelProfileCredentialError(profileLabel, [provider]);
+		throw error;
+	}
+}
+
 export function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string {
 	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
@@ -762,7 +810,12 @@ export async function resolveModelProfileDefaultChain(options: {
 	])) {
 		let apiKey: string | undefined;
 		try {
-			apiKey = await options.modelRegistry.getApiKeyForProvider(provider, options.credentialSessionId);
+			apiKey = await getProfileProviderApiKey(
+				options.modelRegistry,
+				provider,
+				options.credentialSessionId,
+				profileLabel,
+			);
 		} catch (error) {
 			if (requiredProviderSet.has(provider) && !alternativeSet.has(provider)) throw error;
 			continue;
@@ -787,7 +840,12 @@ export async function resolveModelProfileDefaultChain(options: {
 	const proxyApiKey =
 		proxyProvider === undefined
 			? undefined
-			: await options.modelRegistry.getApiKeyForProvider(proxyProvider, options.credentialSessionId);
+			: await getProfileProviderApiKey(
+					options.modelRegistry,
+					proxyProvider,
+					options.credentialSessionId,
+					profileLabel,
+				);
 	if (
 		proxyProvider !== undefined &&
 		!isModelProfileProxyConfigured(proxyProvider, configuredProviderIds, proxyApiKey === kNoAuth)
@@ -886,6 +944,8 @@ export async function resolveModelProfileDefaultChain(options: {
 			aliasIntent: "preset-equivalent",
 			canonicalSessionId: null,
 			credentialSessionId: options.credentialSessionId,
+			isCredentialUnavailable: provider =>
+				isSessionCredentialPinBlocking(options.modelRegistry, provider, options.credentialSessionId),
 		},
 	);
 	return { profileName, entries: defaultChain, ...resolution };
@@ -1083,6 +1143,8 @@ async function resolveAndClampSelectorValue(
 					aliasIntent: options.aliasIntent,
 					canonicalSessionId: options.sessionId,
 					credentialSessionId: options.credentialSessionId,
+					isCredentialUnavailable: provider =>
+						isSessionCredentialPinBlocking(options.modelRegistry, provider, options.credentialSessionId),
 				},
 			);
 			resolved = {
@@ -1213,6 +1275,8 @@ async function concretizeProfileSelectorValue(
 							aliasIntent: "preset-equivalent",
 							canonicalSessionId: prepared.session.sessionId,
 							credentialSessionId,
+							isCredentialUnavailable: provider =>
+								isSessionCredentialPinBlocking(prepared.modelRegistry, provider, credentialSessionId),
 						},
 					)
 				: resolveModelRoleValue(selector, candidates, {
@@ -1322,7 +1386,7 @@ export async function prepareModelProfileActivation(
 		for (const provider of authenticationProbeProviders) {
 			let apiKey: string | undefined;
 			try {
-				apiKey = await options.modelRegistry.getApiKeyForProvider(provider, credentialSessionId);
+				apiKey = await getProfileProviderApiKey(options.modelRegistry, provider, credentialSessionId, profileLabel);
 			} catch (error) {
 				if (requiredProviderSet.has(provider) && !alternativeSet.has(provider)) throw error;
 				continue;
@@ -1357,7 +1421,7 @@ export async function prepareModelProfileActivation(
 		const proxyApiKey =
 			proxyProvider === undefined
 				? undefined
-				: await options.modelRegistry.getApiKeyForProvider(proxyProvider, credentialSessionId);
+				: await getProfileProviderApiKey(options.modelRegistry, proxyProvider, credentialSessionId, profileLabel);
 		if (proxyProvider !== undefined) {
 			const configuredProxyProviders = options.modelRegistry.getConfiguredProviderIds?.();
 			if (!isModelProfileProxyConfigured(proxyProvider, configuredProxyProviders, proxyApiKey === kNoAuth)) {
@@ -1462,6 +1526,8 @@ export async function prepareModelProfileActivation(
 				aliasIntent: "preset-equivalent",
 				canonicalSessionId: options.session.sessionId,
 				credentialSessionId,
+				isCredentialUnavailable: provider =>
+					isSessionCredentialPinBlocking(options.modelRegistry, provider, credentialSessionId),
 			},
 		);
 		const defaultModel = defaultResolution.model;

package/src/config/model-profile-contract.ts

@@ -4,7 +4,10 @@ export const MODEL_PROFILE_DISCOVERY_QUERY = "models.profiles.list";
 export const MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES = 2048;
 const REQUESTED_PROFILE_MAX_BYTES = 256;
 
-const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
+const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([
+	["codex-standard", "codex-medium"],
+	["codex-sol61", "codex-pro"],
+]);
 
 export interface ModelProfileCatalogItem {
 	id: string;