@iowarp/clio-coder 0.4.8 → 0.4.9

package/src/domains/dispatch/extension.ts

@@ -46,6 +46,7 @@ import { WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH } from "../../engine/worker-runti
 import { toolPromptHintsForNames } from "../../tools/builtin-tool-catalog.js";
 import { networkToolsDisabled } from "../../tools/network-policy.js";
 import { applyToolProfile, assertToolProfileEnforceable, type ToolProfileName } from "../../tools/profiles.js";
+import { withGatewayForCapabilities } from "../../tools/surface.js";
 import {
 	applyTaskWorktree,
 	cleanupTaskWorktree,
@@ -1692,12 +1693,19 @@ function effectiveToolNames(
 		(tool): tool is ToolName =>
 			(isBuiltinToolName(tool) || harnessTools.has(tool)) &&
 			tool !== ToolNames.AskUser &&
-			!(networkStripped && tool === ToolNames.WebFetch) &&
+			!(networkStripped && (tool === ToolNames.WebFetch || tool === ToolNames.WebRead)) &&
 			!denied.has(tool) &&
 			!(writeConfined && WRITE_ROOT_REFUSED_TOOLS.has(tool)) &&
 			(target.runtime.id !== "claude-sdk" || isClaudeCanonicalTool(tool)),
 	);
-	return [...new Set(names)].sort();
+	// A native worker reaches a gateway-placed capability (git, web_fetch, an
+	// extension command) through the attached `gateway` tool, so the admitted
+	// list gains `gateway` whenever it names one. The worker's own narrowing
+	// (tools/agent-tools.ts effectiveToolNames) applies the same rule, which is
+	// what keeps the approved tool signature equal to the attested one.
+	const mediated = target.runtime.kind === "http" && target.runtime.id !== "claude-sdk";
+	const surface = mediated ? withGatewayForCapabilities(names) : [...new Set(names)];
+	return surface.sort();
 }
 
 /**
@@ -1716,13 +1724,23 @@ function assertPostRuntimeToolCompatibility(
 	spec: ReturnType<typeof normalizeAgentSpec>,
 	effectiveTools: ReadonlyArray<ToolName>,
 	target: ResolvedTarget,
+	writeConfined: boolean,
 ): void {
 	const compatibility = resolveAgentToolCompatibility(spec, effectiveTools, {
 		mediatesDispatch: WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH,
 	});
 	if (compatibility.compatible) return;
+	// Name the narrowing that removed the tool: blaming the runtime sends the
+	// caller to another model when its own write roots caused the refusal.
+	const confined = writeConfined
+		? compatibility.missingRequired.filter((tool) => WRITE_ROOT_REFUSED_TOOLS.has(tool))
+		: [];
+	const cause =
+		confined.length > 0
+			? `; declared write roots remove ${confined.join(", ")}, so omit write roots (use autonomy: "read-only" or worktree: true) for this agent`
+			: "";
 	throw new Error(
-		`dispatch: admission denied: agent '${agentId}' is incompatible with runtime '${target.runtime.id}' after tool narrowing; missing required tools: ${compatibility.missingRequired.join(", ")}`,
+		`dispatch: admission denied: agent '${agentId}' is incompatible with runtime '${target.runtime.id}' after tool narrowing; missing required tools: ${compatibility.missingRequired.join(", ")}${cause}`,
 	);
 }
 
@@ -2875,11 +2893,30 @@ export function createDispatchBundle(
 		rootRunId: string;
 		terminalCandidate: RunReceipt;
 		timer: ReturnType<typeof setTimeout>;
+		settleCanceled: () => void;
 	}
 	const retryQueue = new Map<string, RetryQueueEntry>();
 	const retryBackoff = new Map<string, BackoffState>();
 	const retryReasons = new Map<string, string>();
 	const assignmentRootsByAttempt = new Map<string, string>();
+	// Fleet lineage is shared ancestry, not control ownership. Keep each
+	// member's retry chain distinct without changing persisted lineage.
+	const controlRootsByAttempt = new Map<string, string>();
+	const controlAttempts = new Map<string, { lineage: RunLineage; reservation: DispatchRequest["reservation"] }>();
+	const canceledControlRoots = new Set<string>();
+	const memberWork = new Map<string, Set<Promise<unknown>>>();
+	function trackMemberWork(runId: string, operation: Promise<unknown>): void {
+		const root = controlRootsByAttempt.get(runId) ?? runId;
+		const work = memberWork.get(root) ?? new Set<Promise<unknown>>();
+		memberWork.set(root, work);
+		work.add(operation);
+		const settled = (): void => {
+			work.delete(operation);
+			if (work.size === 0) memberWork.delete(root);
+		};
+		operation.then(settled, settled);
+	}
+
 	const assignments = new AssignmentRegistry({
 		onStreamError: (error) => reportDispatchDiagnostic("assignment event stream", error),
 	});
@@ -2911,6 +2948,20 @@ export function createDispatchBundle(
 	function lineageFor(req: DispatchRequest, runId: string): RunLineage {
 		const lineage = req.lineage ? { ...req.lineage } : { parentRunId: null, rootRunId: runId, attempt: 0, depth: 0 };
 		assignmentRootsByAttempt.set(runId, lineage.rootRunId);
+		const parent = lineage.parentRunId === null ? undefined : controlAttempts.get(lineage.parentRunId);
+		// Repair ordinals and fleet ancestry do not establish a retry. Only a
+		// known consecutive attempt of the same reservation member can do so.
+		const continuesParent =
+			parent !== undefined &&
+			parent.lineage.rootRunId === lineage.rootRunId &&
+			parent.lineage.depth === lineage.depth &&
+			parent.lineage.attempt + 1 === lineage.attempt &&
+			parent.reservation?.ownerId === req.reservation?.ownerId &&
+			parent.reservation?.memberId === req.reservation?.memberId;
+		const priorControl =
+			continuesParent && lineage.parentRunId !== null ? controlRootsByAttempt.get(lineage.parentRunId) : undefined;
+		controlRootsByAttempt.set(runId, priorControl ?? runId);
+		controlAttempts.set(runId, { lineage, reservation: req.reservation });
 		return lineage;
 	}
 
@@ -2977,7 +3028,8 @@ export function createDispatchBundle(
 
 	/** A reserved plan member owns its retry chain independently of the shared fleet root assignment. */
 	function retryChainIsLive(run: ActiveRun): boolean {
-		if (run.aborted) return false;
+		if (run.aborted || canceledControlRoots.has(controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId))
+			return false;
 		const reservation = run.req.reservation;
 		if (reservation === undefined) return assignments.get(run.lineage.rootRunId)?.status === "running";
 		try {
@@ -3061,9 +3113,18 @@ export function createDispatchBundle(
 		const attempt = run.lineage.attempt + 1;
 		const reason = detail !== null ? `${outcome}: ${detail}` : outcome;
 		const dueAt = now() + delayMs;
+		let settleCanceled!: () => void;
+		let rejectContinuation!: (error: unknown) => void;
+		const continuation = new Promise<void>((resolve, reject) => {
+			settleCanceled = resolve;
+			rejectContinuation = reject;
+		});
+		trackMemberWork(run.runId, continuation);
 		const timer = setTimeout(() => {
 			retryQueue.delete(run.runId);
-			void executeRetry(run, attempt, reason, decision);
+			// Ownership starts at scheduling, covering admission before a handle
+			// exists and terminal receipt work after the handle arrives.
+			executeRetry(run, attempt, reason, decision).then(settleCanceled, rejectContinuation);
 		}, delayMs);
 		retryQueue.set(run.runId, {
 			runId: run.runId,
@@ -3076,6 +3137,7 @@ export function createDispatchBundle(
 			rootRunId,
 			terminalCandidate: receipt,
 			timer,
+			settleCanceled,
 		});
 		context.bus.emit(BusChannels.DispatchProgress, {
 			runId: run.runId,
@@ -3176,6 +3238,7 @@ export function createDispatchBundle(
 		// the worktree it created). A retry shares the assignment lineage but
 		// must receive its own ledger/run identity.
 		delete retryReq.runIdHint;
+		let terminal: Promise<RunReceipt> | undefined;
 		const reasonKey = retryReasonKey(run.lineage.rootRunId, attempt);
 		retryReasons.set(reasonKey, reason);
 		try {
@@ -3241,6 +3304,10 @@ export function createDispatchBundle(
 				if (decision.excludedRouteParts.includes("runtime")) delete retryReq.workerRuntime;
 			}
 			const handle = await dispatch(retryReq, undefined, run.hostRun === undefined ? undefined : { hostRun: run.hostRun });
+			// Cancellation can arrive while retry admission is awaiting a handle.
+			if (canceledControlRoots.has(controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId)) {
+				contract.abort(handle.runId);
+			}
 			// The assignment folds every attempt into one stream with a reset marker.
 			const marker: AssignmentAttemptStartEvent = {
 				type: "attempt_start",
@@ -3262,6 +3329,7 @@ export function createDispatchBundle(
 				runtimeKind: run.runtimeKind,
 				event: marker,
 			});
+			terminal = handle.finalPromise;
 			handle.finalPromise.catch((error) => {
 				assignments.reject(asAssignmentId(run.lineage.rootRunId), error);
 				reportDispatchDiagnostic(`finalize retry run ${handle.runId}`, error);
@@ -3294,6 +3362,7 @@ export function createDispatchBundle(
 				outcomeDetail: denial,
 			});
 		}
+		await terminal;
 	}
 
 	function requireLedger(): Ledger {
@@ -3684,7 +3753,7 @@ export function createDispatchBundle(
 			),
 			req,
 		);
-		assertPostRuntimeToolCompatibility(req.agentId, spec, effectiveTools, target);
+		assertPostRuntimeToolCompatibility(req.agentId, spec, effectiveTools, target, pathScope.writeBoundaries.length > 0);
 		const effectiveAdmission: DispatchAdmissionStage = {
 			...admission,
 			allowedTools: effectiveTools,
@@ -5824,6 +5893,7 @@ export function createDispatchBundle(
 					cwd: lifecycle.cwd,
 					networkAllowed:
 						lifecycle.admission.allowedTools.includes(ToolNames.WebFetch) ||
+						lifecycle.admission.allowedTools.includes(ToolNames.WebRead) ||
 						lifecycle.target.runtime.externalAgentLoop?.network === "externally-governed-unobserved",
 					observedRunEffects,
 					filesystem: nodeResultContractFilesystem(),
@@ -6168,7 +6238,11 @@ export function createDispatchBundle(
 		}
 		// Requests carrying lineage are internal attempts (retry or nested
 		// orchestration) and retain the per-attempt handle contract.
-		if (req.lineage) return { ...handle, finalPromise: handle.finalPromise.finally(() => writerLease?.release()) };
+		if (req.lineage) {
+			const finalPromise = handle.finalPromise.finally(() => writerLease?.release());
+			trackMemberWork(handle.runId, finalPromise);
+			return { ...handle, finalPromise };
+		}
 
 		const assignment = assignments.open(handle.runId, assignmentPolicyFor(handle.effectiveRequest));
 		persistAssignment(registerAssignment(assignment.id), `${assignment.id}:open`);
@@ -6270,7 +6344,13 @@ export function createDispatchBundle(
 			),
 			req,
 		);
-		assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
+		assertPostRuntimeToolCompatibility(
+			req.agentId,
+			agentSpec,
+			effectiveTools,
+			target,
+			pathScope.writeBoundaries.length > 0,
+		);
 		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
 		assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
 		assertWriteRootsEnforceable(target.runtime, pathScope.writeBoundaries);
@@ -6927,6 +7007,7 @@ export function createDispatchBundle(
 	function settleQueuedAssignmentsForShutdown(): void {
 		for (const [finishedRunId, entry] of retryQueue) {
 			clearTimeout(entry.timer);
+			entry.settleCanceled();
 			if (assignments.get(entry.rootRunId)?.status === "running") {
 				settleAssignmentDurably(asAssignmentId(entry.rootRunId), entry.terminalCandidate, "canceled");
 			}
@@ -6972,11 +7053,28 @@ export function createDispatchBundle(
 		return stored?.assignmentId ?? ledger?.get(id)?.lineage?.rootRunId ?? id;
 	}
 
+	function controlRootFor(id: string): string {
+		const exact = controlRootsByAttempt.get(id);
+		if (exact !== undefined) return exact;
+		const roots = new Set<string>();
+		for (const [attempt, root] of assignmentRootsByAttempt) {
+			if (root === id) roots.add(controlRootsByAttempt.get(attempt) ?? root);
+		}
+		if (roots.size > 1) {
+			throw new Error(`dispatch: '${id}' names multiple fleet members; use a concrete member or assignment id`);
+		}
+		return roots.values().next().value ?? assignmentRootFor(id);
+	}
+
 	function currentAssignmentRun(id: string): ActiveRun | null {
-		const rootRunId = assignmentRootFor(id);
+		// An exact live attempt is authoritative even if a sibling has a higher
+		// attempt ordinal. Completed IDs may follow only their own retry chain.
+		const exact = active.get(id);
+		if (exact !== undefined) return exact;
+		const rootRunId = controlRootFor(id);
 		let current: ActiveRun | null = null;
 		for (const run of active.values()) {
-			if (run.lineage.rootRunId !== rootRunId) continue;
+			if ((controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId) !== rootRunId) continue;
 			if (current === null || run.lineage.attempt > current.lineage.attempt) current = run;
 		}
 		return current;
@@ -7030,8 +7128,25 @@ export function createDispatchBundle(
 				await Promise.allSettled([...assignmentWrites]);
 			},
 		},
+		async drainMember(runId) {
+			const root = controlRootFor(runId);
+			const errors: unknown[] = [];
+			while (true) {
+				const pending = [...(memberWork.get(root) ?? [])];
+				const live = currentAssignmentRun(runId);
+				if (live !== null) pending.push(live.finalPromise);
+				if (pending.length === 0) break;
+				for (const result of await Promise.allSettled(pending)) {
+					if (result.status === "rejected" && !errors.includes(result.reason)) errors.push(result.reason);
+				}
+			}
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "dispatch member drain failed", { cause: errors[0] });
+		},
 		abort(runId, reason) {
-			const rootRunId = assignmentRootFor(runId);
+			const rootRunId = controlRootFor(runId);
+			const run = currentAssignmentRun(runId);
+			canceledControlRoots.add(rootRunId);
 			const queued = pendingCapacity.get(rootRunId);
 			if (queued !== undefined && capacityAdmission.cancel(rootRunId)) {
 				persistAssignment(cancelStoredAssignment(rootRunId), `${rootRunId}:cancel-queued`);
@@ -7049,10 +7164,13 @@ export function createDispatchBundle(
 				persistAssignment(cancelStoredAssignment(rootRunId), `${rootRunId}:cancel`);
 			}
 			for (const [finishedRunId, retry] of retryQueue) {
-				if (retry.rootRunId !== rootRunId) continue;
+				if ((controlRootsByAttempt.get(finishedRunId) ?? retry.rootRunId) !== rootRunId) continue;
 				clearTimeout(retry.timer);
+				retry.settleCanceled();
 				retryQueue.delete(finishedRunId);
-				settleAssignmentDurably(asAssignmentId(rootRunId), retry.terminalCandidate, "canceled");
+				if (retry.rootRunId === rootRunId) {
+					settleAssignmentDurably(asAssignmentId(rootRunId), retry.terminalCandidate, "canceled");
+				}
 				context.bus.emit(BusChannels.RunAborted, {
 					source: "dispatch_abort",
 					runId: finishedRunId,
@@ -7067,7 +7185,6 @@ export function createDispatchBundle(
 					event: { type: "retry_canceled", attempt: retry.attempt },
 				});
 			}
-			const run = currentAssignmentRun(rootRunId);
 			if (!run) return;
 			emitRunAborted(run, "dispatch_abort");
 			run.aborted = true;

package/src/domains/dispatch/fleet-preflight.ts

@@ -18,6 +18,7 @@ import { performance } from "node:perf_hooks";
 import { readClioVersion } from "../../core/package-root.js";
 import { shellQuote } from "../../core/shell-quote.js";
 import { clioStateDir } from "../../core/xdg.js";
+import { atomicWrite } from "../../engine/session.js";
 import {
 	evaluateRouteFacts,
 	type FactState,
@@ -91,6 +92,20 @@ export function readFleetPreflightRecords(): FleetPreflightRecord[] {
 	}
 }
 
+/**
+ * Upsert records keyed by (nodeId, projectRoot). Only `clio-coder doctor --fix`
+ * writes: plain doctor stays observation-only, and dispatch admission fails
+ * closed on a node that has no stored passing record.
+ */
+export function recordFleetPreflight(records: ReadonlyArray<FleetPreflightRecord>): void {
+	const merged = new Map<string, FleetPreflightRecord>();
+	for (const record of [...readFleetPreflightRecords(), ...records]) {
+		merged.set(`${record.nodeId}\0${record.projectRoot}`, record);
+	}
+	const file: FleetPreflightStoreFile = { version: 2, records: [...merged.values()] };
+	atomicWrite(storePath(), JSON.stringify(file, null, 2));
+}
+
 export interface FleetPreflightVerdict {
 	ok: boolean;
 	reason: string | null;
@@ -110,19 +125,19 @@ export function fleetPreflightVerdict(
 	if (!record) {
 		return {
 			ok: false,
-			reason: `node '${node.id}' has not passed the fleet preflight for ${projectRoot}; run 'clio-coder doctor'`,
+			reason: `node '${node.id}' has not passed the fleet preflight for ${projectRoot}; run 'clio-coder doctor --fix'`,
 		};
 	}
 	if (record.host !== node.host) {
 		return {
 			ok: false,
-			reason: `node '${node.id}' preflight was recorded for host '${record.host}' but the node now points at '${node.host}'; run 'clio-coder doctor'`,
+			reason: `node '${node.id}' preflight was recorded for host '${record.host}' but the node now points at '${node.host}'; run 'clio-coder doctor --fix'`,
 		};
 	}
 	if (record.localVersion !== readClioVersion()) {
 		return {
 			ok: false,
-			reason: `node '${node.id}' preflight predates a local clio-coder upgrade (${record.localVersion} -> ${readClioVersion()}); run 'clio-coder doctor'`,
+			reason: `node '${node.id}' preflight predates a local clio-coder upgrade (${record.localVersion} -> ${readClioVersion()}); run 'clio-coder doctor --fix'`,
 		};
 	}
 	if (!record.ok) {

package/src/domains/dispatch/fleet-run.ts

@@ -788,6 +788,7 @@ export async function executeFleetRun(input: ExecuteFleetRunInput): Promise<Flee
 			beginWriteBoundary: (window, stepIds) => boundaryEnforcer.begin(window, stepIds),
 			verifyWriteBoundary: (window, stepIds) => boundaryEnforcer.verify(window, stepIds),
 			cancel: (assignmentId) => dispatch.abort(assignmentId),
+			drainMember: (assignmentId) => dispatch.drainMember?.(assignmentId) ?? Promise.resolve(),
 			release: (ownerId) => {
 				if (ownerId === NO_WORKER_RESERVATION) return;
 				dispatch.reservations?.release(ownerId);

package/src/domains/dispatch/gate-decisions.ts

@@ -75,7 +75,7 @@ export interface GateDecisionArtifact {
  * prose line. Two schemas exist because the two topologies ask different
  * questions:
  *
- *   - Review asks "does this work pass?", which is exactly the Slice 2
+ *   - Review asks "does this work pass?", which is exactly the
  *     `verifier-report` contract. There is deliberately no `revise` verdict:
  *     whether a failure is worth another cycle is the coordinator's bounded
  *     continuation policy, not a decision the reviewed model gets to author.
@@ -96,7 +96,7 @@ export interface CompeteGateResult {
 
 export type GateResultParse<T> = { ok: true; result: T } | { ok: false; reason: string };
 
-/** Parse a reviewer answer under the Slice 2 Verifier contract. */
+/** Parse a reviewer answer under the verifier-report contract. */
 function parseReviewGateResult(output: string): GateResultParse<ReviewGateResult> {
 	const result = parseVerifierResult(output);
 	return result === null
@@ -128,7 +128,7 @@ export interface ReviewGateDecision {
 /**
  * Apply the coordinator's review policy to one reviewer answer.
  *
- * The reviewer answers pass or fail under its Slice 2 contract and nothing
+ * The reviewer answers pass or fail under its verifier-report contract and nothing
  * else. `revise` is this function's bounded continuation decision: a failure
  * with cycles left earns another builder attempt, the same failure at the bound
  * is simply the terminal fail, and an answer that does not satisfy the contract

package/src/domains/dispatch/heartbeat.ts

@@ -1,5 +1,5 @@
 /**
- * Pure heartbeat watchdog classifier (Phase 6 slice 3).
+ * Pure heartbeat watchdog classifier.
  *
  * Maps a last-seen monotonic stamp to one of three states. The dispatch domain
  * drives this on each scheduler tick; the orchestrator uses `stale` to surface

package/src/domains/dispatch/host-verification.ts

@@ -5,15 +5,15 @@ import { dirname, join, resolve } from "node:path";
 import { PATH_BOUNDARY_MAX_ENTRIES, pathBoundaryCovers, resolvePathBoundary } from "../../core/path-boundary.js";
 import { withStateFileLockSync } from "../../core/state-file-lock.js";
 import { clioStateDir } from "../../core/xdg.js";
-import { judgeNumericTexts, judgePerfTexts } from "../../tools/verify/scripts.js";
+import { JUDGED_CHECK_MAX_OUTPUT_BYTES, judgeNumericTexts, judgePerfTexts } from "../../tools/verify/scripts.js";
 import { FLEET_COMMAND_BASE_ENV, type FleetCommand } from "../agents/fleet-commands.js";
-import { runCodeStep } from "./code-step.js";
+import { CODE_STEP_CAPTURE_MAX_BYTES, runCodeStep } from "./code-step.js";
 import type { DispatchRequest } from "./contract.js";
 import type { RunHostVerification, RunHostVerificationAttribution, RunHostVerificationCheck } from "./types.js";
 import { captureWorkspaceSnapshot } from "./write-boundary.js";
 
 const OUTPUT_TAIL_BYTES = 2_048;
-const MEMO_VERSION = 2;
+const MEMO_VERSION = 3;
 
 type ResolvedCheck = NonNullable<DispatchRequest["resolvedVerification"]>[number];
 
@@ -164,6 +164,7 @@ function judgeResolvedCheck(
 			referenceText,
 			resolvedCheck.numeric.tolerance,
 			`reference '${resolvedCheck.numeric.reference}'`,
+			resolvedCheck.numeric.reference,
 		);
 		if (report instanceof Error) return { exitCode: 1, outputTail: `numeric-compare: ${report.message}` };
 		return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
@@ -214,20 +215,25 @@ async function runResolvedCheck(input: {
 			outputExcerpt: "",
 		};
 	}
+	const judged = resolvedCheck.kind === "numeric-compare" || resolvedCheck.kind === "perf-budget";
+	const captureMaxBytes = judged ? JUDGED_CHECK_MAX_OUTPUT_BYTES : CODE_STEP_CAPTURE_MAX_BYTES;
 	const outcome = await runCodeStep({
 		stepId: `verification-${input.index + 1}-${resolvedCheck.check.replace(/[^a-z0-9._-]/giu, "_")}`,
 		command,
 		workspaceRoot: resolvedCheck.cwd,
 		artifactDir: join(input.stateDir, "artifacts", input.runId, "verification"),
 		env: input.env,
+		maxOutputBytes: captureMaxBytes,
 	});
 	const artifactPath = outcome.record.artifactPaths[0];
-	const judgement = judgeResolvedCheck(
-		resolvedCheck,
-		outcome.record.exitCode,
-		outcome.record.durationMs,
-		outcome.stdout,
-	);
+	// outputTruncated also covers the report excerpt; only capture loss prevents judgement.
+	const judgement =
+		judged && outcome.record.outputTruncated && outcome.record.outputBytes > captureMaxBytes
+			? {
+					exitCode: 1,
+					outputTail: `verify: ${resolvedCheck.kind} command output exceeded ${captureMaxBytes} bytes before judgement; captured output was truncated`,
+				}
+			: judgeResolvedCheck(resolvedCheck, outcome.record.exitCode, outcome.record.durationMs, outcome.stdout);
 	const check: RunHostVerificationCheck = {
 		check: resolvedCheck.check,
 		argv: [...outcome.record.argv],
@@ -307,11 +313,7 @@ function checkDedupeKey(resolvedCheck: ResolvedCheck): string {
 					: {
 							reference: numeric.reference,
 							referenceDigest: sha256(JSON.stringify(readSealedFile(numeric.reference) ?? null)),
-							tolerance: {
-								absolute: numeric.tolerance.absolute,
-								relative: numeric.tolerance.relative,
-								ulp: numeric.tolerance.ulp,
-							},
+							tolerance: numeric.tolerance,
 						},
 			perf:
 				perf === undefined

package/src/domains/dispatch/receipt-findings.ts

@@ -1,8 +1,7 @@
 /**
- * Cheap, pure findings classifier for the durable receipt summary (v0.2.7
- * Slice 3). It maps the signals already present on a receipt draft and its
- * ledger envelope -- outcome, outcomeDetail, exitCode, toolStats, toolActivity
- * -- to a conservative subset of the canonical EvidenceTag taxonomy.
+ * Cheap, pure findings classifier for the durable receipt summary. It maps
+ * outcome, outcomeDetail, exitCode, toolStats, and toolActivity from the receipt
+ * draft and ledger envelope to a conservative subset of the EvidenceTag taxonomy.
  *
  * This is deliberately NOT buildEvidence. The forensic aggregator reads the
  * persisted receipt, so calling it at record time would create a cycle. This

package/src/domains/dispatch/reservation-store.ts

@@ -36,9 +36,9 @@ export type ReservationMemberStatus = "held" | "consumed" | "released";
 export type ReservationStatus = "active" | "released" | "rolled_back" | "expired";
 
 /**
- * A reservation holds four scarce things and nothing else: a global
- * concurrency slot, a per-node slot, an inference-endpoint slot, and a budget
- * upper bound. Node and endpoint identity matter only because slots bind on
+ * A reservation holds global, per-node, and inference-endpoint concurrency
+ * slots and records an advisory cost upper bound. Node and endpoint identity
+ * matter only because slots bind on
  * those dimensions. Agent, target, model, and runtime
  * identity are route identity, which the failover envelope owns
  * (`assertRouteWithinApprovedEnvelope`); pinning them here made a
@@ -330,12 +330,10 @@ export function transferDispatchReservationToLease(input: {
 }
 
 /**
- * Move a member's held capacity to the node a retry actually resolved, and
- * re-check the aggregate budget against the retry's own estimate. The durable
- * lease moves the capacity slot on a retry, but nothing else re-checks money, so
- * a retry that resolves a costlier route would otherwise run outside what the
- * plan reserved. Atomic under
- * the state-file lock: the old node's slot is released and the new one acquired
+ * Move a member's held capacity to the node a retry actually resolved and
+ * record the retry's own cost estimate. Allocation rechecks capacity while
+ * retaining cost as advisory accounting. Atomic under the state-file lock:
+ * the old node's slot is released and the new one acquired
  * in a single write, so a concurrent plan can never observe both held. Fails
  * closed with a named reason, which the caller surfaces as an admission denial
  * rather than letting the attempt escape its reservation.

package/src/domains/dispatch/route-facts.ts

@@ -102,7 +102,7 @@ export function evaluateRouteFacts(
 		if (requirement.mode === "shadow") return { ok: true, unknowns };
 		return {
 			ok: false,
-			reason: `no probe fact for target '${requirement.targetId}' on node '${requirement.nodeId}'; run 'clio-coder doctor'`,
+			reason: `no probe fact for target '${requirement.targetId}' on node '${requirement.nodeId}'; run 'clio-coder doctor --fix'`,
 			unknowns,
 		};
 	}

package/src/domains/dispatch/state.ts

@@ -1,5 +1,5 @@
 /**
- * Dispatch run ledger with atomic writes (Phase 6 slice 2).
+ * Dispatch run ledger with atomic writes.
  *
  * On-disk layout under `clioStateDir()`:
  *   runs.json                    JSON array of RunEnvelope, newest first
@@ -9,8 +9,8 @@
  * mutate memory only; `persist()` writes the settings-bounded ring (default
  * 1000) atomically via engine.atomicWrite.
  *
- * No worker spawning, no domain wire-up, no SafeEventBus emission yet. Those
- * land in P6S3 and P6S5. This slice is a pure persistence primitive.
+ * This module owns persistence. The dispatch extension wires worker spawning,
+ * cross-domain coordination, and event emission around this ledger.
  *
  * A crash between recordReceipt and persist leaves the receipt JSON on disk
  * without a ledger entry. The dispatch extension closes that gap at startup by

package/src/domains/dispatch/types.ts

@@ -1,6 +1,6 @@
 import type { WorkerContextProvenance } from "../context/worker/contract.js";
 /**
- * Shared run + receipt types for the dispatch domain (Phase 6 slice 2).
+ * Shared run + receipt types for the dispatch domain.
  *
  * RunEnvelope is the live record kept in the ledger (runs.json). RunReceipt is
  * the per-run artifact written under receipts/<runId>.json on completion. Both

package/src/domains/evidence/build.ts

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { rawDurationMs } from "../../core/timers.js";
 import { isProjectVerifierCheckId, isVerificationScriptName } from "../../core/verification-scripts.js";
+import { effectiveToolCall } from "../../tools/surface.js";
 import type {
 	RunEnvelope,
 	RunKind,
@@ -573,7 +574,12 @@ function validationToolCallCandidate(
 	runSources: ReadonlyArray<EvidenceRunSource>,
 ): ValidationToolCallCandidate | null {
 	const call = extractSessionToolCall(entry, linked);
-	if (validationToolCallSummary(call.tool, call.args) === null) return null;
+	// The capability a gateway call reached is what ran; a validation command
+	// is recognized under that name, never under `gateway`.
+	const effective = effectiveToolCall(call.tool, call.args);
+	if (validationToolCallSummary(effective.toolName, effective.viaGateway ? effective.args : call.args) === null) {
+		return null;
+	}
 	return {
 		toolCallId: call.id,
 		runId: validationRunIdFor(linked, runSources),
@@ -1025,7 +1031,15 @@ function extractSessionToolCall(entry: MessageEntry, linked: LinkedSessionEntry)
 		block?.arguments ??
 		block?.args ??
 		undefined;
-	return { id, tool, args, timestamp: entry.timestamp, link: linked.link, sessionId: linked.sessionId };
+	const effective = effectiveToolCall(tool, args);
+	return {
+		id,
+		tool: effective.toolName,
+		args: effective.args ?? args,
+		timestamp: entry.timestamp,
+		link: linked.link,
+		sessionId: linked.sessionId,
+	};
 }
 
 function extractSessionToolResult(entry: MessageEntry, linked: LinkedSessionEntry): SessionToolResult {
@@ -1047,10 +1061,18 @@ function extractSessionToolResult(entry: MessageEntry, linked: LinkedSessionEntr
 		payload?.out ??
 		payload?.content ??
 		(contentText.length > 0 ? contentText : entry.payload);
+	const effective = effectiveToolCall(tool, undefined, payloadObject(result)?.details ?? payload?.details);
+	const resultObject = payloadObject(result);
+	const details = payloadObject(resultObject?.details);
+	let projectedResult = result;
+	if (effective.viaGateway && resultObject && details) {
+		const { capability: _capability, ...innerDetails } = details;
+		projectedResult = { ...resultObject, details: innerDetails };
+	}
 	return {
 		id,
-		tool,
-		result,
+		tool: effective.toolName,
+		result: projectedResult,
 		isError: payload?.isError === true || payload?.error === true,
 		timestamp: entry.timestamp,
 		link: linked.link,
@@ -1351,8 +1373,13 @@ function renderTranscript(
 	}
 	if (sessionLinks.entries.length > 0) {
 		lines.push("", "## Linked Session Transcript");
+		const calls = new Map<string, string>();
 		for (const linked of sessionLinks.entries) {
-			lines.push(...renderSessionTranscriptEntry(linked));
+			if (linked.entry.kind === "message" && linked.entry.role === "tool_call") {
+				const call = extractSessionToolCall(linked.entry, linked);
+				calls.set(call.id, call.tool);
+			}
+			lines.push(...renderSessionTranscriptEntry(linked, calls));
 		}
 	}
 	lines.push("");
@@ -1379,7 +1406,7 @@ function transcriptRunLink(link: SessionRunLink): string {
 	return "";
 }
 
-function renderSessionTranscriptEntry(linked: LinkedSessionEntry): string[] {
+function renderSessionTranscriptEntry(linked: LinkedSessionEntry, calls: ReadonlyMap<string, string>): string[] {
 	const entry = linked.entry;
 	const prefix = `- ${entry.timestamp} session=${linked.sessionId}${transcriptRunLink(linked.link)}`;
 	if (entry.kind === "message") {
@@ -1391,7 +1418,8 @@ function renderSessionTranscriptEntry(linked: LinkedSessionEntry): string[] {
 			const result = extractSessionToolResult(entry, linked);
 			const id = result.id === null ? "" : ` id=${result.id}`;
 			const error = result.isError ? " error=true" : "";
-			return [`${prefix} tool_result ${result.tool}${id}${error}: ${previewUnknown(result.result)}`];
+			const tool = result.id === null ? result.tool : (calls.get(result.id) ?? result.tool);
+			return [`${prefix} tool_result ${tool}${id}${error}: ${previewUnknown(result.result)}`];
 		}
 		const text = collapseWhitespace(extractTextFromPayload(entry.payload));
 		const rendered = text.length > 0 ? truncateText(text, TRANSCRIPT_TEXT_MAX_CHARS) : previewUnknown(entry.payload);