@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/coordinator-mcp/server.ts

@@ -69,7 +69,7 @@ import {
 } from "./event-webhook";
 import {
 	type CoordinatorModelProfileLoader,
-	loadCoordinatorModelProfiles,
+	createCoordinatorModelProfileLoader,
 	resolveCoordinatorMpreset,
 } from "./model-preset";
 import {
@@ -83,6 +83,7 @@ import {
 	requireCoordinatorMutation,
 	safeOpenCoordinatorArtifact,
 } from "./policy";
+import { listCoordinatorJsonFilesWithRetry } from "./projection-scan";
 import {
 	answerBindingMatches,
 	buildCoordinatorAskAnswerSchema,
@@ -834,7 +835,7 @@ function toolSchema(name: CoordinatorToolName): {
 				properties: {
 					after_seq: { type: "integer", minimum: 0 },
 					session_id: sessionId,
-					event_types: { type: "array", items: { type: "string" } },
+					event_types: { type: "array", items: { type: "string", enum: [...COORDINATOR_EVENT_KINDS] } },
 					timeout_ms: {
 						type: "number",
 						description: "Bounded event long-poll timeout in milliseconds, capped at 30 seconds.",
@@ -1497,26 +1498,17 @@ function publicSdkAcknowledgement(result: RuntimePromptAcknowledgement): Record<
 }
 
 async function listJsonFiles(dir: string): Promise<unknown[]> {
-	try {
-		const entries = await fs.readdir(dir);
-		const values = await Promise.all(
-			entries
-				.filter(entry => entry.endsWith(".json") && !entry.startsWith(".gjc-"))
-				.map(async entry => {
-					try {
-						return await readJsonFile(path.join(dir, entry));
-					} catch (error) {
-						if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
-						logger.warn("Coordinator projection read failed", { path: entry, error: String(error) });
-						throw error;
-					}
-				}),
-		);
-		return values.filter(value => value !== null);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
+	const scan = await listCoordinatorJsonFilesWithRetry(dir);
+	if (scan.capped) throw new Error("coordinator_projection_scan_incomplete");
+	if (scan.skippedEmpty > 0 || scan.skippedDebris > 0) {
+		logger.warn("Coordinator projection scan skipped debris", {
+			dir,
+			parsed: scan.parsed,
+			skippedDebris: scan.skippedDebris,
+			skippedEmpty: scan.skippedEmpty,
+		});
 	}
+	return scan.values;
 }
 
 const COORDINATOR_STATUS_EVENT_LIMIT = 100;
@@ -1538,7 +1530,10 @@ function brokerSessionId(record: Record<string, unknown>): string | null {
 }
 
 function brokerSessionScope(record: Record<string, unknown>): string | null {
-	return firstString(asRecord(record.locator) ?? {}, ["repo"]);
+	// Locator v2 records the canonical workspace directory as `cwd`; the removed
+	// `repo` field is never translated, so reading it here silently dropped every
+	// broker row and failed open with an empty scoped listing.
+	return firstString(asRecord(record.locator) ?? {}, ["cwd"]);
 }
 
 function sameCanonicalPath(left: string, right: string, platform: NodeJS.Platform): boolean {
@@ -2642,11 +2637,6 @@ async function writeActiveTurn(namespaceDir: string, turn: TurnRecord): Promise<
 	});
 }
 
-async function clearActiveTurn(namespaceDir: string, turn: TurnRecord): Promise<void> {
-	const active = asRecord(await readJsonFile(activeTurnFile(namespaceDir, turn.session_id)));
-	if (active?.turn_id === turn.turn_id) await removeCoordinatorFile(activeTurnFile(namespaceDir, turn.session_id));
-}
-
 async function readSessionState(namespaceDir: string, sessionId: string): Promise<CoordinatorSessionState | null> {
 	return (await readJsonFile(sessionStateFile(namespaceDir, sessionId))) as CoordinatorSessionState | null;
 }
@@ -2666,9 +2656,6 @@ async function writeSessionStateUnlocked(
 	} = {},
 ): Promise<CoordinatorSessionState> {
 	const persisted = await readSessionState(namespaceDir, sessionId);
-	const session = asRecord(
-		await readJsonFile(path.join(namespaceDir, "sessions", `${safeExternalId("session", sessionId)}.json`)),
-	);
 	// An overwrite is a canonical lifecycle repair, not proof that tool activity ended.
 	const previous = options.overwrite ? null : persisted;
 	const hasCurrentTurn = Object.hasOwn(options, "currentTurnId");
@@ -3260,7 +3247,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		await routerReady;
 	}
 	const platform = options.platform ?? process.platform;
-	const loadModelProfiles = services.resolveModelProfiles ?? loadCoordinatorModelProfiles;
+	const loadModelProfiles = services.resolveModelProfiles ?? createCoordinatorModelProfileLoader(routerAgentDir);
 	// Every authoritative projection is scoped by the collision-resistant namespace identity.
 	const namespaceDir = coordinatorNamespacePath(config);
 	// The prior human-readable directory is migration input only; it is never authority.
@@ -5052,6 +5039,58 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		const keyDigest = createHash("sha256").update(idempotencyKey).digest("hex");
 		return path.join(namespaceDir, "idempotency", `${keyDigest}.json`);
 	}
+	const idempotencyFlights = new Map<string, { requestDigest: string; promise: Promise<Record<string, unknown>> }>();
+	type IdempotencyFlightAdmission =
+		| { kind: "conflict"; response: Record<string, unknown> }
+		| { kind: "joined"; promise: Promise<Record<string, unknown>> }
+		| { kind: "owner"; run: (operation: Promise<Record<string, unknown>>) => Promise<Record<string, unknown>> };
+	function admitIdempotencyFlight(
+		tool: string,
+		idempotencyKey: string,
+		canonicalArgs: Record<string, unknown>,
+	): IdempotencyFlightAdmission {
+		const keyDigest = createHash("sha256").update(idempotencyKey).digest("hex");
+		const requestDigest = createHash("sha256")
+			.update(canonicalJson({ tool, args: canonicalArgs }))
+			.digest("hex");
+		const existingFlight = idempotencyFlights.get(keyDigest);
+		if (existingFlight) {
+			if (existingFlight.requestDigest !== requestDigest)
+				return {
+					kind: "conflict",
+					response: {
+						ok: false,
+						error: { code: "idempotency_conflict", message: "idempotency key was used with a different request" },
+					},
+				};
+			return { kind: "joined", promise: existingFlight.promise };
+		}
+		const result = Promise.withResolvers<Record<string, unknown>>();
+		const flight = { requestDigest, promise: result.promise };
+		idempotencyFlights.set(keyDigest, flight);
+		return {
+			kind: "owner",
+			run: async operation => {
+				void operation.then(result.resolve, result.reject);
+				try {
+					return await result.promise;
+				} finally {
+					if (idempotencyFlights.get(keyDigest) === flight) idempotencyFlights.delete(keyDigest);
+				}
+			},
+		};
+	}
+	async function withIdempotencyFlight(
+		tool: string,
+		idempotencyKey: string,
+		canonicalArgs: Record<string, unknown>,
+		operation: () => Promise<Record<string, unknown>>,
+	): Promise<Record<string, unknown>> {
+		const admission = admitIdempotencyFlight(tool, idempotencyKey, canonicalArgs);
+		if (admission.kind === "conflict") return admission.response;
+		if (admission.kind === "joined") return await admission.promise;
+		return await admission.run(operation());
+	}
 	async function withOrderedSessionStateLocks<T>(
 		lockFiles: readonly string[],
 		operation: () => Promise<T>,
@@ -5083,6 +5122,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		recoverInProgress = false,
 		isNonterminal: (response: Record<string, unknown>) => boolean = isRouterRequestAmbiguous,
 		lockAlreadyHeld = false,
+		flightAlreadyOwned = false,
 	): Promise<Record<string, unknown>> {
 		const keyDigest = createHash("sha256").update(idempotencyKey).digest("hex");
 		const requestDigest = createHash("sha256")
@@ -5187,7 +5227,11 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 			});
 			return response;
 		};
-		return lockAlreadyHeld ? execute() : withSessionStateLock(lockFile, execute);
+		const executeWithLock = async (): Promise<Record<string, unknown>> =>
+			lockAlreadyHeld ? await execute() : await withSessionStateLock(lockFile, execute);
+		return flightAlreadyOwned
+			? await executeWithLock()
+			: await withIdempotencyFlight(tool, idempotencyKey, canonicalArgs, executeWithLock);
 	}
 
 	async function brokerSession(
@@ -5289,11 +5333,28 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 					sessionId,
 				);
 			} catch (closeError) {
-				throw new SdkClientError(
-					UNOBSERVED_COMPENSATION_CODE,
-					`Coordinator creation failed after remote session ${sessionId} was created, and compensation failed.`,
-					{ primary: error, compensation: closeError, session_id: sessionId },
-				);
+				let listed: Record<string, unknown>;
+				try {
+					listed = await paginatedBrokerSessionList(cwd, { cwd });
+				} catch (listError) {
+					throw new SdkClientError(
+						UNOBSERVED_COMPENSATION_CODE,
+						`Coordinator creation failed after remote session ${sessionId} was created, and compensation failed.`,
+						{ primary: error, compensation: closeError, list: listError, session_id: sessionId },
+					);
+				}
+				const rows = jsonRecords(Array.isArray(listed.sessions) ? listed.sessions : []);
+				const row = rows.find(candidate => brokerSessionId(candidate) === sessionId);
+				const deadUncertain =
+					row !== undefined &&
+					row.live !== true &&
+					(row.terminalUncertain === true || (row as Record<string, unknown>).terminal_uncertain === true);
+				if (!deadUncertain)
+					throw new SdkClientError(
+						UNOBSERVED_COMPENSATION_CODE,
+						`Coordinator creation failed after remote session ${sessionId} was created, and compensation failed.`,
+						{ primary: error, compensation: closeError, session_id: sessionId },
+					);
 			}
 			throw error;
 		}
@@ -6721,7 +6782,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 					// any stale pointer directly: once the turn projection is rewritten
 					// terminal, readActiveTurn() intentionally rejects it and cannot
 					// discover the legacy active-turn file to clear.
-					await fs.rm(activeTurnFile(namespaceDir, sessionId), { force: true });
+					await removeCoordinatorFile(activeTurnFile(namespaceDir, sessionId));
 				}
 				// A runtime sidecar can advance a live session while the canonical WAL still
 				// needs projection repair. Preserve that observed lifecycle state (and its
@@ -8412,6 +8473,9 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 			}
 			if (name === "gjc_coordinator_start_session") {
 				requireCoordinatorMutation(config, "sessions", args);
+				const suppliedPrompt = Object.hasOwn(args, "prompt");
+				if (suppliedPrompt && (typeof args.prompt !== "string" || args.prompt.trim().length === 0))
+					return { ok: false, error: { code: "invalid_input", message: "Prompt must not be empty." } };
 				const idempotencyKey = requiredIdempotencyKey(args);
 				const cwd = await canonicalBrokerWorkspace(await assertCoordinatorWorkdir(config, args.cwd));
 				const mpresetResolution = await resolveCoordinatorMpreset(args.mpreset, loadModelProfiles);
@@ -8434,7 +8498,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 						error: { code: "unknown_model", message: modelResolution.error },
 					};
 				}
-				const prompt = typeof args.prompt === "string" && args.prompt.length > 0 ? args.prompt : null;
+				const prompt = suppliedPrompt ? (args.prompt as string) : null;
 				/**
 				 * A prepared session is deliberately not ready for input: its readiness
 				 * is withheld until an operator-supplied thread is bound and activation
@@ -8785,7 +8849,10 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 						code === "live_session"
 					);
 				};
-				return await withOrderedSessionStateLocks(
+				const flight = admitIdempotencyFlight(name, retirementKey, canonicalArgs);
+				if (flight.kind === "conflict") return flight.response;
+				if (flight.kind === "joined") return await flight.promise;
+				const retirementOperation = withOrderedSessionStateLocks(
 					[idempotencyLockFile(creationKey), idempotencyLockFile(retirementKey)],
 					async () =>
 						await withToolIdempotency(
@@ -8969,8 +9036,10 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 							true,
 							isRetirementRetryable,
 							true,
+							true,
 						),
 				);
+				return await flight.run(retirementOperation);
 			}
 			if (name === "gjc_coordinator_activate_session") {
 				requireCoordinatorMutation(config, "sessions", args);
@@ -9079,10 +9148,10 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 			}
 			if (name === "gjc_coordinator_send_prompt") {
 				requireCoordinatorMutation(config, "sessions", args);
+				if (typeof args.prompt !== "string" || args.prompt.trim().length === 0)
+					return { ok: false, error: { code: "invalid_input", message: "Prompt must not be empty." } };
 				const idempotencyKey = requiredIdempotencyKey(args);
 				const sessionId = safeExternalId("session", args.session_id);
-				if (typeof args.prompt !== "string" || args.prompt.length === 0)
-					return { ok: false, error: { code: "invalid_input", message: "prompt is required" } };
 				const prompt = args.prompt;
 				return await withToolIdempotency(
 					name,

package/src/coordinator-mcp/session-reaper.ts

@@ -100,9 +100,15 @@ export function createSessionReaper(deps: SessionReaperDeps, policy: SessionReap
 	function schedule(gen: number): void {
 		timer = setTimeout(() => {
 			if (gen !== generation) return; // stale timer from a prior start()
-			void sweepOnce().finally(() => {
-				if (gen === generation) schedule(gen);
-			});
+			void sweepOnce()
+				.catch(error => {
+					// A refused sweep (e.g. a fail-closed capped projection scan) must not
+					// become an unhandled rejection; log and keep the schedule alive.
+					logger.warn(`session-reaper: sweep refused: ${error instanceof Error ? error.message : String(error)}`);
+				})
+				.finally(() => {
+					if (gen === generation) schedule(gen);
+				});
 		}, sweepIntervalMs);
 		// The reaper must never keep the coordinator process alive by itself.
 		(timer as { unref?: () => void }).unref?.();

package/src/crash/index-store.ts

@@ -613,6 +613,7 @@ export function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: numbe
 	}
 
 	// occurrence
+	if (event.provenance === "eval" || event.provenance === "bun_test") return false;
 	// Clear before deduplication: a replayed occurrence after main-index publish
 	// but before retirement-sidecar publish must still supersede a stale tombstone.
 	index.retiredFingerprints = index.retiredFingerprints.filter(fingerprint => fingerprint !== event.fingerprint);
@@ -698,6 +699,7 @@ async function recoverAndRecomputeRetainedCounts(index: CrashIndex, crashLogPath
 	const recordsByFingerprint = new Map<string, LoadedCrashRecord[]>();
 	const seenRecordIds = new Set<string>();
 	for (const record of parseRecoverableCrashRecords(contents)) {
+		if (record.provenance === "eval" || record.provenance === "bun_test") continue;
 		if (seenRecordIds.has(record.recordId)) continue;
 		seenRecordIds.add(record.recordId);
 		const records = recordsByFingerprint.get(record.fingerprint) ?? [];

package/src/crash/record-loader.ts

@@ -15,6 +15,7 @@ import {
 	CRASH_FINGERPRINT_VERSION,
 	CRASH_RECORD_MARKER,
 	type CrashFingerprint,
+	type CrashProvenance,
 	computeCrashFingerprint,
 	parseCrashRecordMarker,
 } from "@gajae-code/utils";
@@ -33,6 +34,7 @@ export interface LoadedCrashRecord {
 	readonly body: string;
 	/** The `Name: message` part of the header line. */
 	readonly headline: string;
+	readonly provenance?: CrashProvenance;
 }
 
 interface ParsedCrashRecord {
@@ -78,6 +80,7 @@ function parseCandidates(contents: string): ParsedCrashRecord[] {
 	let at = 0;
 	let buffer: string[] = [];
 	let started = false;
+	let provenance: CrashProvenance | undefined;
 	let pending: ParsedCrashRecord | undefined;
 	for (const line of contents.split("\n")) {
 		if (pending) {
@@ -92,6 +95,12 @@ function parseCandidates(contents: string): ParsedCrashRecord[] {
 				continue;
 			}
 			headline = header[2] ?? "";
+			const label = line.slice(line.indexOf("[") + 1, line.indexOf("]"));
+			const provenanceValue = label
+				.split(";")
+				.find(part => part.startsWith("provenance="))
+				?.slice(11);
+			provenance = provenanceValue === "eval" || provenanceValue === "bun_test" ? provenanceValue : undefined;
 			at = parsedAt;
 			buffer = [];
 			started = true;
@@ -116,6 +125,7 @@ function parseCandidates(contents: string): ParsedCrashRecord[] {
 						messageClass: fingerprint?.messageClass ?? "",
 						body: lines.join("\n").trimEnd(),
 						headline,
+						...(provenance === undefined ? {} : { provenance }),
 					},
 					complete: false,
 					bound: marker.version === CRASH_FINGERPRINT_VERSION && fingerprint !== undefined,

package/src/extensibility/extensions/loader.ts

@@ -345,7 +345,6 @@ class ConcreteExtensionAPI implements ExtensionAPI {
 			onQueuedPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
 			onDispatchDisposition?: (promotion: { startsOwnRun: boolean }) => void;
 			preflightSignal?: AbortSignal;
-			sdkRunToken?: string;
 		},
 	): Promise<void> {
 		return Promise.resolve(this.runtime.sendUserMessage(content, options));

package/src/extensibility/extensions/types.ts

@@ -536,7 +536,7 @@ export interface ExtensionContext {
 			onPreflightAcceptCommit?: () => void | Promise<void>;
 			onSkillPrepared?: (meta: { name: string; path: string; lineCount?: number; cleanedArgs?: string }) => void;
 			preflightSignal?: AbortSignal;
-			sdkRunToken?: string;
+			sdkRunCapability?: unknown;
 		},
 	): Promise<unknown>;
 	setPlanMode?(on: boolean): unknown;
@@ -1316,7 +1316,6 @@ export interface ExtensionAPI {
 			onDispatchDisposition?: (promotion: { startsOwnRun: boolean }) => void;
 			preflightSignal?: AbortSignal;
 			/** Internal SDK correlation owner for an exact queued follow-up. */
-			sdkRunToken?: string;
 		},
 	): Promise<void>;
 
@@ -1546,7 +1545,6 @@ export type SendUserMessageHandler = (
 		onQueuedPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
 		preflightSignal?: AbortSignal;
 		/** Internal SDK correlation owner for an exact queued follow-up. */
-		sdkRunToken?: string;
 	},
 ) => void | Promise<void>;
 
@@ -1708,6 +1706,7 @@ export interface ExtensionContextActions {
 			onPreflightAcceptCommit?: () => void | Promise<void>;
 			onSkillPrepared?: (meta: { name: string; path: string; lineCount?: number; cleanedArgs?: string }) => void;
 			preflightSignal?: AbortSignal;
+			sdkRunCapability?: unknown;
 		},
 	) => Promise<unknown>;
 	setPlanMode?: (on: boolean) => unknown;

package/src/extensibility/gjc-plugins/runtime-adapters.ts

@@ -453,6 +453,7 @@ export async function buildPluginMcpConfigs(input: { cwd: string }): Promise<{
 						command: cfg.command,
 						args: cfg.args,
 						cwd: cfg.cwd ? nodePath.resolve(entry.pluginRoot, cfg.cwd) : entry.pluginRoot,
+						timeout: 5_000,
 						// Third-party plugin MCP processes must not inherit host secrets;
 						// only a minimal OS allowlist (PATH/HOME/temp/locale) is provided.
 						noInheritEnv: true,