@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/config/provider-selection-policy.ts

@@ -81,15 +81,8 @@ export function createProviderSelectionPolicy(input: ProviderSelectionPolicyInpu
 		}
 	}
 
-	const orderedProviders = [...explicitProviders];
-	const seen = new Set(explicitSet);
-	for (const provider of input.catalogProviders) {
-		if (seen.has(provider)) {
-			continue;
-		}
-		seen.add(provider);
-		orderedProviders.push(provider);
-	}
+	// One shared implementation with the standalone accessor; see projectProviderOrder.
+	const orderedProviders = projectProviderOrder(explicitProviders, input.catalogProviders);
 
 	return {
 		rank(provider: string): number {
@@ -113,6 +106,35 @@ export function createProviderSelectionPolicy(input: ProviderSelectionPolicyInpu
 	};
 }
 
+/**
+ * Project the deterministic provider order: normalized explicit order first, then
+ * first-wins catalog order for everything else.
+ *
+ * This is the single implementation of that ordering. It reads no credentials and
+ * takes no auth input at all, so any consumer that only needs "which providers, in
+ * what priority" cannot accidentally acquire auth sensitivity. Auth-aware banding
+ * lives exclusively in {@link ProviderSelectionPolicy.rank}.
+ */
+export function projectProviderOrder(
+	explicitProviderOrder: readonly string[],
+	catalogProviders: readonly string[],
+): string[] {
+	const ordered: string[] = [];
+	const seen = new Set<string>();
+	for (const raw of explicitProviderOrder) {
+		const normalized = raw.trim().toLowerCase();
+		if (!normalized || seen.has(normalized)) continue;
+		seen.add(normalized);
+		ordered.push(normalized);
+	}
+	for (const provider of catalogProviders) {
+		if (!provider || seen.has(provider)) continue;
+		seen.add(provider);
+		ordered.push(provider);
+	}
+	return ordered;
+}
+
 export interface ProviderSelectionCatalog {
 	/** Lowercased provider ids in first-wins registry catalog order. */
 	readonly catalogProviders: readonly string[];
@@ -144,3 +166,32 @@ export function buildProviderSelectionCatalog(models: readonly Model<Api>[]): Pr
 	}
 	return { catalogProviders, catalogModels };
 }
+/**
+ * Deterministic provider priority for a catalog, returned in the catalog's own
+ * spelling.
+ *
+ * Ordering and de-duplication run on normalized ids, but the result restores each
+ * provider's first-seen catalog spelling because the autorouting generator matches
+ * provider prefixes with case-sensitive exact strings — a lowercased id would
+ * silently empty that provider's tiers. Providers absent from the catalog are
+ * dropped so a dead declaration cannot pollute a generated declarationFingerprint.
+ *
+ * Reads no credentials: it takes a catalog and an explicit order, nothing else.
+ */
+export function projectCatalogProviderOrder(
+	explicitProviderOrder: readonly string[],
+	models: readonly Model<Api>[],
+): string[] {
+	const { catalogProviders } = buildProviderSelectionCatalog(models);
+	const spelling = new Map<string, string>();
+	for (const model of models) {
+		const normalized = model.provider.trim().toLowerCase();
+		if (normalized && !spelling.has(normalized)) spelling.set(normalized, model.provider);
+	}
+	const restored: string[] = [];
+	for (const provider of projectProviderOrder(explicitProviderOrder, catalogProviders)) {
+		const spelled = spelling.get(provider);
+		if (spelled !== undefined) restored.push(spelled);
+	}
+	return restored;
+}

package/src/config/settings-schema.ts

@@ -4,6 +4,18 @@ import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking-metadata";
 import { DEFAULT_EDIT_MODE_SETTING, EDIT_MODE_SETTINGS, EDIT_MODES, type EditMode } from "../utils/edit-mode";
 import { CONFIGURABLE_SEARCH_PROVIDER_IDS } from "../web/search/types";
+import {
+	AUTOROUTING_SELECTOR_DESCRIPTION,
+	AUTOROUTING_SELECTOR_PATTERN,
+	AUTOROUTING_TIERS,
+	type AutoroutingLocalIssue,
+	type AutoroutingProvenance,
+	type AutoroutingSetup,
+	type AutoroutingTierMapInput,
+	validateAutoroutingLocal,
+	validateAutoroutingProvenance,
+	validateAutoroutingSetup,
+} from "./autorouting-contract";
 import type { ModelSelectorValue } from "./model-selector-value";
 import { UPDATE_CHANNELS } from "./update-channel";
 
@@ -148,6 +160,22 @@ export type AnyUiMetadata = UiBase & {
 	options?: ReadonlyArray<SubmenuOption> | "runtime";
 };
 
+/** JSON Schema fragment carried by settings definitions that own nested validation. */
+export type JsonSchemaObject = {
+	[key: string]: unknown;
+	type?: string;
+	properties?: Record<string, JsonSchemaObject>;
+	additionalProperties?: boolean | JsonSchemaObject;
+	items?: JsonSchemaObject;
+	required?: readonly string[];
+	pattern?: string;
+	minItems?: number;
+	minLength?: number;
+	uniqueItems?: boolean;
+	minimum?: number;
+	const?: unknown;
+};
+
 interface BooleanDef {
 	type: "boolean";
 	default?: boolean;
@@ -186,6 +214,21 @@ type RecordValueDef =
 	| { type: "string-enum"; values: readonly string[] }
 	| { type: "credential-selector" };
 
+interface ConstrainedRecordValueDef {
+	type: "autorouting-selector-value";
+	pattern: string;
+	description: string;
+}
+
+interface ConstrainedRecordDef<T> {
+	type: "constrained-record";
+	default: T;
+	keys: readonly string[];
+	valueSchema: ConstrainedRecordValueDef;
+	description?: string;
+	ui?: UiBase;
+}
+
 interface RecordDef<T> {
 	type: "record";
 	default: Record<string, T>;
@@ -193,13 +236,23 @@ interface RecordDef<T> {
 	ui?: UiBase;
 }
 
-type SettingDef =
+export interface OptionalObjectDef<T> {
+	type: "optional-object";
+	default: undefined;
+	jsonSchema: JsonSchemaObject;
+	validate: (value: unknown) => AutoroutingLocalIssue[];
+	_value?: T;
+}
+
+export type SettingDef =
 	| BooleanDef
 	| StringDef
 	| NumberDef
 	| EnumDef<readonly string[]>
 	| ArrayDef<unknown>
-	| RecordDef<unknown>;
+	| RecordDef<unknown>
+	| ConstrainedRecordDef<unknown>
+	| OptionalObjectDef<unknown>;
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Schema Definition
@@ -261,6 +314,56 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 	},
 ];
 
+const AUTOROUTING_SETUP_JSON_SCHEMA: JsonSchemaObject = {
+	type: "object",
+	properties: {
+		schema: { type: "integer", const: 1 },
+		providers: {
+			type: "array",
+			minItems: 1,
+			uniqueItems: true,
+			items: {
+				type: "string",
+				minLength: 1,
+				pattern: "^[^\\s](?:.*[^\\s])?$",
+			},
+		},
+		models: {
+			type: "array",
+			items: {
+				type: "string",
+				minLength: 1,
+				maxLength: 256,
+				pattern: AUTOROUTING_SELECTOR_PATTERN,
+				not: { pattern: "^\\s*[pP][iI]/" },
+			},
+		},
+	},
+	additionalProperties: false,
+	required: ["schema", "providers"],
+};
+
+const AUTOROUTING_PROVENANCE_JSON_SCHEMA: JsonSchemaObject = {
+	type: "object",
+	properties: {
+		schema: { type: "integer", const: 1 },
+		source: {
+			type: "object",
+			properties: {
+				catalogFingerprint: { type: "string", pattern: "^[0-9a-f]{64}$" },
+				mapFingerprint: { type: "string", pattern: "^[0-9a-f]{64}$" },
+				generatorVersion: { type: "integer", minimum: 1 },
+			},
+			additionalProperties: false,
+			required: ["catalogFingerprint", "mapFingerprint", "generatorVersion"],
+		},
+		declarationFingerprint: { type: "string", pattern: "^[0-9a-f]{64}$" },
+		tiersFingerprint: { type: "string", pattern: "^[0-9a-f]{64}$" },
+	},
+	additionalProperties: false,
+	required: ["schema", "source", "declarationFingerprint", "tiersFingerprint"],
+};
+
 export const SETTINGS_SCHEMA = {
 	// ────────────────────────────────────────────────────────────────────────
 	// General settings (no UI)
@@ -618,7 +721,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"gjc.ralplan.autoHandoff": {
 		type: "enum",
-		values: ["off", "ultragoal", "team"],
+		values: ["off", "ultragoal", "autoresearch"],
 		default: "off",
 	},
 	"gjc.ralplan.maxIterations": {
@@ -3510,6 +3613,39 @@ export const SETTINGS_SCHEMA = {
 		valueSchema: MODEL_SELECTOR_VALUE_SCHEMA,
 	},
 
+	"task.autorouting.enabled": {
+		type: "boolean",
+		default: false,
+	},
+
+	"task.autorouting.tiers": {
+		type: "constrained-record",
+		default: {} as AutoroutingTierMapInput,
+		keys: AUTOROUTING_TIERS,
+		valueSchema: {
+			type: "autorouting-selector-value",
+			minLength: 1,
+			maxLength: 256,
+			pattern: AUTOROUTING_SELECTOR_PATTERN,
+			description: AUTOROUTING_SELECTOR_DESCRIPTION,
+		},
+		description: AUTOROUTING_SELECTOR_DESCRIPTION,
+	},
+
+	"task.autorouting.setup": {
+		type: "optional-object",
+		default: undefined,
+		jsonSchema: AUTOROUTING_SETUP_JSON_SCHEMA,
+		validate: validateAutoroutingSetup,
+	} as OptionalObjectDef<AutoroutingSetup>,
+
+	"task.autorouting.provenance": {
+		type: "optional-object",
+		default: undefined,
+		jsonSchema: AUTOROUTING_PROVENANCE_JSON_SCHEMA,
+		validate: validateAutoroutingProvenance,
+	} as OptionalObjectDef<AutoroutingProvenance>,
+
 	"tasks.todoClearDelay": {
 		type: "number",
 		default: 60,
@@ -3856,7 +3992,11 @@ export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boo
 						? D
 						: Schema[P] extends { type: "record"; default: infer D }
 							? D
-							: never;
+							: Schema[P] extends { type: "constrained-record"; default: infer D }
+								? D
+								: Schema[P] extends OptionalObjectDef<infer D>
+									? D | undefined
+									: never;
 
 /** Get the default value for a setting path */
 export function getDefault<P extends SettingPath>(path: P): SettingValue<P> {
@@ -3930,7 +4070,11 @@ function schemaPaths(value: Record<string, unknown>, prefix = ""): string[] {
 		const path = prefix ? `${prefix}.${key}` : key;
 		const definition = SETTINGS_SCHEMA[path as SettingPath];
 		// Records intentionally accept user-defined keys; validate their entries below.
-		if (definition?.type === "record") {
+		if (
+			definition?.type === "record" ||
+			definition?.type === "constrained-record" ||
+			definition?.type === "optional-object"
+		) {
 			paths.push(path);
 		} else if (child && typeof child === "object" && !Array.isArray(child)) {
 			paths.push(...schemaPaths(child as Record<string, unknown>, path));
@@ -3974,7 +4118,15 @@ function validSettingValue(definition: (typeof SETTINGS_SCHEMA)[SettingPath], va
 			(definition.values as readonly string[]).includes(value)) ||
 		(definition.type === "array" &&
 			validArraySettingValue(value, "items" in definition ? definition.items?.enum : undefined)) ||
-		(definition.type === "record" && !!value && typeof value === "object" && !Array.isArray(value))
+		((definition.type === "record" || definition.type === "constrained-record") &&
+			!!value &&
+			typeof value === "object" &&
+			!Array.isArray(value)) ||
+		(definition.type === "optional-object" &&
+			!!value &&
+			typeof value === "object" &&
+			!Array.isArray(value) &&
+			definition.validate(value).length === 0)
 	);
 }
 
@@ -4022,6 +4174,16 @@ export function validateSettingPatch(patch: Record<string, unknown>): Array<{ pa
 			issues.push({ path, detail });
 			continue;
 		}
+		if (definition.type === "constrained-record" && path === "task.autorouting.tiers") {
+			for (const issue of validateAutoroutingLocal({ tiers: value })) {
+				const nestedPath = issue.path.replace(/^tiers\./u, "");
+				issues.push({
+					path: nestedPath ? `task.autorouting.tiers.${nestedPath}` : "task.autorouting.tiers",
+					detail: issue.detail,
+				});
+			}
+			continue;
+		}
 		if (definition.type === "record" && "valueSchema" in definition && definition.valueSchema) {
 			for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
 				if (!validRecordValue(definition.valueSchema, entry)) {
@@ -4065,6 +4227,33 @@ export function reconcileSettingsSchema(raw: Record<string, unknown>): {
 			schemaSetAtPath(settings, path, next);
 			issues.push({ path, kind: "coerced", detail: `Coerced ${typeof value} to ${definition.type}.` });
 		}
+		if (definition.type === "optional-object") {
+			for (const localIssue of definition.validate(next)) {
+				issues.push({
+					path: localIssue.path ? `${path}.${localIssue.path}` : path,
+					kind: "invalid",
+					detail: localIssue.detail,
+				});
+			}
+			continue;
+		}
+		if (definition.type === "constrained-record") {
+			const autorouting = schemaValueAtPath(settings, "task.autorouting");
+			const tiersFragment =
+				autorouting && typeof autorouting === "object" && !Array.isArray(autorouting)
+					? Object.fromEntries(
+							Object.entries(autorouting).filter(([key]) => key !== "setup" && key !== "provenance"),
+						)
+					: autorouting;
+			for (const localIssue of validateAutoroutingLocal(tiersFragment)) {
+				issues.push({
+					path: localIssue.path ? `task.autorouting.${localIssue.path}` : "task.autorouting",
+					kind: "invalid",
+					detail: localIssue.detail,
+				});
+			}
+			continue;
+		}
 		if (!validSettingValue(definition, next)) {
 			const arrayItemEnum =
 				definition.type === "array" && Array.isArray(next) && "items" in definition

package/src/config/settings.ts

@@ -57,6 +57,11 @@ import {
 	setByPath,
 	withAtomicYamlConfigTransaction,
 } from "./atomic-yaml-patch";
+import {
+	type AutoroutingEffective,
+	validateAutoroutingEffective,
+	validateAutoroutingLocal,
+} from "./autorouting-contract";
 import { isModelSelectorValue, type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
 
 import {
@@ -68,6 +73,7 @@ import {
 	reconcileSettingsSchema,
 	SETTINGS_SCHEMA,
 	type SettingPath,
+	type SettingsSchemaIssue,
 	type SettingsSchemaReport,
 	type SettingValue,
 } from "./settings-schema";
@@ -524,6 +530,9 @@ export class Settings implements NotificationSettingsReader {
 	#legacyCustomImageProviderDiagnosticLogged = false;
 
 	#schemaReport: SettingsSchemaReport = { issues: [], valid: true };
+
+	#autoroutingEffective: AutoroutingEffective = { active: false };
+	#autoroutingLocalIssues: SettingsSchemaIssue[] = [];
 	#schemaMigrationPending = false;
 	/** A newer config schema must never be rewritten by legacy migrations. */
 	#futureSchemaVersion = false;
@@ -692,7 +701,34 @@ export class Settings implements NotificationSettingsReader {
 
 	/** Diagnostics from schema reconciliation during the most recent load. */
 	getSchemaReport(): SettingsSchemaReport {
-		return structuredClone(this.#schemaReport);
+		const issues = [
+			...this.#schemaReport.issues.filter(
+				issue =>
+					!(
+						(issue.kind === "invalid" || issue.kind === "unknown") &&
+						(issue.path === "task.autorouting" || issue.path.startsWith("task.autorouting."))
+					),
+			),
+			...this.#autoroutingLocalIssues,
+			...(this.#autoroutingEffective.active || !this.#autoroutingEffective.issue
+				? []
+				: [
+						{
+							path: "task.autorouting",
+							kind: "invalid" as const,
+							detail: this.#autoroutingEffective.issue.detail,
+						},
+					]),
+		];
+		return {
+			issues: structuredClone(issues),
+			valid: !issues.some(issue => issue.kind === "invalid"),
+		};
+	}
+
+	/** Effective merged autorouting state shared by settings diagnostics and routing policy. */
+	getEffectiveAutorouting(): AutoroutingEffective {
+		return structuredClone(this.#autoroutingEffective);
 	}
 
 	onChanged(listener: (path: SettingPath) => void): () => void {
@@ -1066,6 +1102,9 @@ export class Settings implements NotificationSettingsReader {
 		});
 		cloned.#storage = this.#storage;
 		cloned.#schemaReport = structuredClone(this.#schemaReport);
+
+		cloned.#autoroutingEffective = structuredClone(this.#autoroutingEffective);
+		cloned.#autoroutingLocalIssues = structuredClone(this.#autoroutingLocalIssues);
 		cloned.#schemaMigrationPending = this.#schemaMigrationPending;
 		cloned.#futureSchemaVersion = this.#futureSchemaVersion;
 		cloned.#hasMalformedConfigRoot = this.#hasMalformedConfigRoot;
@@ -1601,6 +1640,15 @@ export class Settings implements NotificationSettingsReader {
 				}
 				setByPath(source, pathSegments, sanitized);
 			}
+
+			const tiersPath = ["task", "autorouting", "tiers"];
+			const tiers = getByPath(source, tiersPath);
+			if (tiers === undefined) continue;
+			if (!tiers || typeof tiers !== "object" || Array.isArray(tiers)) {
+				logger.warn("Settings: retained malformed autorouting tier record for schema diagnostics", {
+					path: tiersPath.join("."),
+				});
+			}
 		}
 	}
 
@@ -5860,6 +5908,18 @@ export class Settings implements NotificationSettingsReader {
 			throw error;
 		}
 	}
+	#recomputeAutoroutingDiagnostic(): void {
+		this.#autoroutingLocalIssues = [this.#global, this.#project, this.#overrides].flatMap(source => {
+			const fragment = getByPath(source, ["task", "autorouting"]);
+			return validateAutoroutingLocal(fragment).map(localIssue => ({
+				path: localIssue.path ? `task.autorouting.${localIssue.path}` : "task.autorouting",
+				kind: "invalid" as const,
+				detail: localIssue.detail,
+			}));
+		});
+		this.#autoroutingEffective = validateAutoroutingEffective(getByPath(this.#merged, ["task", "autorouting"]));
+	}
+
 	#rebuildMerged(): void {
 		const project = structuredClone(this.#project);
 		const overrides = structuredClone(this.#overrides);
@@ -5870,6 +5930,7 @@ export class Settings implements NotificationSettingsReader {
 		}
 		this.#merged = this.#deepMerge(this.#deepMerge({}, this.#global), project);
 		this.#merged = this.#deepMerge(this.#merged, overrides);
+		this.#recomputeAutoroutingDiagnostic();
 	}
 
 	#fireAllHooks(): void {

package/src/config.ts

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { CONFIG_DIR_NAME, getConfigAgentDirName, getProjectDir } from "@gajae-code/utils";
+import { CONFIG_DIR_NAME, getConfigAgentDirName, getProjectDir, getTrustedHomeDir } from "@gajae-code/utils";
 import { expandTilde } from "./tools/path-utils";
 
 export * from "./config/config-file";
@@ -51,7 +50,7 @@ export function getChangelogPath(): string {
  * Project-level: .gjc, .gemini
  */
 const USER_CONFIG_BASES = USER_CONFIG_PRIORITY.map(({ dir, globalAgentDir }) => ({
-	base: () => path.join(os.homedir(), globalAgentDir ? globalAgentDir() : dir),
+	base: () => path.join(getTrustedHomeDir(), globalAgentDir ? globalAgentDir() : dir),
 	name: dir,
 }));
 

package/src/coordinator/contract.ts

@@ -24,7 +24,6 @@ export const COORDINATOR_MCP_TOOL_NAMES = [
 	"gjc_coordinator_ack_codex_handoff",
 	"gjc_delegate_plan",
 	"gjc_delegate_execute",
-	"gjc_delegate_team",
 ] as const;
 
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/src/coordinator-mcp/codex-handoff.ts

@@ -3,6 +3,12 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { withFileLock } from "../config/file-lock";
 import { assertSafeCodexEndpoint } from "./codex-wake-publisher";
+import {
+	ensureCoordinatorDirectory,
+	syncCoordinatorDirectory,
+	syncCoordinatorFile,
+	writeCoordinatorAtomic,
+} from "./durability";
 
 export const CODEX_WAKE_EVENT_KINDS = [
 	"question.opened",
@@ -108,52 +114,71 @@ function wakeEventPath(namespaceDir: string, workUnit: string, eventSeq: number)
 	return path.join(namespaceDir, "codex-wake-events", `${assertWorkUnit(workUnit)}__${assertEventSeq(eventSeq)}.json`);
 }
 
-async function fsyncDirectory(directory: string): Promise<void> {
-	const handle = await fs.open(directory, "r");
-	try {
-		await handle.sync();
-	} finally {
-		await handle.close();
-	}
-}
-
 async function writeAtomic(file: string, value: unknown): Promise<void> {
-	await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-	const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
-	const handle = await fs.open(temp, "wx", 0o600);
-	try {
-		await handle.writeFile(JSON.stringify(value));
-		await handle.sync();
-	} finally {
-		await handle.close();
-	}
-	await fs.rename(temp, file);
-	await fsyncDirectory(path.dirname(file));
+	await writeCoordinatorAtomic(file, JSON.stringify(value));
 }
 
 async function writeExclusive(file: string, value: unknown): Promise<boolean> {
-	await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+	await ensureCoordinatorDirectory(path.dirname(file));
 	const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-	const handle = await fs.open(temp, "wx", 0o600);
-	try {
-		await handle.writeFile(JSON.stringify(value));
-		await handle.sync();
-	} finally {
-		await handle.close();
-	}
+	let linked = false;
+	let result = false;
+	let primaryError: unknown;
+	let tempCreated = false;
 	try {
-		await fs.link(temp, file);
+		const handle = await fs.open(temp, "wx", 0o600);
+		tempCreated = true;
+		let writeError: unknown;
+		try {
+			await handle.writeFile(JSON.stringify(value));
+			await syncCoordinatorFile(handle);
+		} catch (error) {
+			writeError = error;
+		}
+		try {
+			await handle.close();
+		} catch (closeError) {
+			if (writeError) throw new AggregateError([writeError, closeError], "exclusive write and close failed");
+			throw closeError;
+		}
+		if (writeError) throw writeError;
+		try {
+			await fs.link(temp, file);
+			linked = true;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			await syncCoordinatorDirectory(path.dirname(file));
+			result = false;
+		}
+		if (linked) {
+			await syncCoordinatorDirectory(path.dirname(file));
+			result = true;
+		}
 	} catch (error) {
-		await fs.unlink(temp).catch(() => {});
-		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-			await fsyncDirectory(path.dirname(file));
-			return false;
+		primaryError = error;
+	}
+	let cleanupError: unknown;
+	if (tempCreated) {
+		try {
+			await fs.unlink(temp);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") cleanupError = error;
+		}
+	}
+	let cleanupBarrierError: unknown;
+	if (tempCreated && !cleanupError) {
+		try {
+			await syncCoordinatorDirectory(path.dirname(file));
+		} catch (error) {
+			cleanupBarrierError = error;
 		}
-		throw error;
 	}
-	await fs.unlink(temp);
-	await fsyncDirectory(path.dirname(file));
-	return true;
+	const failures = [primaryError, cleanupError, cleanupBarrierError].filter(
+		(error): error is unknown => error !== undefined,
+	);
+	if (failures.length > 1) throw new AggregateError(failures, "exclusive publication and cleanup failed");
+	if (failures.length === 1) throw failures[0];
+	return result;
 }
 
 async function readJson<T>(file: string): Promise<T | null> {
@@ -161,7 +186,8 @@ async function readJson<T>(file: string): Promise<T | null> {
 		return JSON.parse(await fs.readFile(file, "utf8")) as T;
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
-		throw new Error("state_corrupt");
+		if (error instanceof SyntaxError) throw new Error("state_corrupt");
+		throw error;
 	}
 }
 
@@ -196,7 +222,7 @@ function assertCodexHandoffOrigin(value: unknown): asserts value is CodexHandoff
 			(typeof origin.codex_host_session_id === "string" && SAFE_ID.test(origin.codex_host_session_id))
 		) ||
 		!(typeof origin.delegation_id === "string" && SAFE_ID.test(origin.delegation_id)) ||
-		!["plan", "execute", "team"].includes(origin.workflow as string) ||
+		!["plan", "execute"].includes(origin.workflow as string) ||
 		!(typeof origin.bound_at === "string" && Number.isFinite(Date.parse(origin.bound_at)))
 	)
 		throw new Error("state_corrupt");
@@ -343,7 +369,7 @@ export async function listCodexHandoffs(namespaceDir: string): Promise<CodexHand
 		names = await fs.readdir(directory);
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw new Error("state_corrupt");
+		throw error;
 	}
 	const handoffs: CodexHandoffRegistrationV1[] = [];
 	for (const name of names) {
@@ -418,7 +444,7 @@ export async function updateCodexWakeEvent(
 	const file = eventPathForKey(namespaceDir, key);
 	if (patch.status !== undefined && !["pending", "published", "acked", "failed"].includes(patch.status))
 		throw new Error("invalid_wake_event_status");
-	if (patch.attempts_delta !== undefined && !Number.isInteger(patch.attempts_delta))
+	if (patch.attempts_delta !== undefined && (!Number.isSafeInteger(patch.attempts_delta) || patch.attempts_delta < 0))
 		throw new Error("invalid_attempts_delta");
 	return await withFileLock(file, async () => {
 		const event = await readJson<CodexWakeEventV1>(file);
@@ -457,7 +483,7 @@ export async function listCodexWakeEvents(namespaceDir: string, workUnit?: strin
 		names = await fs.readdir(directory);
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw new Error("state_corrupt");
+		throw error;
 	}
 	const events: CodexWakeEventV1[] = [];
 	for (const name of names) {