@gajae-code/coding-agent 0.16.4 → 0.16.6

package/src/config/model-preset-registry.ts

@@ -1,5 +1,6 @@
 import * as crypto from "node:crypto";
 import * as fsSync from "node:fs";
+import type { FileHandle } from "node:fs/promises";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { Api, Model } from "@gajae-code/ai/core";
@@ -939,16 +940,80 @@ function validateGeneration(
 	return generation;
 }
 
-function readJsonSync(file: string): unknown | undefined {
+type RegistryFileStat = {
+	dev: number | bigint;
+	ino: number | bigint;
+	size: number | bigint;
+	isFile(): boolean;
+	isSymbolicLink(): boolean;
+};
+
+function registryFileOpenFlags(): number {
+	return (
+		fsSync.constants.O_RDONLY |
+		(process.platform === "win32" ? 0 : (fsSync.constants.O_NOFOLLOW ?? 0) | (fsSync.constants.O_NONBLOCK ?? 0))
+	);
+}
+
+function sameRegistryFileIdentity(left: RegistryFileStat, right: RegistryFileStat): boolean {
+	return (
+		left.isFile() &&
+		!left.isSymbolicLink() &&
+		right.isFile() &&
+		!right.isSymbolicLink() &&
+		left.dev === right.dev &&
+		left.ino === right.ino
+	);
+}
+
+function readBoundedRegistryFdSync(fd: number): Buffer {
+	const chunks: Buffer[] = [];
+	const buffer = Buffer.allocUnsafe(64 * 1024);
+	let total = 0;
+	for (;;) {
+		const length = Math.min(buffer.length, MODEL_PRESET_REGISTRY_MAX_STATE_BYTES + 1 - total);
+		const bytesRead = fsSync.readSync(fd, buffer, 0, length, null);
+		if (bytesRead === 0) return Buffer.concat(chunks, total);
+		total += bytesRead;
+		chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+		if (total > MODEL_PRESET_REGISTRY_MAX_STATE_BYTES) throw new Error("Registry cache is oversized.");
+	}
+}
+
+function readRegistryBytesSync(file: string): Buffer | undefined {
+	let before: fsSync.Stats;
 	try {
-		const stat = fsSync.lstatSync(file);
-		if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("Registry cache path is not a regular file.");
-		if (stat.size > MODEL_PRESET_REGISTRY_MAX_STATE_BYTES) throw new Error("Registry cache is oversized.");
-		return JSON.parse(fsSync.readFileSync(file, "utf8"));
+		before = fsSync.lstatSync(file);
 	} catch (error) {
 		if (isEnoent(error)) return undefined;
 		throw error;
 	}
+	if (!before.isFile() || before.isSymbolicLink()) throw new Error("Registry cache path is not a regular file.");
+	if (before.size > MODEL_PRESET_REGISTRY_MAX_STATE_BYTES) throw new Error("Registry cache is oversized.");
+	let fd: number | undefined;
+	try {
+		fd = fsSync.openSync(file, registryFileOpenFlags());
+		const opened = fsSync.fstatSync(fd);
+		if (!sameRegistryFileIdentity(before, opened)) throw new Error("Registry cache path changed while opening.");
+		const bytes = readBoundedRegistryFdSync(fd);
+		const finalOpened = fsSync.fstatSync(fd);
+		let after: fsSync.Stats;
+		try {
+			after = fsSync.lstatSync(file);
+		} catch (error) {
+			throw new Error("Registry cache path changed while reading.", { cause: error });
+		}
+		if (!sameRegistryFileIdentity(opened, finalOpened) || !sameRegistryFileIdentity(opened, after))
+			throw new Error("Registry cache path changed while reading.");
+		return bytes;
+	} finally {
+		if (fd !== undefined) fsSync.closeSync(fd);
+	}
+}
+
+function readJsonSync(file: string): unknown | undefined {
+	const bytes = readRegistryBytesSync(file);
+	return bytes === undefined ? undefined : JSON.parse(bytes.toString("utf8"));
 }
 
 /**
@@ -956,16 +1021,44 @@ function readJsonSync(file: string): unknown | undefined {
  * Keep the synchronous reader above for legacy startup paths until their
  * constructor-wide migration can be completed without changing public APIs.
  */
-async function readJsonBun(file: string): Promise<unknown | undefined> {
+async function readRegistryBytesBun(file: string): Promise<Buffer | undefined> {
+	let before: fsSync.BigIntStats;
 	try {
-		const stat = await fs.lstat(file, { bigint: true });
-		if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("Registry cache path is not a regular file.");
-		if (stat.size > BigInt(MODEL_PRESET_REGISTRY_MAX_STATE_BYTES)) throw new Error("Registry cache is oversized.");
-		return JSON.parse(await Bun.file(file).text());
+		before = await fs.lstat(file, { bigint: true });
 	} catch (error) {
 		if (isEnoent(error)) return undefined;
 		throw error;
 	}
+	if (!before.isFile() || before.isSymbolicLink()) throw new Error("Registry cache path is not a regular file.");
+	if (before.size > BigInt(MODEL_PRESET_REGISTRY_MAX_STATE_BYTES)) throw new Error("Registry cache is oversized.");
+	let handle: FileHandle | undefined;
+	try {
+		handle = await fs.open(file, registryFileOpenFlags());
+		const opened = await handle.stat({ bigint: true });
+		if (!sameRegistryFileIdentity(before, opened)) throw new Error("Registry cache path changed while opening.");
+		const bunFileFromDescriptor = (Bun.file as unknown as (descriptor: number) => Bun.BunFile)(handle.fd);
+		const bytes = Buffer.from(
+			await bunFileFromDescriptor.slice(0, MODEL_PRESET_REGISTRY_MAX_STATE_BYTES + 1).arrayBuffer(),
+		);
+		if (bytes.length > MODEL_PRESET_REGISTRY_MAX_STATE_BYTES) throw new Error("Registry cache is oversized.");
+		const finalOpened = await handle.stat({ bigint: true });
+		let after: fsSync.BigIntStats;
+		try {
+			after = await fs.lstat(file, { bigint: true });
+		} catch (error) {
+			throw new Error("Registry cache path changed while reading.", { cause: error });
+		}
+		if (!sameRegistryFileIdentity(opened, finalOpened) || !sameRegistryFileIdentity(opened, after))
+			throw new Error("Registry cache path changed while reading.");
+		return bytes;
+	} finally {
+		await handle?.close();
+	}
+}
+
+async function readJsonBun(file: string): Promise<unknown | undefined> {
+	const bytes = await readRegistryBytesBun(file);
+	return bytes === undefined ? undefined : JSON.parse(bytes.toString("utf8"));
 }
 
 function parseState(value: unknown): RegistryState {
@@ -1576,9 +1669,10 @@ function cloneAcceptedModelPresetRegistry(value: AcceptedModelPresetRegistry): A
 
 function registryFileFingerprint(file: string): string {
 	try {
-		return sha256(fsSync.readFileSync(file));
-	} catch {
-		return "absent";
+		const bytes = readRegistryBytesSync(file);
+		return bytes === undefined ? "absent" : sha256(bytes);
+	} catch (error) {
+		return isEnoent(error) ? "absent" : "rejected";
 	}
 }
 
@@ -1595,9 +1689,10 @@ function acceptedRegistryFingerprint(
 
 async function registryFileFingerprintAsync(file: string): Promise<string> {
 	try {
-		return sha256(new Uint8Array(await Bun.file(file).arrayBuffer()));
-	} catch {
-		return "absent";
+		const bytes = await readRegistryBytesBun(file);
+		return bytes === undefined ? "absent" : sha256(bytes);
+	} catch (error) {
+		return isEnoent(error) ? "absent" : "rejected";
 	}
 }
 
@@ -1624,6 +1719,8 @@ export function loadAcceptedModelPresetRegistry(
 	if (!acceptedRegistryReadIsCacheable(dependencies) || environmentDisabled())
 		return loadAcceptedModelPresetRegistryUncached(agentDir, dependencies);
 	const fingerprint = acceptedRegistryFingerprint(agentDir, dependencies);
+	if (fingerprint.split("|").includes("rejected"))
+		return loadAcceptedModelPresetRegistryUncached(agentDir, dependencies);
 	const cached = acceptedRegistryReadCache.get(agentDir);
 	if (cached && cached.fingerprint === fingerprint) return cloneAcceptedModelPresetRegistry(cached.value);
 	const value = loadAcceptedModelPresetRegistryUncached(agentDir, dependencies);
@@ -1700,6 +1797,8 @@ export async function loadAcceptedModelPresetRegistryAsync(
 	if (!acceptedRegistryReadIsCacheable(dependencies) || environmentDisabled())
 		return loadAcceptedModelPresetRegistryAsyncUncached(agentDir, dependencies);
 	const fingerprint = await acceptedRegistryFingerprintAsync(agentDir, dependencies);
+	if (fingerprint.split("|").includes("rejected"))
+		return loadAcceptedModelPresetRegistryAsyncUncached(agentDir, dependencies);
 	const cached = acceptedRegistryReadCache.get(agentDir);
 	if (cached && cached.fingerprint === fingerprint) return cloneAcceptedModelPresetRegistry(cached.value);
 	const value = await loadAcceptedModelPresetRegistryAsyncUncached(agentDir, dependencies);

package/src/config/model-registry.ts

@@ -4560,10 +4560,10 @@ export class ModelRegistry {
 			.get(model.provider.toLowerCase())
 			?.get(model.id.toLowerCase())?.thinking;
 		if (overrideThinking !== undefined) return { ...model, thinking: overrideThinking as ThinkingConfig };
-		const overlay = [...this.#runtimeModelOverlays, ...this.#customModelOverlays].find(
-			candidate =>
-				candidate.provider === model.provider && candidate.id === model.id && candidate.thinking !== undefined,
-		);
+		const hasDeclaredThinking = (candidate: CustomModelOverlay) =>
+			candidate.provider === model.provider && candidate.id === model.id && candidate.thinking !== undefined;
+		const overlay =
+			this.#runtimeModelOverlays.find(hasDeclaredThinking) ?? this.#customModelOverlays.find(hasDeclaredThinking);
 		return overlay?.thinking === undefined ? model : { ...model, thinking: overlay.thinking };
 	}
 	/**
@@ -5215,15 +5215,20 @@ export class ModelRegistry {
 	 * usable until live catalog evidence exists so offline startup is unchanged.
 	 */
 	getAvailableForProfileActivation(): Model<Api>[] {
+		const bundledIdsByProvider = new Map<string, Set<string>>();
 		return this.getAvailable().filter(model => {
 			const evidence = this.#descriptorDiscoveryEvidence.get(model.provider);
 			if (!evidence?.profileFresh || evidence.profileModelIds === undefined) return true;
 			if (this.#hasCustomModelOverlay(model.provider, model.id)) return true;
-			const bundledModelIds = new Set(
-				(getBundledModels(model.provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[]).map(
-					candidate => candidate.id,
-				),
-			);
+			let bundledModelIds = bundledIdsByProvider.get(model.provider);
+			if (!bundledModelIds) {
+				bundledModelIds = new Set(
+					(getBundledModels(model.provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[]).map(
+						candidate => candidate.id,
+					),
+				);
+				bundledIdsByProvider.set(model.provider, bundledModelIds);
+			}
 			if (!bundledModelIds.has(model.id)) return true;
 			if (
 				evidence.authGeneration !== this.#getProviderEvidenceGeneration(model.provider) ||
@@ -5236,9 +5241,8 @@ export class ModelRegistry {
 	}
 
 	#hasCustomModelOverlay(provider: string, id: string): boolean {
-		return [...this.#customModelOverlays, ...this.#runtimeModelOverlays].some(
-			overlay => overlay.provider === provider && overlay.id === id,
-		);
+		const matches = (overlay: CustomModelOverlay) => overlay.provider === provider && overlay.id === id;
+		return this.#customModelOverlays.some(matches) || this.#runtimeModelOverlays.some(matches);
 	}
 
 	#hasFreshOrStaticModelEvidence(model: Model<Api>): boolean {

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

@@ -163,6 +163,8 @@ export interface PromptRequestV1 {
 	phase: "claimed" | "remote_started" | "accepted" | "linked" | "terminal" | "completed" | "uncertain";
 	runtime_receipt?: { accepted: true; command_id: string; turn_id: string };
 	coordinator_turn_id?: string;
+	/** Retain prompt and source turn until the delegate's outer response is durable. */
+	delegate_response_pending?: boolean;
 	safe_response?: Record<string, unknown>;
 	error_code?: PublicReason | "idempotency_conflict";
 	created_at: string;
@@ -244,7 +246,12 @@ export interface CoordinatorSessionTransactionV1 {
 		scheduler_applied_revision?: number;
 		scheduler_digest?: string;
 	};
-	recovery: { prompt_watermark_at: string | null; last_repaired_at: string | null };
+	recovery: {
+		prompt_watermark_at: string | null;
+		last_repaired_at: string | null;
+		/** One-shot authority for the initial delegate prompt, consumed atomically with its claim. */
+		initial_delegate_request?: { key_digest: string; request_digest: string };
+	};
 }
 interface CoordinatorSessionHistoryV1 {
 	schema_version: 1;
@@ -815,6 +822,7 @@ function assertTransaction(transaction: CoordinatorSessionTransactionV1, namespa
 		typeof request.canonical_prompt.text !== "string" ||
 		!safeId(request.sdk_idempotency_key) ||
 		!promptPhases.has(String(request.phase)) ||
+		(request.delegate_response_pending !== undefined && typeof request.delegate_response_pending !== "boolean") ||
 		!isTime(request.created_at) ||
 		!isTime(request.updated_at) ||
 		(request.coordinator_turn_id !== undefined &&
@@ -1194,6 +1202,12 @@ function assertTransaction(transaction: CoordinatorSessionTransactionV1, namespa
 			(typeof projection.scheduler_digest !== "string" || projection.scheduler_digest.length === 0)) ||
 		(recovery.prompt_watermark_at !== null && !isTime(recovery.prompt_watermark_at)) ||
 		(recovery.last_repaired_at !== null && !isTime(recovery.last_repaired_at)) ||
+		(recovery.initial_delegate_request !== undefined &&
+			(!isRecord(recovery.initial_delegate_request) ||
+				typeof recovery.initial_delegate_request.key_digest !== "string" ||
+				!/^[a-f0-9]{64}$/.test(recovery.initial_delegate_request.key_digest) ||
+				typeof recovery.initial_delegate_request.request_digest !== "string" ||
+				!/^[a-f0-9]{64}$/.test(recovery.initial_delegate_request.request_digest))) ||
 		(queue.selected_promotion !== null &&
 			(!isRecord(queue.selected_promotion) ||
 				!safeId(queue.selected_promotion.from_turn_id) ||
@@ -1837,7 +1851,15 @@ export async function commitCreationWal(
 					scheduler_applied_revision: 0,
 					scheduler_digest: digest(JSON.stringify({ session_id: session.session_id, revision: 1 })),
 				},
-				recovery: { prompt_watermark_at: null, last_repaired_at: null },
+				recovery: {
+					prompt_watermark_at: null,
+					last_repaired_at: null,
+					// Only a newly created WAL may grant pre-dispatch authority. An
+					// existing WAL above must never replenish a consumed/compacted claim.
+					...(intent.kind === "delegate"
+						? { initial_delegate_request: { key_digest: keyDigest, request_digest: request.request_digest } }
+						: {}),
+				},
 			};
 			assertTransaction(transaction, session.namespace_id, session.session_id);
 			await writeAtomic(transactionPath(paths, session.session_id), transaction);
@@ -2320,6 +2342,13 @@ export async function enumeratePublicDeliveries(
 export function compactTransaction(transaction: CoordinatorSessionTransactionV1, now = Date.now()): void {
 	normalizeOutbox(transaction);
 	const old = (time: string): boolean => Date.parse(time) + RETENTION_MS < now;
+	// Prompt acceptance/canonical finalization precedes the outer delegate receipt.
+	// Neither retention nor pressure compaction may erase that recovery authority.
+	const pinnedPrompts = Object.values(transaction.requests.prompts).filter(
+		request => request.delegate_response_pending === true,
+	);
+	const pinnedRequests = new Set<object>(pinnedPrompts);
+	const pinnedTurns = new Set(pinnedPrompts.map(request => request.coordinator_turn_id));
 	for (const [id, event] of Object.entries(transaction.outbox))
 		if (
 			event.emitted &&
@@ -2332,6 +2361,7 @@ export function compactTransaction(transaction: CoordinatorSessionTransactionV1,
 		for (const [id, request] of Object.entries(group))
 			if (
 				request.phase === "completed" &&
+				!pinnedRequests.has(request) &&
 				old(request.updated_at) &&
 				JSON.stringify(transaction.canonical).includes(id) === false
 			)
@@ -2347,6 +2377,7 @@ export function compactTransaction(transaction: CoordinatorSessionTransactionV1,
 		for (const turnId of terminalTurnIds) {
 			const turn = transaction.canonical.turns[turnId];
 			if (!turn) continue;
+			if (pinnedTurns.has(turnId)) continue;
 			// Both promotion endpoints stay addressable for later projection repair;
 			// deleting either would corrupt the WAL instead of completing at capacity.
 			if (