@iowarp/clio-coder 0.4.8 → 0.4.9

package/src/core/tool-names.ts

@@ -2,15 +2,19 @@
  * Canonical tool names. Everything that dispatches a tool call references these constants
  * so mode matrices, safety classifiers, and audit filters never diverge on spelling.
  *
- * The surface is organized in seven planes; each plane is one policy unit
+ * The surface is organized in eight planes; each plane is one policy unit
  * (action class, size posture, details schema, concurrency rule):
- *   OBSERVE      evidence, read, grep, find, ls, code_nav, context, credential_present
+ *   OBSERVE      evidence, read, grep, find, ls, code_nav, context, credential_present, clio_docs, clio_library, data
  *   MUTATE       write, edit
- *   EXECUTE      bash, git, verify
+ *   EXECUTE      bash, git, verify, run_script
  *   ORCHESTRATE  dispatch, monitor, steer, tasks, ledger, panes, limitation, decide
- *   RETRIEVE     web_fetch
+ *   RETRIEVE     web_read, web_fetch
  *   INTERACT     ask_user
  *   ARTIFACT     artifact
+ *   GATEWAY      gateway
+ *
+ * Placement (which names carry an attached schema and which are reached
+ * through the gateway) is a separate axis, declared in src/tools/surface.ts.
  */
 
 export const ToolNames = {
@@ -23,6 +27,9 @@ export const ToolNames = {
 	CodeNav: "code_nav",
 	Context: "context",
 	CredentialPresent: "credential_present",
+	ClioDocs: "clio_docs",
+	ClioLibrary: "clio_library",
+	Data: "data",
 	// MUTATE
 	Write: "write",
 	Edit: "edit",
@@ -30,6 +37,7 @@ export const ToolNames = {
 	Bash: "bash",
 	Git: "git",
 	Verify: "verify",
+	RunScript: "run_script",
 	// ORCHESTRATE
 	Dispatch: "dispatch",
 	Monitor: "monitor",
@@ -40,19 +48,16 @@ export const ToolNames = {
 	Limitation: "limitation",
 	Decide: "decide",
 	// RETRIEVE
+	WebRead: "web_read",
 	WebFetch: "web_fetch",
 	// INTERACT
 	AskUser: "ask_user",
 	// ARTIFACT
 	Artifact: "artifact",
-	// DESIGN-RESERVED, not implemented: gateway, the MCP/DB proxy. One fixed
-	// schema; external capabilities are surfaced through find/describe/call
-	// RESULTS, never as per-capability schemas in the prompt prefix. Contract
-	// sketch: gateway(op: "find" | "describe" | "call", capability?, args?)
-	// -> JSON capability listings / schemas / call results, network action
-	// class, sequential. Reserving the name here keeps classifiers and
-	// profiles from ever assigning "gateway" to a dynamic tool.
-	// Gateway: "gateway",
+	// GATEWAY: one fixed schema; secondary capabilities are surfaced through
+	// find/describe/call RESULTS, never as per-capability schemas in the
+	// prompt prefix.
+	Gateway: "gateway",
 } as const;
 
 export type BuiltinToolName = (typeof ToolNames)[keyof typeof ToolNames];
@@ -72,3 +77,19 @@ export function isBuiltinToolName(name: ToolName): name is BuiltinToolName {
 export function isHarnessExtensionToolName(name: string): name is DynamicToolName {
 	return name.length <= 64 && /^extension_[a-z0-9][a-z0-9_-]*__[a-z][a-z0-9_]*$/.test(name);
 }
+
+/**
+ * Reserved MCP capability namespace: `mcp_<serverId>__<tool>`. The server id
+ * follows the mcp.yaml id charset; the tool segment keeps the server's own
+ * spelling (letters, digits, `_`, `-`, `.`). Syntax conveys origin, never trust
+ * or availability: the gateway launches only trusted servers.
+ */
+export function isMcpToolName(name: string): name is DynamicToolName {
+	return name.length <= 96 && /^mcp_[a-z0-9][a-z0-9_-]*__[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(name);
+}
+
+/** Compose the registry name of one MCP server tool; null when the tool's name cannot be carried. */
+export function mcpToolName(serverId: string, tool: string): DynamicToolName | null {
+	const composed = `mcp_${serverId}__${tool}`;
+	return isMcpToolName(composed) ? composed : null;
+}

package/src/domains/context/clio-md.ts

@@ -130,7 +130,7 @@ function normalizeNestedMarkdown(value: string): string {
 	let cursor = 0;
 	for (const match of mask.matchAll(/^(#{1,2})(\s+)/gm)) {
 		if (match.index === undefined) continue;
-		out += body.slice(cursor, match.index) + "###" + (match[2] ?? "");
+		out += `${body.slice(cursor, match.index)}###${match[2] ?? ""}`;
 		cursor = match.index + match[0].length;
 	}
 	return out + body.slice(cursor);

package/src/domains/context/worker/pressure.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "../../../engine/types.js";
+import { effectiveToolCall } from "../../../tools/surface.js";
 import { estimateAgentContextBreakdown, estimateAgentMessageTokens } from "../../session/context-accounting.js";
 import { contextHash, messageToolCalls } from "./snapshot.js";
 
@@ -93,9 +94,12 @@ export function createWorkerContextGuard(archive: (ref: string, message: AgentMe
 				const projected = { ...message, content };
 				replace(index, message, projected);
 			} else if (message.role === "toolResult" && !message.isError) {
-				const name = toolCalls.get(message.toolCallId)?.name;
+				const call = toolCalls.get(message.toolCallId);
+				// A gateway call carries its capability's read semantics: a page
+				// fetched through the gateway is as evictable as a direct fetch.
+				const name = call ? effectiveToolCall(call.name, call.arguments).toolName : undefined;
 				// Only observations with known read semantics. Preserve mutations and opaque tools.
-				if (!name || !["read", "grep", "find", "ls", "code_nav", "web_fetch"].includes(name)) continue;
+				if (!name || !["read", "grep", "find", "ls", "code_nav", "web_read", "web_fetch"].includes(name)) continue;
 				if (JSON.stringify(message.content).length < 1000) continue;
 				const ref = key(message);
 				const file = archive(ref, structuredClone(message));

package/src/domains/context/working-set/path-index.ts

@@ -25,6 +25,7 @@
  */
 
 import { basename, isAbsolute, join, normalize, resolve } from "node:path";
+import { effectiveToolCall } from "../../../tools/surface.js";
 import type { MessageEntry, SessionEntry } from "../../session/entries.js";
 import type { WorkingSetRef } from "./contract.js";
 import { isTurnStart } from "./horizon.js";
@@ -175,8 +176,12 @@ interface ToolCallFacts {
 	argsKey: string;
 }
 
-function callFacts(toolName: string, args: unknown): ToolCallFacts {
-	return { toolName, args, argsKey: args === undefined ? "" : stableStringify(args) };
+function callFacts(recordedTool: string, recordedArgs: unknown): ToolCallFacts {
+	// A gateway call indexes as the capability it reached (git reads the cwd,
+	// artifact writes its path), never as an opaque `gateway` observation.
+	const effective = effectiveToolCall(recordedTool, recordedArgs);
+	const args = effective.viaGateway ? effective.args : recordedArgs;
+	return { toolName: effective.toolName, args, argsKey: args === undefined ? "" : stableStringify(args) };
 }
 
 function stringField(record: Record<string, unknown> | null, ...keys: string[]): string | null {

package/src/domains/dispatch/code-step.ts

@@ -53,6 +53,8 @@ export interface CodeStepRunInput {
 	workspaceRoot: string;
 	/** Absolute directory the command log is written to; omitted means no artifact. */
 	artifactDir?: string;
+	/** Shared stdout/stderr capture ceiling; defaults to CODE_STEP_CAPTURE_MAX_BYTES. */
+	maxOutputBytes?: number;
 	/** Full process environment the allowlist is drawn from. Defaults to the orchestrator's. */
 	env?: NodeJS.ProcessEnv;
 	/**
@@ -221,6 +223,9 @@ interface SpawnOutcome {
 
 async function spawnCommand(input: CodeStepRunInput, cwd: string, argv: ReadonlyArray<string>): Promise<SpawnOutcome> {
 	const command = input.command;
+	const captureMaxBytes = input.maxOutputBytes ?? CODE_STEP_CAPTURE_MAX_BYTES;
+	if (!Number.isSafeInteger(captureMaxBytes) || captureMaxBytes <= 0)
+		throw new Error("code step: maxOutputBytes must be a positive safe integer");
 	const [executable, ...args] = argv;
 	if (executable === undefined) throw new Error(`code step: command '${command.id}' has no executable`);
 	return await new Promise<SpawnOutcome>((resolvePromise) => {
@@ -247,8 +252,8 @@ async function spawnCommand(input: CodeStepRunInput, cwd: string, argv: Readonly
 		});
 		const collect = (chunk: Buffer, stdout: boolean): void => {
 			outputBytes += chunk.length;
-			if (captured >= CODE_STEP_CAPTURE_MAX_BYTES) return;
-			const room = CODE_STEP_CAPTURE_MAX_BYTES - captured;
+			if (captured >= captureMaxBytes) return;
+			const room = captureMaxBytes - captured;
 			const slice = chunk.length <= room ? chunk : chunk.subarray(0, room);
 			chunks.push(slice);
 			if (stdout) stdoutChunks.push(slice);

package/src/domains/dispatch/contract.ts

@@ -348,6 +348,13 @@ export interface DispatchContract {
 	 */
 	abort(runId: string, reason?: AbortReason): void;
 
+	/**
+	 * Wait for one member's attempts, queued retries and retry admissions to
+	 * settle. Does not cancel work; fleet owners call synchronous abort first
+	 * when stopping. Other members and the global drain lifecycle are untouched.
+	 */
+	drainMember?(runId: string): Promise<void>;
+
 	/**
 	 * Queue operator guidance on a running HTTP or SDK worker. A logical
 	 * assignment id addresses its current attempt. The text is sent as a JSON

package/src/domains/dispatch/execution-role.ts

@@ -51,7 +51,7 @@ export type GateTopologyRole = "builder" | "reviewer" | "candidate" | "judge" |
 
 /**
  * Facts the role is derived from. `capabilityClass` and `resultContractKind`
- * both come from the strict Slice 2 recipe schema, so a role can never be read
+ * both come from the strict recipe schema, so a role can never be read
  * off free-form prose or a display-only field.
  */
 export interface ExecutionRoleInput {
@@ -79,7 +79,7 @@ export interface ExecutionRoleInput {
  *   3. Outside a gate, the recipe's own typed contract decides. A declared
  *      `verifier-report` is the only contract that makes a direct run a
  *      verifier; a Debugger's `debugger-report` deliberately does not, because
- *      Slice 2 forbids it from masquerading as a gate verdict.
+ *      the result schema distinguishes diagnosis from a gate verdict.
  *   4. A read-only recipe with no verifier contract is reconnaissance.
  */
 export function deriveExecutionRole(input: ExecutionRoleInput): ExecutionRole {
@@ -151,7 +151,7 @@ export function withAttemptRole(requestRole: ExecutionRole, attempt: number): Ex
  * Defaulting a reviewer or judge to the builder agent makes the gate a
  * self-review: the same recipe, the same prompt surface, and usually the same
  * model family grading its own output. That verdict is correlated by
- * construction and Slice 1 already refuses to treat it as a quality label, so
+ * construction and cannot count as an independent quality label, so
  * the default has to be an agent whose entire contract is independent typed
  * validation.
  */

package/src/domains/dispatch/execution-scheduler.ts

@@ -141,6 +141,8 @@ export interface ExecutionSchedulerAdapter {
 	 */
 	verifyWriteBoundary?(window: string, stepIds: ReadonlyArray<string>): Promise<ExecutionWriteBoundaryOutcome>;
 	cancel(assignmentId: string): void;
+	/** Wait for owned continuations, including retry admission, before release. */
+	drainMember?(assignmentId: string): Promise<void>;
 	release(ownerId: string): void;
 	releaseUnconsumed(ownerId: string): void;
 	/** Persist a settled result after boundary enforcement and before a dependent starts. */
@@ -230,7 +232,6 @@ export async function executePlan(
 	// A plan with a single agent step has no peers, so it gets no board.
 	const ledgerId = agentSteps.length >= 2 ? `ledger-plan-${plan.hash.slice(0, 12)}-${Date.now().toString(36)}` : null;
 	const ledger = ledgerId === null ? undefined : { id: ledgerId, sequence: 0 };
-	if (ledgerId !== null) await openAgentLedger(ledgerId);
 	const admissions = agentSteps.map((step) => adapter.preflight(step));
 	const reservation = adapter.reserve(plan, admissions);
 	const reservationOwners = new Set([reservation.ownerId]);
@@ -239,7 +240,10 @@ export async function executePlan(
 	const skipped = new Set<string>();
 	const unneeded = new Set<string>();
 	const needsDecision: string[] = [];
-	const running = new Map<string, { assignmentId: string | null }>();
+	const running = new Map<string, { assignmentId: string | null; canceled: boolean }>();
+	const cleanupErrors: unknown[] = [];
+	const memberIds = new Set<string>();
+	const canceledSteps = new Set<string>();
 	/** Per-check verdict, so a loop's resolution is recomputed from live results. */
 	const checkPassed = new Map<string, boolean>();
 	/** Findings a failed agent verification threaded to its repair attempt. */
@@ -258,11 +262,19 @@ export async function executePlan(
 	// aborted through this signal, which the runner turns into a process-group
 	// kill on the whole command tree.
 	const codeAbort = new AbortController();
+	const cancelOne = (owned: { assignmentId: string | null; canceled: boolean }): void => {
+		if (owned.assignmentId === null || owned.canceled) return;
+		owned.canceled = true;
+		try {
+			adapter.cancel(owned.assignmentId);
+		} catch (error) {
+			cleanupErrors.push(error);
+		}
+	};
 	const cancelOwned = (): void => {
 		stopped = true;
-		for (const owned of running.values()) if (owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
 		codeAbort.abort();
-		for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
+		for (const owned of running.values()) cancelOne(owned);
 	};
 	signal?.addEventListener("abort", cancelOwned, { once: true });
 
@@ -277,42 +289,44 @@ export async function executePlan(
 		results.set(step.id, result);
 		if (isWorkspaceMutator(step)) lastMutationSeq = sequence;
 	};
-	for (const step of plan.steps) {
-		const result = replayed.get(step.id);
-		if (result === undefined) continue;
-		if (!result.succeeded || !result.integrityValid) {
-			throw new Error(`execution plan: replayed step '${step.id}' is not a completed successful step`);
-		}
-		recordCompletion(step, result);
-		if (step.loop?.role === "check" && step.kind === "code") {
-			checkPassed.set(step.id, result.succeeded);
-			attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
-		}
-		if (step.loop?.role === "check" && step.kind === "agent") {
-			const loop = loopsById.get(step.loop.loopId);
-			const decide = adapter.decideLoop;
-			if (loop === undefined || decide === undefined) {
-				throw new Error(`execution plan: replayed loop check '${step.id}' has no decider`);
+	const replayPrefix = async (): Promise<void> => {
+		for (const step of plan.steps) {
+			const result = replayed.get(step.id);
+			if (result === undefined) continue;
+			if (!result.succeeded || !result.integrityValid) {
+				throw new Error(`execution plan: replayed step '${step.id}' is not a completed successful step`);
 			}
-			const decision = await decide({
-				loop,
-				step,
-				attempt: step.loop.attempt,
-				terminalAttempt: step.loop.attempt >= loop.maxAttempts,
-				result,
-				priorResults: results,
-			});
-			checkPassed.set(step.id, decision.resolved);
-			attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
-			if (decision.findings !== null) loopFindings.set(`${loop.id}:${step.loop.attempt}`, decision.findings);
-			if (decision.needsDecision !== undefined && decision.needsDecision !== null) {
-				needsDecision.push(decision.needsDecision);
+			recordCompletion(step, result);
+			if (step.loop?.role === "check" && step.kind === "code") {
+				checkPassed.set(step.id, result.succeeded);
+				attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+			}
+			if (step.loop?.role === "check" && step.kind === "agent") {
+				const loop = loopsById.get(step.loop.loopId);
+				const decide = adapter.decideLoop;
+				if (loop === undefined || decide === undefined) {
+					throw new Error(`execution plan: replayed loop check '${step.id}' has no decider`);
+				}
+				const decision = await decide({
+					loop,
+					step,
+					attempt: step.loop.attempt,
+					terminalAttempt: step.loop.attempt >= loop.maxAttempts,
+					result,
+					priorResults: results,
+				});
+				checkPassed.set(step.id, decision.resolved);
+				attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+				if (decision.findings !== null) loopFindings.set(`${loop.id}:${step.loop.attempt}`, decision.findings);
+				if (decision.needsDecision !== undefined && decision.needsDecision !== null) {
+					needsDecision.push(decision.needsDecision);
+				}
+			}
+			if (step.loop?.role === "repair") {
+				repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
 			}
 		}
-		if (step.loop?.role === "repair") {
-			repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
-		}
-	}
+	};
 
 	/**
 	 * A failed predecessor normally disqualifies its dependents. Two deliberate
@@ -422,7 +436,10 @@ export async function executePlan(
 	): Promise<ExecutionStepResult> => {
 		const runCode = adapter.runCode;
 		if (runCode === undefined) throw new Error(`execution plan: no runner for code step '${step.id}'`);
-		return await runCode(step, handoffs, codeAbort.signal, results);
+		const result = await runCode(step, handoffs, codeAbort.signal, results);
+		if (!codeAbort.signal.aborted) return result;
+		canceledSteps.add(step.id);
+		return { ...result, succeeded: false, failureReason: result.failureReason ?? "execution plan canceled this step" };
 	};
 
 	/**
@@ -447,6 +464,7 @@ export async function executePlan(
 		}
 		let halt = false;
 		for (const id of [...candidates].sort()) {
+			if (stopped || signal?.aborted) return true;
 			const step = stepsById.get(id);
 			if (step?.kind !== "code") continue;
 			const spent = revalidations.get(id) ?? 0;
@@ -474,7 +492,7 @@ export async function executePlan(
 				if (plan.onFailure === "stop") {
 					stopped = true;
 					codeAbort.abort();
-					for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
+
 					halt = true;
 				}
 			}
@@ -544,7 +562,12 @@ export async function executePlan(
 			return { loopId: loop.id, resolved: false, attempts, repairs, reason };
 		});
 
+	let outcome: ExecutionPlanResult | undefined;
+	let primaryError: unknown;
+	let failed = false;
 	try {
+		if (ledgerId !== null) await openAgentLedger(ledgerId);
+		await replayPrefix();
 		let waveIndex = 0;
 		while (waveIndex < plan.waves.length) {
 			const wave = plan.waves[waveIndex];
@@ -588,56 +611,119 @@ export async function executePlan(
 					boundaryWindow,
 					group.map((entry) => entry.step),
 				);
-				const started = await Promise.all(
-					launch.map(async ({ step, handoffs }) => ({
-						step,
-						handle: await adapter.run(
-							step,
-							handoffs,
-							{ ownerId: reservationByStep.get(step.id) ?? reservation.ownerId, memberId: step.id },
-							ledger,
-						),
-					})),
-				);
-				for (const { step, handle } of started) running.set(step.id, { assignmentId: handle.assignmentId });
+				const failures: unknown[] = [];
+				const fail = (error: unknown): void => {
+					failures.push(error);
+					cancelOwned();
+				};
 				const onSettled = (step: ExecutionPlanStep, result: ExecutionStepResult): void => {
-					if (isPlanFailure(step, result) && plan.onFailure === "stop") {
-						stopped = true;
-						for (const [runningStepId, owned] of running) {
-							if (runningStepId !== step.id && owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
-						}
-						codeAbort.abort();
-						for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
-					}
+					if (isPlanFailure(step, result) && plan.onFailure === "stop") cancelOwned();
 				};
-				const ran = await Promise.all([
-					...started.map(async ({ step, handle }) => {
-						const result = await handle.result;
-						onSettled(step, result);
-						return { step: step as ExecutionPlanStep, result };
-					}),
-					...codeWork.map(async ({ step, handoffs }) => {
-						const result = await runCodeStepNode(step, handoffs);
-						onSettled(step, result);
-						return { step: step as ExecutionPlanStep, result };
+				const terminals: Array<Promise<PromiseSettledResult<{ step: ExecutionPlanStep; result: ExecutionStepResult }>[]>> =
+					[];
+				// Own each launch independently and observe its terminal promise as
+				// soon as it arrives, even while a sibling is still starting.
+				await Promise.allSettled(
+					launch.map(async ({ step, handoffs }) => {
+						if (stopped || signal?.aborted) return;
+						const owned = { assignmentId: null as string | null, canceled: false };
+						running.set(step.id, owned);
+						try {
+							const handle = await adapter.run(
+								step,
+								handoffs,
+								{ ownerId: reservationByStep.get(step.id) ?? reservation.ownerId, memberId: step.id },
+								ledger,
+							);
+							owned.assignmentId = handle.assignmentId;
+							memberIds.add(handle.assignmentId);
+							const terminal = handle.result.then(
+								(result) => {
+									// Preserve receipt references and output; this overlay records
+									// scheduler cancellation, not a fabricated worker receipt.
+									if (owned.canceled) canceledSteps.add(step.id);
+									const settled = owned.canceled
+										? { ...result, succeeded: false, failureReason: result.failureReason ?? "execution plan canceled this step" }
+										: result;
+									onSettled(step, settled);
+									if (settled.succeeded) running.delete(step.id);
+									return { step: step as ExecutionPlanStep, result: settled };
+								},
+								(error: unknown) => {
+									fail(error);
+									throw error;
+								},
+							);
+							terminals.push(Promise.allSettled([terminal]));
+							if (stopped || signal?.aborted) cancelOne(owned);
+						} catch (error) {
+							running.delete(step.id);
+							fail(error);
+						}
+						return;
 					}),
-				]);
+				);
+				// Code work retains the startup barrier and shares cancellation with
+				// agents, but has no assignment handle to release.
+				const codeTerminals =
+					stopped || signal?.aborted
+						? []
+						: codeWork.map(async ({ step, handoffs }) => {
+								try {
+									const result = await runCodeStepNode(step, handoffs);
+									onSettled(step, result);
+									return { step: step as ExecutionPlanStep, result };
+								} catch (error) {
+									fail(error);
+									throw error;
+								}
+							});
+				const outcomes = (await Promise.all([...terminals, Promise.allSettled(codeTerminals)])).flat();
+				for (const id of memberIds) {
+					try {
+						await adapter.drainMember?.(id);
+						memberIds.delete(id);
+					} catch (error) {
+						fail(error);
+					}
+				}
+				const ran = outcomes.flatMap((outcome) => (outcome.status === "fulfilled" ? [outcome.value] : []));
+				const settlementOrder = [...launch, ...codeWork].map(({ step }) => step.id);
+				ran.sort((a, b) => settlementOrder.indexOf(a.step.id) - settlementOrder.indexOf(b.step.id));
+
 				// The boundary is settled before anything is recorded or handed on, so
 				// a rolled-back step never appears upstream of the work it would have
 				// contaminated.
-				const settled = await closeBoundary(boundaryWindow, enforced, ran);
+				let settled: typeof ran;
+				try {
+					settled = await closeBoundary(boundaryWindow, enforced, ran);
+				} catch (error) {
+					if (failures.length === 0) throw error;
+					throw new AggregateError([...failures, error], "execution plan failure and boundary verification failed", {
+						cause: failures[0],
+					});
+				}
 				for (const { step, result } of settled) {
-					running.set(step.id, { assignmentId: result.assignmentId });
 					recordCompletion(step, result);
-					await adapter.onStepSettled?.(step, result);
+					try {
+						await adapter.onStepSettled?.(step, result);
+					} catch (error) {
+						failures.push(error);
+						cancelOwned();
+					}
 					if (step.loop?.role === "repair") {
 						repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
 					}
 					running.delete(step.id);
 				}
+				if (failures.length === 1) throw failures[0];
+				if (failures.length > 1)
+					throw new AggregateError(failures, "execution plan launch or result failed", { cause: failures[0] });
 				// Loop continuation is decided after the wave settles, so a gate's
 				// verdict is read from a sealed result rather than from a live stream.
-				for (const { step, result } of settled) await settleCheck(step, result);
+				for (const { step, result } of settled) {
+					if (!signal?.aborted && !canceledSteps.has(step.id)) await settleCheck(step, result);
+				}
 				// A loop that spent its last attempt without converging ends the run
 				// under a stop policy, whether the verdict came from an exit code or
 				// from a gate that answered "no" perfectly well.
@@ -647,7 +733,6 @@ export async function executePlan(
 				});
 				if ((exhausted || settled.some(({ step, result }) => isPlanFailure(step, result))) && plan.onFailure === "stop") {
 					stopped = true;
-					for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
 				}
 			}
 			if (!stopped && adapter.spliceAfter !== undefined) {
@@ -682,7 +767,7 @@ export async function executePlan(
 			}
 			waveIndex += 1;
 		}
-		return {
+		outcome = {
 			planHash: plan.hash,
 			results,
 			skipped: [...skipped],
@@ -693,11 +778,51 @@ export async function executePlan(
 			writeBoundaries: [...writeBoundaries],
 		};
 	} catch (error) {
+		failed = true;
+		primaryError = error;
 		cancelOwned();
-		throw error;
 	} finally {
 		signal?.removeEventListener("abort", cancelOwned);
-		for (const ownerId of reservationOwners) adapter.release(ownerId);
-		if (ledgerId !== null) await closeAgentLedger(ledgerId);
+		for (const id of memberIds) {
+			try {
+				await adapter.drainMember?.(id);
+			} catch (error) {
+				cleanupErrors.push(error);
+			}
+		}
+
+		// Every started launch and terminal is settled before capacity or the
+		// shared ledger is released, including late handles after cancellation.
+		for (const ownerId of reservationOwners) {
+			if (stopped || signal?.aborted) {
+				try {
+					adapter.releaseUnconsumed(ownerId);
+				} catch (error) {
+					cleanupErrors.push(error);
+				}
+			}
+			try {
+				adapter.release(ownerId);
+			} catch (error) {
+				cleanupErrors.push(error);
+			}
+		}
+		if (ledgerId !== null) {
+			try {
+				await closeAgentLedger(ledgerId);
+			} catch (error) {
+				cleanupErrors.push(error);
+			}
+		}
+	}
+	if (cleanupErrors.length > 0) {
+		throw new AggregateError(
+			failed ? [primaryError, ...cleanupErrors] : cleanupErrors,
+			"execution plan cleanup failed",
+			failed ? { cause: primaryError } : undefined,
+		);
 	}
+	if (failed) throw primaryError;
+	if (outcome === undefined) throw new Error("execution plan did not produce an outcome");
+	return outcome;
 }