@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/dispatch/extension.ts

@@ -77,6 +77,7 @@ import type { PromptsContract } from "../prompts/contract.js";
 import { type EffectivePricing, resolveEffectivePricing } from "../providers/catalog.js";
 import {
 	type CapabilityFlags,
+	canonicalEndpointKey,
 	canonicalizeWireModelId,
 	type EndpointCapacity,
 	endpointCapacityFor,
@@ -181,7 +182,12 @@ import {
 	type HeartbeatStatus,
 	heartbeatMonotonicAt,
 } from "./heartbeat.js";
-import { hostVerificationRejection, runHostVerification } from "./host-verification.js";
+import {
+	type BatchVerificationGate,
+	createBatchVerificationGate,
+	hostVerificationRejection,
+	runHostVerification,
+} from "./host-verification.js";
 import { renderDispatchIntentRequirements } from "./intent-requirements.js";
 import { adaptJointRouteInput } from "./joint-route-adapter.js";
 import {
@@ -201,6 +207,8 @@ import {
 	type DispatchPathScope,
 	declaredScopeReplacementDiagnostic,
 	declaredScopeReplacementNotice,
+	inferredScopeParentTokenDiagnostic,
+	inferredScopeParentTokenNotice,
 	resolveDispatchPathScope,
 } from "./path-scope.js";
 import { deriveEnvelopePhaseDurations, deriveRunPhaseDurations, recordRunTimingBestEffort } from "./phase-timing.js";
@@ -456,8 +464,8 @@ function calculateUsageCostUsd(meter: RunTokenMeter, pricing: EffectivePricing["
  * admit a route before settings are resolved, and it defers to the one place
  * that owns the default rather than restating the number here.
  */
-export function admissionMaxOutputTokens(settings: EffectiveSettings): number {
-	return settings?.defaults.maxTokens ?? DEFAULT_SETTINGS.defaults.maxTokens;
+function admissionMaxOutputTokens(settings: EffectiveSettings): number {
+	return settings?.chat.maxOutputTokens ?? DEFAULT_SETTINGS.chat.maxOutputTokens;
 }
 
 function conservativeRouteAdmissionEstimateUsd(pricing: EffectivePricing, maxOutputTokens: number): number {
@@ -509,7 +517,7 @@ function eventContainsFirstModelToken(event: Record<string, unknown>): boolean {
 }
 
 function eventStartsTool(event: Record<string, unknown>): boolean {
-	return event.type === "tool_execution_start" || event.type === "clio_tool_start";
+	return event.type === "tool_execution_start" || event.type === "clio_coder_tool_start";
 }
 
 function finitePositive(value: unknown): number | undefined {
@@ -686,7 +694,7 @@ async function awaitEventDrain(drained: Promise<void>, graceMs = DISPATCH_DRAIN_
 function reportDispatchDiagnostic(scope: string, error: unknown): void {
 	const message = error instanceof Error ? error.message : String(error);
 	try {
-		process.stderr.write(`[clio:dispatch] ${scope}: ${message}\n`);
+		process.stderr.write(`[clio-coder:dispatch] ${scope}: ${message}\n`);
 	} catch {
 		// stderr itself is best-effort
 	}
@@ -892,7 +900,7 @@ export interface WorkspaceRootFacts {
  * claimed `npm test` then "validated" in 4ms. None of that is a model failure.
  * The harness knows the cwd exactly and was sending it nowhere.
  */
-export function readWorkspaceRootFacts(
+function readWorkspaceRootFacts(
 	cwd: string,
 	readEntries: (dir: string) => Dirent[] = readDirentsSafely,
 ): WorkspaceRootFacts {
@@ -922,7 +930,7 @@ function readDirentsSafely(dir: string): Dirent[] {
  * projection of CLIO-CODER.md: a read-only scout that cannot afford the handbook read
  * still needs its first shell call to land in the right place.
  */
-export function renderWorkerWorkspaceContext(workspace: WorkspaceRootFacts): string {
+function renderWorkerWorkspaceContext(workspace: WorkspaceRootFacts): string {
 	const lines = ["# Workspace", `Root: ${workspace.root}`, "Your process starts here; relative paths resolve from it."];
 	if (workspace.entries.length > 0) {
 		lines.push(`Top level: ${workspace.entries.join(", ")}${workspace.truncated ? ", …" : ""}`);
@@ -975,7 +983,7 @@ function renderPipelineInput(input: PipelineInput): PipelineInputRender {
  * the command actually printed rather than a summary of it. Like pipeline
  * input, this is data and is never presented as instructions.
  */
-export function renderPredecessorHandoffs(handoffs: ReadonlyArray<ExecutionHandoff>): WorkerPromptMessage | null {
+function renderPredecessorHandoffs(handoffs: ReadonlyArray<ExecutionHandoff>): WorkerPromptMessage | null {
 	if (handoffs.length === 0) return null;
 	const body = [
 		"Outputs from this step's declared predecessors, in dependency order.",
@@ -1105,7 +1113,7 @@ export interface WorkerDynamicContext {
  * the projected "Verification expectations" body (verification-class runs
  * only); when off, output is byte-identical to the historical renderer.
  */
-export function renderWorkerProjectContext(
+function renderWorkerProjectContext(
 	project: ProjectStructuredContext,
 	options: { includeVerification?: boolean } = {},
 ): string {
@@ -1147,7 +1155,7 @@ function workerProjectContextIncludesVerification(body: string): boolean {
 	return body.includes("\nVerification expectations:\n");
 }
 
-export function buildDynamicPromptMessages(
+function buildDynamicPromptMessages(
 	req: DispatchRequest,
 	dynamicContext: WorkerDynamicContext = {},
 ): WorkerPromptMessage[] {
@@ -1355,7 +1363,7 @@ interface DispatchLifecycleStage {
 interface AcpDelegationLifecycleStage {
 	admission: DispatchAdmissionStage;
 	pathScope: DispatchPathScope;
-	agentConfig: ReturnType<ConfigContract["get"]>["delegation"]["agents"][number];
+	agentConfig: ReturnType<ConfigContract["get"]>["integrations"]["externalAgents"]["entries"][number];
 	cwd: string;
 	systemPrompt: string;
 	dynamicPromptMessages: ReadonlyArray<WorkerPromptMessage>;
@@ -1603,11 +1611,7 @@ function assertPostRuntimeToolCompatibility(
 }
 
 function workerToolCallHardCap(settings: EffectiveSettings): number {
-	const rawEnvCap = process.env.CLIO_CODER_WORKER_TOOL_CALL_CAP?.trim();
-	const parsedEnvCap = rawEnvCap && /^[1-9]\d*$/.test(rawEnvCap) ? Number(rawEnvCap) : Number.NaN;
-	return Number.isSafeInteger(parsedEnvCap)
-		? parsedEnvCap
-		: (settings?.guardrails.workerToolCallCap ?? GUARDRAIL_DEFAULTS.workerToolCallCap);
+	return settings?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
 }
 
 function resolveEffectiveWorkerBudget(input: {
@@ -1735,15 +1739,15 @@ function acpRuntimeLimitations(): string[] {
 }
 
 function readWorkerTargets(settings: ReturnType<ConfigContract["get"]> | undefined): WorkerTargets {
-	const workerDefault = settings?.workers?.default
+	const workerDefault = settings?.fleet?.default
 		? {
-				target: settings.workers.default.target ?? null,
-				model: settings.workers.default.model ?? null,
-				thinkingLevel: (settings.workers.default.thinkingLevel ?? "off") as ThinkingLevel,
+				target: settings.fleet.default.target ?? null,
+				model: settings.fleet.default.model ?? null,
+				thinkingLevel: (settings.fleet.default.thinkingLevel ?? "off") as ThinkingLevel,
 			}
 		: null;
 	const workerProfiles: WorkerProfileMap = {};
-	for (const [name, profile] of Object.entries(settings?.workers?.profiles ?? {})) {
+	for (const [name, profile] of Object.entries(settings?.fleet?.profiles ?? {})) {
 		workerProfiles[name] = {
 			target: profile.target ?? null,
 			model: profile.model ?? null,
@@ -1751,7 +1755,7 @@ function readWorkerTargets(settings: ReturnType<ConfigContract["get"]> | undefin
 		};
 	}
 	const agentBindings: WorkerAgentBindingMap = {};
-	for (const [agentId, profileName] of Object.entries(settings?.workers?.agentBindings ?? {})) {
+	for (const [agentId, profileName] of Object.entries(settings?.fleet?.agentProfiles ?? {})) {
 		const id = agentId.trim();
 		const profile = profileName.trim();
 		if (id.length > 0 && profile.length > 0) agentBindings[id] = profile;
@@ -1928,17 +1932,17 @@ function buildDispatchWorkerSpec(input: DispatchWorkerSpecInput, config?: Config
 	if (input.req.trustProjectCompatRoots !== undefined) {
 		spec.trustProjectCompatRoots = input.req.trustProjectCompatRoots;
 	} else if (settings) {
-		spec.trustProjectCompatRoots = settings.skills.trustProjectCompatRoots === true;
+		spec.trustProjectCompatRoots = settings.integrations.projectResources.trustProjectImports === true;
 	}
-	spec.gitCommitAttribution = settings?.attribution.gitCommits ?? true;
+	spec.gitCommitAttribution = settings?.integrations.git.commitAttribution ?? true;
 	// Non-stall posture (Symphony §10.5): a dispatched worker has no operator
 	// to answer a permission prompt by default, so the resolution policy ships
 	// with the spec and the worker enforces it within bounded time. Under the
 	// escalate posture the configured timeout/fallback bounds ride along so the
 	// worker still cannot hang when no operator resolves the ask.
-	spec.onPermission = settings?.workers.onPermission ?? "deny";
+	spec.onPermission = settings?.fleet.permissions.mode ?? "deny";
 	if (spec.onPermission === "escalate") {
-		const escalation = settings?.workers.escalation;
+		const escalation = settings?.fleet.permissions.escalation;
 		if (escalation) spec.escalation = { timeoutMs: escalation.timeoutMs, fallback: escalation.fallback };
 	}
 	assertRuntimeCanHonorWorkerPermissionMode(input.target.runtime, spec.onPermission);
@@ -2032,7 +2036,7 @@ function autonomyEnforcementForAcpDelegation(
 			dangerousBypass: true,
 		};
 	}
-	// clio-policy applies the exact autonomy mapping to every permission
+	// clio-coder-policy applies the exact autonomy mapping to every permission
 	// request. deny-all is stricter than every autonomy level, but is still a
 	// Clio-mediated upper bound rather than an external approximation.
 	return { grade: "mediated", autonomy, ...authorityEvidence, externalMode: toolGovernance };
@@ -2426,7 +2430,7 @@ export function createDispatchBundle(
 	const heartbeatIntervalMs = options?.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
 	const getResilienceCooldownMs = (): number => {
 		if (options?.resilienceCooldownMs !== undefined) return options.resilienceCooldownMs;
-		const settingsVal = getEffectiveSettings()?.workers?.resilienceCooldownMs;
+		const settingsVal = getEffectiveSettings()?.fleet?.retry.routeCooldownMs;
 		if (settingsVal !== undefined && settingsVal >= 0) return settingsVal;
 		return DEFAULT_RESILIENCE_COOLDOWN_MS;
 	};
@@ -2500,6 +2504,29 @@ export function createDispatchBundle(
 		return Object.fromEntries(Object.entries(configuredEndpointCapacities()).map(([key, value]) => [key, value.limit]));
 	}
 
+	/**
+	 * Endpoints still bound by the blind one-slot default have never been
+	 * probed by any process, or their record expired. A fresh home carried that
+	 * bound into its first batch and refused two tasks on a server running
+	 * four, until the operator happened to run `targets --probe`. Probe each
+	 * such endpoint once per process, in the background and without the
+	 * inference-based reasoning check: the slot count is a header read, and the
+	 * model's first dispatch call is seconds away at the earliest. The probe
+	 * lands in the provider statuses and the durable slot store, which is where
+	 * admission already looks.
+	 */
+	const probedDefaultBoundEndpoints = new Set<string>();
+	function probeEndpointsAtDefaultBound(): void {
+		const capacities = configuredEndpointCapacities();
+		for (const target of getEffectiveSettings()?.targets ?? []) {
+			const key = canonicalEndpointKey(target);
+			if (key === null || capacities[key]?.source !== "local-native-default") continue;
+			if (probedDefaultBoundEndpoints.has(key)) continue;
+			probedDefaultBoundEndpoints.add(key);
+			void providers.probeTarget(target.id, { reasoning: false }).catch(() => undefined);
+		}
+	}
+
 	function endpointCapacityForTarget(targetId: string): EndpointCapacity | null {
 		const status = providers.list().find((entry) => entry.target.id === targetId);
 		const target = status?.target ?? providers.getTarget(targetId);
@@ -2598,7 +2625,7 @@ export function createDispatchBundle(
 	}
 
 	function configuredGlobalCapacity(settings: EffectiveSettings): number {
-		const configured = settings?.budget.concurrency;
+		const configured = settings?.fleet.concurrency;
 		return scheduling.maxWorkers?.() ?? (configured === "auto" || configured === undefined ? 4 : Math.max(1, configured));
 	}
 
@@ -2724,7 +2751,7 @@ export function createDispatchBundle(
 	const finalizedCosts: Array<{ usd: number; provenance: import("../providers/index.js").CostProvenance }> = [];
 
 	function workersMaxRetries(settings: EffectiveSettings = getEffectiveSettings()): number {
-		const value = settings?.workers?.maxRetries;
+		const value = settings?.fleet?.retry.maxRetries;
 		return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 2;
 	}
 
@@ -3369,6 +3396,23 @@ export function createDispatchBundle(
 				agentId: req.agentId,
 			});
 		}
+		// A reinterpreted "../" token is the one legacy-mode scope fact that earns
+		// the channel: it fires only where the dispatch used to fail outright, so
+		// it cannot warn on the ordinary intent-less dispatch the comment above
+		// keeps quiet. Anchoring is reported alongside dropping because it is the
+		// half that adds to scope, putting a path in working context that the
+		// prose never literally spelled.
+		const parentTokenDiagnostic = inferredScopeParentTokenDiagnostic(pathScope);
+		if (parentTokenDiagnostic !== null) {
+			reportDispatchDiagnostic("inferred scope parent tokens", new Error(parentTokenDiagnostic));
+		}
+		const parentTokenNotice = inferredScopeParentTokenNotice(pathScope);
+		if (parentTokenNotice !== null) {
+			context.bus.emit(BusChannels.DispatchScopeNotice, {
+				...parentTokenNotice,
+				agentId: req.agentId,
+			});
+		}
 	}
 
 	async function resolveLifecycle(req: DispatchRequest, settings: EffectiveSettings): Promise<DispatchLifecycleStage> {
@@ -3402,6 +3446,7 @@ export function createDispatchBundle(
 						autoSelected: req.agentSelection?.mode === "auto",
 						resultContractKind: spec.resultContract.kind,
 						specs: agents.listSpecs(),
+						intent: req.intent ?? null,
 					});
 		if (capabilityMismatch?.verdict === "refuse") throw new Error(capabilityMismatch.detail);
 		const pathScope = resolveDispatchPathScope(req);
@@ -3418,11 +3463,11 @@ export function createDispatchBundle(
 			providers,
 		);
 		enforceCapabilityGate(target.target.id, target.modelCapabilities, req.requiredCapabilities);
-		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
+		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
 		assertWorkerBudgetEnforceable(target.runtime, spec.budget !== null || req.budget !== undefined);
 
 		const cwd = req.cwd ?? process.cwd();
-		const sessionAutonomy = settings?.autonomy ?? "auto-edit";
+		const sessionAutonomy = settings?.safety.autonomy ?? "auto-edit";
 		const effectiveAutonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
 		const effectiveTools = withLedgerToolNarrowing(
 			effectiveToolNames(admission.allowedTools, target, pathScope.writeBoundaries.length > 0, deniedToolNames(req)),
@@ -3434,18 +3479,17 @@ export function createDispatchBundle(
 			allowedTools: effectiveTools,
 		};
 		const personaBody = workerPersonaBody(req, recipe, effectiveTools);
+		const hasCanonicalContext = effectiveTools.includes(ToolNames.Context);
+		const hasBoundSkills =
+			hasCanonicalContext && recipe.skills !== undefined && recipe.skills.length > 0 && req.noSkills !== true;
 		const compiledWorkerPrompt = await prompts.compileWorkerPrompt({
 			autonomy: effectiveAutonomy,
 			providerSupportsTools: target.runtime.kind === "subprocess" ? null : targetToolCapability(target),
 			toolNames: effectiveTools,
-			toolPromptHints: toolPromptHintsForNames(effectiveTools),
-			hasCanonicalContext: effectiveTools.includes(ToolNames.Context),
-			hasBoundSkills:
-				effectiveTools.includes(ToolNames.Context) &&
-				recipe.skills !== undefined &&
-				recipe.skills.length > 0 &&
-				req.noSkills !== true,
-			onPermission: settings?.workers.onPermission ?? "deny",
+			toolPromptHints: toolPromptHintsForNames(effectiveTools, hasBoundSkills ? "bound-worker" : "worker"),
+			hasCanonicalContext,
+			hasBoundSkills,
+			onPermission: settings?.fleet.permissions.mode ?? "deny",
 			persona: {
 				id: `persona.${recipe.id}`,
 				relPath: recipe.filepath,
@@ -3473,7 +3517,7 @@ export function createDispatchBundle(
 			capabilityClass: spec.capabilityClass,
 			projectContextTier: tier,
 			autonomy: effectiveAutonomy,
-			onPermission: settings?.workers.onPermission ?? "deny",
+			onPermission: settings?.fleet.permissions.mode ?? "deny",
 			project,
 			workspace: readWorkspaceRootFacts(cwd),
 		});
@@ -3493,7 +3537,7 @@ export function createDispatchBundle(
 		// Match chat-loop's LOCAL_API_KEY_FALLBACK so dispatch-spawned workers can
 		// reach openai-compat local endpoints (LM Studio, llama.cpp) without
 		// requiring the user to invent a credential.
-		const apiKey = auth?.apiKey ?? (auth === null ? "clio-local-target" : undefined);
+		const apiKey = auth?.apiKey ?? (auth === null ? "clio-coder-local-target" : undefined);
 		const runtimeKind: RunKind = target.runtime.kind;
 		const limitations = runtimeLimitations(runtimeKind, target.runtime.id);
 		return {
@@ -3548,16 +3592,16 @@ export function createDispatchBundle(
 			}
 		}
 		if (!settings) throw new Error("dispatch: effective settings required for ACP delegation");
-		const configured = settings.delegation.agents.find((entry) => entry.id === agentId);
+		const configured = settings.integrations.externalAgents.entries.find((entry) => entry.id === agentId);
 		if (!configured) throw new Error(`dispatch: ACP delegation agent '${agentId}' not configured`);
-		const toolGovernance = configured.toolGovernance ?? "clio-policy";
+		const toolGovernance = configured.toolGovernance ?? "clio-coder-policy";
 		if (options?.autonomyOverride === true && toolGovernance === "agent-managed") {
 			throw new Error(
-				`dispatch: ACP delegation agent '${agentId}' uses toolGovernance='agent-managed', which cannot enforce an explicit one-run autonomy override; choose clio-policy or deny-all governance, or omit --autonomy`,
+				`dispatch: ACP delegation agent '${agentId}' uses toolGovernance='agent-managed', which cannot enforce an explicit one-run autonomy override; choose clio-coder-policy or deny-all governance, or omit --autonomy`,
 			);
 		}
 		const admission = resolveDelegationAdmissionStage(req, safety);
-		const sessionAutonomy = settings.autonomy ?? "auto-edit";
+		const sessionAutonomy = settings.safety.autonomy ?? "auto-edit";
 		const autonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
 		if (toolGovernance === "agent-managed" && autonomy !== sessionAutonomy) {
 			throw new Error(
@@ -3755,15 +3799,15 @@ export function createDispatchBundle(
 				if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
 				if (eventStartsTool(event)) markObservedPhase("firstToolAt");
 			}
-			if (event.type === "clio_tool_start" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_tool_start" && event.payload && typeof event.payload.tool === "string") {
 				recordToolStart(inFlightTools, event.payload);
 			}
 			// ACP is an external protocol peer, never an authority for Clio's
 			// deterministic terminal taxonomy. Ignore even syntactically valid
 			// assertions; only a future coordinator-side classifier may set one.
-			if (event.type === "clio_run_outcome" && !reportedSpoofedOutcome) {
+			if (event.type === "clio_coder_run_outcome" && !reportedSpoofedOutcome) {
 				reportedSpoofedOutcome = true;
-				reportDispatchDiagnostic("ACP outcome event", new Error("ignored untrusted clio_run_outcome assertion"));
+				reportDispatchDiagnostic("ACP outcome event", new Error("ignored untrusted clio_coder_run_outcome assertion"));
 			}
 			if (isRecord(event)) {
 				const finishEntry = appendDispatchFinishContractEntry(finishContractEntries, event);
@@ -3794,7 +3838,7 @@ export function createDispatchBundle(
 					if (message !== null) failureMessage = message;
 				}
 			}
-			if (event.type === "clio_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
 				const requestId =
 					typeof event.payload.requestId === "string" ? event.payload.requestId : `delegation-permission-${Date.now()}`;
 				const origin = runIdForPermissionAudit !== null ? `delegation:${runIdForPermissionAudit}` : "delegation:unknown";
@@ -3820,7 +3864,7 @@ export function createDispatchBundle(
 					...(runIdForPermissionAudit !== null ? { requestedBy: runIdForPermissionAudit } : {}),
 				});
 			}
-			if (event.type === "clio_tool_finish" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_tool_finish" && event.payload && typeof event.payload.tool === "string") {
 				recordToolCompletion(inFlightTools, event.payload);
 				recordToolFinish(toolStats, event.payload);
 				if (event.payload.decision === "allowed") safetyDecisionCounts.allowed += 1;
@@ -4022,7 +4066,7 @@ export function createDispatchBundle(
 			const finalFailureMessage = result.failureMessage ?? failureMessage;
 			const finalToolStats = snapshotToolStats(toolStats);
 			const unfinished = snapshotUnfinishedTools(inFlightTools);
-			const toolGovernance = lifecycle.agentConfig.toolGovernance ?? "clio-policy";
+			const toolGovernance = lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy";
 			return {
 				runId: envelope.id,
 				agentId: req.agentId,
@@ -4075,7 +4119,7 @@ export function createDispatchBundle(
 				dynamicHash: lifecycle.dynamicHash,
 				promptSignature: lifecycle.promptSignature,
 				toolSignature: lifecycle.toolSignature,
-				clioVersion: readClioVersion(),
+				clioCoderVersion: readClioVersion(),
 				piMonoVersion: readPiMonoVersion(),
 				platform: process.platform,
 				nodeVersion: process.version,
@@ -4089,7 +4133,7 @@ export function createDispatchBundle(
 				quality: createRunReceiptQuality({ runtimeEnforceable: false, enforcementPassed: null, resultContract: null }),
 				autonomyEnforcement: autonomyEnforcementForAcpDelegation(
 					lifecycle.autonomy,
-					lifecycle.agentConfig.toolGovernance ?? "clio-policy",
+					lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy",
 					lifecycle.sessionAutonomy,
 					req.autonomy,
 				),
@@ -4119,7 +4163,7 @@ export function createDispatchBundle(
 					toolCallsRequested: result.delegation.toolCallsRequested,
 					toolCallsApproved: result.delegation.toolCallsApproved,
 					toolCallsDenied: result.delegation.toolCallsDenied,
-					toolGovernance: lifecycle.agentConfig.toolGovernance ?? "clio-policy",
+					toolGovernance: lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy",
 					toolCallLog: acp.toolCallLog(),
 				},
 				sessionId: result.delegation.acpSessionId,
@@ -4345,6 +4389,7 @@ export function createDispatchBundle(
 	async function dispatchAttempt(
 		req: DispatchRequest,
 		observer?: DispatchAdmissionObserver,
+		settlement?: BatchVerificationGate,
 	): Promise<{
 		runId: string;
 		events: AsyncIterableIterator<unknown>;
@@ -4354,7 +4399,7 @@ export function createDispatchBundle(
 		const requestedAt = new Date(now()).toISOString();
 		const timing: RunPhaseMarks = { requestedAt, decisionStartedAt: requestedAt };
 		const settings = getEffectiveSettings();
-		const isAcpAgent = settings?.delegation?.agents?.some((entry) => entry.id === req.agentId) ?? false;
+		const isAcpAgent = settings?.integrations.externalAgents?.entries?.some((entry) => entry.id === req.agentId) ?? false;
 		if (isAcpAgent && !req.delegationAgentId) {
 			req.delegationAgentId = req.agentId;
 		}
@@ -4374,7 +4419,7 @@ export function createDispatchBundle(
 			const recipe = agents.get(req.agentId);
 			const activation = consumeActiveRouteApproval({
 				request: req,
-				settings: settings?.routing,
+				settings: settings?.fleet.adaptiveRouting,
 				capabilityClass: recipe === null ? null : normalizeAgentSpec(recipe).capabilityClass,
 				failover: failoverModeFor(req),
 				requestedAt,
@@ -4440,10 +4485,12 @@ export function createDispatchBundle(
 			}
 			rebindReservationSlot(req, "local", null, UNKNOWN_PRICING_ADMISSION_ESTIMATE_USD, settings);
 			routeObservation = observeShadowRoute(req, undefined, settings);
-			return attachRouteObservation({
-				...(await dispatchAcpDelegation(req, settings, timing, routeObservation.decision, observer)),
-				effectiveRequest: req,
-			});
+			const delegated = await dispatchAcpDelegation(req, settings, timing, routeObservation.decision, observer);
+			// An ACP member never runs host verification, so it can only ever leave
+			// the barrier. It still edits the checkout, so the barrier has to wait
+			// for it; dispatch() releases it when its finalPromise settles.
+			settlement?.live(delegated.runId);
+			return attachRouteObservation({ ...delegated, effectiveRequest: req });
 		}
 
 		req = routeAroundCoolingTarget(req, settings) ?? req;
@@ -4668,7 +4715,7 @@ export function createDispatchBundle(
 				context.bus.emit(BusChannels.DispatchProgress, {
 					runId,
 					agentId: req.agentId,
-					event: { type: "clio_write_record_downgraded", payload: downgrade },
+					event: { type: "clio_coder_write_record_downgraded", payload: downgrade },
 				});
 			},
 		});
@@ -4722,8 +4769,8 @@ export function createDispatchBundle(
 					policySource?: string;
 					reason?: string;
 					skillActivation?: unknown;
-					// Worker permission-escalation fields (clio_permission_escalated /
-					// clio_permission_resolved escalate path).
+					// Worker permission-escalation fields (clio_coder_permission_escalated /
+					// clio_coder_permission_resolved escalate path).
 					requestId?: string;
 					summary?: string;
 					target?: string;
@@ -4736,12 +4783,12 @@ export function createDispatchBundle(
 				if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
 				if (eventStartsTool(event)) markObservedPhase("firstToolAt");
 			}
-			if (event.type === "clio_tool_start" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_tool_start" && event.payload && typeof event.payload.tool === "string") {
 				recordToolStart(inFlightTools, event.payload);
 			}
-			if (event.type === "clio_steer_received") acknowledgeSteer(event.payload?.sequence);
+			if (event.type === "clio_coder_steer_received") acknowledgeSteer(event.payload?.sequence);
 			if (
-				event.type === "clio_run_outcome" &&
+				event.type === "clio_coder_run_outcome" &&
 				isRunOutcomeCode(event.payload?.outcomeCode) &&
 				event.payload.outcomeCode !== "worker_final_output_missing" &&
 				event.payload.outcomeCode !== "host_verification_rejected"
@@ -4764,7 +4811,11 @@ export function createDispatchBundle(
 				}
 				recordWorkerRunEffect(runEffects, event);
 			}
-			if (event.type === "clio_permission_escalated" && event.payload && typeof event.payload.requestId === "string") {
+			if (
+				event.type === "clio_coder_permission_escalated" &&
+				event.payload &&
+				typeof event.payload.requestId === "string"
+			) {
 				escalationCounts.requested += 1;
 				const ctx = isRecord(event.payload.decision) ? event.payload.decision : null;
 				const classification = ctx !== null && isRecord(ctx.classification) ? ctx.classification : null;
@@ -4825,7 +4876,7 @@ export function createDispatchBundle(
 					if (message !== null) failureMessage = message;
 				}
 			}
-			if (event.type === "clio_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
 				// Escalation resolutions already have a request event. Policy
 				// deny/fail is non-stalling, so dispatch mints the adjacent pair.
 				const source = event.payload.source;
@@ -4878,7 +4929,7 @@ export function createDispatchBundle(
 					...(runIdForPermissionAudit !== null ? { requestedBy: runIdForPermissionAudit } : {}),
 				});
 			}
-			if (event.type === "clio_tool_finish" && event.payload && typeof event.payload.tool === "string") {
+			if (event.type === "clio_coder_tool_finish" && event.payload && typeof event.payload.tool === "string") {
 				recordToolCompletion(inFlightTools, event.payload);
 				recordToolFinish(toolStats, event.payload);
 				if (isSkillActivation(event.payload.skillActivation)) {
@@ -5237,7 +5288,7 @@ export function createDispatchBundle(
 				dynamicHash: lifecycle.dynamicHash,
 				promptSignature: lifecycle.promptSignature,
 				toolSignature: lifecycle.toolSignature,
-				clioVersion: readClioVersion(),
+				clioCoderVersion: readClioVersion(),
 				piMonoVersion: readPiMonoVersion(),
 				platform: process.platform,
 				nodeVersion: process.version,
@@ -5262,7 +5313,7 @@ export function createDispatchBundle(
 				...(skillActivations.length > 0 ? { skillActivations: [...skillActivations] } : {}),
 				autonomyEnforcement: autonomyEnforcementForWorkerSpec(
 					spec,
-					lifecycle.settings?.autonomy ?? "auto-edit",
+					lifecycle.settings?.safety.autonomy ?? "auto-edit",
 					req.autonomy,
 				),
 				safety: {
@@ -5364,6 +5415,14 @@ export function createDispatchBundle(
 			return { assessment, rigor };
 		};
 
+		// The worker is spawned and its ledger row exists, so from here it can
+		// write and the batch barrier has to wait for it. Registered after the
+		// try/catch at 4939-5068, which aborts the worker and releases the lease on
+		// failure, so a run that never reaches the barrier is never made live.
+		// Paired with the abandon in dispatch(), which fires the moment
+		// finalPromise settles.
+		settlement?.live(envelope.id);
+
 		const finalPromise = (async (): Promise<RunReceipt> => {
 			try {
 				const result = await workerDone;
@@ -5488,12 +5547,21 @@ export function createDispatchBundle(
 					finalDetail = WORKER_FINAL_OUTPUT_MISSING_DETAIL;
 					failureMessage = finalDetail;
 				}
-				const hostVerification = await runHostVerification({
+				const hostVerificationInput = {
 					runId: envelope.id,
 					request: req,
 					workerSuccessful: finalOutcome === "succeeded",
-					onDiagnostic: (error) => reportDispatchDiagnostic(`write host verification memo for ${envelope.id}`, error),
-				});
+					onDiagnostic: (error: unknown) =>
+						reportDispatchDiagnostic(`write host verification memo for ${envelope.id}`, error),
+				};
+				// This await is the batch barrier. It already sits before
+				// buildReceiptDraft below, which is why batch settlement needs no
+				// receipt restructuring: every member parks here with its outcome
+				// resolved and nothing sealed.
+				const hostVerification =
+					settlement === undefined
+						? await runHostVerification(hostVerificationInput)
+						: await settlement.arrive(hostVerificationInput);
 				const hostRejection = hostVerificationRejection(hostVerification);
 				if (hostRejection !== null && finalOutcome === "succeeded") {
 					finalOutcome = "failed";
@@ -5686,6 +5754,7 @@ export function createDispatchBundle(
 	async function dispatch(
 		req: DispatchRequest,
 		observer?: DispatchAdmissionObserver,
+		settlement?: BatchVerificationGate,
 	): Promise<{
 		runId: string;
 		events: AsyncIterableIterator<unknown>;
@@ -5733,7 +5802,7 @@ export function createDispatchBundle(
 		}
 		let handle: Awaited<ReturnType<typeof dispatchAttempt>>;
 		try {
-			handle = await dispatchAttempt(prepared, observer);
+			handle = await dispatchAttempt(prepared, observer, settlement);
 		} catch (error) {
 			writerLease?.release();
 			if (createdWorktree !== undefined) {
@@ -5748,6 +5817,14 @@ export function createDispatchBundle(
 			}
 			throw error;
 		}
+		// A finalization that throws before the barrier, and an ACP handle that
+		// never reaches it at all, must not park their siblings forever. A member
+		// that already arrived is parked and abandon() is a no-op for it, so this
+		// fires harmlessly on the normal path.
+		if (settlement !== undefined) {
+			const release = (): void => settlement.abandon(handle.runId);
+			handle.finalPromise.then(release, release);
+		}
 		// 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()) };
@@ -5775,7 +5852,7 @@ export function createDispatchBundle(
 		req: DispatchRequest,
 		settings: EffectiveSettings = getEffectiveSettings(),
 	): DispatchPlanTaskResolution {
-		const isAcpAgent = settings?.delegation?.agents?.some((entry) => entry.id === req.agentId) ?? false;
+		const isAcpAgent = settings?.integrations.externalAgents?.entries?.some((entry) => entry.id === req.agentId) ?? false;
 		if (isAcpAgent && !req.delegationAgentId) req = { ...req, delegationAgentId: req.agentId };
 		const validation = routeValidationProjection(req, true);
 		const validated = validateJobSpec(validation.jobSpec);
@@ -5851,7 +5928,7 @@ export function createDispatchBundle(
 			req,
 		);
 		assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
-		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
+		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
 		assertWorkerBudgetEnforceable(target.runtime, agentSpec.budget !== null || req.budget !== undefined);
 		assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
 		assertWriteRootsEnforceable(target.runtime, pathScope.writeBoundaries);
@@ -5913,7 +5990,7 @@ export function createDispatchBundle(
 			specs,
 			request: req,
 			mode,
-			activeAgentRoles: settings?.routing.agentAutomation.activeAgentRoles ?? [],
+			activeAgentRoles: settings?.fleet.adaptiveRouting.agentRoles ?? [],
 			...(agentIntent === undefined ? {} : { intentOverride: agentIntent }),
 		});
 		const settingsFingerprint = computeSettingsFingerprint(settings ?? null);
@@ -6008,7 +6085,7 @@ export function createDispatchBundle(
 		const recipe = agents.get(req.agentId);
 		return planActiveRoute({
 			request: req,
-			settings: settings?.routing,
+			settings: settings?.fleet.adaptiveRouting,
 			capabilityClass: recipe === null ? null : normalizeAgentSpec(recipe).capabilityClass,
 			failover: failoverModeFor(req),
 			fixed,
@@ -6121,10 +6198,19 @@ export function createDispatchBundle(
 		finalPromise: Promise<ReadonlyArray<RunReceipt>>;
 	}> {
 		if (reqs.length === 0) throw new Error("dispatch: batch requires at least one request");
+		// Two or more concurrent workers share one checkout, so a declared check
+		// run while a sibling is still editing judges a tree neither worker
+		// authored. The barrier only exists when there is both something to verify
+		// and something that could race it; a one-request batch and a batch with no
+		// declared check keep today's per-run path exactly.
+		const settlement =
+			reqs.length > 1 && reqs.some((req) => (req.resolvedVerification?.length ?? 0) > 0)
+				? createBatchVerificationGate()
+				: undefined;
 		const handles: Array<Awaited<ReturnType<typeof dispatch>> & { agentId: string }> = [];
 		try {
 			for (const req of reqs) {
-				const handle = await dispatch(req);
+				const handle = await dispatch(req, undefined, settlement);
 				handles.push({ ...handle, agentId: req.agentId });
 			}
 		} catch (err) {
@@ -6219,7 +6305,7 @@ export function createDispatchBundle(
 			costProvenance: "unknown",
 			compiledPromptHash: null,
 			staticCompositionHash: null,
-			clioVersion: readClioVersion(),
+			clioCoderVersion: readClioVersion(),
 			piMonoVersion: readPiMonoVersion(),
 			platform: process.platform,
 			nodeVersion: process.version,
@@ -6343,6 +6429,7 @@ export function createDispatchBundle(
 				// Reconciliation is best-effort; a failure never blocks startup.
 			}
 			startHeartbeatWatchdog();
+			probeEndpointsAtDefaultBound();
 		},
 		async stop() {
 			// Shutdown is process-local. The durable machine-wide drain belongs to