@iowarp/clio-coder 0.3.6 → 0.3.8

package/src/domains/dispatch/path-scope.ts

@@ -0,0 +1,370 @@
+import {
+	asDirectoryPathBoundary,
+	normalizePathBoundaryEntry,
+	PathBoundaryError,
+	pathBoundaryCovers,
+	resolvePathBoundary,
+} from "../../core/path-boundary.js";
+import type { DispatchRequest } from "./contract.js";
+
+/** Path-like tokens retained for requests that do not carry typed intent. */
+const DISPATCH_PATH_TOKEN_RE = /(?:[\w.-]+\/)+[\w.-]+|\b[\w-]+\.[A-Za-z0-9]{1,8}\b/g;
+const HTTP_URL_RE = /\bhttps?:\/\/\S+/gu;
+const POSIX_ABSOLUTE_TOKEN_RE = /(?:^|[\s("'])((?:\/[\w.~+-]+)+)/gu;
+const WINDOWS_ABSOLUTE_TOKEN_RE = /(?:^|[\s("'])([A-Za-z]:[\\/][^\s"']+)/gu;
+const BACKSLASH_PATH_RE = /\b[A-Za-z_.-][\w.-]*\\(?:(?:[\w.-]+\\)+[\w.-]+|[\w-]+\.[A-Za-z0-9]{1,8})\b/gu;
+const DOUBLE_SEPARATOR_PATH_RE = /\b[\w.-]+\/\/[\w./-]+/gu;
+
+export type DispatchPathProvenanceKind = "declared" | "derived" | "inferred";
+export type DispatchPathConfidence = "certain" | "high" | "medium" | "low";
+export type DispatchPathProvenanceSource =
+	| "intent.read_roots"
+	| "intent.write_roots"
+	| "intent.relevant_paths"
+	| "writeRoots"
+	| "task"
+	| "briefing";
+export type DispatchPathProvenanceReason =
+	| "explicit_intent"
+	| "legacy_write_roots"
+	| "task_path_token"
+	| "briefing_path_token";
+
+export interface DispatchPathProvenanceEvidence {
+	provenance: DispatchPathProvenanceKind;
+	source: DispatchPathProvenanceSource;
+	confidence: DispatchPathConfidence;
+	reason: DispatchPathProvenanceReason;
+}
+
+export interface DispatchPathProvenanceEntry {
+	path: string;
+	evidence: DispatchPathProvenanceEvidence[];
+}
+
+export interface DispatchPathScopeProvenance {
+	version: 1;
+	mode: "declared" | "legacy-inferred";
+	workingContextPaths: DispatchPathProvenanceEntry[];
+	writeBoundaries: DispatchPathProvenanceEntry[];
+}
+
+export interface DispatchPathScope {
+	source: "declared" | "inferred";
+	workingContextPaths: ReadonlyArray<string>;
+	writeBoundaries: ReadonlyArray<string>;
+	inferredOnlyPaths: ReadonlyArray<string>;
+	provenance: DispatchPathScopeProvenance;
+}
+
+export interface DeclaredScopeReplacementNotice {
+	code: "typed_scope_replaced_inferred_paths";
+	level: "warning";
+	omittedPaths: ReadonlyArray<string>;
+	message: string;
+}
+
+export interface LegacyScopeInferenceNotice {
+	code: "legacy_scope_inferred" | "legacy_scope_empty";
+	level: "warning";
+	paths: ReadonlyArray<{
+		path: string;
+		policy: "working-context" | "write-boundary";
+		provenance: DispatchPathProvenanceKind;
+		source: DispatchPathProvenanceSource;
+		confidence: DispatchPathConfidence;
+	}>;
+	message: string;
+}
+
+export type DispatchPathScopeInferenceErrorCode = "legacy_scope_path_absolute" | "legacy_scope_path_malformed";
+
+export class DispatchPathScopeInferenceError extends Error {
+	readonly code: DispatchPathScopeInferenceErrorCode;
+	readonly source: "task" | "briefing";
+	readonly token: string;
+
+	constructor(code: DispatchPathScopeInferenceErrorCode, source: "task" | "briefing", token: string, detail: string) {
+		super(`${code}: ${source} contains ${detail} '${token}'; declare intent explicitly`);
+		this.name = "DispatchPathScopeInferenceError";
+		this.code = code;
+		this.source = source;
+		this.token = token;
+	}
+}
+
+const DECLARED_EVIDENCE = {
+	readRoots: {
+		provenance: "declared",
+		source: "intent.read_roots",
+		confidence: "certain",
+		reason: "explicit_intent",
+	},
+	writeRoots: {
+		provenance: "declared",
+		source: "intent.write_roots",
+		confidence: "certain",
+		reason: "explicit_intent",
+	},
+	relevantPaths: {
+		provenance: "declared",
+		source: "intent.relevant_paths",
+		confidence: "certain",
+		reason: "explicit_intent",
+	},
+} as const satisfies Record<"readRoots" | "writeRoots" | "relevantPaths", DispatchPathProvenanceEvidence>;
+
+function cloneEvidence(evidence: DispatchPathProvenanceEvidence): DispatchPathProvenanceEvidence {
+	return { ...evidence };
+}
+
+function addProvenance(
+	entries: Map<string, DispatchPathProvenanceEntry>,
+	path: string,
+	evidence: DispatchPathProvenanceEvidence,
+): void {
+	const current = entries.get(path);
+	if (current === undefined) {
+		entries.set(path, { path, evidence: [cloneEvidence(evidence)] });
+		return;
+	}
+	if (!current.evidence.some((entry) => entry.source === evidence.source)) {
+		current.evidence.push(cloneEvidence(evidence));
+	}
+}
+
+function sortedEntries(entries: Map<string, DispatchPathProvenanceEntry>): DispatchPathProvenanceEntry[] {
+	return [...entries.values()]
+		.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0))
+		.map((entry) => ({ path: entry.path, evidence: entry.evidence.map(cloneEvidence) }));
+}
+
+/** Build the required field-level provenance for normalized declared intent. */
+export function declaredIntentPathProvenance(input: {
+	readRoots: ReadonlyArray<string>;
+	writeRoots: ReadonlyArray<string>;
+	relevantPaths: ReadonlyArray<string>;
+}): DispatchPathProvenanceEntry[] {
+	const entries = new Map<string, DispatchPathProvenanceEntry>();
+	for (const path of input.readRoots) addProvenance(entries, path, DECLARED_EVIDENCE.readRoots);
+	for (const path of input.writeRoots) addProvenance(entries, path, DECLARED_EVIDENCE.writeRoots);
+	for (const path of input.relevantPaths) addProvenance(entries, path, DECLARED_EVIDENCE.relevantPaths);
+	return sortedEntries(entries);
+}
+
+function inferredPaths(req: Pick<DispatchRequest, "task" | "briefing">): string[] {
+	const paths = new Set<string>();
+	const text = `${req.task}\n${req.briefing ?? ""}`;
+	for (const match of text.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+		const token = inferredPathToken(match[0]);
+		if (token.startsWith("http://") || token.startsWith("https://")) continue;
+		paths.add(token);
+	}
+	return [...paths];
+}
+
+function inferredPathToken(token: string): string {
+	return token.replace(/\.+$/u, "");
+}
+
+function failMalformedText(text: string, source: "task" | "briefing"): void {
+	const withoutUrls = text.replace(HTTP_URL_RE, (url) => " ".repeat(url.length));
+	const absolute = POSIX_ABSOLUTE_TOKEN_RE.exec(withoutUrls)?.[1];
+	POSIX_ABSOLUTE_TOKEN_RE.lastIndex = 0;
+	if (absolute !== undefined) {
+		throw new DispatchPathScopeInferenceError("legacy_scope_path_absolute", source, absolute, "an absolute path token");
+	}
+	const windowsAbsolute = WINDOWS_ABSOLUTE_TOKEN_RE.exec(withoutUrls)?.[1];
+	WINDOWS_ABSOLUTE_TOKEN_RE.lastIndex = 0;
+	if (windowsAbsolute !== undefined) {
+		throw new DispatchPathScopeInferenceError(
+			"legacy_scope_path_absolute",
+			source,
+			windowsAbsolute,
+			"an absolute path token",
+		);
+	}
+	for (const pattern of [BACKSLASH_PATH_RE, DOUBLE_SEPARATOR_PATH_RE]) {
+		const malformed = pattern.exec(withoutUrls)?.[0];
+		pattern.lastIndex = 0;
+		if (malformed !== undefined) {
+			throw new DispatchPathScopeInferenceError(
+				"legacy_scope_path_malformed",
+				source,
+				malformed,
+				"a malformed path token",
+			);
+		}
+	}
+}
+
+function strictInferredPaths(
+	text: string,
+	source: "task" | "briefing",
+): Array<{ path: string; evidence: DispatchPathProvenanceEvidence }> {
+	failMalformedText(text, source);
+	const withoutUrls = text.replace(HTTP_URL_RE, (url) => " ".repeat(url.length));
+	const evidence: DispatchPathProvenanceEvidence =
+		source === "task"
+			? { provenance: "inferred", source, confidence: "medium", reason: "task_path_token" }
+			: { provenance: "inferred", source, confidence: "low", reason: "briefing_path_token" };
+	const result: Array<{ path: string; evidence: DispatchPathProvenanceEvidence }> = [];
+	for (const match of withoutUrls.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+		const token = inferredPathToken(match[0]);
+		try {
+			result.push({ path: normalizePathBoundaryEntry(token), evidence });
+		} catch (error) {
+			const code =
+				error instanceof PathBoundaryError && error.code === "absolute"
+					? "legacy_scope_path_absolute"
+					: "legacy_scope_path_malformed";
+			throw new DispatchPathScopeInferenceError(
+				code,
+				source,
+				token,
+				code === "legacy_scope_path_absolute" ? "an absolute path token" : "a malformed path token",
+			);
+		}
+	}
+	return result;
+}
+
+function legacyPathScope(req: DispatchRequest, cwd: string): DispatchPathScope {
+	const workingEntries = new Map<string, DispatchPathProvenanceEntry>();
+	const writeEntries = new Map<string, DispatchPathProvenanceEntry>();
+	const writeEvidence: DispatchPathProvenanceEvidence = {
+		provenance: "derived",
+		source: "writeRoots",
+		confidence: "high",
+		reason: "legacy_write_roots",
+	};
+	for (const root of req.writeRoots ?? []) {
+		addProvenance(workingEntries, root, writeEvidence);
+		addProvenance(writeEntries, asDirectoryPathBoundary(resolvePathBoundary(cwd, root)), writeEvidence);
+	}
+	for (const candidate of strictInferredPaths(req.task, "task")) {
+		addProvenance(workingEntries, candidate.path, candidate.evidence);
+	}
+	if (req.briefing !== undefined) {
+		for (const candidate of strictInferredPaths(req.briefing, "briefing")) {
+			addProvenance(workingEntries, candidate.path, candidate.evidence);
+		}
+	}
+	const workingContext = [...workingEntries.values()].map((entry) => ({
+		path: entry.path,
+		evidence: entry.evidence.map(cloneEvidence),
+	}));
+	const writeBoundaries = [...writeEntries.values()].map((entry) => ({
+		path: entry.path,
+		evidence: entry.evidence.map(cloneEvidence),
+	}));
+	return {
+		source: "inferred",
+		workingContextPaths: workingContext.map((entry) => entry.path),
+		writeBoundaries: writeBoundaries.map((entry) => entry.path),
+		inferredOnlyPaths: [],
+		provenance: {
+			version: 1,
+			mode: "legacy-inferred",
+			workingContextPaths: workingContext,
+			writeBoundaries,
+		},
+	};
+}
+
+/** Resolve every policy-bearing path projection for one dispatch request. */
+export function resolveDispatchPathScope(req: DispatchRequest): DispatchPathScope {
+	const cwd = req.cwd ?? process.cwd();
+	if (req.intent === undefined) return legacyPathScope(req, cwd);
+
+	const declaredProvenance = declaredIntentPathProvenance(req.intent);
+	const declaredPaths = declaredProvenance.map((entry) => entry.path);
+	const inferredOnlyPaths = inferredPaths(req).filter((candidate) => !pathBoundaryCovers(declaredPaths, candidate));
+	const writeEvidence = DECLARED_EVIDENCE.writeRoots;
+	const writeBoundaries = req.intent.writeRoots.map((root) => ({
+		path: resolvePathBoundary(cwd, root),
+		evidence: [cloneEvidence(writeEvidence)],
+	}));
+	return {
+		source: "declared",
+		workingContextPaths: declaredPaths,
+		writeBoundaries: writeBoundaries.map((entry) => entry.path),
+		inferredOnlyPaths,
+		provenance: {
+			version: 1,
+			mode: "declared",
+			workingContextPaths: declaredProvenance,
+			writeBoundaries,
+		},
+	};
+}
+
+/** Render the named diagnostic for the declared-scope replacement tradeoff. */
+export function declaredScopeReplacementDiagnostic(scope: DispatchPathScope): string | null {
+	if (scope.source !== "declared" || scope.inferredOnlyPaths.length === 0) return null;
+	return `typed_scope_replaced_inferred_paths: typed intent omitted prose-inferred paths ${scope.inferredOnlyPaths.join(
+		", ",
+	)}; those paths did not select project rules or expand worker authority`;
+}
+
+/** Render the interactive warning for the declared-scope replacement tradeoff. */
+export function declaredScopeReplacementNotice(scope: DispatchPathScope): DeclaredScopeReplacementNotice | null {
+	if (scope.source !== "declared" || scope.inferredOnlyPaths.length === 0) return null;
+	const omittedPaths = [...scope.inferredOnlyPaths];
+	return {
+		code: "typed_scope_replaced_inferred_paths",
+		level: "warning",
+		omittedPaths,
+		message: `[dispatch scope] typed intent replaced prose path inference; omitted paths: ${omittedPaths.join(
+			", ",
+		)}. Those paths did not select project rules or expand worker authority.`,
+	};
+}
+
+function legacyNoticePaths(scope: DispatchPathScope): LegacyScopeInferenceNotice["paths"] {
+	const paths: Array<LegacyScopeInferenceNotice["paths"][number]> = [];
+	for (const [policy, entries] of [
+		["working-context", scope.provenance.workingContextPaths],
+		["write-boundary", scope.provenance.writeBoundaries],
+	] as const) {
+		for (const entry of entries) {
+			for (const evidence of entry.evidence) {
+				paths.push({
+					path: entry.path,
+					policy,
+					provenance: evidence.provenance,
+					source: evidence.source,
+					confidence: evidence.confidence,
+				});
+			}
+		}
+	}
+	return paths;
+}
+
+/** Render the operator-visible warning for a legacy scope resolution. */
+export function legacyScopeInferenceNotice(scope: DispatchPathScope): LegacyScopeInferenceNotice | null {
+	if (scope.source !== "inferred") return null;
+	const paths = legacyNoticePaths(scope);
+	if (paths.length === 0) {
+		return {
+			code: "legacy_scope_empty",
+			level: "warning",
+			paths,
+			message:
+				"[dispatch scope] legacy dispatch has no declared intent and inferred no policy-bearing paths. Path-scoped rules received no inferred match input, and worker authority did not expand.",
+		};
+	}
+	const rendered = paths
+		.map(
+			(entry) =>
+				`${entry.policy} ${entry.path} (provenance=${entry.provenance} source=${entry.source} confidence=${entry.confidence})`,
+		)
+		.join("; ");
+	return {
+		code: "legacy_scope_inferred",
+		level: "warning",
+		paths,
+		message: `[dispatch scope] legacy dispatch resolved policy-bearing scope without declared intent: ${rendered}. Review this scope before execution.`,
+	};
+}

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

@@ -10,7 +10,7 @@ import type { RunEnvelope, RunReceipt, RunReceiptDraft, RunReceiptIntegrity, Run
  * base, so there are no historical receipts to keep verifying: a receipt is
  * either this version or it is not a receipt.
  */
-export const RUN_RECEIPT_INTEGRITY_VERSION: RunReceiptIntegrity["version"] = 15;
+export const RUN_RECEIPT_INTEGRITY_VERSION: RunReceiptIntegrity["version"] = 20;
 export type ReceiptIntegrityVersion = RunReceiptIntegrity["version"];
 export type ReceiptIntegrityField = keyof RunReceiptDraft;
 export const RUN_RECEIPT_INTEGRITY_ALGORITHM = "sha256";
@@ -76,6 +76,8 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	agentAudience: true,
 	requestOrigin: true,
 	task: true,
+	intent: true,
+	pathScope: true,
 	// Historical receipts omit this field, so their receipt and ledger payloads remain unchanged.
 	budget: true,
 	targetId: true,
@@ -93,12 +95,13 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	reroutes: true,
 	pipeline: true,
 	gate: true,
+	council: true,
 	plan: true,
+	fleetGate: true,
 	personaOverride: true,
 	projectContext: true,
 	// Always set on receipts written after #104 landed; absent only on older
-	// receipts, which digest exactly as they did before these fields existed,
-	// so the integrity version stays where it is.
+	// receipts, which omit these fields from canonical serialization.
 	rulesApplied: true,
 	operatorProfileApplied: true,
 	exitCode: true,
@@ -128,6 +131,8 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	toolStats: true,
 	toolActivity: true,
 	verification: true,
+	hostVerification: true,
+	worktree: true,
 	routingIntent: true,
 	quality: true,
 	skillActivations: true,
@@ -143,7 +148,7 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	validationGrounding: true,
 	capabilityMismatch: true,
 	// Same reasoning: absent unless the run had an agent ledger, so a receipt
-	// without one digests byte-identically to one produced before it existed.
+	// without one omits the field from canonical serialization.
 	ledgerContribution: true,
 	sessionId: true,
 	briefing: true,

package/src/domains/dispatch/state.ts

@@ -25,10 +25,26 @@ import { resolveGuardrail } from "../../core/guardrails.js";
 import { withStateFileLock } from "../../core/state-file-lock.js";
 import { clioStateDir, stateRootRemoved } from "../../core/xdg.js";
 import { atomicWrite } from "../../engine/session.js";
+import type { ExecutionStepResult } from "./execution-scheduler.js";
 import { computeReceiptFindingsSummary } from "./receipt-findings.js";
 import { withReceiptIntegrity } from "./receipt-integrity.js";
 import type { RunEnvelope, RunReceipt, RunReceiptDraft, RunStatus } from "./types.js";
 
+export interface FleetRunRecord {
+	version: 1;
+	id: string;
+	fleet: string;
+	planHash: string;
+	stepIds: string[];
+	planSteps: unknown[];
+	vars: Record<string, string>;
+	startedAt: string;
+	endedAt: string | null;
+	resumedFrom: string | null;
+	steps: Array<{ stepId: string; result: ExecutionStepResult }>;
+	dynamicPlans?: Array<{ stepId: string; hash: string }>;
+}
+
 export interface LedgerOptions {
 	maxRuns?: number;
 }
@@ -45,7 +61,7 @@ export type CreateRunInput = Omit<
 	| "receiptPath"
 	| "tokenCount"
 	| "costUsd"
->;
+> & { id?: string };
 
 export interface Ledger {
 	create(input: CreateRunInput): RunEnvelope;
@@ -59,7 +75,7 @@ export interface Ledger {
 	reload(): void;
 }
 
-function newRunId(): string {
+export function newRunId(): string {
 	const n = BigInt(`0x${randomBytes(8).toString("hex")}`);
 	const raw = n.toString(36);
 	if (raw.length >= 12) return raw.slice(0, 12);
@@ -74,6 +90,23 @@ function receiptPathFor(runId: string): string {
 	return join(clioStateDir(), "receipts", `${runId}.json`);
 }
 
+function fleetRunPath(runId: string): string {
+	return join(clioStateDir(), "fleet-runs", `${runId}.json`);
+}
+
+export function readFleetRun(runId: string): FleetRunRecord | null {
+	try {
+		const parsed = JSON.parse(readFileSync(fleetRunPath(runId), "utf8")) as FleetRunRecord;
+		return parsed.version === 1 && parsed.id === runId ? structuredClone(parsed) : null;
+	} catch {
+		return null;
+	}
+}
+
+export async function writeFleetRun(record: FleetRunRecord): Promise<void> {
+	await atomicWrite(fleetRunPath(record.id), `${JSON.stringify(record, null, 2)}\n`);
+}
+
 function readRuns(): RunEnvelope[] {
 	const path = runsPath();
 	if (!existsSync(path)) return [];
@@ -169,7 +202,7 @@ export function openLedger(opts?: LedgerOptions): Ledger {
 	return {
 		create(input: CreateRunInput): RunEnvelope {
 			const envelope: RunEnvelope = {
-				id: newRunId(),
+				id: input.id ?? newRunId(),
 				agentId: input.agentId,
 				executionRole: input.executionRole,
 				...(input.agentAudience !== undefined ? { agentAudience: input.agentAudience } : {}),

package/src/domains/dispatch/types.ts

@@ -14,6 +14,8 @@ import type { EvidenceTag } from "../evidence/index.js";
 import type { CostProvenance, RuntimeTargetSnapshot } from "../providers/index.js";
 import type { RunToolBudgetEnvelope } from "./budget-envelope.js";
 import type { ExecutionRole, GateTopologyRole } from "./execution-role.js";
+import type { DispatchIntent } from "./intent.js";
+import type { DispatchPathScopeProvenance } from "./path-scope.js";
 import type { RouteDecisionV1 } from "./route-decision.js";
 import type { RoutingIntent } from "./routing-intent.js";
 
@@ -41,7 +43,8 @@ export type RunOutcomeCode =
 	| "worker_tool_call_cap_exhausted"
 	| "loop_guard_tools_disabled_exhausted"
 	| "result_contract_exhausted"
-	| "worker_final_output_missing";
+	| "worker_final_output_missing"
+	| "host_verification_rejected";
 
 export function isRunOutcomeCode(value: unknown): value is RunOutcomeCode {
 	return (
@@ -49,7 +52,8 @@ export function isRunOutcomeCode(value: unknown): value is RunOutcomeCode {
 		value === "worker_tool_call_cap_exhausted" ||
 		value === "loop_guard_tools_disabled_exhausted" ||
 		value === "result_contract_exhausted" ||
-		value === "worker_final_output_missing"
+		value === "worker_final_output_missing" ||
+		value === "host_verification_rejected"
 	);
 }
 
@@ -122,12 +126,16 @@ export interface RunPersonaOverride {
 
 /**
  * Effective project-context decision for a run, recorded on every receipt so
- * evidence can prove what a worker saw without rehashing. `tier: "none"` is
- * written explicitly: it distinguishes "policy said none" from a
- * pre-provenance receipt where the whole block is absent. `chars` and
- * `contentHash` describe the rendered dynamic message body when bounded;
- * `sections` lists extra projected sections that actually rendered
- * (currently only "verification-expectations", never for ACP delegation).
+ * evidence can prove what a worker saw without rehashing. `tier` is the
+ * recipe's CLIO-CODER.md handbook policy and is written explicitly: `none`
+ * distinguishes "policy said none" from a pre-provenance receipt where the
+ * whole block is absent. `chars` and `contentHash` describe every structured
+ * message that was actually sent, whatever the tier, and `sections` names
+ * them: `workspace-root` (sent under both tiers, so a none-tier run still
+ * records characters), `clio-md` (bounded only), and
+ * `verification-expectations` (bounded only, never for ACP delegation). A
+ * none-tier block naming only `workspace-root` is a consistent record; the
+ * trust adapter treats any other none-tier content as contradictory.
  */
 export interface RunProjectContextProvenance {
 	tier: "none" | "bounded";
@@ -238,6 +246,13 @@ export interface RunGateProvenance {
 	verdict?: "pass" | "fail" | "revise";
 }
 
+export interface RunCouncilProvenance {
+	group: string;
+	label: string;
+	color?: string;
+	round: number;
+}
+
 /**
  * Plan-approval provenance for multi-task, compete, or remote dispatch.
  * `approval: "operator"` records that a supervised autonomy level parked the
@@ -248,7 +263,7 @@ export interface RunGateProvenance {
  */
 export interface RunPlanProvenance {
 	hash: string;
-	topology: "parallel" | "sequential" | "pipeline" | "review" | "compete" | "detached" | "fleet";
+	topology: "parallel" | "sequential" | "pipeline" | "review" | "compete" | "council" | "detached" | "fleet";
 	taskCount: number;
 	approval: "operator" | "full-auto";
 	source: null | {
@@ -311,7 +326,7 @@ export interface RunPhaseDurations {
  * bumping one without the other is a compile error.
  */
 export interface RunReceiptIntegrity {
-	version: 15;
+	version: 20;
 	algorithm: "sha256";
 	digest: string;
 }
@@ -449,6 +464,7 @@ export interface RunEnvelope {
 	pipeline?: RunPipelineProvenance;
 	/** Review/compete gate provenance; present only on runs of a gated dispatch. */
 	gate?: RunGateProvenance;
+	council?: RunCouncilProvenance;
 	/** Plan-approval provenance; present only on runs of an approval-gated plan. */
 	plan?: RunPlanProvenance;
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
@@ -674,6 +690,25 @@ export interface RunReceiptVerification {
 		| "receipt-unavailable";
 }
 
+export interface RunHostVerificationCheck {
+	check: string;
+	argv: string[];
+	cwd: string;
+	exitCode: number;
+	durationMs: number;
+	memo: boolean;
+	outputTail: string;
+	artifactPath?: string;
+	/** Original evidence owner on a memo hit. */
+	evidenceRunId?: string;
+}
+
+export interface RunHostVerification {
+	status: "verified" | "rejected" | "skipped";
+	reason?: string;
+	checks: RunHostVerificationCheck[];
+}
+
 export interface RunReceipt {
 	runId: string;
 	agentId: string;
@@ -682,6 +717,10 @@ export interface RunReceipt {
 	agentAudience?: AgentAudience;
 	requestOrigin?: DispatchRequestOrigin;
 	task: string;
+	/** Normalized dispatch intent admitted before worker execution. */
+	intent?: DispatchIntent;
+	/** Resolved policy-bearing paths with field source and confidence, without source prose. */
+	pathScope?: DispatchPathScopeProvenance;
 	/** Integrity-sealed recipe policy, invocation request, effective phase, and admission reasons. */
 	budget?: RunToolBudgetEnvelope;
 	/** Proof of briefing content without copying its prose into the receipt. */
@@ -714,8 +753,11 @@ export interface RunReceipt {
 	pipeline?: RunPipelineProvenance;
 	/** Review/compete gate provenance; present only on runs of a gated dispatch. */
 	gate?: RunGateProvenance;
+	council?: RunCouncilProvenance;
 	/** Plan-approval provenance; present only on runs of an approval-gated plan. */
 	plan?: RunPlanProvenance;
+	/** Version 5 fleet gate artifact authored by this run. */
+	fleetGate?: { path: string; pathHash: string };
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
 	personaOverride?: RunPersonaOverride;
 	/** Effective project-context tier for this run; absent on receipts written before this field landed. */
@@ -764,6 +806,17 @@ export interface RunReceipt {
 	toolActivity?: ToolActivitySummary;
 	/** Integrity-sealed evidence confidence. Sealed on every receipt. */
 	verification: RunReceiptVerification;
+	/** Orchestrator-executed declared checks. Worker self-report never populates this field. */
+	hostVerification?: RunHostVerification;
+	/** Isolated writer checkout and its collect-time application result. */
+	worktree?: {
+		path: string;
+		branch: string;
+		diffHash: string;
+		apply: "merge" | "preserve";
+		applied: boolean;
+		reason?: string;
+	};
 	/** Required normalized routing request, sealed without task or prompt data. */
 	routingIntent: RoutingIntent;
 	/** Required routing-quality facts known at receipt finalization. */
@@ -786,8 +839,7 @@ export interface RunReceipt {
 	 * What this run contributed to its dispatch's agent ledger. Optional and
 	 * absent unless the run had a ledger, following validationGrounding and
 	 * capabilityMismatch: receiptDigestFields skips undefined, so a receipt
-	 * without one digests exactly as it did before this landed and
-	 * RUN_RECEIPT_INTEGRITY_VERSION stays where it is.
+	 * without one omits the field from canonical serialization.
 	 */
 	ledgerContribution?: RunLedgerContribution;
 	/**