pi-cohort 7.6.3 → 7.6.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [7.6.5] - 2026-10-29
+
+### Fixed
+- Interrupted external children complete bounded child/host cleanup before settling and remain paused with zero exit and preserved diagnostics. Applied abort evidence handles error-shaped terminals without rewriting an earlier terminal; cleanup uncertainty does not trigger fallback or fail-fast. Normal interruption retains the diagnostic surface, but forced cleanup may close it; `retained` records the last known close outcome, not proof of liveness or inspectability. Unconfirmed termination reports `Process termination could not be confirmed; manual cleanup may be required.` The paired pi-gauntlet completion checks exclude explicitly interrupted children from closure-review and cadence credit. Actual-process tests with fake backends prove core behavior only: the live cmux runtime and reporter's installed adapter version remain unavailable, so no live reproduction or companion retention compliance is claimed. (#36)
+
+## [7.6.4] - 2026-10-29
+
+### Fixed
+- Async children on external execution backends no longer falsely need attention while a tool call runs past the idle threshold within an open turn; replay now opens the turn, preserving the silence ceiling and final-answer closure. (#37)
+
 ## [7.6.3] - 2026-10-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "7.6.3",
+  "version": "7.6.5",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/execution-backend/child-host-controller.ts

@@ -11,7 +11,7 @@ import { getPiSpawnCommand, PiRuntimeLaunchError, type PiRuntimeIdentity } from
 
 export interface ChildHostAttempt { readonly attemptId: string; readonly command: string; readonly args: readonly string[]; readonly cwd: string; readonly environment: Readonly<Record<string, string>>; }
 export interface ChildHostExit { readonly status: number | null; readonly signal: string | null; }
-export interface ChildHostController { readonly lease: ExecutionBackendLease; readonly ready: Promise<void>; startAttempt(attempt: ChildHostAttempt): Promise<ChildHostExit>; shutdown(): Promise<void>; releaseObserver(): Promise<void>; }
+export interface ChildHostController { readonly lease: ExecutionBackendLease; readonly ready: Promise<void>; readonly hostExit: Promise<ChildHostExit>; dispose(): void; startAttempt(attempt: ChildHostAttempt): Promise<ChildHostExit>; shutdown(): Promise<void>; releaseObserver(): Promise<void>; }
 export interface ChildHostControllerOptions { readonly runtime: PiRuntimeIdentity; readonly backend: ExecutionBackend; readonly runId: string; readonly childId: string; readonly cwd: string; readonly title?: string; readonly signal: AbortSignal; }
 export interface ChildHostControllerDependencies { readonly fs?: typeof fs; readonly ensureJiti?: (root: string) => string | undefined; readonly childHostCommand?: () => { command: string; args: readonly string[] }; readonly platform?: NodeJS.Platform; readonly createServer?: typeof net.createServer; }
 
@@ -36,6 +36,8 @@ export async function createChildHostController(options: ChildHostControllerOpti
 	let server: net.Server | undefined;
 	let socket: net.Socket | undefined;
 	let closed = false;
+	let disposed = false;
+	const launchAborter = new AbortController();
 	let abortListener: (() => void) | undefined;
 	const cleanup = () => {
 		if (abortListener) options.signal.removeEventListener("abort", abortListener);
@@ -75,10 +77,17 @@ export async function createChildHostController(options: ChildHostControllerOpti
 			rejectReady?.(cause); rejectReady = undefined;
 			if (active) { active.reject(cause); active = undefined; }
 			if (pendingShutdown) { pendingShutdown.reject(cause); pendingShutdown = undefined; }
-			cleanup();
+			if (!ready) cleanup();
+		};
+		const disconnect = () => {
+			if (closed) return;
+			const cause = disconnected(!ready ? "before ready" : active ? "during attempt" : pendingShutdown ? "before shutdown acknowledgement" : "after ready");
+			disconnectCause = cause;
+			fail(cause);
 		};
 		server = (dependencies.createServer ?? net.createServer)(connection => {
 			if (socket || closed) { connection.destroy(); return; }
+			connection.on("error", disconnect);
 			socket = connection;
 			const decoder = new ChildHostFrameDecoder();
 			connection.on("data", data => {
@@ -88,7 +97,10 @@ export async function createChildHostController(options: ChildHostControllerOpti
 					if (message.runId !== options.runId || message.childId !== options.childId) { connection.destroy(); return; }
 					if (!ready) {
 						if (message.kind !== "host_ready") { connection.destroy(); return; }
-						ready = true; resolveReady?.(); resolveReady = undefined; rejectReady = undefined; continue;
+						ready = true;
+						if (abortListener) options.signal.removeEventListener("abort", abortListener);
+						abortListener = undefined;
+						resolveReady?.(); resolveReady = undefined; rejectReady = undefined; continue;
 					}
 					if (message.kind === "attempt_started" && active?.attemptId === message.attemptId && !active.started) { active.started = true; continue; }
 					if (message.kind === "attempt_spawn_error" && active?.attemptId === message.attemptId) {
@@ -98,21 +110,15 @@ export async function createChildHostController(options: ChildHostControllerOpti
 						const pending = active; active = undefined; pending.resolve({ status: message.status, signal: message.signal }); continue;
 					}
 					if (message.kind === "shutdown_ack" && pendingShutdown && !active) {
-						const pending = pendingShutdown; pendingShutdown = undefined; closed = true; connection.end(); cleanup(); pending.resolve(); continue;
+						const pending = pendingShutdown; pendingShutdown = undefined; closed = true; pending.resolve(); continue;
 					}
 					connection.destroy(); return;
 				}
 			});
-			connection.once("close", () => {
-				if (!closed) {
-					const cause = disconnected(!ready ? "before ready" : active ? "during attempt" : pendingShutdown ? "before shutdown acknowledgement" : "after ready");
-					disconnectCause = cause;
-					fail(cause);
-				}
-			});
+			connection.once("close", disconnect);
 		});
 		server.once("error", cause => fail(cause instanceof Error ? cause : new Error("child host server error")));
-		abortListener = () => fail(aborted());
+		abortListener = () => { launchAborter.abort(); fail(aborted()); };
 		options.signal.addEventListener("abort", abortListener, { once: true });
 		await new Promise<void>((resolve, reject) => server!.listen(socketPath!, () => resolve()).once("error", reject));
 		fileSystem.chmodSync(socketPath, 0o600);
@@ -127,13 +133,34 @@ export async function createChildHostController(options: ChildHostControllerOpti
 			environment,
 			runId: options.runId,
 			childId: options.childId,
-			signal: options.signal,
+			signal: launchAborter.signal,
 			...(options.title === undefined ? {} : { awareness: { title: options.title } }),
 		});
+		let resolveHostExit!: (exit: ChildHostExit) => void;
+		const hostExit = new Promise<ChildHostExit>(resolve => { resolveHostExit = resolve; });
+		void (async () => {
+			try {
+				for await (const event of lease!.events) {
+					if (disposed) break;
+					if (event.type === "exited" && event.surface.kind === lease!.handle.surface.kind && event.surface.id === lease!.handle.surface.id) {
+						resolveHostExit({ status: event.status, signal: event.signal });
+					}
+				}
+			} catch { /* Missing exit evidence remains unconfirmed. */ }
+		})();
 		return {
+			hostExit,
+			dispose() {
+				if (disposed) return;
+				disposed = true;
+				fail(disconnected("after disposal"));
+				attemptedIds.clear();
+				cleanup();
+			},
 			get lease() { return lease!; },
 			ready: readyPromise,
 			startAttempt(attempt) {
+				if (socket?.writableEnded || socket?.destroyed) disconnect();
 				if (closed || !socket || !ready) return Promise.reject(disconnectCause ?? disconnected("before ready"));
 				if (pendingShutdown) return Promise.reject(new Error("child host is shutting down"));
 				if (active) return Promise.reject(new Error("child host is busy"));
@@ -146,6 +173,7 @@ export async function createChildHostController(options: ChildHostControllerOpti
 				});
 			},
 			shutdown() {
+				if (socket?.writableEnded || socket?.destroyed) disconnect();
 				if (closed) return disconnectCause ? Promise.reject(disconnectCause) : Promise.resolve();
 				if (!socket || !ready) return Promise.reject(disconnectCause ?? disconnected("before ready"));
 				if (active || pendingShutdown) return Promise.reject(new Error("child host is busy"));

package/src/execution-backend/reporting-extension.ts

@@ -51,12 +51,12 @@ function append(
 	} as ExecutionReport);
 }
 
-function result(messages: readonly AgentMessage[]): Omit<ExecutionReport, "protocolVersion" | "runId" | "childId" | "attemptId" | "sequence" | "timestamp"> {
+function result(messages: readonly AgentMessage[], appliedAbort: boolean): Omit<ExecutionReport, "protocolVersion" | "runId" | "childId" | "attemptId" | "sequence" | "timestamp"> {
 	messages.forEach(assertNoMalformedStandardMessage);
 	const standardMessages = messages.filter(isStandardMessage);
 	const finalAssistant = [...standardMessages].reverse().find(isAssistantMessage);
 	if (!finalAssistant) return { kind: "result", outcome: "failed", finalOutput: "", error: "result_missing" };
-	const interrupted = finalAssistant.stopReason === "aborted";
+	const interrupted = appliedAbort || finalAssistant.stopReason === "aborted";
 	const failed = !interrupted && (finalAssistant.stopReason === "error" || typeof finalAssistant.errorMessage === "string");
 	return {
 		kind: "result",
@@ -134,7 +134,8 @@ export function createExecutionReportingExtension(
 			if (existing.some((report) => report.kind === "result")) return;
 			if (!existing.some((report) => report.kind === "settled")) append(pi, context, config, { kind: "settled" });
 			const messages = context.sessionManager.getBranch().flatMap((entry) => entry.type === "message" ? [entry.message] : []);
-			append(pi, context, config, result(messages));
+			const appliedAbort = existing.some((report) => report.kind === "control" && report.action === "abort" && report.state === "applied");
+			append(pi, context, config, result(messages, appliedAbort));
 		});
 	};
 }

package/src/runs/background/external-attempt.ts

@@ -76,8 +76,8 @@ export interface ExternalBackgroundAttemptResult {
 }
 
 function mapExitCode(result: ExternalAttemptResult): number | null {
-	if (result.outcome === "success") return 0;
-	// A failed or interrupted durable outcome must not become success from zero exit.
+	if (result.interrupted || result.outcome === "success") return 0;
+	// Non-interrupted failures must not become success from zero exit.
 	const code = result.exit.code;
 	return code !== null && code !== 0 ? code : 1;
 }
@@ -123,6 +123,7 @@ function synthesizeChildEvents(message: unknown, emit: (event: SynthesizedChildE
 		emit({ type: "tool_execution_end" });
 		emit({ type: "tool_result_end", message });
 	} else if (msg.role === "assistant") {
+		emit({ type: "message_start" });
 		// Emit tool_execution_start for each tool call in the assistant content.
 		if (Array.isArray(msg.content)) {
 			for (const part of msg.content) {
@@ -183,7 +184,7 @@ export async function runExternalBackgroundAttempt(
 		model: attemptResult.model,
 		error: attemptResult.error,
 		finalOutput: attemptResult.finalOutput,
-		interrupted: attemptResult.outcome === "interrupted",
+		interrupted: attemptResult.interrupted,
 		observedMutationAttempt: observedMutationFromMessages(attemptResult.messages),
 	};
 }

package/src/runs/background/subagent-runner.ts

@@ -6,6 +6,7 @@ import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import type { Message } from "@earendil-works/pi-ai";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { formatInterruptedCleanup } from "../../shared/formatters.ts";
 import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
 import { getPiSpawnCommand, parsePiRuntime, PiRuntimeLaunchError, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
 import { captureSingleOutputSnapshot, finalizeSingleOutput, formatFileOnlyFailure, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
@@ -90,6 +91,7 @@ import type { DetachedExecutionBackendConfig } from "../../execution-backend/typ
 import {
 	createExternalExecution,
 	externalExecutionDiagnosticCode,
+	isInterruptedExternalAttemptError,
 	type ExternalExecution,
 } from "../shared/external-execution.ts";
 import { runExternalBackgroundAttempt } from "./external-attempt.ts";
@@ -135,6 +137,7 @@ interface SubagentRunConfig {
 }
 
 interface StepResult {
+	interrupted?: RunPiStreamingResult["interrupted"];
 	agent: string;
 	output: string;
 	error?: string;
@@ -823,12 +826,14 @@ export async function runSingleStep(
 						});
 					} catch (error) {
 						if (error instanceof PiRuntimeLaunchError) throw error;
+						const interrupted = isInterruptedExternalAttemptError(error);
 						run = {
 							stderr: "",
-							exitCode: 1,
+							exitCode: interrupted ? 0 : 1,
+							interrupted,
 							messages: [],
 							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
-							error: safeExternalFailure("attempt", error),
+							error: interrupted ? error.message : safeExternalFailure("attempt", error),
 							finalOutput: "",
 							executionHandle: externalOwner.handle,
 						};
@@ -837,14 +842,14 @@ export async function runSingleStep(
 					cleanupTempDir(tempDir); // F1: caller (not helper) cleans up tempDir
 				}
 
-				const hiddenError = run.exitCode === 0 && !run.error ? detectSubagentError(run.messages) : null;
+				const hiddenError = run.exitCode === 0 && !run.interrupted && !run.error ? detectSubagentError(run.messages) : null;
 				const blockedOutput = stripAcceptanceReport(getFinalOutput(run.messages));
 				const blockedError = run.exitCode === 0 && !run.interrupted && !run.error && !hiddenError?.hasError && blockedLine(blockedOutput)
 					? blockedOutput
 					: undefined;
 				let structuredOutput: unknown;
 				let structuredError: string | undefined;
-				if (effectiveStructuredOutput && run.exitCode === 0 && !run.error && !hiddenError?.hasError && !blockedError) {
+				if (effectiveStructuredOutput && run.exitCode === 0 && !run.interrupted && !run.error && !hiddenError?.hasError && !blockedError) {
 					const structured = readStructuredOutput({
 						schema: effectiveStructuredOutput.schema,
 						schemaPath: effectiveStructuredOutput.schemaPath,
@@ -853,7 +858,7 @@ export async function runSingleStep(
 					if (structured.error) structuredError = structured.error;
 					else structuredOutput = structured.value;
 				}
-				const completionGuard = run.exitCode === 0 && !run.error && !hiddenError?.hasError && !blockedError && step.completionGuard !== false
+				const completionGuard = run.exitCode === 0 && !run.interrupted && !run.error && !hiddenError?.hasError && !blockedError && step.completionGuard !== false
 					? evaluateCompletionMutationGuard({
 						agent: step.agent,
 						task: taskForCompletionGuard,
@@ -871,7 +876,7 @@ export async function runSingleStep(
 						? 1
 						: hiddenError?.hasError
 						? (hiddenError.exitCode ?? 1)
-						: run.error && run.exitCode === 0
+						: run.error && !run.interrupted && run.exitCode === 0
 							? 1
 							: run.exitCode;
 				const error = blockedError
@@ -884,7 +889,7 @@ export async function runSingleStep(
 						: run.error || (run.exitCode !== 0 && run.stderr.trim() ? run.stderr.trim() : undefined));
 				const attempt: ModelAttempt = {
 					model: candidate ?? run.model ?? step.model ?? "default",
-					success: effectiveExitCode === 0 && !error,
+					success: effectiveExitCode === 0 && (run.interrupted || !error),
 					exitCode: effectiveExitCode,
 					error,
 					usage: run.usage,
@@ -894,7 +899,7 @@ export async function runSingleStep(
 				completionGuardTriggeredFinal = completionGuardTriggered;
 				finalOutputSnapshot = outputSnapshot;
 				finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput } as RunPiStreamingResult & { structuredOutput?: unknown };
-				if (attempt.success || completionGuardTriggered || blockedError) break;
+				if (run.interrupted || attempt.success || completionGuardTriggered || blockedError) break;
 				if (!isRetryableModelFailure(error) || index === candidates.length - 1) break;
 				attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
 			}
@@ -1145,7 +1150,7 @@ export async function runSingleStep(
 
 	// Finish only after core finalization, retaining every failed external leaf.
 	if (externalOwner) {
-		const isDelivered = effectiveFinalExitCode === 0 && !acceptanceCanFailRun;
+		const isDelivered = effectiveFinalExitCode === 0 && !acceptanceCanFailRun && !finalResult?.interrupted;
 		let finishResult: Awaited<ReturnType<ExternalExecution["finish"]>>;
 		try {
 			finishResult = await externalOwner.finish(isDelivered ? "delivered" : "retained");
@@ -1998,6 +2003,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					onChildEvent: (event) => updateStepFromChildEvent(fi, event),
 				});
 				const taskEndTime = Date.now();
+				if (singleResult.interrupted) interrupted = true;
 				statusPayload.steps[fi].status = singleResult.exitCode === 0 ? "complete" : "failed";
 				statusPayload.steps[fi].endedAt = taskEndTime;
 				statusPayload.steps[fi].durationMs = taskEndTime - taskStartTime;
@@ -2029,6 +2035,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					agent: pr.agent,
 					output: pr.output,
 					error: pr.error,
+					...(pr.interrupted ? { interrupted: true } : {}),
 					success: pr.exitCode === 0,
 					exitCode: pr.exitCode,
 					skipped: pr.skipped,
@@ -2293,6 +2300,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						const taskEndTime = Date.now();
 						const taskDuration = taskEndTime - taskStartTime;
 
+						if (singleResult.interrupted) interrupted = true;
 						statusPayload.steps[fi].status = singleResult.exitCode === 0 ? "complete" : "failed";
 						statusPayload.steps[fi].endedAt = taskEndTime;
 						statusPayload.steps[fi].durationMs = taskDuration;
@@ -2361,6 +2369,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						agent: pr.agent,
 						output: pr.output,
 						error: pr.error,
+						...(pr.interrupted ? { interrupted: true } : {}),
 						success: pr.exitCode === 0,
 						exitCode: pr.exitCode,
 						skipped: pr.skipped,
@@ -2477,6 +2486,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				agent: singleResult.agent,
 				output: singleResult.output,
 				error: singleResult.error,
+				...(singleResult.interrupted ? { interrupted: true } : {}),
 				success: singleResult.exitCode === 0,
 				exitCode: singleResult.exitCode,
 				sessionFile: singleResult.sessionFile,
@@ -2511,6 +2521,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 
 			const stepEndTime = Date.now();
+			if (singleResult.interrupted) interrupted = true;
 			statusPayload.steps[flatIndex].status = singleResult.exitCode === 0 ? "complete" : "failed";
 			statusPayload.steps[flatIndex].endedAt = stepEndTime;
 			statusPayload.steps[flatIndex].durationMs = stepEndTime - stepStartTime;
@@ -2682,11 +2693,12 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			mode: resultMode,
 			success: !interrupted && results.every((r) => r.success),
 			state: interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed",
-			summary: interrupted ? "Paused after interrupt. Waiting for explicit next action." : summary,
+			summary: interrupted ? "Paused after interrupt. Waiting for explicit next action." + formatInterruptedCleanup(results) : summary,
 			results: results.map((r) => ({
 				agent: r.agent,
 				output: r.output,
 				error: r.error,
+				...(r.interrupted ? { interrupted: true } : {}),
 				success: r.success,
 				skipped: r.skipped || undefined,
 				sessionFile: r.sessionFile,

package/src/runs/foreground/chain-execution.ts

@@ -35,7 +35,7 @@ import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skill
 import type { ExtensionConfig } from "../../shared/types.ts";
 import { runSync } from "./execution.ts";
 import type { PiRuntimeIdentity } from "../shared/pi-spawn.ts";
-import { buildChainSummary, buildChainOutputsSection, buildChainStopSection, type ChainSummaryOptions } from "../../shared/formatters.ts";
+import { buildChainSummary, buildChainOutputsSection, buildChainStopSection, formatInterruptedCleanup, type ChainSummaryOptions } from "../../shared/formatters.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, resolveChildCwd } from "../../shared/utils.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
@@ -748,7 +748,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					const interrupted = interruptedIndexInStep >= 0 ? parallelResults[interruptedIndexInStep] : undefined;
 					if (interrupted) {
 						return {
-							content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` }],
+							content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` + formatInterruptedCleanup(results) }],
 							details: buildChainExecutionDetails(makeDetailsInput({
 								currentStepIndex: stepIndex,
 								currentFlatIndex: globalTaskIndex - step.parallel.length + interruptedIndexInStep,
@@ -957,7 +957,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				const interrupted = interruptedIndexInStep >= 0 ? parallelResults[interruptedIndexInStep] : undefined;
 				if (interrupted) {
 					return {
-						content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` }],
+						content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` + formatInterruptedCleanup(results) }],
 						details: buildChainExecutionDetails(makeDetailsInput({
 							currentStepIndex: stepIndex,
 							currentFlatIndex: globalTaskIndex - dynamicParallelStep.parallel.length + interruptedIndexInStep,
@@ -1228,7 +1228,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 				if (r.interrupted) {
 					return {
-						content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${r.agent}). Waiting for explicit next action.` }],
+						content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${r.agent}). Waiting for explicit next action.` + formatInterruptedCleanup(results) }],
 						details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex - 1 })),
 					};
 				}

package/src/runs/foreground/execution.ts

@@ -76,6 +76,8 @@ import {
 } from "./attempt-finalization.ts";
 import {
 	createExternalExecution,
+	externalExecutionDiagnosticCode,
+	isInterruptedExternalAttemptError,
 	type ExternalExecution,
 	type ExternalExecutionOptions,
 } from "../shared/external-execution.ts";
@@ -808,7 +810,16 @@ export async function runSync(
 				});
 			} catch (error) {
 				runtimeFailure = error instanceof PiRuntimeLaunchError;
-				result = failedResult(agentName, task, runtimeFailure ? (error as Error).message : safeExternalFailure("attempt"));
+				if (isInterruptedExternalAttemptError(error)) {
+					const code = externalExecutionDiagnosticCode(error);
+					result = {
+						...failedResult(agentName, task, `${error.message}${code ? ` (${code})` : ""}`),
+						exitCode: 0,
+						interrupted: true,
+					};
+				} else {
+					result = failedResult(agentName, task, runtimeFailure ? (error as Error).message : safeExternalFailure("attempt"));
+				}
 			}
 		} else {
 			try {
@@ -825,7 +836,7 @@ export async function runSync(
 		sumUsage(aggregateUsage, result.usage);
 		totalToolCount += result.progressSummary?.toolCount ?? 0;
 		totalDurationMs += result.progressSummary?.durationMs ?? 0;
-		const attemptSucceeded = result.exitCode === 0 && !result.error;
+		const attemptSucceeded = result.exitCode === 0 && (result.interrupted || !result.error);
 		const attempt: ModelAttempt = {
 			model: candidate ?? result.model ?? agent.model ?? "default",
 			success: attemptSucceeded,
@@ -834,7 +845,7 @@ export async function runSync(
 			usage: { ...result.usage },
 		};
 		modelAttempts.push(attempt);
-		if (attemptSucceeded) {
+		if (result.interrupted || attemptSucceeded) {
 			break;
 		}
 		if (runtimeFailure || blockedLine(result.error ?? "") || !isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {

package/src/runs/foreground/external-single-attempt.ts

@@ -133,9 +133,9 @@ export async function runExternalSingleAttempt(input: RunExternalSingleAttemptIn
 		result.exitCode = exitCodeOf(attemptResult.exit);
 
 		const observedMutationAttempt = toolMutationFromAssistantMessages(attemptResult.messages);
-		const interruptedByControl = attemptResult.outcome === "interrupted";
+		const interruptedByControl = attemptResult.interrupted;
 
-		return finalizeSingleAttempt(result, progress, {
+		const finalized = finalizeSingleAttempt(result, progress, {
 			agent,
 			options,
 			outputSnapshot: shared.outputSnapshot,
@@ -145,6 +145,8 @@ export async function runExternalSingleAttempt(input: RunExternalSingleAttemptIn
 			emitControlEvent,
 			startTime,
 		});
+		if (attemptResult.interrupted) finalized.error = attemptResult.error;
+		return finalized;
 	} finally {
 		cleanupTempDir(tempDir);
 	}

package/src/runs/foreground/subagent-executor.ts

@@ -15,6 +15,7 @@ import { handleManagementAction } from "../../agents/agent-management.ts";
 import { buildDoctorReport } from "../../extension/doctor.ts";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.ts";
 import { runSync } from "./execution.ts";
+import { formatInterruptedCleanup } from "../../shared/formatters.ts";
 import { recordSyncCost, renderGrandTotal, sumNestedCost } from "../../extension/grand-total.ts";
 import { resolveModelCandidate } from "../shared/model-fallback.ts";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
@@ -1843,7 +1844,7 @@ async function runParallelPath(data: ExecutionContextData, deps: CallExecutorDep
 		rememberForegroundRun(deps.state, { runtime: data.runtime, sessionRoot: data.sessionRoot, runId, mode: "parallel", cwd: effectiveCwd, results: details.results });
 		if (interrupted) {
 			return {
-				content: [{ type: "text", text: withWorktreeSuffix(`Parallel run paused after interrupt (${interrupted.agent}). Waiting for explicit next action.`) }],
+				content: [{ type: "text", text: withWorktreeSuffix(`Parallel run paused after interrupt (${interrupted.agent}). Waiting for explicit next action.`) + formatInterruptedCleanup(results) }],
 				details,
 			};
 		}
@@ -2124,7 +2125,7 @@ async function runSinglePath(data: ExecutionContextData, deps: CallExecutorDeps)
 
 	if (r.interrupted) {
 		return {
-			content: [{ type: "text", text: `Run paused after interrupt (${params.agent}). Waiting for explicit next action.` }],
+			content: [{ type: "text", text: `Run paused after interrupt (${params.agent}). Waiting for explicit next action.` + formatInterruptedCleanup([r]) }],
 			details,
 		};
 	}

package/src/runs/shared/external-execution.ts

@@ -79,6 +79,10 @@ export function externalExecutionDiagnosticCode(error: unknown): ExternalExecuti
 	return error instanceof ExternalExecutionDiagnosticError ? error.code : undefined;
 }
 
+export function isInterruptedExternalAttemptError(error: unknown): error is Error & { interrupted: true } {
+	return error instanceof Error && (error as Error & { interrupted?: boolean }).interrupted === true;
+}
+
 export type ExternalExecutionDisposition = "delivered" | "retained";
 export interface ExternalExecutionFinishResult {
 	readonly handle: ExecutionSurfaceHandle;
@@ -104,6 +108,7 @@ export interface ExternalExecutionDependencies {
 	readonly readSession?: (sessionFile: string) => Promise<string>;
 	readonly ensureSessionFile?: (sessionFile: string) => void;
 	readonly readyDeadline?: (ready: Promise<void>, timeoutMs: number, safeLabel: string) => Promise<void>;
+	readonly monotonicNow?: () => number;
 	readonly controlDeadline?: <T>(promise: Promise<T>, timeoutMs: number, label: string) => Promise<T>;
 }
 
@@ -168,9 +173,9 @@ function proveControl(replayed: ReplayedSession, action: "abort" | "shutdown"):
 	if (requested < 0 || applied <= requested) throw new Error(`durable ${action} control evidence is missing`);
 }
 
-function mapResult(request: ExternalAttemptRequest, replayed: ReplayedSession, exit: ChildHostExit): ExternalAttemptResult {
+function mapResult(request: ExternalAttemptRequest, replayed: ReplayedSession, exit: ChildHostExit, validateExit = true): ExternalAttemptResult {
 	if (!replayed.result) throw new ExternalExecutionDiagnosticError("result_missing");
-	if (replayed.result.outcome === "success" && (exit.status !== 0 || exit.signal !== null)) throw new Error("successful durable result conflicts with child exit");
+	if (validateExit && replayed.result.outcome === "success" && (exit.status !== 0 || exit.signal !== null)) throw new Error("successful durable result conflicts with child exit");
 	const messages = replayed.messages.filter((message): message is Message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
 	const aggregate = usageFrom(messages);
 	return {
@@ -240,6 +245,8 @@ export async function createExternalExecution(
 	const deadline = dependencies.readyDeadline ?? withReadyDeadline;
 	const controlTimeoutMs = options.controlTimeoutMs ?? 30_000;
 	const controlDeadline = dependencies.controlDeadline ?? withControlDeadline;
+	const now = dependencies.monotonicNow ?? (() => performance.now());
+	let interruptedFinish: ExternalExecutionFinishResult | undefined;
 	const ready = deadline(controller.ready, options.readyTimeoutMs ?? 30_000, controller.lease.handle.display.label);
 	void ready.catch(() => {});
 	const watchDependencies = defaultWatchDependencies();
@@ -260,11 +267,20 @@ export async function createExternalExecution(
 	const runAttempt = async (request: ExternalAttemptRequest): Promise<ExternalAttemptResult> => {
 		if (active) throw new Error("external execution owner is busy");
 		if (!request.attemptId || attemptedIds.has(request.attemptId)) throw new Error("external execution attemptId has already been used");
+		if (interruptedFinish) throw new Error("external execution owner has been interruption-cleaned");
 		active = true;
 		attemptedIds.add(request.attemptId);
 		let control: ExecutionControlChannel | undefined;
 		let watcher: SessionWatcher | undefined;
 		const abort = abortPromise([request.signal, request.interruptSignal]);
+		let interruptedAt: number | undefined;
+		let disposed = false;
+		const acceptInterruption = () => { interruptedAt ??= now(); };
+		const signals = [request.signal, request.interruptSignal];
+		for (const signal of signals) {
+			if (signal?.aborted) acceptInterruption();
+			else signal?.addEventListener("abort", acceptInterruption, { once: true });
+		}
 		try {
 			await ready;
 			ensureSessionFile(request.sessionFile);
@@ -273,39 +289,163 @@ export async function createExternalExecution(
 			watcher = createWatcher(request.sessionFile, identity, request.onNewSessionMessage);
 			const environment = { ...request.environment, [PI_COHORT_REPORT_CONFIG]: control.configPath };
 			const exitPromise = controller.startAttempt({ attemptId: request.attemptId, command: request.command, args: [...request.args], cwd: request.cwd, environment });
-			const first = await Promise.race([
+			let observedExit: ChildHostExit | undefined;
+			let hostExited = false;
+			void exitPromise.then(exit => { observedExit = exit; }, () => {});
+			void controller.hostExit.then(() => { hostExited = true; }, () => {});
+			const finalizeInterrupted = async (initial?: ReplayedSession, initialError?: unknown, shutdownRequest?: Promise<string>): Promise<ExternalAttemptResult> => {
+				acceptInterruption();
+				let endpoint = interruptedAt! + controlTimeoutMs;
+				let fallback = false;
+				let closed = false;
+				let closeAttempted = false;
+				let hostShutdownRequested = false;
+				const diagnostics: string[] = [];
+				const note = (error: unknown) => { diagnostics.push(error instanceof Error ? error.message : String(error)); };
+				const wait = <T>(promise: Promise<T>, label: string) => {
+					void promise.catch(() => {});
+					const remaining = Math.max(0, endpoint - now());
+					return remaining > 0 ? controlDeadline(promise, remaining, label) : Promise.reject(new Error(`${label} deadline exhausted`));
+				};
+				const forceCleanup = async () => {
+					if (closeAttempted) return;
+					closeAttempted = true;
+					endpoint = interruptedAt! + 2 * controlTimeoutMs;
+					try { await wait(options.backend.close(controller.lease.handle, "explicit_cleanup"), "explicit cleanup"); closed = true; } catch (error) { note(error); }
+				};
+				let replayed = initial;
+				let primary = initialError;
+				if (!initial) {
+					try { await wait(control!.request("abort"), "abort request"); } catch (error) { note(error); }
+					if (!initialError) {
+						try { replayed = await wait(watcher!.terminal, "post-abort terminal"); } catch (error) { primary = error; fallback = true; }
+					}
+				}
+				try { await wait(shutdownRequest ?? control!.request("shutdown"), "child shutdown"); } catch (error) { note(error); fallback = true; }
+				if (fallback) endpoint = interruptedAt! + 2 * controlTimeoutMs;
+				try {
+					replayed = replayExecutionSession(await wait(readSession(request.sessionFile), "final replay"), identity);
+					if (!replayed.result && !initialError) primary = new ExternalExecutionDiagnosticError("result_missing");
+				} catch (error) { primary ??= error; }
+				if (fallback) await forceCleanup();
+				try { await wait(exitPromise, "post-shutdown exit"); } catch (error) { note(error); fallback = true; }
+				if (observedExit) {
+					hostShutdownRequested = true;
+					try { await wait(controller.shutdown(), "host shutdown"); } catch (error) { note(error); fallback = true; }
+				}
+				if (fallback) await forceCleanup();
+				if (observedExit && !hostShutdownRequested) {
+					hostShutdownRequested = true;
+					try { await wait(controller.shutdown(), "host shutdown"); } catch (error) { note(error); }
+				}
+				if (!observedExit) {
+					// A failed observation is not exit evidence; keep resources until the remaining budget expires.
+					const remainingExit = exitPromise.catch(() => new Promise<ChildHostExit>(() => {}));
+					try { await wait(remainingExit, "child exit observation"); } catch (error) { note(error); }
+					if (observedExit) {
+						hostShutdownRequested = true;
+						try { await wait(controller.shutdown(), "host shutdown"); } catch (error) { note(error); }
+					}
+				}
+				// Socket delivery is not application; shutdown reports can arrive until process settlement.
+				if (observedExit && now() < endpoint) {
+					try { replayed = replayExecutionSession(await wait(readSession(request.sessionFile), "final replay"), identity); }
+					catch (error) { primary ??= error; }
+				}
+				if (!hostExited) {
+					try { await wait(controller.hostExit, "host exit observation"); } catch (error) { note(error); }
+				}
+				if (!primary) {
+					try {
+						if (!replayed?.result) throw new ExternalExecutionDiagnosticError("result_missing");
+						if (!initial) proveControl(replayed, "abort");
+						proveControl(replayed, "shutdown");
+					} catch (error) { primary = error; }
+				}
+				try { watcher!.close(); } catch (error) { note(error); }
+				finally {
+					try { controller.dispose(); } catch (error) { note(error); }
+					finally {
+						disposed = true;
+						try { await wait(control!.close(), "control disposal"); } catch (error) { note(error); }
+						finally {
+							try { await wait(releaseObserver(), "observer release"); } catch (error) { note(error); }
+						}
+					}
+				}
+				interruptedFinish = { handle: controller.lease.handle, retained: !closed };
+				if (!observedExit || !hostExited || (fallback && !closed)) diagnostics.push("Process termination could not be confirmed; manual cleanup may be required.");
+				if (primary) {
+					const error = primary instanceof Error ? primary : new Error(String(primary));
+					Object.assign(error, { interrupted: true });
+					if (diagnostics.length) error.message += `; ${diagnostics.join("; ")}`;
+					throw error;
+				}
+				const result = mapResult(request, replayed!, observedExit ?? { status: null, signal: null }, false);
+				return { ...result, interrupted: true, ...(diagnostics.length ? { error: [result.error, ...diagnostics].filter(Boolean).join("; ") } : {}) };
+			};
+			let first;
+			try { first = await Promise.race([
 				watcher.terminal.then(replayed => ({ kind: "result" as const, replayed })),
 				exitPromise.then(exit => ({ kind: "exit" as const, exit })),
 				abort.promise.then(() => ({ kind: "abort" as const })),
+			]); } catch (error) {
+				if (interruptedAt !== undefined) return await finalizeInterrupted(undefined, error);
+				throw error;
+			}
+			if (first.kind === "abort") return await finalizeInterrupted();
+			if (first.kind === "result" && (interruptedAt !== undefined || first.replayed.result?.outcome === "interrupted")) return await finalizeInterrupted(first.replayed);
+			const finalReplay = () => Promise.race([
+				readSession(request.sessionFile).then(content => replayExecutionSession(content, identity)),
+				abort.promise.then(() => undefined),
 			]);
 			let replayed: ReplayedSession;
 			let exit: ChildHostExit;
-			if (first.kind === "abort") {
-				await control.request("abort");
-				replayed = await controlDeadline(watcher.terminal, controlTimeoutMs, "post-abort terminal");
-				if (replayed.result.outcome !== "interrupted") throw new Error("abort did not produce an interrupted durable result");
-				await control.request("shutdown");
-				exit = await controlDeadline(exitPromise, controlTimeoutMs, "post-shutdown exit");
-				replayed = replayExecutionSession(await readSession(request.sessionFile), identity);
-				proveControl(replayed, "abort");
-				proveControl(replayed, "shutdown");
-			} else if (first.kind === "result") {
+			if (first.kind === "result") {
 				replayed = first.replayed;
-				await control.request("shutdown");
-				exit = await controlDeadline(exitPromise, controlTimeoutMs, "post-shutdown exit");
-				replayed = replayExecutionSession(await readSession(request.sessionFile), identity);
+				const shutdownRequest = control.request("shutdown");
+				try {
+					const shutdown = await Promise.race([shutdownRequest.then(() => "shutdown" as const), abort.promise.then(() => "abort" as const)]);
+					if (shutdown === "abort") return await finalizeInterrupted(replayed, undefined, shutdownRequest);
+					const stopped = await Promise.race([
+						controlDeadline(exitPromise, controlTimeoutMs, "post-shutdown exit").then(exit => ({ exit })),
+						abort.promise.then(() => ({ exit: undefined })),
+					]);
+					if (!stopped.exit || interruptedAt !== undefined) return await finalizeInterrupted(replayed, undefined, shutdownRequest);
+					exit = stopped.exit;
+				} catch (error) {
+					if (interruptedAt !== undefined && !disposed) return await finalizeInterrupted(replayed, error, shutdownRequest);
+					throw error;
+				}
+				let final: ReplayedSession | undefined;
+				try { final = await finalReplay(); } catch (error) {
+					if (interruptedAt !== undefined) return await finalizeInterrupted(replayed, error, shutdownRequest);
+					throw error;
+				}
+				if (!final || interruptedAt !== undefined) return await finalizeInterrupted(replayed, undefined, shutdownRequest);
+				replayed = final;
 				proveControl(replayed, "shutdown");
 			} else {
 				exit = first.exit;
-				replayed = replayExecutionSession(await readSession(request.sessionFile), identity);
-				if (!replayed.result) throw new ExternalExecutionDiagnosticError("result_missing");
+				let final: ReplayedSession | undefined;
+				try {
+					final = await finalReplay();
+					if (final && !final.result) throw new ExternalExecutionDiagnosticError("result_missing");
+				} catch (error) {
+					if (interruptedAt !== undefined) return await finalizeInterrupted(undefined, error);
+					throw error;
+				}
+				if (!final) return await finalizeInterrupted();
+				replayed = final;
+				if (interruptedAt !== undefined || replayed.result!.outcome === "interrupted") return await finalizeInterrupted(replayed);
 			}
 			return mapResult(request, replayed, exit);
 		} finally {
 			abort.close();
-			watcher?.close();
-			await control?.close();
-			active = false;
+			for (const signal of signals) signal?.removeEventListener("abort", acceptInterruption);
+			try {
+				if (!disposed) { watcher?.close(); await control?.close(); }
+			} finally { active = false; }
 		}
 	};
 
@@ -317,13 +457,17 @@ export async function createExternalExecution(
 			if (finishDisposition && finishDisposition !== disposition) {
 				return Promise.reject(new Error(`external execution owner is already finishing as ${finishDisposition}`));
 			}
+			if (interruptedFinish && disposition === "delivered") {
+				return Promise.reject(new Error("interruption-cleaned external execution owner accepts only retained finish"));
+			}
 			finishDisposition = disposition;
 			return (finishPromise ??= (async () => {
 				if (active) throw new Error("external execution owner is busy");
+				if (interruptedFinish) return interruptedFinish;
 				if (disposition === "retained") {
 					await finishWithCleanup(
 						async () => { await controller.shutdown(); },
-						releaseObserver,
+						async () => { try { await releaseObserver(); } finally { controller.dispose(); } },
 					);
 					return { handle: controller.lease.handle, retained: true };
 				}
@@ -332,7 +476,7 @@ export async function createExternalExecution(
 						await controller.shutdown();
 						await options.backend.close(controller.lease.handle, "delivered");
 					},
-					releaseObserver,
+					async () => { try { await releaseObserver(); } finally { controller.dispose(); } },
 				);
 				return { handle: controller.lease.handle, retained: false };
 			})().catch(error => {

package/src/shared/formatters.ts

@@ -53,6 +53,13 @@ export function formatDuration(ms: number): string {
 	return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
 }
 
+export function formatInterruptedCleanup(results: readonly Pick<SingleResult, "agent" | "interrupted" | "error">[]): string {
+	const lines = results.flatMap((result, index) => result.interrupted && result.error
+		? [`Child ${index + 1} (${result.agent}): ${result.error}`]
+		: []);
+	return lines.length ? `\n\n${lines.join("\n")}` : "";
+}
+
 export interface ChainSummaryOptions {
 	stop?: StopRecord;
 	outputs?: ChainTaskOutputEntry[];