@gajae-code/coding-agent 0.15.4 → 0.15.6

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 { listCoordinatorJsonFiles } from "./projection-scan";
 import {
 	answerBindingMatches,
 	buildCoordinatorAskAnswerSchema,
@@ -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 listCoordinatorJsonFiles(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;
@@ -3260,7 +3252,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.
@@ -8412,6 +8404,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 +8429,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
@@ -9079,10 +9074,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/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,6 +536,7 @@ export interface ExtensionContext {
 			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;
@@ -754,6 +755,8 @@ export interface AgentStartEvent extends SharedAgentStartEvent {
 export interface AgentFailedEvent {
 	type: "agent_failed";
 	error: AgentFailureDiagnostic;
+	/** Internal SDK queue-owner binding for exact lifecycle attribution. */
+	sdkRunToken?: string;
 	/** Attempt correlation for the failing run, when scoped (matches the
 	 * agent_start/agent_end scope contract). */
 	scope?: AttemptScope;
@@ -1313,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>;
 
@@ -1543,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>;
 
@@ -1705,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,

package/src/extensibility/shared-events.ts

@@ -184,6 +184,8 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
 	type: "agent_end";
 	messages: AgentMessage[];
+	/** Internal SDK queue-owner binding for exact lifecycle attribution. */
+	sdkRunToken?: string;
 	/** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
 	stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
 	/** Present for maintenance checkpoints; non-aborted checkpoints are not terminal. */

package/src/gjc-runtime/empty-delete-gc.ts

@@ -0,0 +1,301 @@
+/**
+ * Official GC of already-quarantined empty `.gjc-delete-*` receipts.
+ * Roots are operator operands — never hardcoded host paths.
+ */
+
+import { randomUUID } from "node:crypto";
+import type { BigIntStats } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { exactUnlinkDirect, type NativeExactUnlinkResult } from "@gajae-code/natives";
+
+export const EMPTY_DELETE_PREFIX = ".gjc-delete-";
+const EMPTY_DELETE_RECEIPT_PATTERN =
+	/^\.gjc-delete-session-state-lock-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/u;
+const EMPTY_FILE_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+export interface EmptyDeleteIdentity {
+	dev: bigint;
+	ino: bigint;
+	nlink: bigint;
+	size: bigint;
+	mtimeNs: bigint;
+	parentDev: bigint;
+	parentIno: bigint;
+	sha256: string;
+}
+
+export interface EmptyDeleteGcRecord {
+	root: string;
+	path: string;
+	action: "would_remove" | "removed" | "kept" | "skipped";
+	reason: string;
+	identity?: EmptyDeleteIdentity;
+	/** A dry-run candidate is an observation, never deletion authority. */
+	observationOnly?: boolean;
+	/** Retained-object paths a native direct unlink left behind; operator-recoverable only there. */
+	retainedPaths?: { detached?: string; successor?: string; placeholder?: string; unknown?: string };
+}
+
+export interface EmptyDeleteGcReport {
+	dry_run: boolean;
+	roots: string[];
+	records: EmptyDeleteGcRecord[];
+	would_remove: number;
+	removed: number;
+	kept: number;
+	skipped: number;
+	errors: string[];
+}
+
+export interface EmptyDeleteGcOptions {
+	roots: string[];
+	prune: boolean;
+}
+
+export interface EmptyDeleteGcDependencies {
+	/** Internal seam for deterministic collect-to-prune race tests. */
+	collect?: (root: string) => Promise<EmptyDeleteGcRecord[]>;
+	exactUnlinkDirect?: typeof exactUnlinkDirect;
+}
+
+function isUnsafeName(name: string): boolean {
+	return name.includes("/") || name.includes("\0") || name === "." || name === "..";
+}
+
+function identityOf(stat: BigIntStats): Omit<EmptyDeleteIdentity, "parentDev" | "parentIno" | "sha256"> {
+	return {
+		dev: stat.dev,
+		ino: stat.ino,
+		nlink: stat.nlink,
+		size: stat.size,
+		mtimeNs: stat.mtimeNs,
+	};
+}
+
+/**
+ * Extract the operator-recoverable retained paths a native direct unlink can leave behind.
+ * Any of them means debris still exists outside the receipt namespace, so the caller
+ * records them and fails the run instead of reporting a clean prune.
+ */
+function retainedPathsOf(
+	result: NativeExactUnlinkResult,
+): { detached?: string; successor?: string; placeholder?: string; unknown?: string } | undefined {
+	if (
+		result.detachedPath === undefined &&
+		result.retainedSuccessorPath === undefined &&
+		result.retainedPlaceholderPath === undefined &&
+		result.retainedUnknownPath === undefined
+	)
+		return undefined;
+	return {
+		detached: result.detachedPath,
+		successor: result.retainedSuccessorPath,
+		placeholder: result.retainedPlaceholderPath,
+		unknown: result.retainedUnknownPath,
+	};
+}
+
+function isEmptyDeleteReceiptName(name: string): boolean {
+	return EMPTY_DELETE_RECEIPT_PATTERN.test(name);
+}
+
+function sameRootIdentity(left: BigIntStats, right: BigIntStats): boolean {
+	return left.isDirectory() && right.isDirectory() && left.dev === right.dev && left.ino === right.ino;
+}
+
+function rootRaceRecord(root: string): EmptyDeleteGcRecord[] {
+	return [{ root, path: root, action: "skipped", reason: "root_race" }];
+}
+
+export async function collectEmptyDeleteReceipts(
+	root: string,
+	deps: { lstat?: (file: string, options: { bigint: true }) => Promise<BigIntStats> } = {},
+): Promise<EmptyDeleteGcRecord[]> {
+	const lstatFile = deps.lstat ?? ((file: string) => fs.lstat(file, { bigint: true }));
+	const records: EmptyDeleteGcRecord[] = [];
+	const resolvedRoot = path.resolve(root);
+	let rootStat: BigIntStats;
+	try {
+		rootStat = await lstatFile(resolvedRoot, { bigint: true });
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return [{ root, path: root, action: "skipped", reason: "missing_root" }];
+		}
+		throw error;
+	}
+	if (rootStat.isSymbolicLink()) {
+		return [{ root, path: root, action: "skipped", reason: "symlink_root" }];
+	}
+	if (!rootStat.isDirectory()) {
+		return [{ root, path: root, action: "skipped", reason: "not_directory" }];
+	}
+	let names: string[];
+	try {
+		names = await fs.readdir(resolvedRoot);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return rootRaceRecord(root);
+		}
+		throw error;
+	}
+	// Enumeration is the first operation that can observe a replacement root. Do not
+	// attribute any names from that enumeration until the original root identity is
+	// proved to still own the pathname.
+	try {
+		const enumeratedRoot = await lstatFile(resolvedRoot, { bigint: true });
+		if (!sameRootIdentity(rootStat, enumeratedRoot)) return rootRaceRecord(root);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return rootRaceRecord(root);
+		throw error;
+	}
+	for (const name of names) {
+		if (isUnsafeName(name) || !isEmptyDeleteReceiptName(name)) continue;
+		const file = path.join(resolvedRoot, name);
+		let stat: BigIntStats;
+		try {
+			stat = await lstatFile(file, { bigint: true });
+		} catch (error) {
+			// ENOENT is an ordinary race with concurrent cleanup, but silently dropping the
+			// entry would shrink the report without trace; record it as a raced candidate so
+			// discovery stays fail-closed. Any other stat failure is a hard discovery error.
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				records.push({ root, path: file, action: "skipped", reason: "raced" });
+				continue;
+			}
+			throw error;
+		}
+		if (stat.isSymbolicLink()) {
+			records.push({ root, path: file, action: "kept", reason: "symlink" });
+			continue;
+		}
+		if (!stat.isFile()) {
+			records.push({ root, path: file, action: "kept", reason: "not_regular" });
+			continue;
+		}
+		if (stat.size !== 0n) {
+			records.push({ root, path: file, action: "kept", reason: "non_empty" });
+			continue;
+		}
+		if (stat.nlink !== 1n) {
+			records.push({ root, path: file, action: "kept", reason: "nlink" });
+			continue;
+		}
+		records.push({
+			root,
+			path: file,
+			action: "would_remove",
+			reason: "empty_delete_receipt",
+			identity: {
+				...identityOf(stat),
+				parentDev: rootStat.dev,
+				parentIno: rootStat.ino,
+				sha256: EMPTY_FILE_SHA256,
+			},
+		});
+	}
+	// The candidate lstat calls above are pathname operations. Revalidate once more
+	// before returning so a replaced root can never leak its external candidate paths
+	// (or their identities) into a GC report.
+	try {
+		const finalRoot = await lstatFile(resolvedRoot, { bigint: true });
+		if (!sameRootIdentity(rootStat, finalRoot)) return rootRaceRecord(root);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return rootRaceRecord(root);
+		throw error;
+	}
+	return records;
+}
+
+export async function runEmptyDeleteGc(
+	options: EmptyDeleteGcOptions,
+	deps: EmptyDeleteGcDependencies = {},
+): Promise<EmptyDeleteGcReport> {
+	const report: EmptyDeleteGcReport = {
+		dry_run: !options.prune,
+		roots: options.roots,
+		records: [],
+		would_remove: 0,
+		removed: 0,
+		kept: 0,
+		skipped: 0,
+		errors: [],
+	};
+	const collect = deps.collect ?? collectEmptyDeleteReceipts;
+	const unlink = deps.exactUnlinkDirect ?? exactUnlinkDirect;
+	for (const root of options.roots) {
+		let records: EmptyDeleteGcRecord[];
+		try {
+			records = await collect(root);
+		} catch (error) {
+			report.errors.push(`${root}: ${error instanceof Error ? error.message : String(error)}`);
+			continue;
+		}
+		for (const record of records) {
+			if (record.action === "would_remove" && !options.prune) record.observationOnly = true;
+			if (
+				record.action === "skipped" &&
+				(record.reason === "raced" ||
+					record.reason === "root_race" ||
+					(record.path === root &&
+						(record.reason === "missing_root" ||
+							record.reason === "symlink_root" ||
+							record.reason === "not_directory")))
+			) {
+				report.errors.push(`${record.path}: ${record.reason}`);
+			}
+			if (record.action === "would_remove" && options.prune) {
+				try {
+					if (!record.identity) {
+						record.action = "kept";
+						record.reason = "identity_missing";
+					} else {
+						const result = unlink(record.path, {
+							...record.identity,
+							quarantineName: `.gjc-delete-gc-${randomUUID()}.json`,
+						});
+						const retainedPaths = retainedPathsOf(result);
+						if (result.ok) {
+							record.action = "removed";
+						} else if (result.code === "not_found") {
+							record.action = "skipped";
+							record.reason = "gone";
+						} else if (result.code === "identity_mismatch") {
+							record.action = "kept";
+							record.reason = "identity_drift";
+						} else {
+							record.action = "kept";
+							record.reason = `unlink_failed:${result.code ?? "unknown"}`;
+							report.errors.push(`${record.path}: ${record.reason}`);
+						}
+						// Objects the native layer retained (post-detach failure or a successor at
+						// the private quarantine name) are recoverable only at those paths; surface
+						// them and fail the run instead of silently stranding debris.
+						if (retainedPaths !== undefined) {
+							record.retainedPaths = retainedPaths;
+							record.reason = result.ok ? `retained:${result.code ?? "cleanup_pending"}` : record.reason;
+							report.errors.push(
+								`${record.path}: retained debris requires operator recovery: ${JSON.stringify(retainedPaths)}`,
+							);
+						}
+					}
+				} catch (error) {
+					if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+						record.action = "skipped";
+						record.reason = "gone";
+					} else {
+						record.action = "kept";
+						record.reason = `unlink_failed:${error instanceof Error ? error.message : String(error)}`;
+						report.errors.push(`${record.path}: ${record.reason}`);
+					}
+				}
+			}
+			report.records.push(record);
+			if (record.action === "would_remove") report.would_remove += 1;
+			else if (record.action === "removed") report.removed += 1;
+			else if (record.action === "skipped") report.skipped += 1;
+			else report.kept += 1;
+		}
+	}
+	return report;
+}

package/src/gjc-runtime/gc-render.ts

@@ -88,6 +88,35 @@ export function buildGcReportText(report: GcReport): string {
 		lines.push("");
 	}
 
+	if (report.empty_delete_receipts) {
+		const empty = report.empty_delete_receipts;
+		lines.push(`Empty .gjc-delete receipts (${empty.records.length})`);
+		if (empty.records.length === 0) {
+			lines.push("  (none)");
+		} else {
+			for (const record of empty.records) {
+				const action = record.action === "would_remove" ? "would remove" : record.action;
+				lines.push(`  [${action}] ${record.path} :: ${record.reason}`);
+				if (record.retainedPaths) {
+					const retained = [
+						["detached", record.retainedPaths.detached],
+						["successor", record.retainedPaths.successor],
+						["placeholder", record.retainedPaths.placeholder],
+						["unknown", record.retainedPaths.unknown],
+					].filter((entry): entry is [string, string] => entry[1] !== undefined);
+					if (retained.length > 0)
+						lines.push(`    retained: ${retained.map(([kind, p]) => `${kind}=${p}`).join(" ")}`);
+				}
+			}
+		}
+		for (const error of empty.errors) lines.push(`  [error] ${error}`);
+		lines.push(
+			`  Summary: roots=${empty.roots.length} would_remove=${empty.would_remove} removed=${empty.removed} ` +
+				`kept=${empty.kept} skipped=${empty.skipped} errors=${empty.errors.length}`,
+		);
+		lines.push("");
+	}
+
 	if (report.warnings.length > 0) {
 		lines.push(`Warnings (${report.warnings.length})`);
 		for (const warning of report.warnings) lines.push(`  [${warning.store}/${warning.scope}] ${warning.message}`);