@gajae-code/coding-agent 0.15.6 → 0.16.0

package/src/coordinator-mcp/server.ts

@@ -83,7 +83,7 @@ import {
 	requireCoordinatorMutation,
 	safeOpenCoordinatorArtifact,
 } from "./policy";
-import { listCoordinatorJsonFiles } from "./projection-scan";
+import { listCoordinatorJsonFilesWithRetry } from "./projection-scan";
 import {
 	answerBindingMatches,
 	buildCoordinatorAskAnswerSchema,
@@ -835,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.",
@@ -1498,7 +1498,7 @@ function publicSdkAcknowledgement(result: RuntimePromptAcknowledgement): Record<
 }
 
 async function listJsonFiles(dir: string): Promise<unknown[]> {
-	const scan = await listCoordinatorJsonFiles(dir);
+	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", {
@@ -1530,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 {
@@ -2634,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;
 }
@@ -2658,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");
@@ -5044,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>,
@@ -5075,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")
@@ -5179,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(
@@ -5281,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;
 		}
@@ -6713,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
@@ -8780,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(
@@ -8964,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);

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/gjc-runtime/launch-worktree-reservation.ts

@@ -0,0 +1,242 @@
+/**
+ * Cross-process reservation for a deterministic launch-worktree path.
+ *
+ * The durable session index is the long-lived ownership record, but a newly
+ * planned worktree has no index row yet. This reservation closes that interval:
+ * it is acquired before preparation and removed after `host_registered` is
+ * durably appended to the index.
+ */
+
+import { createHash, randomUUID } from "node:crypto";
+import type { Dirent } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { resolveEquivalentPath } from "@gajae-code/utils";
+import {
+	type FileLockGcObservation,
+	processStartTime,
+	readFileLockObservationForGc,
+	removeFileLockDirForGc,
+} from "../config/file-lock";
+import { processIncarnation } from "../sdk/broker/process-incarnation";
+
+const RESERVATION_VERSION = 1;
+const RESERVATION_DIRECTORY = "launch-worktree-reservations";
+
+interface LaunchWorktreeReservationRecord {
+	version: typeof RESERVATION_VERSION;
+	worktreePath: string;
+	pid: number;
+	start_time?: string;
+	processIncarnation: string | null;
+	timestamp: number;
+	reservationId: string;
+}
+
+export interface LaunchWorktreeReservation {
+	release(): Promise<void>;
+}
+
+function canonicalWorktreePath(worktreePath: string): string {
+	return resolveEquivalentPath(path.resolve(worktreePath));
+}
+
+function reservationRoot(agentDir: string): string {
+	return path.join(agentDir, "sdk", "sessions", RESERVATION_DIRECTORY);
+}
+
+function launchWorktreeReservationDirectory(agentDir: string, worktreePath: string): string {
+	const digest = createHash("sha256").update(canonicalWorktreePath(worktreePath)).digest("hex");
+	return path.join(reservationRoot(agentDir), `${digest}.lock`);
+}
+
+/** Test seam for seeding a dead-owner reservation at the exact production path. */
+export function launchWorktreeReservationDirectoryForTest(agentDir: string, worktreePath: string): string {
+	return launchWorktreeReservationDirectory(agentDir, worktreePath);
+}
+
+function isErrno(error: unknown, code: string): boolean {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+function isReservationRecord(value: unknown): value is LaunchWorktreeReservationRecord {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const record = value as Partial<LaunchWorktreeReservationRecord>;
+	return (
+		record.version === RESERVATION_VERSION &&
+		typeof record.worktreePath === "string" &&
+		record.worktreePath.length > 0 &&
+		typeof record.pid === "number" &&
+		Number.isSafeInteger(record.pid) &&
+		record.pid > 0 &&
+		(record.start_time === undefined || (typeof record.start_time === "string" && record.start_time.length > 0)) &&
+		(record.processIncarnation === null ||
+			(typeof record.processIncarnation === "string" && record.processIncarnation.length > 0)) &&
+		typeof record.timestamp === "number" &&
+		Number.isFinite(record.timestamp) &&
+		typeof record.reservationId === "string" &&
+		record.reservationId.length > 0
+	);
+}
+
+async function readReservation(lockDir: string): Promise<LaunchWorktreeReservationRecord | null> {
+	let value: unknown;
+	try {
+		value = await Bun.file(path.join(lockDir, "info")).json();
+	} catch (error) {
+		if (isErrno(error, "ENOENT") || error instanceof SyntaxError) return null;
+		throw error;
+	}
+	return isReservationRecord(value) ? value : null;
+}
+
+function ownerDefinitelyExited(record: LaunchWorktreeReservationRecord): boolean {
+	try {
+		process.kill(record.pid, 0);
+	} catch (error) {
+		return isErrno(error, "ESRCH");
+	}
+	if (record.processIncarnation !== null) {
+		const actualIncarnation = processIncarnation(record.pid);
+		if (actualIncarnation !== undefined) return actualIncarnation !== record.processIncarnation;
+	}
+	if (record.start_time) {
+		const actualStartTime = processStartTime(record.pid);
+		if (actualStartTime !== null) return actualStartTime !== record.start_time;
+	}
+	return false;
+}
+
+async function removeReservation(
+	lockDir: string,
+	record: LaunchWorktreeReservationRecord,
+): Promise<"removed" | "kept"> {
+	// Capture the exact on-disk identity BEFORE authorizing removal: the generic
+	// GC remover only deletes a tree whose pre-verdict identity it was handed,
+	// so a successor reservation published at the same path is never reaped.
+	let observation: FileLockGcObservation | null;
+	try {
+		observation = await readFileLockObservationForGc(lockDir);
+	} catch {
+		return "kept";
+	}
+	if (!observation) return "kept";
+	let onDisk: unknown;
+	try {
+		onDisk = JSON.parse(observation.bytes);
+	} catch {
+		return "kept";
+	}
+	if (
+		!isReservationRecord(onDisk) ||
+		onDisk.reservationId !== record.reservationId ||
+		onDisk.pid !== record.pid ||
+		onDisk.timestamp !== record.timestamp ||
+		canonicalWorktreePath(onDisk.worktreePath) !== canonicalWorktreePath(record.worktreePath)
+	)
+		return "kept";
+	const result = await removeFileLockDirForGc(lockDir, observation.info, observation.identity);
+	return result === "removed" ? "removed" : "kept";
+}
+
+async function writeReservation(lockDir: string, record: LaunchWorktreeReservationRecord): Promise<void> {
+	try {
+		await Bun.write(path.join(lockDir, "info"), JSON.stringify(record));
+	} catch (error) {
+		await fs.rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+async function tryPublishReservation(lockDir: string, record: LaunchWorktreeReservationRecord): Promise<boolean> {
+	const pendingDir = `${lockDir}.pending.${process.pid}.${randomUUID()}`;
+	await fs.mkdir(pendingDir, { mode: 0o700 });
+	try {
+		await writeReservation(pendingDir, record);
+		try {
+			await fs.rename(pendingDir, lockDir);
+			return true;
+		} catch (error) {
+			if (isErrno(error, "EEXIST") || isErrno(error, "ENOTEMPTY")) return false;
+			if (isErrno(error, "EPERM")) {
+				try {
+					await fs.stat(lockDir);
+					return false;
+				} catch (statError) {
+					if (!isErrno(statError, "ENOENT")) throw statError;
+				}
+			}
+			throw error;
+		}
+	} finally {
+		await fs.rm(pendingDir, { recursive: true, force: true }).catch(() => undefined);
+	}
+}
+
+/**
+ * Atomically claim `worktreePath`, returning `null` only when another live or
+ * unverified launch already owns the same deterministic target. A dead or
+ * PID-reused owner is reclaimed before retrying the exclusive directory create.
+ */
+export async function reserveLaunchWorktree(
+	agentDir: string,
+	worktreePath: string,
+): Promise<LaunchWorktreeReservation | null> {
+	const canonicalPath = canonicalWorktreePath(worktreePath);
+	const lockDir = launchWorktreeReservationDirectory(agentDir, canonicalPath);
+	await fs.mkdir(path.dirname(lockDir), { recursive: true, mode: 0o700 });
+	const ownStartTime = processStartTime(process.pid) ?? undefined;
+	const ownIncarnation = processIncarnation(process.pid) ?? null;
+
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		const record: LaunchWorktreeReservationRecord = {
+			version: RESERVATION_VERSION,
+			worktreePath: canonicalPath,
+			pid: process.pid,
+			...(ownStartTime ? { start_time: ownStartTime } : {}),
+			processIncarnation: ownIncarnation,
+			timestamp: Date.now(),
+			reservationId: randomUUID(),
+		};
+		if (await tryPublishReservation(lockDir, record)) {
+			return {
+				async release(): Promise<void> {
+					await removeReservation(lockDir, record);
+				},
+			};
+		}
+
+		const existing = await readReservation(lockDir);
+		if (
+			!existing ||
+			canonicalWorktreePath(existing.worktreePath) !== canonicalPath ||
+			!ownerDefinitelyExited(existing)
+		)
+			return null;
+		if ((await removeReservation(lockDir, existing)) !== "removed") return null;
+	}
+
+	return null;
+}
+
+/** Remove the transient reservation only after the matching worktree is indexed. */
+export async function releaseLaunchWorktreeReservationAfterRegistration(
+	agentDir: string,
+	worktreePath: string,
+): Promise<void> {
+	const canonicalPath = canonicalWorktreePath(worktreePath);
+	let entries: Dirent[];
+	try {
+		entries = await fs.readdir(reservationRoot(agentDir), { withFileTypes: true });
+	} catch (error) {
+		if (isErrno(error, "ENOENT")) return;
+		throw error;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.endsWith(".lock")) continue;
+		const lockDir = path.join(reservationRoot(agentDir), entry.name);
+		const record = await readReservation(lockDir);
+		if (!record || canonicalWorktreePath(record.worktreePath) !== canonicalPath) continue;
+		await removeReservation(lockDir, record);
+	}
+}

package/src/gjc-runtime/managed-owner-supervisor.ts

@@ -15,6 +15,8 @@ export const MANAGED_OWNER_GENERATION_ENV = "GJC_TMUX_OWNER_GENERATION";
 export const MANAGED_OWNER_STATE_DIR_ENV = "GJC_TMUX_OWNER_STATE_DIR";
 export const MANAGED_OWNER_RUN_ID_ENV = "GJC_MANAGED_OWNER_RUN_ID";
 export const MANAGED_OWNER_INCARNATION_ENV = "GJC_MANAGED_OWNER_INCARNATION";
+/** Suppresses command-derived durable artifacts for Broker-owned opaque spawn children. */
+export const MANAGED_OWNER_REDACT_COMMAND_ENV = "GJC_MANAGED_OWNER_REDACT_COMMAND";
 
 let bootstrapSigtermPending = false;
 const captureBootstrapSigterm = () => {
@@ -140,26 +142,32 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 	if (!supervisorStartTime) throw new Error("managed_owner_supervisor_start_time_unavailable");
 	await fs.mkdir(root, { recursive: true, mode: 0o700 });
 	const childToken = crypto.randomUUID();
-	const binding: ManagedOwnerBinding = {
-		schema_version: 2,
-		generation,
-		session_id: sessionId,
-		run_id: runId,
-		endpoint_incarnation: incarnation,
-		child_token: childToken,
-		command,
-		command_sha256: commandDigest(command),
-		supervisor_pid: process.pid,
-		supervisor_start_time: supervisorStartTime,
-		created_at: new Date().toISOString(),
-	};
-	await writeDurableExclusive(path.join(root, `child-${childToken}.binding.json`), binding);
+	const redactCommand = process.env[MANAGED_OWNER_REDACT_COMMAND_ENV] === "1";
+	const binding: ManagedOwnerBinding | null = redactCommand
+		? null
+		: {
+				schema_version: 2,
+				generation,
+				session_id: sessionId,
+				run_id: runId,
+				endpoint_incarnation: incarnation,
+				child_token: childToken,
+				command,
+				command_sha256: commandDigest(command),
+				supervisor_pid: process.pid,
+				supervisor_start_time: supervisorStartTime,
+				created_at: new Date().toISOString(),
+			};
+	if (binding) await writeDurableExclusive(path.join(root, `child-${childToken}.binding.json`), binding);
+	const childEnvironment: NodeJS.ProcessEnv = { ...process.env, [MANAGED_OWNER_CHILD_TOKEN_ENV]: childToken };
+	delete childEnvironment[MANAGED_OWNER_COMMAND_ENV];
+	delete childEnvironment[MANAGED_OWNER_REDACT_COMMAND_ENV];
 	const child = Bun.spawn({
 		cmd: command,
 		stdin: "inherit",
 		stdout: "inherit",
 		stderr: "inherit",
-		env: { ...process.env, [MANAGED_OWNER_CHILD_TOKEN_ENV]: childToken },
+		env: childEnvironment,
 	});
 	const childStartTime = await managedOwnerProcessProvenance(child.pid);
 	if (!childStartTime) throw new Error("managed_owner_child_start_time_unavailable");
@@ -167,24 +175,26 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 	if (!childProcess) {
 		const exitCode = await child.exited;
 		if (child.signalCode === "SIGABRT") {
-			const receipt: ManagedOwnerSigabrtReceipt = {
-				schema_version: 2,
-				generation,
-				session_id: sessionId,
-				run_id: runId,
-				endpoint_incarnation: incarnation,
-				child_token: childToken,
-				command_sha256: binding.command_sha256,
-				supervisor_pid: process.pid,
-				supervisor_start_time: supervisorStartTime,
-				child_pid: child.pid,
-				child_start_time: childStartTime,
-				signal: "SIGABRT",
-				signal_number: 6,
-				exit_code: exitCode,
-				received_at: new Date().toISOString(),
-			};
-			await writeDurableExclusive(path.join(root, `sigabrt-${childToken}.receipt.json`), receipt);
+			if (binding) {
+				const receipt: ManagedOwnerSigabrtReceipt = {
+					schema_version: 2,
+					generation,
+					session_id: sessionId,
+					run_id: runId,
+					endpoint_incarnation: incarnation,
+					child_token: childToken,
+					command_sha256: binding.command_sha256,
+					supervisor_pid: process.pid,
+					supervisor_start_time: supervisorStartTime,
+					child_pid: child.pid,
+					child_start_time: childStartTime,
+					signal: "SIGABRT",
+					signal_number: 6,
+					exit_code: exitCode,
+					received_at: new Date().toISOString(),
+				};
+				await writeDurableExclusive(path.join(root, `sigabrt-${childToken}.receipt.json`), receipt);
+			}
 			process.exitCode = 134;
 			return;
 		}
@@ -246,24 +256,26 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 		});
 	}
 	if (child.signalCode === "SIGABRT") {
-		const receipt: ManagedOwnerSigabrtReceipt = {
-			schema_version: 2,
-			generation,
-			session_id: sessionId,
-			run_id: runId,
-			endpoint_incarnation: incarnation,
-			child_token: childToken,
-			command_sha256: binding.command_sha256,
-			supervisor_pid: process.pid,
-			supervisor_start_time: supervisorStartTime,
-			child_pid: child.pid,
-			child_start_time: childStartTime,
-			signal: "SIGABRT",
-			signal_number: 6,
-			exit_code: exitCode,
-			received_at: new Date().toISOString(),
-		};
-		await writeDurableExclusive(path.join(root, `sigabrt-${childToken}.receipt.json`), receipt);
+		if (binding) {
+			const receipt: ManagedOwnerSigabrtReceipt = {
+				schema_version: 2,
+				generation,
+				session_id: sessionId,
+				run_id: runId,
+				endpoint_incarnation: incarnation,
+				child_token: childToken,
+				command_sha256: binding.command_sha256,
+				supervisor_pid: process.pid,
+				supervisor_start_time: supervisorStartTime,
+				child_pid: child.pid,
+				child_start_time: childStartTime,
+				signal: "SIGABRT",
+				signal_number: 6,
+				exit_code: exitCode,
+				received_at: new Date().toISOString(),
+			};
+			await writeDurableExclusive(path.join(root, `sigabrt-${childToken}.receipt.json`), receipt);
+		}
 		process.exitCode = 134;
 		return;
 	}