@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/src/runs/background/stale-run-reconciler.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { resultFilePath, resultPayloadPathForSessionRun, writeAsyncResultFile } from "./result-files.ts";
 import { updateActiveRunIndex } from "./active-run-index.ts";
+import { readProcessTerminal } from "./process-terminal.ts";
 import { readStatus } from "../../shared/utils.ts";
 import { DIRS, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode } from "../../shared/types.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
@@ -10,6 +11,7 @@ import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
 import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.ts";
 import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
+import { currentPidNamespaceScope } from "./pid-namespace.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -36,6 +38,7 @@ interface ReconcileAsyncRunOptions {
 	startedRun?: StartedRunMetadata;
 	missingStatusGraceMs?: number;
 	staleAlivePidMs?: number;
+	pidNamespaceScope?: () => string | undefined;
 }
 
 interface ReconcileAsyncRunResult {
@@ -99,13 +102,13 @@ interface ResultChildOutcome {
 	sessionFile?: string;
 	model?: string;
 	thinking?: string;
-	attemptedModels?: string[];
-	modelAttempts?: NonNullable<AsyncStatus["steps"]>[number]["modelAttempts"];
+	requestedModel?: string;
 	contextOverflow?: boolean;
 }
 
 interface ResultRepairData {
 	state: "complete" | "failed" | "partial" | "paused" | "stopped" | "rejected";
+	error?: string;
 	results?: ResultChildOutcome[];
 }
 
@@ -120,7 +123,8 @@ function regularFileExists(filePath: string): boolean {
 
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
-		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: unknown };
+		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; error?: unknown; results?: unknown };
+		if (data.error !== undefined && typeof data.error !== "string") throw new Error(`Invalid async result file '${resultPath}': error must be a string.`);
 		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 		const results = Array.isArray(data.results)
 			? data.results.map((entry, index) => {
@@ -131,7 +135,7 @@ function readResultRepairData(resultPath: string): ResultRepairData | undefined
 				return child;
 			})
 			: undefined;
-		return { state, ...(results ? { results } : {}) };
+		return { state, ...(data.error ? { error: data.error } : {}), ...(results ? { results } : {}) };
 	} catch (error) {
 		if (isNotFoundError(error)) return undefined;
 		throw new Error(`Failed to read async result file '${resultPath}': ${getErrorMessage(error)}`, {
@@ -146,9 +150,16 @@ function childState(overallState: ResultRepairData["state"], child: ResultChildO
 	return overallState;
 }
 
+function failureDiagnostic(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value : undefined;
+}
+
 function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now: number): AsyncStatus | undefined {
 	const repair = readResultRepairData(resultPath);
 	if (!repair) return undefined;
+	const rootError = failureDiagnostic(status.error)
+		?? failureDiagnostic(repair.error)
+		?? repair.results?.map((child) => child.success === false ? failureDiagnostic(child.error) : undefined).find(Boolean);
 	const steps = (status.steps ?? []).map((step, index) => {
 		if (step.status !== "running" && step.status !== "pending") return step;
 		const child = repair.results?.[index];
@@ -167,14 +178,14 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model,
 			thinking,
-			attemptedModels: child?.attemptedModels ?? step.attemptedModels,
-			modelAttempts: child?.modelAttempts ?? step.modelAttempts,
+			requestedModel: child?.requestedModel ?? step.requestedModel,
 			contextOverflow: child?.contextOverflow ?? step.contextOverflow,
 		};
 	});
 	const terminalStatus: AsyncStatus = {
 		...status,
 		state: repair.state,
+		...(rootError && (repair.state === "failed" || repair.state === "partial") ? { error: rootError } : {}),
 		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
 			processTerminal: { version: 1 as const, state: "unknown" as const, runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" as const },
 		} : {}),
@@ -202,6 +213,7 @@ function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, no
 		mode: startedRun.mode ?? "single",
 		state: "running",
 		pid: startedRun.pid,
+		pidNamespaceScope: currentPidNamespaceScope(),
 		startedAt,
 		lastUpdate: now,
 		currentStep: 0,
@@ -219,7 +231,14 @@ function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, no
 function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, reason?: string): { status: AsyncStatus; result: Record<string, unknown>; message: string } {
 	const runId = status.runId || path.basename(asyncDir);
 	const pid = typeof status.pid === "number" ? status.pid : "unknown";
-	const baseMessage = reason ?? `Async runner process ${pid} exited or disappeared before writing a result. Marked run failed by stale-run reconciliation.`;
+	const terminal = readProcessTerminal(asyncDir, { runId }) ?? status.processTerminal;
+	const runnerExit = terminal?.state === "observed" || terminal?.state === "unknown"
+		? terminal.instances?.find((instance) => instance.kind === "runner" && instance.processInstanceId === terminal.runnerProcessInstanceId)
+		: undefined;
+	const exitText = runnerExit?.kind === "runner"
+		? `exited with code ${runnerExit.exitCode ?? "none"}${runnerExit.signal ? ` (signal ${runnerExit.signal})` : ""}`
+		: "exited or disappeared";
+	const baseMessage = reason ?? `Async runner process ${pid} ${exitText} before writing a result. Marked run failed by stale-run reconciliation.`;
 	const diagnostics = readRunnerStartupDiagnostics(asyncDir);
 	const message = diagnostics ? `${baseMessage}\n\nRunner stderr tail:\n${diagnostics}` : baseMessage;
 	const steps = status.steps?.length ? status.steps : [{ agent: "subagent", status: "running" as const }];
@@ -264,8 +283,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
 				success: step.status === "complete" || step.status === "completed",
 				model: step.model,
-				attemptedModels: step.attemptedModels,
-				modelAttempts: step.modelAttempts,
+				requestedModel: step.requestedModel,
 				contextOverflow: step.contextOverflow,
 				sessionFile: step.sessionFile,
 			})),
@@ -339,9 +357,18 @@ export function reconcileNestedAsyncDescendants(route: NestedRoute, options: Rec
 	}
 }
 
-export function checkPidLiveness(pid: number, kill: KillFn = process.kill): PidLiveness {
+export function checkPidLiveness(pid: number, kill: KillFn = process.kill, probeZombie = false): PidLiveness {
 	try {
 		kill(pid, 0);
+		if (probeZombie && process.platform === "linux") {
+			try {
+				const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+				const closeParen = stat.lastIndexOf(") ");
+				if (closeParen >= 0 && stat[closeParen + 2] === "Z") return "dead";
+			} catch {
+				// Fall back to kill(pid, 0) when procfs is unavailable or unreadable.
+			}
+		}
 		return "alive";
 	} catch (error) {
 		const code = typeof error === "object" && error !== null && "code" in error
@@ -378,9 +405,26 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 			? terminalStatusFromResult(effectiveStatus, existingResultPath, now)
 			: undefined;
 		if (terminalStatus) {
-			writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);
-			updateActiveRunIndex(asyncDir, terminalStatus.state, terminalStatus.toolCallId);
-			return { status: terminalStatus, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
+			const currentStatus = readStatus(asyncDir);
+			const currentRootError = failureDiagnostic(currentStatus?.error);
+			const currentTerminal = currentStatus?.processTerminal?.state === "observed" || currentStatus?.processTerminal?.state === "unknown"
+				? currentStatus.processTerminal
+				: undefined;
+			const steps = terminalStatus.steps?.map((step, index) => {
+				const currentStepTerminal = currentStatus?.steps?.[index]?.processTerminal;
+				return currentStepTerminal?.state === "observed" || currentStepTerminal?.state === "unknown"
+					? { ...step, processTerminal: currentStepTerminal }
+					: step;
+			});
+			const statusToWrite: AsyncStatus = {
+				...terminalStatus,
+				...(currentRootError ? { error: currentRootError } : {}),
+				...(currentTerminal ? { processTerminal: currentTerminal } : {}),
+				...(steps ? { steps } : {}),
+			};
+			writeAtomicJson(statusPath, statusToWrite);
+			updateActiveRunIndex(asyncDir, statusToWrite.state, statusToWrite.toolCallId);
+			return { status: statusToWrite, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
 		}
 		if (effectiveStatus.displayDismissedAt === undefined) return { status: effectiveStatus, repaired: false, resultPath: existingResultPath };
 	}
@@ -399,14 +443,21 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 		}
 	}
 
-	const liveness = checkPidLiveness(effectiveStatus.pid, options.kill);
+	const observedScope = options.pidNamespaceScope ? options.pidNamespaceScope() : currentPidNamespaceScope();
+	// An observer without a scope (macOS/Windows host sharing a container's temp root) cannot match a recorded one.
+	const pidScopeMismatch = effectiveStatus.pidNamespaceScope !== undefined && effectiveStatus.pidNamespaceScope !== observedScope;
+	// A local zombie is evidence about this runner only when its namespace is known to match.
+	const pidScopeVerified = effectiveStatus.pidNamespaceScope !== undefined && effectiveStatus.pidNamespaceScope === observedScope;
+	const observedLiveness = checkPidLiveness(effectiveStatus.pid, options.kill, pidScopeVerified);
+	const liveness = observedLiveness === "dead" && pidScopeMismatch ? "unknown" : observedLiveness;
 	if (liveness !== "dead") {
 		const staleAfterMs = options.staleAlivePidMs ?? 24 * 60 * 60 * 1000;
 		const lastUpdate = effectiveStatus.lastUpdate ?? effectiveStatus.startedAt;
 		if (now - lastUpdate <= staleAfterMs) return { status: status ?? null, repaired: false, resultPath };
-		const message = `Async runner process ${effectiveStatus.pid} still has a live PID, but status has not updated for ${now - lastUpdate}ms. Marked run failed by stale-run reconciliation because PID ownership cannot be verified.`;
+		const probe = liveness === "alive" ? "is still live" : "cannot be probed from this process";
+		const message = `Async runner PID ${effectiveStatus.pid} ${probe}; status has not updated for ${now - lastUpdate}ms, so stale-run reconciliation marked the run failed because PID ownership is unverified.`;
 		return writeFailedRepair(asyncDir, effectiveStatus, resultPath, now, message);
 	}
 
 	return writeFailedRepair(asyncDir, effectiveStatus, resultPath, now);
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/steering.ts

@@ -14,6 +14,7 @@ import type {
 import { readStatus } from "../../shared/utils.ts";
 import { previewDisplayText } from "../../shared/display-text.ts";
 import { redactSecretValues } from "../shared/permissions.ts";
+import type { SteerDeliveryMode } from "./control-channel.ts";
 
 export const MAX_STEERING_REQUESTS = 20;
 export const STEERING_MESSAGE_PREVIEW_LIMIT = 160;
@@ -22,6 +23,21 @@ export function steeringMessagePreview(message: string): string {
 	return previewDisplayText(redactSecretValues(message), STEERING_MESSAGE_PREVIEW_LIMIT);
 }
 
+/** FIFO match of one accepted steer to an emitted user message; equal text claims the oldest entry. */
+export function takeMatchingAcceptedSteer<T extends { text: string }>(accepted: T[], messageText: string): T | undefined {
+	const index = accepted.findIndex((entry) => entry.text === messageText);
+	if (index < 0) return undefined;
+	const [entry] = accepted.splice(index, 1);
+	return entry;
+}
+
+/** Settlement reason for one accepted request that never got a matching user `message_end`. */
+export function unconsumedSteerReason(mode?: SteerDeliveryMode): string {
+	return mode === "follow_up"
+		? "child completed before consuming follow-up"
+		: "child completed before consuming steering";
+}
+
 export function steeringReceipt(message: string, receipt: string): string {
 	const preview = steeringMessagePreview(message);
 	const longestFence = Math.max(2, ...[...preview.matchAll(/`{3,}/g)].map((match) => match[0]!.length));
@@ -93,7 +109,9 @@ export function updateSteeringTarget(
 		if (fields.replacementRunId) target.replacementRunId = fields.replacementRunId;
 		return target;
 	}
-	if ((target.state === "routed" || target.state === "queued") && state !== "routed" && state !== "queued") status.pending = Math.max(0, status.pending - 1);
+	const wasPending = target.state === "routed" || target.state === "queued";
+	const nowPending = state === "routed" || state === "queued";
+	if (wasPending && !nowPending) status.pending = Math.max(0, status.pending - 1);
 	target.state = state;
 	if (state === "routed") target.routedAt = now;
 	if (state === "delivered") {
@@ -108,7 +126,7 @@ export function updateSteeringTarget(
 	if (state === "recovered") target.recoveredAt = now;
 	if (fields.reason) target.reason = fields.reason;
 	if (fields.replacementRunId) target.replacementRunId = fields.replacementRunId;
-	incrementStateCount(status, state);
+	if (!wasPending || !nowPending) incrementStateCount(status, state);
 	return target;
 }
 
@@ -239,4 +257,4 @@ export async function waitForSteeringAction(input: {
 	}
 	const status = readSteeringStatus(input.asyncDir);
 	return status ? actionResultFromSteeringStatus(status, input.sourceRunId, input.requestId) : undefined;
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/subagent-runner-bootstrap.ts

@@ -0,0 +1,276 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { acquireSessionLease } from "../shared/session-lease.ts";
+import { readProcessTerminalCandidate, writeProcessTerminalCandidate, markProcessTerminalCandidateLeaseRelease } from "./process-terminal-candidate.ts";
+import { persistRunnerStartupFailure } from "./runner-startup-failure.ts";
+import type { DefaultChildSessionFactoryOptions } from "../shared/child-session.ts";
+import type { SubagentRunConfig } from "./subagent-runner.ts";
+
+export type { SubagentRunConfig } from "./subagent-runner.ts";
+
+type ExecutionModule = {
+	runConfiguredSubagentExecution(config: SubagentRunConfig, options?: DefaultChildSessionFactoryOptions): Promise<void>;
+};
+
+export interface RunnerBootstrapOptions extends DefaultChildSessionFactoryOptions {
+	/** Test-only seam for proving that execution loading stays behind startup commit. */
+	loadExecutionModule?: () => Promise<ExecutionModule>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateChildStep(value: unknown, field: string): void {
+	if (!isRecord(value)) {
+		throw new Error(`Invalid runner configuration: '${field}' must be an object.`);
+	}
+	if (typeof value.agent !== "string" || !value.agent) {
+		throw new Error(`Invalid runner configuration: '${field}.agent' must be a non-empty string.`);
+	}
+	if (typeof value.task !== "string") {
+		throw new Error(`Invalid runner configuration: '${field}.task' must be a string.`);
+	}
+	for (const requiredBoolean of ["inheritProjectContext", "inheritGlobalContext", "inheritSkills"] as const) {
+		if (typeof value[requiredBoolean] !== "boolean") {
+			throw new Error(`Invalid runner configuration: '${field}.${requiredBoolean}' must be a boolean.`);
+		}
+	}
+}
+
+function validateStep(value: unknown, index: number): void {
+	const field = `steps[${index}]`;
+	if (!isRecord(value)) {
+		throw new Error(`Invalid runner configuration: '${field}' must be an object.`);
+	}
+	if ("expand" in value || "collect" in value) {
+		if (!isRecord(value.expand)) {
+			throw new Error(`Invalid runner configuration: '${field}.expand' must be an object.`);
+		}
+		if (!isRecord(value.collect)) {
+			throw new Error(`Invalid runner configuration: '${field}.collect' must be an object.`);
+		}
+		validateChildStep(value.parallel, `${field}.parallel`);
+		return;
+	}
+	if (Array.isArray(value.parallel)) {
+		if (value.parallel.length === 0) {
+			throw new Error(`Invalid runner configuration: '${field}.parallel' must not be empty.`);
+		}
+		value.parallel.forEach((step, childIndex) => validateChildStep(step, `${field}.parallel[${childIndex}]`));
+		return;
+	}
+	validateChildStep(value, field);
+}
+
+export function validateSubagentRunConfig(value: unknown): asserts value is SubagentRunConfig {
+	if (!isRecord(value)) {
+		throw new Error("Invalid runner configuration: root must be an object.");
+	}
+	for (const field of ["id", "resultPath", "cwd", "asyncDir"] as const) {
+		if (typeof value[field] !== "string" || !value[field]) {
+			throw new Error(`Invalid runner configuration: '${field}' must be a non-empty string.`);
+		}
+	}
+	if (typeof value.placeholder !== "string") {
+		throw new Error("Invalid runner configuration: 'placeholder' must be a string.");
+	}
+	if (!Array.isArray(value.steps) || value.steps.length === 0) {
+		throw new Error("Invalid runner configuration: 'steps' must be a non-empty array.");
+	}
+	value.steps.forEach(validateStep);
+}
+
+async function waitForStartupControl(controlPath: string, token: string, action: "ack" | "confirm" | "proceed", timeoutMs = 30_000): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() <= deadline) {
+		if (fs.existsSync(controlPath)) {
+			let payload: { action?: unknown; token?: unknown };
+			try {
+				payload = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { action?: unknown; token?: unknown };
+			} catch (error) {
+				throw new Error(`Failed to read runner startup control '${controlPath}': ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (payload.token !== token) {
+				throw new Error("Runner startup control token does not match.");
+			}
+			if (payload.action === action) {
+				return;
+			}
+			if (payload.action !== "ack" && payload.action !== "confirm" && payload.action !== "proceed") {
+				throw new Error("Runner startup control action is invalid.");
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, 20));
+	}
+	throw new Error(`Timed out after ${timeoutMs}ms waiting for runner startup control '${action}'.`);
+}
+
+/** Owns startup authorization and any revival lease across dynamically loaded execution. */
+export async function runConfiguredSubagent(rawConfig: unknown, options: RunnerBootstrapOptions = {}): Promise<void> {
+	validateSubagentRunConfig(rawConfig);
+	const config = rawConfig;
+	let lease: ReturnType<typeof acquireSessionLease> | undefined;
+	let startupCommitted = config.revivalLease === undefined && config.launchBarrierToken === undefined;
+	let executionLoaded = false;
+	const startupPath = path.join(config.asyncDir, "runner-startup.json");
+	const startupAckPath = path.join(config.asyncDir, "runner-startup-ack.json");
+	const startupConfirmPath = path.join(config.asyncDir, "runner-startup-confirm.json");
+	const startupProceedPath = path.join(config.asyncDir, "runner-startup-proceed.json");
+	const releaseOnExit = (): void => {
+		try {
+			lease?.release();
+		} catch {
+			// Dead-owner leases are reclaimed on the next revival.
+		}
+	};
+	process.once("exit", releaseOnExit);
+	try {
+		if (config.launchBarrierToken) {
+			await waitForStartupControl(startupProceedPath, config.launchBarrierToken, "proceed");
+			startupCommitted = true;
+			try {
+				fs.rmSync(startupProceedPath, { force: true });
+			} catch {
+				// Best effort after commit.
+			}
+		} else if (config.revivalLease) {
+			lease = acquireSessionLease(config.revivalLease);
+			config.revivalLeaseToken = lease.owner.token;
+			writeAtomicJson(startupPath, { state: "ready", token: lease.owner.token, pid: process.pid, owner: lease.owner });
+			await waitForStartupControl(startupAckPath, lease.owner.token, "ack");
+			writeAtomicJson(startupPath, { state: "acknowledged", token: lease.owner.token, pid: process.pid });
+			await waitForStartupControl(startupConfirmPath, lease.owner.token, "confirm");
+			writeAtomicJson(startupPath, { state: "confirmed", token: lease.owner.token, pid: process.pid });
+			await waitForStartupControl(startupProceedPath, lease.owner.token, "proceed");
+			startupCommitted = true;
+			for (const controlPath of [startupAckPath, startupConfirmPath, startupProceedPath]) {
+				try {
+					fs.rmSync(controlPath, { force: true });
+				} catch {
+					// Best effort after commit.
+				}
+			}
+		}
+		if (lease) {
+			// Persist token identity before the heavy import so an import rejection
+			// still leaves the parent enough evidence to prove lease release.
+			const candidate = readProcessTerminalCandidate(config.asyncDir);
+			if (candidate) {
+				writeProcessTerminalCandidate(config.asyncDir, {
+					...candidate,
+					sessionFile: config.revivalLease?.sessionFile,
+					revivalLeaseToken: lease.owner.token,
+				});
+			}
+		}
+		const { loadExecutionModule, ...executionOptions } = options;
+		const testExecutionModule = process.env.SELESAI_SUBAGENTS_TEST_RUNNER_EXECUTION_MODULE;
+		const execution = await (loadExecutionModule?.() ?? (testExecutionModule ? import(testExecutionModule) : import("./subagent-runner.ts")));
+		executionLoaded = true;
+		await execution.runConfiguredSubagentExecution(config, executionOptions);
+	} catch (error) {
+		if (!startupCommitted) {
+			try {
+				writeAtomicJson(startupPath, { state: "error", pid: process.pid, error: error instanceof Error ? error.message : String(error) });
+			} catch {
+				// The parent will time out and terminate if startup evidence cannot be written.
+			}
+		} else if (!executionLoaded) {
+			try {
+				persistRunnerStartupFailure({
+					asyncDir: config.asyncDir,
+					runId: config.id,
+					runnerProcessInstanceId: config.runnerProcessInstanceId ?? "unknown-runner-instance",
+					message: `Subagent runner startup failed: ${error instanceof Error ? error.message : String(error)}`,
+					...(config.sessionId ? { sessionId: config.sessionId } : {}),
+					...(config.completionOwnerId ? { completionOwnerId: config.completionOwnerId } : {}),
+					candidate: {
+						...(config.revivalLease?.sessionFile ? { sessionFile: config.revivalLease.sessionFile } : {}),
+						...(config.revivalLeaseToken ? { revivalLeaseToken: config.revivalLeaseToken } : {}),
+					},
+				});
+			} catch (persistenceError) {
+				console.error("Failed to persist runner startup failure:", persistenceError);
+			}
+		}
+		throw error;
+	} finally {
+		process.off("exit", releaseOnExit);
+		if (lease) {
+			let acknowledged = false;
+			try {
+				acknowledged = lease.release();
+			} catch (error) {
+				console.error("Failed to release session revival lease:", error);
+			}
+			try {
+				markProcessTerminalCandidateLeaseRelease(config.asyncDir, lease.owner.token, acknowledged);
+			} catch (error) {
+				console.error("Failed to record session revival lease release:", error);
+			}
+		}
+	}
+}
+
+function startConfiguredSubagent(config: unknown): void {
+	runConfiguredSubagent(config).then(
+		() => process.exit(0),
+		(error) => {
+			console.error("Subagent runner error:", error);
+			process.exit(1);
+		},
+	);
+}
+
+function monitorTestParent(): void {
+	const parentPid = Number(process.env.SELESAI_SUBAGENTS_TEST_PARENT_PID);
+	if (!Number.isSafeInteger(parentPid) || parentPid <= 0 || parentPid === process.pid) {
+		return;
+	}
+	const check = () => {
+		try {
+			process.kill(parentPid, 0);
+		} catch {
+			process.exit(1);
+		}
+	};
+	check();
+	setInterval(check, 250).unref();
+}
+
+const isRunnerEntrypoint = Boolean(process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href);
+if (isRunnerEntrypoint) {
+	monitorTestParent();
+	const configArg = process.argv[2];
+	if (configArg) {
+		try {
+			const config = JSON.parse(fs.readFileSync(configArg, "utf-8")) as unknown;
+			try {
+				fs.unlinkSync(configArg);
+			} catch {
+				// Temp-config cleanup is best effort.
+			}
+			startConfiguredSubagent(config);
+		} catch (error) {
+			console.error("Subagent runner error:", error);
+			process.exit(1);
+		}
+	} else {
+		let input = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => {
+			input += chunk;
+		});
+		process.stdin.on("end", () => {
+			try {
+				startConfiguredSubagent(JSON.parse(input) as unknown);
+			} catch (error) {
+				console.error("Subagent runner error:", error);
+				process.exit(1);
+			}
+		});
+	}
+}