@iowarp/clio-coder 0.3.4 → 0.3.7

package/src/domains/dispatch/extension.ts

@@ -12,13 +12,14 @@
 import { createHash, randomBytes } from "node:crypto";
 import { type Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
 import { isAbsolute, relative, resolve as resolvePath, sep } from "node:path";
-import { BusChannels, type DispatchCompletedPayload } from "../../core/bus-events.js";
+import { BusChannels, type DispatchCompletedPayload, type DispatchRunIdentity } from "../../core/bus-events.js";
 import { DEFAULT_SETTINGS, type DelegationToolGovernance } from "../../core/defaults.js";
 import type { DomainBundle, DomainContext, DomainExtension } from "../../core/domain-loader.js";
 import { GUARDRAIL_DEFAULTS } from "../../core/guardrails.js";
 import { readClioVersion, readPiMonoVersion } from "../../core/package-root.js";
 import { canonicalizeExistingPath } from "../../core/path-canonical.js";
 import { protectedResidencyModels } from "../../core/residency-protection.js";
+import { responseModelIdObservationFromRecord } from "../../core/response-model-id.js";
 import {
 	responseSchemaConflictsWithTools,
 	runtimeSpeaksResponseSchemaDialect,
@@ -39,6 +40,12 @@ 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 {
+	applyTaskWorktree,
+	cleanupTaskWorktree,
+	createTaskWorktree,
+	gitCheckoutRoot,
+} from "../../tools/task-worktree.js";
 import { truncateUtf8 } from "../../tools/truncate-utf8.js";
 import {
 	serializeWorkerRuntimeDescriptor,
@@ -134,8 +141,10 @@ import {
 	registerDetachedBatch,
 } from "./batch-store.js";
 import { type BatchState, createBatch, onRunComplete, snapshotBatch } from "./batch-tracker.js";
+import { type RunToolBudgetEnvelope, resolveToolBudgetEnvelope } from "./budget-envelope.js";
 import { assessCapabilityMismatch, type CapabilityMismatch } from "./capability-match.js";
 import { capacityLeaseUsage, createNodeLeaseUsageReader } from "./capacity-lease.js";
+import { acquireCheckoutWriterLease, type CheckoutWriterLease } from "./checkout-writer-lease.js";
 import type {
 	DispatchAdmissionObserver,
 	DispatchContract,
@@ -157,6 +166,7 @@ import {
 import { routeFactVerdict } from "./fleet-preflight.js";
 import { competeStanceLiner, isBoundedGateRolePrompt } from "./gate-role-prompts.js";
 import { classifyHeartbeat, DEFAULT_HEARTBEAT_SPEC, type HeartbeatSpec, type HeartbeatStatus } from "./heartbeat.js";
+import { hostVerificationRejection, runHostVerification } from "./host-verification.js";
 import { adaptJointRouteInput } from "./joint-route-adapter.js";
 import {
 	configuredJointNodes,
@@ -207,7 +217,7 @@ import { createRouteObserver, type RouteObservationHandle, type RouteObserver }
 import { reduceRouteQuality } from "./route-quality.js";
 import { defaultRoutingIntent } from "./routing-intent.js";
 import { detectRunIdentity } from "./run-identity.js";
-import { type Ledger, openLedger } from "./state.js";
+import { type Ledger, newRunId, openLedger } from "./state.js";
 import {
 	countToolCalls,
 	hasPotentiallyMutatingAttempt,
@@ -307,6 +317,7 @@ interface ActiveRun {
 	requestOrigin?: DispatchRequestOrigin;
 	agentId: string;
 	task: string;
+	budget?: RunToolBudgetEnvelope;
 	cwd: string;
 	/** Fleet node this run was placed on; null when no placement resolved it. */
 	node: RunNodeIdentity | null;
@@ -1287,6 +1298,7 @@ interface DispatchLifecycleStage {
 	capabilityMismatch: CapabilityMismatch | null;
 	effectiveAutonomy: AutonomyLevel;
 	budget: WorkerBudget;
+	budgetEnvelope: RunToolBudgetEnvelope;
 	settings?: Readonly<ReturnType<ConfigContract["get"]>>;
 }
 
@@ -1411,7 +1423,7 @@ function assertWriteRootsEnforceable(runtime: RuntimeDescriptor, writeRoots: Rea
 function assertWorkerBudgetEnforceable(runtime: RuntimeDescriptor, hasDeclaredBudget: boolean): void {
 	if (!hasDeclaredBudget || runtime.kind !== "subprocess") return;
 	throw new Error(
-		`dispatch: runtime '${runtime.id}' cannot enforce an explicit agent budget because subprocess workers do not expose per-tool mediation; choose a native or claude-sdk worker`,
+		`dispatch: runtime '${runtime.id}' cannot enforce an explicit dispatch budget because subprocess workers do not expose per-tool mediation; choose a native or claude-sdk worker`,
 	);
 }
 
@@ -1543,26 +1555,36 @@ 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);
+}
+
 function resolveEffectiveWorkerBudget(input: {
+	req: DispatchRequest;
+	recipeId: string;
 	declared: ReturnType<typeof normalizeAgentSpec>["budget"];
 	allowedTools: ReadonlyArray<ToolName>;
 	settings: EffectiveSettings;
-}): WorkerBudget {
-	const rawEnvCap = process.env.CLIO_CODER_WORKER_TOOL_CALL_CAP?.trim();
-	const parsedEnvCap = rawEnvCap && /^[1-9]\d*$/.test(rawEnvCap) ? Number(rawEnvCap) : Number.NaN;
-	const hardCap = Number.isSafeInteger(parsedEnvCap)
-		? parsedEnvCap
-		: (input.settings?.guardrails.workerToolCallCap ?? GUARDRAIL_DEFAULTS.workerToolCallCap);
+}): RunToolBudgetEnvelope {
+	const hardCap = workerToolCallHardCap(input.settings);
 	const declared = input.declared ?? {
 		toolCalls: hardCap,
 		readReserve: Math.min(5, Math.max(0, hardCap - 1)),
 		synthesis: true,
 	};
-	const toolCalls = Math.min(declared.toolCalls, hardCap);
-	const readReserve = input.allowedTools.includes(ToolNames.Read)
-		? Math.min(declared.readReserve, Math.max(0, toolCalls - 1))
-		: 0;
-	return { toolCalls, readReserve, synthesis: declared.synthesis, hardCap };
+	return resolveToolBudgetEnvelope({
+		recipeId: input.recipeId,
+		policy: declared,
+		...(input.req.budget === undefined ? {} : { request: input.req.budget }),
+		hardCap,
+		hasReadTool: input.allowedTools.includes(ToolNames.Read),
+		retry: (input.req.lineage?.attempt ?? 0) > 0,
+		revision: input.req.gate?.role === "builder" && input.req.gate.cycle > 1 && input.req.gate.verdict === "revise",
+	});
 }
 
 function frozenProtectedArtifactState(state: ProtectedArtifactState | undefined): ProtectedArtifactState {
@@ -1812,7 +1834,7 @@ function buildDispatchWorkerSpec(input: DispatchWorkerSpecInput, config?: Config
 	// A gate role that overrides the recipe contract gets no worker-side repair,
 	// for the same reason it gets no recipe validation.
 	if (appliesRecipeResultContract(input.req.gate?.role) && input.recipe?.resultContract) {
-		spec.resultContract = input.recipe.resultContract;
+		spec.resultContract = input.req.resultContractOverride ?? input.recipe.resultContract;
 	}
 	const product = input.req.product ?? input.recipe?.product;
 	if (product) spec.product = product;
@@ -3193,7 +3215,7 @@ export function createDispatchBundle(
 		);
 		enforceCapabilityGate(target.target.id, target.modelCapabilities, req.requiredCapabilities);
 		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
-		assertWorkerBudgetEnforceable(target.runtime, spec.budget !== null);
+		assertWorkerBudgetEnforceable(target.runtime, spec.budget !== null || req.budget !== undefined);
 
 		const cwd = req.cwd ?? process.cwd();
 		const sessionAutonomy = settings?.autonomy ?? "auto-edit";
@@ -3231,7 +3253,13 @@ export function createDispatchBundle(
 			workingContextPaths: workerWorkingContextPaths(req),
 		});
 		const systemPrompt = compiledWorkerPrompt.systemPrompt;
-		const budget = resolveEffectiveWorkerBudget({ declared: spec.budget, allowedTools: effectiveTools, settings });
+		const budgetEnvelope = resolveEffectiveWorkerBudget({
+			req,
+			recipeId: recipe.id,
+			declared: spec.budget,
+			allowedTools: effectiveTools,
+			settings,
+		});
 		// Fetch structured project context only for tiers that receive it, so
 		// read-only scouts never pay the CLIO-CODER.md read. The tier is spec policy
 		// (capability-class default, recipe frontmatter override).
@@ -3291,7 +3319,8 @@ export function createDispatchBundle(
 			operatorProfileApplied: compiledWorkerPrompt.operatorProfileApplied ?? false,
 			capabilityMismatch,
 			effectiveAutonomy,
-			budget,
+			budget: budgetEnvelope.effective,
+			budgetEnvelope,
 			...(settings ? { settings } : {}),
 		};
 	}
@@ -3473,6 +3502,7 @@ export function createDispatchBundle(
 					role?: string;
 					usage?: unknown;
 					model?: unknown;
+					responseModelIdObservation?: unknown;
 					responseModel?: unknown;
 					responseId?: unknown;
 					stopReason?: unknown;
@@ -3522,12 +3552,16 @@ export function createDispatchBundle(
 				tokenMeter.cacheReadTokens += typeof u.cacheRead === "number" ? u.cacheRead : 0;
 				tokenMeter.cacheWriteTokens += typeof u.cacheWrite === "number" ? u.cacheWrite : 0;
 				tokenMeter.reasoningTokens += extractReasoningTokenCount(u);
-				const model = readStringOrNull(event.message.model);
-				const responseModel = readStringOrNull(event.message.responseModel);
-				const responseId = readStringOrNull(event.message.responseId);
-				if (model !== null || responseModel !== null || responseId !== null) {
-					upstreamResponses.push({ model, responseModel, responseId });
-				}
+				const requestedModelId = readStringOrNull(event.message.model);
+				const responseModelIdObservation = responseModelIdObservationFromRecord(event.message, "not-observed");
+				const differingResponseModelId = readStringOrNull(event.message.responseModel);
+				const providerResponseId = readStringOrNull(event.message.responseId);
+				upstreamResponses.push({
+					requestedModelId,
+					responseModelIdObservation,
+					differingResponseModelId,
+					providerResponseId,
+				});
 				if (event.message.stopReason === "error") {
 					const message = readStringOrNull(event.message.errorMessage);
 					if (message !== null) failureMessage = message;
@@ -3584,10 +3618,12 @@ export function createDispatchBundle(
 		let identity!: ReturnType<typeof detectRunIdentity>;
 		try {
 			envelope = ledgerRef.create({
+				...(req.runIdHint !== undefined ? { id: req.runIdHint } : {}),
 				agentId: req.agentId,
 				executionRole: withAttemptRole(req.executionRole, req.lineage?.attempt ?? 0),
 				requestOrigin: lifecycle.requestOrigin,
 				task: req.task,
+				...(req.intent !== undefined ? { intent: structuredClone(req.intent) } : {}),
 				targetId,
 				wireModelId,
 				runtimeId,
@@ -3619,6 +3655,7 @@ export function createDispatchBundle(
 				...(lifecycle.pipeline ? { pipeline: lifecycle.pipeline } : {}),
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
+				...(req.council !== undefined ? { council: req.council } : {}),
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 			});
@@ -3761,6 +3798,7 @@ export function createDispatchBundle(
 				executionRole: envelope.executionRole,
 				requestOrigin: lifecycle.requestOrigin,
 				task: req.task,
+				...(req.intent !== undefined ? { intent: structuredClone(req.intent) } : {}),
 				targetId,
 				wireModelId,
 				runtimeId,
@@ -3775,6 +3813,7 @@ export function createDispatchBundle(
 				...(lifecycle.pipeline ? { pipeline: lifecycle.pipeline } : {}),
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
+				...(req.council !== undefined ? { council: req.council } : {}),
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 				projectContext: lifecycle.projectContext,
@@ -3887,6 +3926,7 @@ export function createDispatchBundle(
 				durationMs,
 				exitCode: receipt.exitCode,
 				toolActivity: receipt.toolActivity ?? null,
+				...(receipt.hostVerification !== undefined ? { hostVerification: receipt.hostVerification.status } : {}),
 				...(receipt.skillActivations && receipt.skillActivations.length > 0
 					? { skillActivations: [...receipt.skillActivations] }
 					: {}),
@@ -4142,6 +4182,11 @@ export function createDispatchBundle(
 			return handle;
 		};
 		if (req.delegationAgentId) {
+			if (req.budget !== undefined) {
+				throw new Error(
+					"dispatch: budget envelopes cannot be enforced on an ACP delegation target; dispatch to a native or claude-sdk worker",
+				);
+			}
 			assertPlannedNodeIdentity(req, { id: "local", kind: "local" });
 			assertProtectedArtifactsEnforceable("acp-delegation", false, protectedArtifactState);
 			if (req.responseSchema !== undefined) {
@@ -4372,6 +4417,7 @@ export function createDispatchBundle(
 					role?: string;
 					usage?: unknown;
 					model?: unknown;
+					responseModelIdObservation?: unknown;
 					responseModel?: unknown;
 					responseId?: unknown;
 					stopReason?: unknown;
@@ -4412,7 +4458,8 @@ export function createDispatchBundle(
 			if (
 				event.type === "clio_run_outcome" &&
 				isRunOutcomeCode(event.payload?.outcomeCode) &&
-				event.payload.outcomeCode !== "worker_final_output_missing"
+				event.payload.outcomeCode !== "worker_final_output_missing" &&
+				event.payload.outcomeCode !== "host_verification_rejected"
 			) {
 				if (acceptsOutcomeCodeEvents) {
 					trustedOutcomeCodes.add(event.payload.outcomeCode);
@@ -4477,12 +4524,16 @@ export function createDispatchBundle(
 				tokenMeter.cacheReadTokens += typeof u.cacheRead === "number" ? u.cacheRead : 0;
 				tokenMeter.cacheWriteTokens += typeof u.cacheWrite === "number" ? u.cacheWrite : 0;
 				tokenMeter.reasoningTokens += extractReasoningTokenCount(u);
-				const model = readStringOrNull(event.message.model);
-				const responseModel = readStringOrNull(event.message.responseModel);
-				const responseId = readStringOrNull(event.message.responseId);
-				if (model !== null || responseModel !== null || responseId !== null) {
-					upstreamResponses.push({ model, responseModel, responseId });
-				}
+				const requestedModelId = readStringOrNull(event.message.model);
+				const responseModelIdObservation = responseModelIdObservationFromRecord(event.message, "not-observed");
+				const differingResponseModelId = readStringOrNull(event.message.responseModel);
+				const providerResponseId = readStringOrNull(event.message.responseId);
+				upstreamResponses.push({
+					requestedModelId,
+					responseModelIdObservation,
+					differingResponseModelId,
+					providerResponseId,
+				});
 				if (event.message.stopReason === "error") {
 					const message = readStringOrNull(event.message.errorMessage);
 					if (message !== null) failureMessage = message;
@@ -4568,11 +4619,14 @@ export function createDispatchBundle(
 		let identity!: ReturnType<typeof detectRunIdentity>;
 		try {
 			envelope = ledgerRef.create({
+				...(req.runIdHint !== undefined ? { id: req.runIdHint } : {}),
 				agentId: req.agentId,
 				executionRole: withAttemptRole(req.executionRole, req.lineage?.attempt ?? 0),
 				agentAudience: lifecycle.agentAudience,
 				requestOrigin: lifecycle.requestOrigin,
 				task: req.task,
+				...(req.intent !== undefined ? { intent: structuredClone(req.intent) } : {}),
+				budget: lifecycle.budgetEnvelope,
 				targetId: lifecycle.target.target.id,
 				wireModelId: lifecycle.target.wireModelId,
 				runtimeId: lifecycle.target.runtime.id,
@@ -4621,6 +4675,7 @@ export function createDispatchBundle(
 				...(lifecycle.pipeline ? { pipeline: lifecycle.pipeline } : {}),
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
+				...(req.council !== undefined ? { council: req.council } : {}),
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 				...(heartbeatAt ? { heartbeatAt: heartbeatIso(heartbeatAt.current) } : {}),
@@ -4638,8 +4693,10 @@ export function createDispatchBundle(
 			// reroute lineage depth, and the model context window for the
 			// per-worker meter. All optional so consumers degrade to local/plain.
 			const fleetIdentity = {
+				budget: lifecycle.budgetEnvelope,
 				...(placement !== undefined && placement !== null ? { node: placement.node.id } : {}),
 				...(req.gate !== undefined ? { gate: { role: req.gate.role, cycle: req.gate.cycle } } : {}),
+				...(req.council !== undefined ? { council: req.council } : {}),
 				...(req.reroutes !== undefined && req.reroutes.length > 0 ? { rerouteCount: req.reroutes.length } : {}),
 				...(lifecycle.target.modelCapabilities !== undefined &&
 				lifecycle.target.modelCapabilities !== null &&
@@ -4743,6 +4800,7 @@ export function createDispatchBundle(
 			requestOrigin: lifecycle.requestOrigin,
 			agentId: req.agentId,
 			task: req.task,
+			budget: lifecycle.budgetEnvelope,
 			cwd: lifecycle.cwd,
 			node: placement?.node ?? null,
 			aborted: false,
@@ -4790,6 +4848,15 @@ export function createDispatchBundle(
 			const tokenCount =
 				tokenMeter.inputTokens + tokenMeter.outputTokens + tokenMeter.cacheReadTokens + tokenMeter.cacheWriteTokens;
 			const protectedArtifacts = protectedArtifactReceiptSummary(spec.protectedArtifactState);
+			const fleetGate = (() => {
+				if (req.fleetGateReceipt === undefined) return null;
+				try {
+					const content = readFileSync(resolvePath(lifecycle.cwd, req.fleetGateReceipt.path));
+					return { path: req.fleetGateReceipt.path, pathHash: createHash("sha256").update(content).digest("hex") };
+				} catch {
+					return { path: req.fleetGateReceipt.path, pathHash: createHash("sha256").update("").digest("hex") };
+				}
+			})();
 			// Sealed from the stored board, never from anything the worker said
 			// about itself. Absent when the run had no ledger.
 			const ledgerContribution = (() => {
@@ -4817,6 +4884,7 @@ export function createDispatchBundle(
 				agentAudience: lifecycle.agentAudience,
 				requestOrigin: lifecycle.requestOrigin,
 				task: req.task,
+				budget: lifecycle.budgetEnvelope,
 				targetId: lifecycle.target.target.id,
 				wireModelId: lifecycle.target.wireModelId,
 				runtimeId: lifecycle.target.runtime.id,
@@ -4824,6 +4892,7 @@ export function createDispatchBundle(
 				outcome,
 				outcomeCode,
 				lineage,
+				...(req.intent !== undefined ? { intent: structuredClone(req.intent) } : {}),
 				identity,
 				node: placement?.node ?? LOCAL_RUN_NODE,
 				...receiptAttestationFields(worker.attestation?.() ?? null),
@@ -4834,7 +4903,9 @@ export function createDispatchBundle(
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(steering.length > 0 ? { steering: steering.map((entry) => ({ ...entry })) } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
+				...(req.council !== undefined ? { council: req.council } : {}),
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
+				...(fleetGate !== null ? { fleetGate } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 				projectContext: lifecycle.projectContext,
 				rulesApplied: lifecycle.rulesApplied,
@@ -4964,6 +5035,7 @@ export function createDispatchBundle(
 				durationMs,
 				exitCode: receipt.exitCode,
 				toolActivity: receipt.toolActivity ?? null,
+				...(receipt.hostVerification !== undefined ? { hostVerification: receipt.hostVerification.status } : {}),
 				...(receipt.skillActivations && receipt.skillActivations.length > 0
 					? { skillActivations: [...receipt.skillActivations] }
 					: {}),
@@ -5062,7 +5134,7 @@ export function createDispatchBundle(
 				const capturedOutput = outputCapture.snapshot();
 				const observedRunEffects = runEffects.snapshot();
 				const appliedResultContract = appliesRecipeResultContract(req.gate?.role)
-					? (lifecycle.recipe?.resultContract ?? null)
+					? (req.resultContractOverride ?? lifecycle.recipe?.resultContract ?? null)
 					: null;
 				const resultContract = validateRecipeResult({
 					contract: appliedResultContract,
@@ -5126,13 +5198,40 @@ export function createDispatchBundle(
 					finalDetail = [finalDetail, describeUngroundedValidations(validationGrounding)].filter(Boolean).join("; ");
 				}
 				const hasTerminalArtifact =
-					lifecycle.recipe?.resultContract.kind === "architect-plan" && resultValidation?.conformance === "pass";
+					(req.resultContractOverride ?? lifecycle.recipe?.resultContract)?.kind === "architect-plan" &&
+					resultValidation?.conformance === "pass";
 				if (finalOutcome === "succeeded" && !hasDurableFinalOutput(capturedOutput) && !hasTerminalArtifact) {
 					finalOutcome = "failed";
 					outcomeCode = "worker_final_output_missing";
 					finalDetail = WORKER_FINAL_OUTPUT_MISSING_DETAIL;
 					failureMessage = finalDetail;
 				}
+				const hostVerification = await runHostVerification({
+					runId: envelope.id,
+					request: req,
+					workerSuccessful: finalOutcome === "succeeded",
+					onDiagnostic: (error) => reportDispatchDiagnostic(`write host verification memo for ${envelope.id}`, error),
+				});
+				const hostRejection = hostVerificationRejection(hostVerification);
+				if (hostRejection !== null && finalOutcome === "succeeded") {
+					finalOutcome = "failed";
+					outcomeCode = hostRejection.outcomeCode;
+					finalDetail = hostRejection.detail;
+					failureMessage = finalDetail;
+				}
+				let worktreeReceipt: RunReceiptDraft["worktree"];
+				if (req.taskWorktree !== undefined && finalOutcome === "succeeded") {
+					worktreeReceipt = applyTaskWorktree({
+						worktree: req.taskWorktree,
+						apply: req.apply ?? "merge",
+						protectedPaths: getProtectedArtifactState().artifacts.map((artifact) => artifact.path),
+					});
+					if (worktreeReceipt.reason !== undefined) {
+						finalOutcome = "failed";
+						finalDetail = worktreeReceipt.reason;
+						failureMessage = finalDetail;
+					}
+				}
 				const status = runStatusForOutcome(finalOutcome);
 				const failureClass = classifyFailure(evidence, result, finalOutcome, outcomeCode);
 				const receiptDraft = buildReceiptDraft(
@@ -5146,6 +5245,8 @@ export function createDispatchBundle(
 					sealedResultContractFact,
 					validationGrounding === null ? null : { ...validationGrounding, ungrounded: [...validationGrounding.ungrounded] },
 				);
+				if (hostVerification !== undefined) receiptDraft.hostVerification = hostVerification;
+				if (worktreeReceipt !== undefined) receiptDraft.worktree = worktreeReceipt;
 				const ledgerPatch: Partial<RunEnvelope> = {
 					status,
 					outcome: finalOutcome,
@@ -5176,6 +5277,13 @@ export function createDispatchBundle(
 				ledgerRef.update(envelope.id, ledgerPatch);
 				const receipt = ledgerRef.recordReceipt(envelope.id, sealRouteDecision(receiptDraft, routeObservation.decision));
 				await ledgerRef.persist();
+				if (worktreeReceipt?.applied === true && req.taskWorktree !== undefined) {
+					try {
+						cleanupTaskWorktree(req.taskWorktree, true);
+					} catch (cleanupError) {
+						reportDispatchDiagnostic(`clean applied task worktree ${req.taskWorktree.runId}`, cleanupError);
+					}
+				}
 				active.delete(envelope.id);
 				recordTargetOutcome(
 					lifecycle.target.target.id,
@@ -5263,10 +5371,58 @@ export function createDispatchBundle(
 		events: AsyncIterableIterator<unknown>;
 		finalPromise: Promise<RunReceipt>;
 	}> {
+		let prepared = req;
+		let createdWorktree: DispatchRequest["taskWorktree"];
+		let writerLease: CheckoutWriterLease | undefined;
+		const writerRecipe = agents.get(req.agentId);
+		if (writerRecipe !== null && normalizeAgentSpec(writerRecipe).capabilityClass === "workspace-edit") {
+			const checkout = req.taskWorktree?.root ?? gitCheckoutRoot(req.cwd ?? process.cwd());
+			if (checkout !== null) writerLease = acquireCheckoutWriterLease({ checkout });
+		}
+		if (req.worktree === true && req.taskWorktree === undefined) {
+			const requestedCwd = resolvePath(req.cwd ?? process.cwd());
+			const root = gitCheckoutRoot(requestedCwd);
+			if (root === null) throw new Error("worktree_non_git_checkout");
+			if (req.taskWorktreeDestination !== undefined && root !== req.taskWorktreeDestination) {
+				writerLease?.release();
+				throw new Error("dispatch: worktree merge destination differs from the approved execution snapshot");
+			}
+			const runId = newRunId();
+			let taskWorktree: NonNullable<DispatchRequest["taskWorktree"]>;
+			try {
+				taskWorktree = createTaskWorktree(root, runId);
+			} catch (error) {
+				writerLease?.release();
+				throw error;
+			}
+			createdWorktree = taskWorktree;
+			const cwdRelative = relative(root, requestedCwd);
+			const workerCwd = resolvePath(taskWorktree.path, cwdRelative);
+			const writeRoots = req.writeRoots?.map((entry) => {
+				const rel = relative(root, entry);
+				return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel) ? entry : resolvePath(taskWorktree.path, rel);
+			});
+			prepared = {
+				...req,
+				runIdHint: runId,
+				taskWorktree,
+				cwd: workerCwd,
+				protectedArtifactRemap: { sourceRoot: root, workerRoot: taskWorktree.path },
+				...(writeRoots === undefined ? {} : { writeRoots }),
+			};
+		}
 		let handle: Awaited<ReturnType<typeof dispatchAttempt>>;
 		try {
-			handle = await dispatchAttempt(req, observer);
+			handle = await dispatchAttempt(prepared, observer);
 		} catch (error) {
+			writerLease?.release();
+			if (createdWorktree !== undefined) {
+				try {
+					cleanupTaskWorktree(createdWorktree, true);
+				} catch (cleanupError) {
+					reportDispatchDiagnostic(`clean task worktree ${createdWorktree.runId} after admission failure`, cleanupError);
+				}
+			}
 			if (req.reservation !== undefined && req.lineage === undefined) {
 				rollbackDispatchReservation(req.reservation.ownerId, now());
 			}
@@ -5274,7 +5430,7 @@ 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;
+		if (req.lineage) return { ...handle, finalPromise: handle.finalPromise.finally(() => writerLease?.release()) };
 
 		const assignment = assignments.open(handle.runId, assignmentPolicyFor(handle.effectiveRequest));
 		persistAssignment(registerAssignment(assignment.id), `${assignment.id}:open`);
@@ -5287,9 +5443,10 @@ export function createDispatchBundle(
 		const reservation = req.reservation;
 		const terminal =
 			reservation === undefined
-				? assignment.terminal
+				? assignment.terminal.finally(() => writerLease?.release())
 				: assignment.terminal.finally(() => {
 						releaseDispatchReservationMember(reservation.ownerId, reservation.memberId, now());
+						writerLease?.release();
 					});
 		return { runId: handle.runId, events: assignment.events, finalPromise: terminal };
 	}
@@ -5306,6 +5463,11 @@ export function createDispatchBundle(
 		req = validation.restore(validated.spec);
 
 		if (req.delegationAgentId) {
+			if (req.budget !== undefined) {
+				throw new Error(
+					"dispatch: budget envelopes cannot be enforced on an ACP delegation target; dispatch to a native or claude-sdk worker",
+				);
+			}
 			const protectedArtifactState = getProtectedArtifactState();
 			assertProtectedArtifactsEnforceable("acp-delegation", false, protectedArtifactState);
 			if (req.responseSchema !== undefined) {
@@ -5369,6 +5531,7 @@ export function createDispatchBundle(
 		);
 		assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
 		assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
+		assertWorkerBudgetEnforceable(target.runtime, agentSpec.budget !== null || req.budget !== undefined);
 		assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
 		assertWriteRootsEnforceable(target.runtime, req.writeRoots);
 		assertProtectedArtifactsEnforceable(
@@ -5376,6 +5539,13 @@ export function createDispatchBundle(
 			target.runtime.kind !== "subprocess",
 			getProtectedArtifactState(),
 		);
+		resolveEffectiveWorkerBudget({
+			req,
+			recipeId: recipe.id,
+			declared: agentSpec.budget,
+			allowedTools: effectiveTools,
+			settings,
+		});
 		return {
 			agentId: req.agentId,
 			specFingerprint: agentSpecFingerprint(agentSpec),
@@ -5660,6 +5830,137 @@ export function createDispatchBundle(
 		};
 	}
 
+	async function sealCouncilSynthesis(input: {
+		group: string;
+		round: number;
+		kind: "none" | "vote";
+		text: string;
+		subjects: ReadonlyArray<{ runId: string; digest: string | null }>;
+		template: RunReceipt;
+	}): Promise<RunReceipt> {
+		const l = requireLedger();
+		const runId = newRunId();
+		const task = `Council ${input.kind} synthesis`;
+		// The synthesis is the council's own verdict, filed under the origin the
+		// council was asked from: an internal origin would keep it out of the
+		// transcript worker fold, and with it out of /share.
+		const origin = input.template.requestOrigin ?? "agent";
+		const gate = { role: "synthesis" as const, group: input.group, cycle: input.round, subjects: [...input.subjects] };
+		const council = { group: input.group, label: "synthesis", round: input.round };
+		const created = l.create({
+			id: runId,
+			agentId: "council-synthesis",
+			executionRole: "judge",
+			requestOrigin: origin,
+			task,
+			targetId: input.template.targetId,
+			wireModelId: input.template.wireModelId,
+			runtimeId: input.template.runtimeId,
+			runtimeKind: input.template.runtimeKind,
+			sessionId: input.template.sessionId,
+			cwd: input.template.reproducibility?.cwd ?? process.cwd(),
+		});
+		const endedAt = new Date().toISOString();
+		l.update(runId, {
+			status: "completed",
+			outcome: "succeeded",
+			endedAt,
+			exitCode: 0,
+			gate,
+			council,
+			...(input.template.plan !== undefined ? { plan: input.template.plan } : {}),
+		});
+		const receipt = l.recordReceipt(runId, {
+			runId,
+			agentId: "council-synthesis",
+			executionRole: "judge",
+			requestOrigin: origin,
+			task,
+			targetId: input.template.targetId,
+			wireModelId: input.template.wireModelId,
+			runtimeId: input.template.runtimeId,
+			runtimeKind: input.template.runtimeKind,
+			startedAt: created.startedAt,
+			endedAt,
+			outcome: "succeeded",
+			outcomeDetail: null,
+			exitCode: 0,
+			tokenCount: 0,
+			inputTokenCount: 0,
+			outputTokenCount: 0,
+			reasoningTokenCount: 0,
+			cacheReadTokenCount: 0,
+			cacheWriteTokenCount: 0,
+			output: { state: "final", text: input.text, bytes: Buffer.byteLength(input.text, "utf8"), truncated: false },
+			costUsd: 0,
+			costProvenance: "unknown",
+			compiledPromptHash: null,
+			staticCompositionHash: null,
+			clioVersion: readClioVersion(),
+			piMonoVersion: readPiMonoVersion(),
+			platform: process.platform,
+			nodeVersion: process.version,
+			toolCalls: 0,
+			toolStats: [],
+			verification: { state: "unverified", basis: "no-validation-tool" },
+			routingIntent: defaultRoutingIntent({}),
+			quality: createRunReceiptQuality({ runtimeEnforceable: false, enforcementPassed: null, resultContract: null }),
+			reproducibility: collectReproducibility(input.template.reproducibility?.cwd ?? process.cwd(), null),
+			sessionId: input.template.sessionId,
+			gate,
+			council,
+			...(input.template.plan !== undefined ? { plan: input.template.plan } : {}),
+		});
+		await l.persist();
+		// The synthesis never ran as a worker, so nothing else publishes its
+		// lifecycle. The Fleet Runs board and /share are built from these
+		// events, and a council whose synthesis they cannot see is a council
+		// whose verdict the operator cannot read or share.
+		const identity: DispatchRunIdentity = {
+			runId,
+			agentId: "council-synthesis",
+			task,
+			requestOrigin: origin,
+			targetId: receipt.targetId,
+			wireModelId: receipt.wireModelId,
+			runtimeId: receipt.runtimeId,
+			runtimeKind: receipt.runtimeKind,
+			gate: { role: gate.role, cycle: gate.cycle },
+			council,
+		};
+		context.bus.emit(BusChannels.DispatchEnqueued, { ...identity, requestOrigin: origin });
+		context.bus.emit(BusChannels.DispatchStarted, {
+			...identity,
+			requestOrigin: origin,
+			pid: null,
+			assignmentId: runId,
+			attempt: 0,
+		});
+		context.bus.emit(BusChannels.DispatchCompleted, {
+			...identity,
+			requestOrigin: origin,
+			outcome: "succeeded",
+			outcomeCode: null,
+			outcomeDetail: null,
+			lineage: input.template.lineage ?? { parentRunId: null, rootRunId: runId, attempt: 0, depth: 0 },
+			tokenCount: 0,
+			inputTokenCount: 0,
+			outputTokenCount: 0,
+			cacheReadTokenCount: 0,
+			cacheWriteTokenCount: 0,
+			reasoningTokenCount: 0,
+			staticShellHash: null,
+			sessionShellHash: null,
+			dynamicHash: null,
+			costUsd: 0,
+			costProvenance: "unknown",
+			durationMs: 0,
+			exitCode: 0,
+			toolActivity: null,
+		});
+		return receipt;
+	}
+
 	const extension: DomainExtension = {
 		async start() {
 			// No in-memory executor survives a process restart, so every active
@@ -5773,6 +6074,7 @@ export function createDispatchBundle(
 				runId: run.runId,
 				agentId: run.agentId,
 				task: run.task,
+				...(run.budget !== undefined ? { budget: run.budget } : {}),
 				runtimeKind: run.runtimeKind,
 				outcomePhase: run.stallKilled ? "terminating" : run.aborted ? "aborting" : "running",
 				heartbeat,
@@ -5893,6 +6195,7 @@ export function createDispatchBundle(
 		protectedArtifactState: () => getProtectedArtifactState(),
 		dispatch,
 		dispatchBatch,
+		sealCouncilSynthesis,
 		listRuns(status) {
 			const l = requireLedger();
 			return status ? l.list({ status }) : l.list();