@gajae-code/coding-agent 0.18.5 → 0.18.6

package/src/coordinator-mcp/server.ts

@@ -740,13 +740,18 @@ function toolSchema(
 		return {
 			name,
 			description:
-				"Create a durable turn and deliver a bounded follow-up prompt for a selected coordinator bridge session.",
+				"Create a durable turn, or set steer:true with the active turn_id to deliver requested input to that running turn. queue:true is only for a separate later task; it is not consumption acknowledgement.",
 			inputSchema: {
 				type: "object",
 				properties: {
 					session_id: sessionId,
 					prompt: { type: "string" },
 					queue: { type: "boolean" },
+					steer: { type: "boolean" },
+					turn_id: {
+						type: "string",
+						description: "Required with steer:true; the existing active coordinator turn.",
+					},
 					force: { type: "boolean" },
 					idempotency_key: idempotencyKey,
 					allow_mutation: allowMutation,
@@ -829,7 +834,12 @@ function toolSchema(
 					summary: { type: "string" },
 					blocker: { type: "string" },
 					pr_url: { type: "string" },
-					evidence_paths: { type: "array", items: { type: "string" } },
+					evidence_paths: {
+						type: "array",
+						items: { type: "string" },
+						description:
+							"Evidence must be inside configured artifact roots. Agent session logs are not automatically allowed.",
+					},
 					idempotency_key: idempotencyKey,
 					allow_mutation: allowMutation,
 				},
@@ -1250,8 +1260,10 @@ const COORDINATOR_IDEMPOTENCY_RESPONSE_BYTE_CAP = 64 * 1024;
 const COORDINATOR_IDEMPOTENCY_STRING_BYTE_CAP = 8 * 1024;
 const PUBLIC_ERROR_MESSAGES: Record<string, string> = {
 	invalid_input: "Coordinator request input is invalid.",
+	turn_not_active: "Feedback requires the selected active turn; no new coordinator turn was created.",
 	invalid_request: "Coordinator request is invalid.",
 	invalid_session_id: "Coordinator session id is invalid.",
+	invalid_turn_id: "Coordinator turn id is invalid.",
 	unknown_operation: "Coordinator operation is unsupported.",
 	not_found: "Coordinator resource was not found.",
 	resource_gone: "Coordinator resource is no longer available.",
@@ -2608,8 +2620,20 @@ export async function appendCoordinatorEventForTest(
 	return appendCoordinatorEvent(namespaceDir, input);
 }
 
+// Tool arguments and env values arrive untyped. `Number.parseInt(String(v))`
+// reads a leading digit prefix ("1e4" -> 1, "5s" -> 5) and flattens arrays
+// ([50] -> "50"), so a malformed value silently became a 1 ms timeout or a
+// one-row limit. Numbers pass through; strings must be plain decimal digits;
+// anything else is NaN so each caller falls back to its default.
+function integerArg(value: unknown): number {
+	if (typeof value === "number") return value;
+	if (typeof value !== "string") return Number.NaN;
+	const trimmed = value.trim();
+	return /^\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : Number.NaN;
+}
+
 function boundedEventLimit(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (!Number.isFinite(parsed) || parsed <= 0) return 100;
 	return Math.min(parsed, 100);
 }
@@ -3178,7 +3202,7 @@ export const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30_000;
 export const COORDINATOR_POLL_INTERVAL_MAX_MS = 10_000;
 
 function parsePositiveIntegerMs(value: unknown, fallback: number): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
@@ -3194,7 +3218,7 @@ export function boundedRuntimePromptAckTimeoutMs(value: unknown): number {
 }
 
 export function boundedEventWatchTimeoutMs(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (parsed === 0) return 0;
 	return Math.min(Number.isFinite(parsed) && parsed > 0 ? parsed : 1000, COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS);
 }
@@ -3204,7 +3228,7 @@ export function boundedPollIntervalMs(value: unknown): number {
 }
 
 function boundedLineCount(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (!Number.isFinite(parsed) || parsed <= 0) return 80;
 	return Math.min(parsed, 400);
 }
@@ -5178,7 +5202,20 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	}
 
 	async function queryLastAssistant(session: Record<string, unknown>): Promise<string | null> {
-		const item = sdkQueryPageItem(await querySession(session, "session.last_assistant"), "session.last_assistant");
+		let item: unknown;
+		try {
+			item = sdkQueryPageItem(await querySession(session, "session.last_assistant"), "session.last_assistant");
+		} catch (error) {
+			// Compatibility with running older hosts: this exact Q17 diagnostic
+			// denotes an absent text payload, not a missing session or closed store.
+			if (
+				error instanceof SdkClientError &&
+				error.code === "resource_gone" &&
+				error.message === "snapshot payload is unavailable"
+			)
+				return null;
+			throw error;
+		}
 		if (typeof item === "string") return item;
 		const message = asRecord(item);
 		return typeof message?.text === "string"
@@ -5227,6 +5264,19 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	function publicError(error: unknown): Record<string, unknown> {
 		if (error instanceof Error && error.message.startsWith("coordinator_mutation_call_not_allowed:"))
 			return { ok: false, reason: error.message };
+		if (error instanceof Error) {
+			const reason = error.message.startsWith("coordinator_artifact_outside_allowed_roots:")
+				? "artifact_outside_allowed_roots"
+				: error.message === "coordinator_artifact_state_root_denied"
+					? "artifact_state_root_denied"
+					: undefined;
+			if (reason)
+				return {
+					ok: false,
+					reason,
+					error: { code: "invalid_input", message: PUBLIC_ERROR_MESSAGES.invalid_input },
+				};
+		}
 		const directCode = error instanceof SdkClientError ? error.code : sinkErrorCode(error);
 		const messageCode =
 			error instanceof Error && Object.hasOwn(PUBLIC_ERROR_MESSAGES, error.message) ? error.message : undefined;
@@ -10354,6 +10404,91 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 				const idempotencyKey = requiredIdempotencyKey(args);
 				const sessionId = safeExternalId("session", args.session_id);
 				const prompt = args.prompt;
+				if (args.steer === true) {
+					if (args.queue === true || args.force === true)
+						return {
+							ok: false,
+							error: { code: "invalid_input", message: "steer cannot be combined with queue or force." },
+						};
+					const turnId = safeTurnId(args.turn_id);
+					return await withToolIdempotency(
+						name,
+						idempotencyKey,
+						{ session_id: sessionId, turn_id: turnId, prompt, steer: true, allow_mutation: true },
+						async () =>
+							await withSessionTransition(sessionId, async () => {
+								const transaction = await readSessionTransaction(questionPaths, sessionId);
+								const turn = transaction?.canonical.turns[turnId];
+								if (
+									!transaction ||
+									!turn ||
+									transaction.canonical.queue.active_turn_id !== turnId ||
+									(turn.status !== "active" && turn.status !== "waiting_for_answer")
+								)
+									return {
+										ok: false,
+										error: {
+											code: "turn_not_active",
+											message: "Feedback requires the selected active turn; no new turn was created.",
+										},
+									};
+								const runtimeCommandId = turn.delivery.runtime_command_id;
+								const runtimeTurnId = turn.delivery.runtime_turn_id;
+								if (
+									typeof runtimeCommandId !== "string" ||
+									runtimeCommandId.length === 0 ||
+									typeof runtimeTurnId !== "string" ||
+									runtimeTurnId.length === 0
+								)
+									return {
+										ok: false,
+										error: {
+											code: "turn_not_active",
+											message:
+												"Feedback requires the selected active turn's runtime identity; no new turn was created.",
+										},
+									};
+								const session = asRecord(await readJsonFile(sessionFile(sessionId)));
+								if (!session) throw new Error("resource_gone");
+								await assertPersistedSessionAuthority(transaction.canonical.session);
+								const clientRef = `coordinator-feedback:${createHash("sha256")
+									.update(JSON.stringify([sessionId, turnId, idempotencyKey]))
+									.digest("hex")}`;
+								const expectedSdkRunToken = `${runtimeCommandId}:${runtimeTurnId}`;
+								const response = asRecord(
+									await controlSession(
+										session,
+										"turn.steer",
+										{ text: prompt, clientRef, expectedSdkRunToken },
+										idempotencyKey,
+									),
+								);
+								const result = asRecord(response?.result);
+								return {
+									ok: result?.accepted === true,
+									session_id: sessionId,
+									turn_id: turnId,
+									delivery: "steer",
+									queued: false,
+									consumption_verified: false,
+									steer_client_ref: clientRef,
+									result,
+								};
+							}),
+						true,
+						response => {
+							const result = asRecord(response.result);
+							const resultError = asRecord(result?.error);
+							return (
+								["ambiguous", "uncertain_after_send", "connection_closed", "timeout"].includes(
+									String(asRecord(response.error)?.code),
+								) ||
+								result?.status === "uncertain" ||
+								resultError?.code === "delivery_uncertain"
+							);
+						},
+					);
+				}
 				return await withToolIdempotency(
 					name,
 					idempotencyKey,

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

@@ -22,6 +22,11 @@ export const DEFAULT_SESSION_IDLE_TTL_MS = 30 * 60_000; // 30 min idle → reap
 export const DEFAULT_SESSION_SWEEP_INTERVAL_MS = 5 * 60_000; // sweep every 5 min
 export const MIN_SESSION_IDLE_TTL_MS = 60_000; // never reap a <1min-idle session
 export const MIN_SESSION_SWEEP_INTERVAL_MS = 30_000;
+/**
+ * Longest delay setTimeout honors. Bun, like Node, treats any larger delay as 1 ms,
+ * so an operator's very long sweep interval would otherwise re-sweep back to back.
+ */
+export const MAX_SESSION_SWEEP_INTERVAL_MS = 2 ** 31 - 1;
 /** After this many consecutive reap failures the session is force-evicted from the index. */
 export const MAX_REAP_FAILURES = 3;
 
@@ -92,7 +97,10 @@ export interface SessionReaper {
 
 export function createSessionReaper(deps: SessionReaperDeps, policy: SessionReaperPolicy): SessionReaper {
 	const idleTtlMs = Math.max(MIN_SESSION_IDLE_TTL_MS, policy.idleTtlMs);
-	const sweepIntervalMs = Math.max(MIN_SESSION_SWEEP_INTERVAL_MS, policy.sweepIntervalMs);
+	const sweepIntervalMs = Math.min(
+		MAX_SESSION_SWEEP_INTERVAL_MS,
+		Math.max(MIN_SESSION_SWEEP_INTERVAL_MS, policy.sweepIntervalMs),
+	);
 	let timer: ReturnType<typeof setTimeout> | null = null;
 	let generation = 0;
 	let inProgress = false;

package/src/defaults/gjc/skills/deep-interview/SKILL.md

@@ -265,7 +265,7 @@ Is that topology and locked intent right? Should any component or intent be adde
 
 Options should include contextually relevant choices such as **Looks right**, **Add/remove/merge components**, **Defer one or more components**, plus free-text, translated/localized according to `language.instruction` when present. This is the only pre-scoring question and preserves the one-question-per-round rule.
 
-The Round 0 `ask` call MUST include `deepInterview.round = 0`, `deepInterview.component = "review-topology"`, `deepInterview.dimension = "topology"`, `deepInterview.ambiguity` (the observed 0..1 ambiguity at ask time; `1` before Round 1 scoring), `deepInterview.intent_contract.items` containing the exact displayed locked-intent items, and `deepInterview.intent_contract.confirmation_options` listing only the displayed affirmative labels that lock the proposal (normally **Looks right**). The runtime recorder canonicalizes and locks this contract only when the user selects one of those labels; correction, deferral, free-text, and clarification answers never lock the pre-question proposal. Do not manually copy raw free text into intent evidence, and do not continue if this required recorder write fails. An incomplete Round 0 object (for example missing `deepInterview.ambiguity` or the whole `deepInterview.intent_contract`) is rejected before coercion with a correction naming the omitted fields; retry once with every required field populated from the visible payload context, never by re-sending the incomplete object or inventing contract items — the recorder never locks intent without an affirmative user answer.
+While state is in the `interviewing` phase, every `ask` MUST contain exactly one non-empty question with structured `deepInterview` metadata on that question; never add an empty `metadata` or `ignore` question. The entire `deepInterview` object is required, not merely the prose round header or `workflowGate`. After native final-spec persistence transitions to `handoff`, Phase 5 next-workflow/approval asks are ordinary asks without interview round metadata. The Round 0 `ask` call MUST include `deepInterview.round = 0`, `deepInterview.component = "review-topology"`, `deepInterview.dimension = "topology"`, `deepInterview.ambiguity` (the observed 0..1 ambiguity at ask time; `1` before Round 1 scoring), `deepInterview.intent_contract.items` containing the exact displayed locked-intent items, and `deepInterview.intent_contract.confirmation_options` listing only the displayed affirmative labels that lock the proposal (normally **Looks right**). The runtime recorder canonicalizes and locks this contract only when the user selects one of those labels; correction, deferral, free-text, and clarification answers never lock the pre-question proposal. Do not manually copy raw free text into intent evidence, and do not continue if this required recorder write fails. An incomplete Round 0 object (for example missing `deepInterview.ambiguity` or the whole `deepInterview.intent_contract`) is rejected before coercion with a correction naming the omitted fields; retry once with every required field populated from the visible payload context, never by re-sending the incomplete object or inventing contract items — the recorder never locks intent without an affirmative user answer.
 
 3. **Lock topology into state** after the answer. Store a normalized component list and confirmation timestamp:
 

package/src/edit/modes/replace.ts

@@ -1,8 +1,8 @@
 /**
  * Fuzzy matching utilities for the edit tool.
  *
- * Provides both character-level and line-level fuzzy matching with progressive
- * fallback strategies for finding text in files.
+ * Provides both character-level and line-level fuzzy matching with staged
+ * strategies for finding text in files.
  */
 import type { AgentToolResult } from "@gajae-code/agent-core";
 import { markDesignedError } from "@gajae-code/utils/error-classification";
@@ -430,7 +430,7 @@ export function findContextLine(
 	lines: string[],
 	context: string,
 	startFrom: number,
-	options?: { allowFuzzy?: boolean; skipFunctionFallback?: boolean },
+	options?: { allowFuzzy?: boolean; skipParenRetry?: boolean },
 ): ContextLineResult {
 	const allowFuzzy = options?.allowFuzzy ?? true;
 	const trimmedContext = context.trim();
@@ -570,14 +570,14 @@ export function findContextLine(
 		};
 	}
 
-	if (!options?.skipFunctionFallback && trimmedContext.endsWith("()")) {
+	if (!options?.skipParenRetry && trimmedContext.endsWith("()")) {
 		const withParen = trimmedContext.replace(/\(\)\s*$/u, "(");
 		const withoutParen = trimmedContext.replace(/\(\)\s*$/u, "");
-		const parenResult = findContextLine(lines, withParen, startFrom, { allowFuzzy, skipFunctionFallback: true });
+		const parenResult = findContextLine(lines, withParen, startFrom, { allowFuzzy, skipParenRetry: true });
 		if (parenResult.index !== undefined || (parenResult.matchCount ?? 0) > 0) {
 			return parenResult;
 		}
-		return findContextLine(lines, withoutParen, startFrom, { allowFuzzy, skipFunctionFallback: true });
+		return findContextLine(lines, withoutParen, startFrom, { allowFuzzy, skipParenRetry: true });
 	}
 
 	return { index: undefined, confidence: bestScore };

package/src/edit/streaming.ts

@@ -7,7 +7,7 @@
  * - compute unified diff previews for the in-flight args
  *   (`computeDiffPreview`), and
  * - render a text placeholder while no diff exists yet
- *   (`renderStreamingFallback`).
+ *   (`renderStreamingPlaceholder`).
  *
  * The shared renderer / `ToolExecutionComponent` consult the strategy via
  * the injected `editMode` rather than probing argument shape.
@@ -72,7 +72,7 @@ export interface EditStreamingStrategy<Args = unknown> {
 	 * Rendered inline while the diff hasn't been computed yet (or when the
 	 * compute returned `null` because args are still too partial).
 	 */
-	renderStreamingFallback(args: Args, uiTheme: Theme): string;
+	renderStreamingPlaceholder(args: Args, uiTheme: Theme): string;
 }
 export interface EditRequestTargetInventory {
 	paths: string[];
@@ -169,7 +169,7 @@ export function getEditRequestTargetInventory(
 	if (editMode === "hashline") {
 		const input = typeof values.input === "string" ? values.input : "";
 		const headerPaths = getHashlineTargetPaths(input);
-		// `path` is only a fallback for headerless input; explicit §PATH headers are the full target set.
+		// `path` is only the target for headerless input; explicit §PATH headers are the full target set.
 		if (headerPaths.length > 0) return { paths: orderedDistinctPaths(headerPaths) };
 		return { paths: orderedDistinctPaths([topLevelPath]) };
 	}
@@ -197,8 +197,8 @@ export function getEditRequestTargetInventory(
 	return { paths: orderedDistinctPaths([topLevelPath, ...editPaths, partialPath]) };
 }
 
-const STREAMING_FALLBACK_LINES = 12;
-const STREAMING_FALLBACK_WIDTH = 80;
+const STREAMING_PLACEHOLDER_LINES = 12;
+const STREAMING_PLACEHOLDER_WIDTH = 80;
 
 function isHashlineHeaderLine(line: string): boolean {
 	return line.trimEnd().startsWith(HL_FILE_PREFIX);
@@ -236,15 +236,15 @@ function trimHashlineStreamingSyntax(lines: string[]): string[] {
 	return lines.slice(index).filter(line => !isHashlineEnvelopeMarkerLine(line));
 }
 
-function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
+function renderHashlineInputPlaceholder(input: string, uiTheme: Theme): string {
 	const lines = trimHashlineStreamingSyntax(sanitizeText(input).split("\n"));
 	if (!lines.some(line => line.trim().length > 0)) return "";
 
-	const displayLines = lines.slice(-STREAMING_FALLBACK_LINES);
+	const displayLines = lines.slice(-STREAMING_PLACEHOLDER_LINES);
 	const hidden = lines.length - displayLines.length;
 	let text = "\n\n";
 	text += displayLines
-		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_FALLBACK_WIDTH)))
+		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_PLACEHOLDER_WIDTH)))
 		.join("\n");
 	if (hidden > 0) {
 		text += uiTheme.fg("dim", `\n… (streaming +${hidden} lines)`);
@@ -376,7 +376,7 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 		ctx.signal.throwIfAborted();
 		return [toPerFilePreview(args.path, result)];
 	},
-	renderStreamingFallback() {
+	renderStreamingPlaceholder() {
 		return "";
 	},
 };
@@ -405,7 +405,7 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 		ctx.signal.throwIfAborted();
 		return [toPerFilePreview(args.path, result)];
 	},
-	renderStreamingFallback() {
+	renderStreamingPlaceholder() {
 		return "";
 	},
 };
@@ -552,7 +552,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		try {
 			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
 		} catch {
-			// Single-section fallback keeps the original error rendering for the
+			// Single-section handling keeps the original error rendering for the
 			// "haven't typed `§ PATH` yet" case.
 			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
@@ -590,8 +590,8 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback(args, uiTheme) {
-		return typeof args.input === "string" ? renderHashlineInputFallback(args.input, uiTheme) : "";
+	renderStreamingPlaceholder(args, uiTheme) {
+		return typeof args.input === "string" ? renderHashlineInputPlaceholder(args.input, uiTheme) : "";
 	},
 };
 
@@ -642,7 +642,7 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback() {
+	renderStreamingPlaceholder() {
 		return "";
 	},
 };
@@ -656,7 +656,7 @@ const vimStrategy: EditStreamingStrategy<unknown> = {
 	async computeDiffPreview() {
 		return null;
 	},
-	renderStreamingFallback() {
+	renderStreamingPlaceholder() {
 		return "";
 	},
 };

package/src/exec/bash-shell-supervisor.ts

@@ -1,6 +1,7 @@
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import * as childProcess from "node:child_process";
 import { createHmac } from "node:crypto";
+import type { EventEmitter } from "node:events";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -121,6 +122,63 @@ async function reapLinuxAdoptedZombies(excludedPid: number | undefined): Promise
 	}
 }
 
+/**
+ * Reap adopted zombies only when the kernel reports a child state change.
+ *
+ * As the Linux child subreaper, the supervisor inherits orphaned descendants
+ * and must reap them, but a full `/proc` sweep is expensive. Polling it on a
+ * short interval kept every idle supervisor busy (issue #5972), so sweeps are
+ * driven by SIGCHLD instead. At most one sweep runs at a time, and a SIGCHLD that
+ * arrives mid-sweep schedules exactly one follow-up so a zombie created after
+ * its `/proc` entry was passed is never missed. Returns the unsubscribe hook.
+ */
+export function startLinuxAdoptedZombieReaper(
+	excludedPid: number | undefined,
+	reap: (excludedPid: number | undefined) => Promise<void> = reapLinuxAdoptedZombies,
+	signals: Pick<EventEmitter, "on" | "off"> = process,
+): () => void {
+	if (process.platform !== "linux") return () => undefined;
+	let running = false;
+	let rerun = false;
+	let stopped = false;
+	let sweepPending = false;
+	const sweep = (): void => {
+		if (stopped) return;
+		if (running) {
+			rerun = true;
+			return;
+		}
+		if (sweepPending) return;
+		sweepPending = true;
+		running = true;
+		void reap(excludedPid)
+			.catch(() => undefined)
+			.finally(() => {
+				running = false;
+				sweepPending = false;
+				if (!rerun || stopped) return;
+				rerun = false;
+				// Defer recursive call to avoid stack overflow
+				setImmediate(() => {
+					if (!stopped && !running) sweep();
+				});
+			});
+	};
+	try {
+		signals.on("SIGCHLD", sweep);
+	} catch {
+		// Signal handler installation may fail in some environments
+	}
+	return () => {
+		stopped = true;
+		try {
+			signals.off("SIGCHLD", sweep);
+		} catch {
+			// Signal handler removal may fail in some environments
+		}
+	};
+}
+
 function signalFromExit(code: number | null, signal: NodeJS.Signals | null): NodeJS.Signals | null {
 	if (signal) return signal;
 	if (code === null || code <= 128) return null;
@@ -210,8 +268,7 @@ export async function runBashShellSupervisor(): Promise<void> {
 		stdio: ["pipe", "pipe", "pipe"],
 		windowsHide: true,
 	});
-	const zombieReaper = setInterval(() => void reapLinuxAdoptedZombies(worker.pid), 25);
-	zombieReaper.unref();
+	const stopZombieReaper = startLinuxAdoptedZombieReaper(worker.pid);
 	const pendingRuns: number[] = [];
 	let terminating = false;
 	let protocolToken: string | undefined;
@@ -315,7 +372,7 @@ export async function runBashShellSupervisor(): Promise<void> {
 		);
 	});
 	worker.once("exit", async (code, signal) => {
-		clearInterval(zombieReaper);
+		stopZombieReaper();
 		const resultSignal = signalFromExit(code, signal);
 		if (code === 0 && resultSignal === null) {
 			await reapLinuxSubreaperChildren();