@gajae-code/coding-agent 0.17.4 → 0.17.6

package/src/config/file-lock.ts

@@ -44,12 +44,14 @@ export type FileLockAcquireReason = "acquire_timeout" | "orphan_transition";
  * generation); this records the cause that exhaustion must report.
  */
 export interface FileLockStaleRemovalFailure {
-	/** Guarded-removal outcome the acquire path can record, or `"error"` when the removal attempt threw. */
-	outcome: "cleanup_failed" | "error";
+	/** Guarded-removal outcome; refusals are surfaced only after exhaustion revalidates the dead generation. */
+	outcome: "cleanup_failed" | "owner_changed" | "missing" | "error";
 	/** Native/errno code carried by the refusal, when one was present. */
 	code?: string;
 	/** Human-readable cause surfaced to the operator at exhaustion. */
 	message: string;
+	/** Platform-specific manual cleanup command, set only when the same dead owner persists at exhaustion. */
+	manualCleanupCommand?: string;
 }
 
 export class FileLockAcquireError extends Error {
@@ -70,10 +72,12 @@ export class FileLockAcquireError extends Error {
 					removalFailure.code ? ` [${removalFailure.code}]` : ""
 				})`
 			: "";
+		const cleanupDetail = removalFailure?.manualCleanupCommand
+			? `; manual cleanup is appropriate only after independently verifying this exact directory still belongs to the dead owner and no successor has taken it: ${removalFailure.manualCleanupCommand}`
+			: "";
 		super(
 			`Failed to acquire lock for ${filePath} after ${attempts} attempts: ${detail}${removalDetail} (${lockPath}); ` +
-				`a live owner is never displaced — if this is an SDK broker (gjc sdk session list), it must finish or be stopped before retrying; ` +
-				`the lock is a directory, remove it only by deleting the directory (${lockPath}) once no live owner remains`,
+				`a live owner is never displaced — if this is an SDK broker (gjc sdk session list), it must finish or be stopped before retrying${cleanupDetail}`,
 		);
 		this.code = reason;
 		this.name = "FileLockAcquireError";
@@ -1069,6 +1073,10 @@ function ownerIncarnationChanged(owner: FileLockOwnerToken, startTimeCache?: Map
 	return currentStartTime !== null && currentStartTime !== owner.start_time;
 }
 
+function ownerGenerationIsDead(owner: FileLockOwnerToken): boolean {
+	return ownerLiveness(owner.pid) === "dead" || ownerIncarnationChanged(owner);
+}
+
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing" | "cleanup_failed";
 
@@ -1550,13 +1558,17 @@ async function staleLockSnapshot(
 
 type StaleLockRemovalAttempt = { removed: true } | { removed: false; failure?: FileLockStaleRemovalFailure };
 
-type RecordedStaleRemovalFailure = { owner: FileLockOwnerToken; failure: FileLockStaleRemovalFailure };
+type RecordedStaleRemovalFailure = {
+	owner: FileLockOwnerToken;
+	identity: GenericFileLockDirIdentity;
+	failure: FileLockStaleRemovalFailure;
+};
 
 /**
- * A recorded refusal describes exactly one dead owner generation. Re-read the pathname at
- * exhaustion and report it only while that same generation still owns the directory, so a
- * refusal recorded for a dead generation is never pinned onto a live successor that took
- * the pathname over before the budget ran out.
+ * A recorded refusal describes exactly one dead owner generation and directory identity.
+ * Re-read the pathname at exhaustion and report it only while both still match, so a refusal
+ * recorded for a dead generation is never pinned onto a successor that took the pathname over
+ * before the budget ran out, even if its legacy owner bytes are identical.
  */
 async function staleRemovalFailureForCurrentGeneration(
 	lockPath: string,
@@ -1564,13 +1576,31 @@ async function staleRemovalFailureForCurrentGeneration(
 ): Promise<FileLockStaleRemovalFailure | undefined> {
 	if (!recorded) return undefined;
 	try {
-		const current = await readLockInfo(lockPath);
-		return current && sameFileLockOwnerToken(current, recorded.owner) ? recorded.failure : undefined;
+		const observation = await readLockInfoObservation(lockPath);
+		if (!observation) return undefined;
+		const current = parseLockInfoBytes(observation.bytes);
+		if (!current || !sameFileLockOwnerToken(current, recorded.owner) || !ownerGenerationIsDead(current))
+			return undefined;
+		const currentIdentity = fileLockDirIdentityFromPathState(observation.state, observation.bytes);
+		if (!sameGenericFileLockDirIdentity(recorded.identity, currentIdentity)) return undefined;
+		return {
+			...recorded.failure,
+			manualCleanupCommand: manualLockCleanupCommand(lockPath),
+		};
 	} catch {
 		return undefined;
 	}
 }
 
+function manualLockCleanupCommand(lockPath: string): string {
+	if (process.platform === "win32") {
+		const quotedPath = lockPath.replace(/'/g, "''");
+		return `Remove-Item -LiteralPath '${quotedPath}' -Recurse -Force`;
+	}
+	const quotedPath = lockPath.replace(/'/g, "'\\''");
+	return `rm -rf -- '${quotedPath}'`;
+}
+
 async function removeStaleLockForAcquire(
 	lockPath: string,
 	snapshot: LockStaleSnapshot,
@@ -1579,8 +1609,21 @@ async function removeStaleLockForAcquire(
 	try {
 		const outcome = await removeFileLockDirForGc(lockPath, snapshot.owner, snapshot.identity);
 		if (outcome === "removed") return { removed: true };
-		// `owner_changed`/`missing` mean a successor or a concurrent reclaimer already
-		// owns the pathname; that is ordinary contention, not a host removal failure.
+		// Either refusal can mean a successor or an incomplete publication owns the path;
+		// keep it only as a diagnostic candidate and expose it at exhaustion if the same
+		// dead owner still persists. Never fall back to path-only deletion.
+		if (outcome === "owner_changed" || outcome === "missing") {
+			return {
+				removed: false,
+				failure: {
+					outcome,
+					message:
+						outcome === "owner_changed"
+							? "the identity-bound removal guard returned owner_changed; no path-only fallback was attempted"
+							: "the guarded removal could not read the owner record; no path-only fallback was attempted",
+				},
+			};
+		}
 		if (outcome !== "cleanup_failed") return { removed: false };
 		return {
 			removed: false,
@@ -2207,7 +2250,9 @@ export async function acquireFileLock(filePath: string, options: FileLockOptions
 			continue;
 		}
 		staleRemovalFailure =
-			stale.stale && staleRemoval.failure ? { owner: stale.owner, failure: staleRemoval.failure } : undefined;
+			stale.stale && staleRemoval.failure
+				? { owner: stale.owner, identity: stale.identity, failure: staleRemoval.failure }
+				: undefined;
 		if (!opts.signal) {
 			await Bun.sleep(opts.retryDelayMs);
 			continue;

package/src/config/model-discovery-manager.ts

@@ -222,11 +222,11 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 					? result.stale
 						? "cached"
 						: "ok"
-					: result.fetched
+					: result.fetched ||
+							(result.cacheFresh && result.cacheAuthoritative && result.dynamicModelIds?.length === 0)
 						? "empty"
-						: // No fetch happened (non-authoritative retry backoff, or an
-							// ineligible cache) and no eligible row served models: the
-							// provider is unvalidated, not authoritatively empty.
+						: // No fetch happened and no fresh authoritative empty row
+							// attested to this result, so the provider is unvalidated.
 							"unavailable";
 		const state: ProviderDiscoveryState = {
 			provider: provider.provider,

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

@@ -1528,15 +1528,58 @@ export async function prepareModelProfileActivation(
 			previousDefaultFallbackRuntimeState: options.session.getDefaultFallbackRuntimeState?.(),
 		};
 	} catch (error) {
-		restoreCanonicalVariant(options.modelRegistry, options.session.sessionId, previousCanonicalVariant);
+		try {
+			restoreCanonicalVariant(options.modelRegistry, options.session.sessionId, previousCanonicalVariant);
+		} catch (rollbackError) {
+			throw incompleteModelProfileRollbackError("preparation", "profile preflight", error, [
+				{ stage: "restore canonical model variant", error: rollbackError },
+			]);
+		}
 		throw error;
 	}
 }
 
+function modelProfileFailureReason(error: unknown, stage: string): string {
+	try {
+		if (error instanceof ModelProfileCredentialError) return "required credentials unavailable";
+		if (error instanceof Error && error.message.startsWith("No API key for ")) return "credentials unavailable";
+	} catch {
+		// An exotic error getter must not replace the activation failure.
+	}
+	return stage.includes("settings") || stage.startsWith("persist ") || stage.endsWith(" setting")
+		? "settings write failed"
+		: "operation failed";
+}
+
+class ModelProfileActivationStageError extends Error {
+	readonly stage: string;
+
+	constructor(stage: string, error: unknown) {
+		super(`${stage} (${modelProfileFailureReason(error, stage)})`, { cause: error });
+		this.name = "ModelProfileActivationStageError";
+		this.stage = stage;
+	}
+}
+
+function incompleteModelProfileRollbackError(
+	phase: "preparation" | "activation",
+	stage: string,
+	error: unknown,
+	rollbackErrors: readonly { stage: string; error: unknown }[],
+): AggregateError {
+	const primary = new ModelProfileActivationStageError(stage, error);
+	const incomplete = rollbackErrors.map(failure => new ModelProfileActivationStageError(failure.stage, failure.error));
+	return new AggregateError(
+		[primary, ...incomplete],
+		`Model profile ${phase} failed at ${primary.message}; rollback incomplete: ${incomplete.map(failure => failure.message).join("; ")}. Prior state may be unverified.`,
+	);
+}
+
 export async function applyPreparedModelProfileActivation(
 	prepared: PreparedModelProfileActivation,
 	options: ApplyModelProfileActivationOptions = {},
 ): Promise<void> {
+	let activationStage = "default chain";
 	let modelMutationStarted = false;
 	let overridesChanged = false;
 	let modelRolesChanged = false;
@@ -1567,15 +1610,21 @@ export async function applyPreparedModelProfileActivation(
 			}
 		}
 		if (prepared.defaultModel) {
-			modelMutationStarted = true;
+			activationStage = "model selection";
 			await prepared.session.setModelTemporary(
 				prepared.defaultModel,
 				options.thinkingLevelOverride ?? prepared.defaultThinkingLevel,
-				{ cause: "profile-activation" },
+				{
+					cause: "profile-activation",
+					onMutationStarted: () => {
+						modelMutationStarted = true;
+					},
+				},
 			);
 		}
 		// Always reinstall the model role layer from the durable base plus the
 		// new profile's roles so omitted roles from the previous profile are dropped.
+		activationStage = "model role overrides";
 		prepared.settings.override("modelRoles", {
 			...prepared.baseModelRoles,
 			...prepared.modelRoles,
@@ -1584,6 +1633,7 @@ export async function applyPreparedModelProfileActivation(
 		// Always reinstall the agent role layer from the durable base plus the
 		// new profile's roles: a default-only or role-free successor must drop
 		// the previous profile's role-agent mappings rather than inheriting them.
+		activationStage = "agent role overrides";
 		prepared.settings.override("task.agentModelOverrides", {
 			...prepared.baseAgentModelOverrides,
 			...prepared.agentModelOverrides,
@@ -1591,65 +1641,74 @@ export async function applyPreparedModelProfileActivation(
 		overridesChanged = true;
 		if (options.persistDefault) {
 			persistentMutationStarted = true;
+			activationStage = "persist model roles";
 			prepared.settings.set("modelRoles", {});
+			activationStage = "persist agent roles";
 			prepared.settings.set("task.agentModelOverrides", {});
 			if (prepared.defaultThinkingLevel !== undefined && prepared.defaultThinkingLevel !== ThinkingLevel.Inherit) {
+				activationStage = "persist thinking level";
 				prepared.settings.set("defaultThinkingLevel", prepared.defaultThinkingLevel);
 			}
+			activationStage = "persist default profile";
 			prepared.settings.set("modelProfile.default", prepared.profileName);
+			activationStage = "forward settings flush";
 			await prepared.settings.flushOrThrow();
 		}
+		activationStage = "active profile marker";
 		prepared.session.setActiveModelProfile?.(prepared.profileName);
 		if (prepared.defaultModel) {
+			activationStage = "canonical model variant";
 			prepared.modelRegistry.seedCanonicalVariant?.(prepared.session.sessionId, prepared.defaultModel);
 			resumeDefaultChanged = true;
+			activationStage = "resume default model";
 			prepared.session.recordResumeDefaultModel?.(`${prepared.defaultModel.provider}/${prepared.defaultModel.id}`);
 		}
+		activationStage = "installed role tracking";
 		prepared.session.noteProfileInstalledOverrides?.(
 			Object.keys(prepared.modelRoles),
 			Object.keys(prepared.agentModelOverrides),
 			prepared.previousModel,
 		);
 	} catch (error) {
-		const rollbackErrors: unknown[] = [];
-		const restore = (action: () => void): void => {
+		const rollbackErrors: Array<{ stage: string; error: unknown }> = [];
+		const restore = (stage: string, action: () => void): void => {
 			try {
 				action();
 			} catch (rollbackError) {
-				rollbackErrors.push(rollbackError);
+				rollbackErrors.push({ stage, error: rollbackError });
 			}
 		};
 		if (persistentMutationStarted) {
-			restore(() =>
+			restore("restore default profile setting", () =>
 				prepared.previousPersistedDefaultProfile === undefined
 					? prepared.settings.unset("modelProfile.default")
 					: prepared.settings.set("modelProfile.default", prepared.previousPersistedDefaultProfile),
 			);
-			restore(() =>
+			restore("restore model role setting", () =>
 				prepared.previousPersistedModelRoles === undefined
 					? prepared.settings.unset("modelRoles")
 					: prepared.settings.set("modelRoles", prepared.previousPersistedModelRoles),
 			);
-			restore(() =>
+			restore("restore agent role setting", () =>
 				prepared.previousPersistedAgentModelOverrides === undefined
 					? prepared.settings.unset("task.agentModelOverrides")
 					: prepared.settings.set("task.agentModelOverrides", prepared.previousPersistedAgentModelOverrides),
 			);
-			restore(() =>
+			restore("restore thinking level setting", () =>
 				prepared.previousPersistedDefaultThinkingLevel === undefined
 					? prepared.settings.unset("defaultThinkingLevel")
 					: prepared.settings.set("defaultThinkingLevel", prepared.previousPersistedDefaultThinkingLevel),
 			);
 		}
 		if (modelRolesChanged) {
-			restore(() =>
+			restore("restore model role overrides", () =>
 				prepared.previousModelRolesOverride === undefined
 					? prepared.settings.clearOverride("modelRoles")
 					: prepared.settings.override("modelRoles", prepared.previousModelRolesOverride),
 			);
 		}
 		if (overridesChanged) {
-			restore(() =>
+			restore("restore agent role overrides", () =>
 				prepared.previousAgentModelOverridesOverride === undefined
 					? prepared.settings.clearOverride("task.agentModelOverrides")
 					: prepared.settings.override("task.agentModelOverrides", prepared.previousAgentModelOverridesOverride),
@@ -1670,15 +1729,17 @@ export async function applyPreparedModelProfileActivation(
 					throw new Error("Model-less profile activation rollback is unavailable");
 				}
 			} catch (rollbackError) {
-				rollbackErrors.push(rollbackError);
+				rollbackErrors.push({ stage: "restore live model", error: rollbackError });
 			}
 		}
 		if (resumeDefaultChanged) {
-			restore(() => prepared.session.recordResumeDefaultModel?.(prepared.previousSessionDefaultModel));
+			restore("restore resume default", () =>
+				prepared.session.recordResumeDefaultModel?.(prepared.previousSessionDefaultModel),
+			);
 		}
 		if (defaultChainChanged) {
 			const previousChain = prepared.previousDefaultChainState;
-			restore(() =>
+			restore("restore default chain", () =>
 				prepared.session.setConfiguredModelChain(
 					"default",
 					previousChain?.entries ??
@@ -1691,26 +1752,25 @@ export async function applyPreparedModelProfileActivation(
 			);
 		}
 		if (prepared.previousDefaultFallbackRuntimeState) {
-			restore(() =>
+			restore("restore fallback runtime", () =>
 				prepared.session.restoreDefaultFallbackRuntimeState?.(prepared.previousDefaultFallbackRuntimeState!),
 			);
 		}
-		restore(() => prepared.session.setActiveModelProfile?.(prepared.previousActiveModelProfile));
-		restore(() =>
+		restore("restore active profile", () =>
+			prepared.session.setActiveModelProfile?.(prepared.previousActiveModelProfile),
+		);
+		restore("restore canonical model variant", () =>
 			restoreCanonicalVariant(prepared.modelRegistry, prepared.session.sessionId, prepared.previousCanonicalVariant),
 		);
 		if (persistentMutationStarted) {
 			try {
 				await prepared.settings.flushOrThrow();
 			} catch (rollbackError) {
-				rollbackErrors.push(rollbackError);
+				rollbackErrors.push({ stage: "restore settings flush", error: rollbackError });
 			}
 		}
 		if (rollbackErrors.length > 0) {
-			throw new AggregateError(
-				[error, ...rollbackErrors],
-				"Model profile activation failed and rollback was incomplete",
-			);
+			throw incompleteModelProfileRollbackError("activation", activationStage, error, rollbackErrors);
 		}
 		throw error;
 	}

package/src/config/model-registry.ts

@@ -83,6 +83,8 @@ import { ModelDiscoveryManager, type ProviderDiscoveryState } from "./model-disc
 import {
 	loadAcceptedModelPresetProfiles,
 	type ModelPresetRegistryDependencies,
+	type ModelPresetRegistryRefreshResult,
+	refreshModelPresetRegistry,
 	refreshModelPresetRegistryInBackground,
 } from "./model-preset-registry";
 
@@ -1902,6 +1904,17 @@ export class ModelRegistry {
 		});
 	}
 
+	/** Refresh the signed profile catalog online, then publish its accepted snapshot. */
+	async refreshModelPresetProfilesFromRegistry(): Promise<ModelPresetRegistryRefreshResult> {
+		const result = await refreshModelPresetRegistry({
+			...this.#modelPresetRegistryDependencies,
+			agentDir: this.#modelPresetRegistryAgentDir,
+			knownManifestSha256: this.#loadedModelPresetRegistryManifestSha256,
+		});
+		await this.refreshStatic();
+		return result;
+	}
+
 	/**
 	 * Reload models from disk and refresh runtime provider discovery state.
 	 */
@@ -2547,12 +2560,20 @@ export class ModelRegistry {
 		for (const providerConfig of this.#discoveryManager.providers) {
 			if (providerId && providerConfig.provider !== providerId) continue;
 			let expectedProvenance: string | undefined;
+			let effectiveConfig: DiscoveryProviderConfig | undefined;
+			let expectedAuthGeneration: string | undefined;
+			let expectedEndpoint: string | undefined;
 			try {
-				const effectiveConfig = this.#effectiveDiscoveryProviderConfig(providerConfig);
+				effectiveConfig = this.#effectiveDiscoveryProviderConfig(providerConfig);
+				const effectiveAuthGeneration =
+					authEvidence ?? this.#getProviderEvidenceGeneration(effectiveConfig.provider);
+				const effectiveEndpoint = this.#normalizeDiscoveryEvidenceEndpoint(effectiveConfig.baseUrl ?? "");
+				expectedAuthGeneration = effectiveAuthGeneration;
+				expectedEndpoint = effectiveEndpoint;
 				expectedProvenance = fingerprintConfiguredDiscoveryRequestShape(
 					effectiveConfig,
-					authEvidence ?? this.#getProviderEvidenceGeneration(effectiveConfig.provider),
-					this.#normalizeDiscoveryEvidenceEndpoint(effectiveConfig.baseUrl ?? ""),
+					effectiveAuthGeneration,
+					effectiveEndpoint,
 				);
 			} catch {
 				// A context that cannot be fully derived cannot vouch for a cache row.
@@ -2561,6 +2582,30 @@ export class ModelRegistry {
 			const models = publishDiscoveryState
 				? this.#discoveryManager.loadCached(providerConfig, this.#cacheDbPath, expectedProvenance)
 				: this.#readCachedDiscoverableModels(providerConfig, expectedProvenance);
+			if (publishDiscoveryState) {
+				const cache =
+					effectiveConfig !== undefined
+						? readModelCache<Api>(effectiveConfig.provider, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath)
+						: null;
+				if (
+					effectiveConfig !== undefined &&
+					expectedAuthGeneration !== undefined &&
+					expectedEndpoint !== undefined &&
+					expectedProvenance !== undefined &&
+					cache?.fresh === true &&
+					cache.authoritative === true &&
+					cache.dynamicModelIds !== undefined &&
+					cache.dynamicModelProvenance === expectedProvenance
+				) {
+					this.#configuredDiscoveryEvidence.set(effectiveConfig.provider, {
+						authGeneration: expectedAuthGeneration,
+						endpoint: expectedEndpoint,
+						modelIds: new Set(cache.dynamicModelIds),
+					});
+				} else {
+					this.#configuredDiscoveryEvidence.delete(providerConfig.provider);
+				}
+			}
 			// Cache rows persist sanitized transport metadata (no headers), so a
 			// rebooted registry re-derives the provider transport override from the
 			// same source the live publish path uses — mirroring the cached
@@ -3293,16 +3338,24 @@ export class ModelRegistry {
 			const currentEndpoint = this.#normalizeDiscoveryEvidenceEndpoint(
 				this.#effectiveDiscoveryProviderConfig(provider).baseUrl ?? "",
 			);
+			const authoritativeState =
+				state !== undefined &&
+				state.error === undefined &&
+				!state.stale &&
+				((state.status === "ok" && discovery.fetched) ||
+					state.status === "empty" ||
+					(state.status === "ok" && !discovery.fetched));
 			if (
 				evidence !== undefined &&
-				(state?.status === "ok" || state?.status === "empty") &&
-				discovery.fetched &&
+				authoritativeState &&
 				currentAuthGeneration === evidence.authGeneration &&
 				currentEndpoint === evidence.endpoint
 			) {
 				this.#configuredDiscoveryEvidence.set(provider.provider, evidence);
 			} else if (
-				(state?.status !== "cached" && !(state?.status === "ok" && !discovery.fetched)) ||
+				(state?.status !== "cached" &&
+					state?.status !== "empty" &&
+					!(state?.status === "ok" && !discovery.fetched)) ||
 				state.error !== undefined ||
 				this.#configuredDiscoveryEvidence.get(provider.provider)?.authGeneration !== currentAuthGeneration ||
 				this.#configuredDiscoveryEvidence.get(provider.provider)?.endpoint !== currentEndpoint
@@ -5425,6 +5478,10 @@ export class ModelRegistry {
 	 */
 	getAvailableForProfileActivation(): Model<Api>[] {
 		const bundledIdsByProvider = new Map<string, Set<string>>();
+		// Evidence staleness depends only on the provider, and resolving it scans the
+		// catalog for the provider base URL. Decide it once per provider per call so a
+		// multi-thousand-model catalog is not rescanned for every model.
+		const staleEvidenceByProvider = new Map<string, boolean>();
 		return this.getAvailable().filter(model => {
 			const evidence = this.#descriptorDiscoveryEvidence.get(model.provider);
 			if (!evidence?.profileFresh || evidence.profileModelIds === undefined) return true;
@@ -5439,12 +5496,15 @@ export class ModelRegistry {
 				bundledIdsByProvider.set(model.provider, bundledModelIds);
 			}
 			if (!bundledModelIds.has(model.id)) return true;
-			if (
-				evidence.authGeneration !== this.#getProviderEvidenceGeneration(model.provider) ||
-				evidence.profileEndpoint !==
-					this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(model.provider) ?? "")
-			)
-				return true;
+			let staleEvidence = staleEvidenceByProvider.get(model.provider);
+			if (staleEvidence === undefined) {
+				staleEvidence =
+					evidence.authGeneration !== this.#getProviderEvidenceGeneration(model.provider) ||
+					evidence.profileEndpoint !==
+						this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(model.provider) ?? "");
+				staleEvidenceByProvider.set(model.provider, staleEvidence);
+			}
+			if (staleEvidence) return true;
 			return evidence.profileModelIds.has(model.id);
 		});
 	}

package/src/config/model-resolver.ts

@@ -87,6 +87,7 @@ export function resolveStartupModelRefreshSelectors(
 export async function refreshMissingQualifiedModelProviders(
 	selectors: ModelSelectorValue | undefined,
 	modelRegistry: Pick<ModelRegistry, "getAvailable" | "getRefreshableProviders" | "refreshProvider">,
+	credentialSessionId?: string,
 ): Promise<boolean> {
 	const refreshedProviders = new Set<string>();
 	for (const selector of normalizeModelSelectorValue(selectors)) {
@@ -104,7 +105,11 @@ export async function refreshMissingQualifiedModelProviders(
 		)
 			continue;
 
-		await modelRegistry.refreshProvider(provider, "online-if-uncached");
+		if (credentialSessionId === undefined) {
+			await modelRegistry.refreshProvider(provider, "online-if-uncached");
+		} else {
+			await modelRegistry.refreshProvider(provider, "online-if-uncached", credentialSessionId);
+		}
 		refreshedProviders.add(provider);
 	}
 	return refreshedProviders.size > 0;

package/src/coordinator-mcp/question-state.ts

@@ -1879,7 +1879,10 @@ export async function bindCreationRequest(
 			)
 		)
 			throw new Error("session_closing");
-		if (request.canonical_create_intent && canonicalJson(request.canonical_create_intent) !== canonicalJson(intent))
+		if (
+			request.canonical_create_intent &&
+			creationIntentDigest(request.canonical_create_intent) !== creationIntentDigest(intent)
+		)
 			throw new Error("idempotency_conflict");
 		request.canonical_create_intent ??= intent;
 		request.session_id = session.session_id;

package/src/coordinator-mcp/server.ts

@@ -10995,16 +10995,24 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 							}
 							if (status !== "accepted")
 								throw new SdkClientError("terminal_uncertain", "Workflow gate answer was not accepted.");
-							const resolvedAt =
-								typeof resolution?.resolved_at === "string" ? resolution.resolved_at : new Date().toISOString();
+							const reportedResolvedAt =
+								typeof resolution?.resolved_at === "string" &&
+								Number.isFinite(Date.parse(resolution.resolved_at))
+									? resolution.resolved_at
+									: undefined;
+							// The gate timestamp is remote metadata; retention must age the local receipt from
+							// the coordinator's own persistence time so a skewed or replayed response cannot
+							// delete a fresh answer.
+							const persistedAt = new Date().toISOString();
+							const resolvedAt = reportedResolvedAt ?? persistedAt;
 							await withAdmittedSessionTransaction(questionPaths, sessionId, async transaction => {
 								const question = transaction.canonical.questions[questionId];
 								if (!question || question.claim_fence_epoch !== (claimed as { fence: number }).fence)
 									throw new Error("terminal_uncertain");
 								question.status = "answered";
-								question.answered_at = resolvedAt;
-								question.updated_at = resolvedAt;
-								question.history.push({ at: resolvedAt, status: "answered", reason: null });
+								question.answered_at = persistedAt;
+								question.updated_at = persistedAt;
+								question.history.push({ at: persistedAt, status: "answered", reason: null });
 								const authority = transaction.canonical.gate_authorities[question.authority_id];
 								if (authority)
 									authority.outcome = { state: "answered", turn_id: turnId, question_id: questionId };
@@ -11022,7 +11030,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 									resolved_at: resolvedAt,
 								};
 								request.phase = "completed";
-								request.updated_at = resolvedAt;
+								request.updated_at = persistedAt;
 							});
 							return {
 								ok: true,

package/src/exec/bash-executor.ts

@@ -319,6 +319,8 @@ export interface BashExecutorOptions {
 	sessionKey?: string;
 	/** Additional environment variables to inject */
 	env?: Record<string, string>;
+	/** Environment names to hide from this command's inherited environment. */
+	unsetEnv?: string[];
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
@@ -578,6 +580,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			command: finalCommand,
 			cwd: commandCwd,
 			env: commandEnv,
+			unsetEnv: options?.unsetEnv,
 			timeoutMs: executionTimeoutMs,
 			signal: runAbortController.signal,
 		};