@iowarp/clio-coder 0.3.6 → 0.3.8

package/src/domains/context/project-rules.ts

@@ -203,12 +203,62 @@ function ruleMatchesAnyPath(rule: ProjectRule, workingPaths: ReadonlyArray<strin
 			continue;
 		}
 		for (const path of workingPaths) {
-			if (regex.test(normalizeGlobInput(path))) return true;
+			const normalized = normalizeGlobInput(path);
+			if (regex.test(normalized)) return true;
+			if (normalized.endsWith("/") && globMatchesInsideDirectory(regex, pattern, normalized)) return true;
 		}
 	}
 	return false;
 }
 
+function materializedGlobVariants(pattern: string): string[] {
+	let variants = [""];
+	const normalized = normalizeGlobInput(pattern);
+	for (let index = 0; index < normalized.length; index += 1) {
+		const character = normalized[index];
+		if (character === undefined) break;
+		if (character === "*" && normalized[index + 1] === "*" && normalized[index + 2] === "/") {
+			variants = variants.flatMap((prefix) => [prefix, `${prefix}x/`]).slice(0, 64);
+			index += 2;
+			continue;
+		}
+		if (character === "*" && normalized[index + 1] === "*") {
+			variants = variants.map((prefix) => `${prefix}x`);
+			index += 1;
+			continue;
+		}
+		if (character === "*" || character === "?") {
+			variants = variants.map((prefix) => `${prefix}x`);
+			continue;
+		}
+		if (character === "[") {
+			const end = normalized.indexOf("]", index + 1);
+			const selected = end === -1 ? "x" : (normalized[index + 1] ?? "x");
+			variants = variants.map((prefix) => `${prefix}${selected}`);
+			index = end === -1 ? index : end;
+			continue;
+		}
+		variants = variants.map((prefix) => `${prefix}${character}`);
+	}
+	return variants;
+}
+
+function globMatchesInsideDirectory(regex: RegExp, pattern: string, directory: string): boolean {
+	const candidates = new Set<string>([`${directory}x`, `${directory}x/x`]);
+	for (const materialized of materializedGlobVariants(pattern)) {
+		if (materialized.startsWith(directory)) candidates.add(materialized);
+		const segments = materialized.split("/");
+		for (let index = 0; index < segments.length; index += 1) {
+			const suffix = segments.slice(index).join("/");
+			if (suffix.length > 0) candidates.add(`${directory}${suffix}`);
+		}
+		for (let index = 0; index < materialized.length; index += 1) {
+			candidates.add(`${directory}${materialized.slice(index)}`);
+		}
+	}
+	return [...candidates].some((candidate) => regex.test(candidate));
+}
+
 /**
  * Select the rules that should load now. Unconditional rules (no `paths`) always
  * load; a path-scoped rule loads only when one of its globs matches a path

package/src/domains/dispatch/active-route-planner.ts

@@ -37,6 +37,12 @@ export function routeValidationProjection(
 		// Presentation-only parentage stamped by the calling tool, on the same
 		// terms: a model must not be able to author it.
 		parentToolCallId,
+		resolvedVerification,
+		resultContractOverride,
+		fleetGateReceipt,
+		taskWorktree,
+		runIdHint,
+		taskWorktreeDestination,
 		...raw
 	} = request;
 	const awaitingEnvelope =
@@ -54,6 +60,14 @@ export function routeValidationProjection(
 			...(assignmentDeadlineAt !== undefined ? { assignmentDeadlineAt } : {}),
 			...(ledger !== undefined ? { ledger } : {}),
 			...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+			...(resolvedVerification !== undefined
+				? { resolvedVerification: resolvedVerification.map((check) => ({ ...check, argv: [...check.argv] })) }
+				: {}),
+			...(resultContractOverride !== undefined ? { resultContractOverride } : {}),
+			...(fleetGateReceipt !== undefined ? { fleetGateReceipt: { ...fleetGateReceipt } } : {}),
+			...(taskWorktree !== undefined ? { taskWorktree } : {}),
+			...(runIdHint !== undefined ? { runIdHint } : {}),
+			...(taskWorktreeDestination !== undefined ? { taskWorktreeDestination } : {}),
 			...(awaitingEnvelope ? { failover: "approved" as const } : {}),
 		}),
 	};

package/src/domains/dispatch/assignment-reconcile.ts

@@ -1,8 +1,9 @@
 /**
  * Startup reconciliation for durable assignments. The in-memory retry queue and
- * assignment registry do not survive a restart (Symphony §14.3), so every
- * durable record still marked `running` after a crash is orphaned: no active
- * attempt, no queued retry, and no attached terminal promise can ever settle it.
+ * assignment registry do not survive a restart (Symphony §14.3), so a durable
+ * record whose process owner is gone is orphaned: no active attempt, no queued
+ * retry, and no attached terminal promise can ever settle it. Running records
+ * owned by a live sibling process are deliberately left alone.
  *
  * This pass resolves each orphan deterministically against durable ledger
  * evidence so a later `wait`/`collect` can never observe a stuck `running`
@@ -11,7 +12,7 @@
  */
 
 import type { AssignmentStatus } from "./assignment.js";
-import type { DurableAssignmentRecord } from "./assignment-store.js";
+import type { AssignmentVerdictOwner, DurableAssignmentRecord } from "./assignment-store.js";
 
 /** Minimal terminal view of one attempt's durable ledger row. */
 export interface ReconcileAttemptView {
@@ -25,13 +26,16 @@ export interface ReconcileAttemptView {
 export interface AssignmentReconcileDeps {
 	/** Durable records currently marked `running`. */
 	listRunning: () => ReadonlyArray<DurableAssignmentRecord>;
+	/** Decide liveness from the record's durable pid and process birth token. */
+	ownerAlive: (record: DurableAssignmentRecord) => boolean;
 	/** Resolve one attempt's terminal view from the ledger, or null if pruned. */
 	lookupAttempt: (runId: string) => ReconcileAttemptView | null;
-	/** Persist the reconciled terminal status. */
+	/** Persist the reconciled terminal status, as the record's verdict owner when it has one. */
 	settle: (
 		assignmentId: string,
 		terminalRunId: string,
 		status: Exclude<AssignmentStatus, "running">,
+		owner?: AssignmentVerdictOwner,
 	) => Promise<unknown>;
 }
 
@@ -44,6 +48,10 @@ export interface AssignmentReconcileSummary {
 
 /**
  * Deterministic rule, in priority order:
+ *  -1. a record owned by a live process is not an orphan and remains running;
+ *   0. a record whose verdict belongs to its opener is failed (abandoned): the
+ *      opener died before reaching a verdict, and a green attempt under it is
+ *      one step of a run, never the run's answer;
  *   1. a recovered succeeded terminal attempt wins (`succeeded`);
  *   2. otherwise the last terminal attempt marks the assignment `failed`;
  *   3. otherwise no attempt is recoverable and the assignment is failed
@@ -53,6 +61,15 @@ export async function reconcileOrphanAssignments(deps: AssignmentReconcileDeps):
 	const summary: AssignmentReconcileSummary = { recovered: 0, abandoned: 0 };
 	for (const record of deps.listRunning()) {
 		if (record.status !== "running") continue;
+		if (deps.ownerAlive(record)) continue;
+		if (record.verdictOwner !== undefined) {
+			// Attempts under a claimed row are fleet steps, not the fleet verdict.
+			// Filing a green step as the terminal id of an abandoned fleet would
+			// contradict that step's immutable ledger result.
+			await deps.settle(record.assignmentId, record.assignmentId, "failed", record.verdictOwner);
+			summary.abandoned += 1;
+			continue;
+		}
 		const views = record.attempts
 			.map((runId) => deps.lookupAttempt(runId))
 			.filter((view): view is ReconcileAttemptView => view !== null);

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

@@ -5,6 +5,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { BIRTH_TOKEN_SOURCE_AVAILABLE, processAlive, processBirthToken } from "../../core/process-identity.js";
 import { withStateFileLock } from "../../core/state-file-lock.js";
 import { clioStateDir } from "../../core/xdg.js";
 import { atomicWrite } from "../../engine/session.js";
@@ -12,11 +13,54 @@ import type { AssignmentStatus } from "./assignment.js";
 
 const MAX_ASSIGNMENT_RECORDS = 1_000;
 
+/**
+ * Who decides a record's status.
+ *
+ * Absent is the ordinary case: the record is one logical dispatch, so the
+ * attempts filed under it are the only thing that can settle it. A fleet claims
+ * the verdict instead, because a fleet root gathers every step of a run under
+ * one id and no single step is the run's answer. Without the claim the last
+ * step to settle writes the row, which reports a green step of an aborted run
+ * as the run's outcome.
+ */
+export type AssignmentVerdictOwner = "fleet";
+
+/**
+ * Durable identity of the process executing a running assignment. A pid alone
+ * is not enough: the OS may recycle it after a crash, so the process birth
+ * token must still match before another extension treats the owner as live.
+ */
+export interface AssignmentProcessOwner {
+	pid: number;
+	processBirthToken: string;
+	acquiredAt: string;
+}
+
+export interface AssignmentProcessOwnerProbe {
+	birthToken(pid: number): string | null;
+	/** True when a missing birth token proves that the process is gone. */
+	tokenProvesDeath?: boolean;
+	/** Liveness fallback for platforms whose birth token is synthetic. */
+	alive?(pid: number): boolean;
+}
+
+/**
+ * One durable logical-dispatch row.
+ *
+ * `attempts` holds terminal run ids: an agent attempt's receipt id, and for a
+ * fleet also each deterministic step's `code-*` run id, whose evidence lives
+ * under `code-steps/<assignmentId>/`. `status` answers for the whole record,
+ * so for a fleet it answers for the whole run rather than for its last step.
+ */
 export interface DurableAssignmentRecord {
 	assignmentId: string;
 	attempts: string[];
 	terminalRunId: string | null;
 	status: AssignmentStatus;
+	/** Set when something other than the attempts decides `status`. */
+	verdictOwner?: AssignmentVerdictOwner;
+	/** Process lease held only while this record is running. */
+	processOwner?: AssignmentProcessOwner;
 }
 
 interface AssignmentStoreFile {
@@ -28,6 +72,18 @@ function storePath(): string {
 	return join(clioStateDir(), "assignments.json");
 }
 
+function validProcessOwner(value: unknown): value is AssignmentProcessOwner {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const owner = value as Partial<AssignmentProcessOwner>;
+	return (
+		Number.isSafeInteger(owner.pid) &&
+		(owner.pid ?? 0) > 0 &&
+		typeof owner.processBirthToken === "string" &&
+		typeof owner.acquiredAt === "string" &&
+		Number.isFinite(Date.parse(owner.acquiredAt))
+	);
+}
+
 function validRecord(value: unknown): value is DurableAssignmentRecord {
 	if (typeof value !== "object" || value === null) return false;
 	const record = value as Partial<DurableAssignmentRecord>;
@@ -36,6 +92,8 @@ function validRecord(value: unknown): value is DurableAssignmentRecord {
 		Array.isArray(record.attempts) &&
 		record.attempts.every((runId) => typeof runId === "string") &&
 		(record.terminalRunId === null || typeof record.terminalRunId === "string") &&
+		(record.verdictOwner === undefined || record.verdictOwner === "fleet") &&
+		(record.processOwner === undefined || validProcessOwner(record.processOwner)) &&
 		(record.status === "running" ||
 			record.status === "succeeded" ||
 			record.status === "failed" ||
@@ -57,7 +115,32 @@ function readStore(): DurableAssignmentRecord[] {
 }
 
 function copyRecord(record: DurableAssignmentRecord): DurableAssignmentRecord {
-	return { ...record, attempts: [...record.attempts] };
+	return {
+		...record,
+		attempts: [...record.attempts],
+		...(record.processOwner === undefined ? {} : { processOwner: { ...record.processOwner } }),
+	};
+}
+
+const defaultProcessOwnerProbe: AssignmentProcessOwnerProbe = {
+	birthToken: processBirthToken,
+	tokenProvesDeath: BIRTH_TOKEN_SOURCE_AVAILABLE,
+	alive: processAlive,
+};
+
+/** True only when the durable identity still names the same live process. */
+export function assignmentProcessOwnerAlive(
+	record: Pick<DurableAssignmentRecord, "processOwner">,
+	probe: AssignmentProcessOwnerProbe = defaultProcessOwnerProbe,
+): boolean {
+	const owner = record.processOwner;
+	if (owner === undefined) return false;
+	const current = probe.birthToken(owner.pid);
+	if (current === null || current !== owner.processBirthToken) return false;
+	// A synthetic `pid-N` token cannot distinguish pid reuse, so require an
+	// independent liveness signal on platforms without a real birth-token source.
+	if (probe.tokenProvesDeath === false) return probe.alive?.(owner.pid) ?? false;
+	return true;
 }
 
 function writeStore(assignments: ReadonlyArray<DurableAssignmentRecord>): void {
@@ -114,49 +197,103 @@ export async function renameStoredAssignment(
 	return copyRecord(result);
 }
 
-export function registerAssignment(assignmentId: string): Promise<DurableAssignmentRecord> {
-	return updateRecord(
+function currentProcessOwner(): AssignmentProcessOwner {
+	const token = processBirthToken();
+	if (token === null) throw new Error("dispatch: cannot establish assignment owner process birth token");
+	return {
+		pid: process.pid,
+		processBirthToken: token,
+		acquiredAt: new Date().toISOString(),
+	};
+}
+
+function openRecord(assignmentId: string): DurableAssignmentRecord {
+	return {
 		assignmentId,
-		(current) => current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" },
-	);
+		attempts: [],
+		terminalRunId: null,
+		status: "running",
+		processOwner: currentProcessOwner(),
+	};
+}
+
+function ensureRunningProcessOwner(record: DurableAssignmentRecord): DurableAssignmentRecord {
+	if (record.status !== "running" || record.processOwner !== undefined) return record;
+	return { ...record, processOwner: currentProcessOwner() };
+}
+
+function clearProcessOwner(record: DurableAssignmentRecord): DurableAssignmentRecord {
+	const result = { ...record };
+	delete result.processOwner;
+	return result;
+}
+
+export function registerAssignment(assignmentId: string): Promise<DurableAssignmentRecord> {
+	return updateRecord(assignmentId, (current) => ensureRunningProcessOwner(current ?? openRecord(assignmentId)));
+}
+
+/**
+ * Reserve this record's status for `owner`, opening the record if it is new.
+ * Attempts filed by anyone are still recorded; only the verdict is reserved,
+ * and until the owner settles it the record stays `running`.
+ */
+export function claimAssignmentVerdict(
+	assignmentId: string,
+	owner: AssignmentVerdictOwner,
+): Promise<DurableAssignmentRecord> {
+	return updateRecord(assignmentId, (current) => ({
+		...ensureRunningProcessOwner(current ?? openRecord(assignmentId)),
+		verdictOwner: owner,
+	}));
 }
 
 export function recordAssignmentAttempt(assignmentId: string, runId: string): Promise<DurableAssignmentRecord> {
 	return updateRecord(assignmentId, (current) => {
-		const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" as const };
+		const base = ensureRunningProcessOwner(current ?? openRecord(assignmentId));
 		return base.attempts.includes(runId) ? base : { ...base, attempts: [...base.attempts, runId] };
 	});
 }
 
 export function failQueuedAssignment(assignmentId: string): Promise<DurableAssignmentRecord> {
 	return updateRecord(assignmentId, (current) => {
-		const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" as const };
-		return base.status === "running" ? { ...base, status: "failed" } : base;
+		const base = current ?? openRecord(assignmentId);
+		if (base.verdictOwner !== undefined) return base;
+		return base.status === "running" ? clearProcessOwner({ ...base, status: "failed" }) : base;
 	});
 }
 
 export function timeoutStoredAssignment(assignmentId: string): Promise<DurableAssignmentRecord> {
 	return updateRecord(assignmentId, (current) => {
-		const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" as const };
-		return base.status === "running" ? { ...base, status: "timed_out" } : base;
+		const base = current ?? openRecord(assignmentId);
+		if (base.verdictOwner !== undefined) return base;
+		return base.status === "running" ? clearProcessOwner({ ...base, status: "timed_out" }) : base;
 	});
 }
 
 export function cancelStoredAssignment(assignmentId: string): Promise<DurableAssignmentRecord> {
 	return updateRecord(assignmentId, (current) => {
-		const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" as const };
-		return base.status === "running" ? { ...base, status: "canceled" } : base;
+		const base = current ?? openRecord(assignmentId);
+		if (base.verdictOwner !== undefined) return base;
+		return base.status === "running" ? clearProcessOwner({ ...base, status: "canceled" }) : base;
 	});
 }
 
+/**
+ * File `terminalRunId` as an attempt and, when the caller owns the verdict, set
+ * the record's status. An attempt settling under a claimed record settles
+ * itself and not the record: one fleet step reaching a green receipt says
+ * nothing about the six steps behind it that never ran.
+ */
 export function settleStoredAssignment(
 	assignmentId: string,
 	terminalRunId: string,
 	status: Exclude<AssignmentStatus, "running">,
+	owner?: AssignmentVerdictOwner,
 ): Promise<DurableAssignmentRecord> {
 	return updateRecord(assignmentId, (current) => {
-		const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" as const };
+		const base = current ?? openRecord(assignmentId);
 		const attempts = base.attempts.includes(terminalRunId) ? base.attempts : [...base.attempts, terminalRunId];
-		return { ...base, attempts, terminalRunId, status };
+		if (base.verdictOwner !== owner) return { ...base, attempts };
+		return clearProcessOwner({ ...base, attempts, terminalRunId, status });
 	});
 }

package/src/domains/dispatch/backoff.ts

@@ -54,6 +54,7 @@ export function isDeterministicOutcomeCode(code: RunOutcomeCode | null | undefin
 		code === "worker_tool_call_cap_exhausted" ||
 		code === "loop_guard_tools_disabled_exhausted" ||
 		code === "result_contract_exhausted" ||
-		code === "worker_final_output_missing"
+		code === "worker_final_output_missing" ||
+		code === "host_verification_rejected"
 	);
 }

package/src/domains/dispatch/capability-match.ts

@@ -77,6 +77,7 @@ const REPORTING_CONTRACT_KINDS: ReadonlySet<ResultContract["kind"]> = new Set([
 	"research-report",
 	"provenance-report",
 	"debugger-report",
+	"oracle-report",
 ]);
 
 /** Preferred mutating specialist per task shape, best first. */

package/src/domains/dispatch/checkout-writer-lease.ts

@@ -0,0 +1,175 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { BIRTH_TOKEN_SOURCE_AVAILABLE, processAlive, processBirthToken } from "../../core/process-identity.js";
+import { withStateFileLockSync } from "../../core/state-file-lock.js";
+import { clioStateDir } from "../../core/xdg.js";
+import { atomicWrite } from "../../engine/session.js";
+
+export interface CheckoutWriterLeaseRecord {
+	version: 1;
+	checkout: string;
+	pid: number;
+	processBirthToken: string;
+	acquiredAt: string;
+}
+
+export interface CheckoutWriterLease {
+	checkout: string;
+	path: string;
+	release(): void;
+}
+
+export interface CheckoutWriterLeaseProbe {
+	birthToken(pid: number): string | null;
+	tokenProvesDeath?: boolean;
+	alive?(pid: number): boolean;
+}
+
+const held = new Map<string, { count: number; path: string }>();
+let exitHooksInstalled = false;
+
+function canonicalCheckout(checkout: string): string {
+	return realpathSync(checkout);
+}
+
+function checkoutWriterLeasePath(checkout: string): string {
+	const canonical = canonicalCheckout(checkout);
+	const key = createHash("sha256").update(canonical, "utf8").digest("hex");
+	return join(clioStateDir(), "checkout-writer-leases", `${key}.json`);
+}
+
+function validRecord(value: unknown): value is CheckoutWriterLeaseRecord {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const record = value as Partial<CheckoutWriterLeaseRecord>;
+	return (
+		record.version === 1 &&
+		typeof record.checkout === "string" &&
+		Number.isSafeInteger(record.pid) &&
+		(record.pid ?? 0) > 0 &&
+		typeof record.processBirthToken === "string" &&
+		typeof record.acquiredAt === "string" &&
+		Number.isFinite(Date.parse(record.acquiredAt))
+	);
+}
+
+function readRecord(path: string): CheckoutWriterLeaseRecord | null {
+	if (!existsSync(path)) return null;
+	try {
+		const value = JSON.parse(readFileSync(path, "utf8")) as unknown;
+		if (!validRecord(value)) throw new Error("invalid schema");
+		return value;
+	} catch (error) {
+		throw new Error(
+			`checkout writer lease is unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+}
+
+function ownerAlive(record: CheckoutWriterLeaseRecord, probe: CheckoutWriterLeaseProbe): boolean {
+	const current = probe.birthToken(record.pid);
+	if (current === null || current !== record.processBirthToken) return false;
+	if (probe.tokenProvesDeath === false) return probe.alive?.(record.pid) ?? false;
+	return true;
+}
+
+const defaultProbe: CheckoutWriterLeaseProbe = {
+	birthToken: processBirthToken,
+	tokenProvesDeath: BIRTH_TOKEN_SOURCE_AVAILABLE,
+	alive: processAlive,
+};
+
+function releaseAllOnExit(): void {
+	for (const [checkout, entry] of held) {
+		try {
+			withStateFileLockSync(entry.path, () => {
+				const record = readRecord(entry.path);
+				if (record?.checkout === checkout && record.pid === process.pid) unlinkSync(entry.path);
+			});
+		} catch {
+			// Process exit is best effort. A stale record is reclaimed by the next admission.
+		}
+	}
+	held.clear();
+}
+
+function installExitHooks(): void {
+	if (exitHooksInstalled) return;
+	exitHooksInstalled = true;
+	process.once("exit", releaseAllOnExit);
+}
+
+export function acquireCheckoutWriterLease(input: {
+	checkout: string;
+	nowMs?: number;
+	pid?: number;
+	processBirthToken?: string;
+	probe?: CheckoutWriterLeaseProbe;
+}): CheckoutWriterLease {
+	const checkout = canonicalCheckout(input.checkout);
+	const path = checkoutWriterLeasePath(checkout);
+	const local = held.get(checkout);
+	if (local !== undefined && (input.pid === undefined || input.pid === process.pid)) {
+		local.count += 1;
+		let released = false;
+		return {
+			checkout,
+			path,
+			release: () => {
+				if (released) return;
+				released = true;
+				releaseCheckoutWriterLease(checkout);
+			},
+		};
+	}
+	mkdirSync(dirname(path), { recursive: true });
+	const ownerPid = input.pid ?? process.pid;
+	const token = input.processBirthToken ?? processBirthToken(ownerPid);
+	if (token === null) throw new Error("dispatch: cannot establish checkout writer process birth token");
+	withStateFileLockSync(path, () => {
+		const existing = readRecord(path);
+		if (existing !== null && ownerAlive(existing, input.probe ?? defaultProbe)) {
+			throw new Error(`checkout_writer_lease_held: checkout writer lease is held by pid ${existing.pid}`);
+		}
+		const record: CheckoutWriterLeaseRecord = {
+			version: 1,
+			checkout,
+			pid: ownerPid,
+			processBirthToken: token,
+			acquiredAt: new Date(input.nowMs ?? Date.now()).toISOString(),
+		};
+		atomicWrite(path, JSON.stringify(record, null, 2));
+	});
+	if (ownerPid === process.pid) {
+		held.set(checkout, { count: 1, path });
+		installExitHooks();
+	}
+	let released = false;
+	return {
+		checkout,
+		path,
+		release: () => {
+			if (released) return;
+			released = true;
+			if (ownerPid === process.pid) releaseCheckoutWriterLease(checkout);
+			else releaseLeaseRecord(path, checkout, ownerPid, token);
+		},
+	};
+}
+
+function releaseLeaseRecord(path: string, checkout: string, pid: number, token: string): void {
+	withStateFileLockSync(path, () => {
+		const record = readRecord(path);
+		if (record?.checkout === checkout && record.pid === pid && record.processBirthToken === token) unlinkSync(path);
+	});
+}
+
+function releaseCheckoutWriterLease(checkout: string): void {
+	const entry = held.get(checkout);
+	if (entry === undefined) return;
+	entry.count -= 1;
+	if (entry.count > 0) return;
+	held.delete(checkout);
+	const token = processBirthToken(process.pid);
+	if (token !== null) releaseLeaseRecord(entry.path, checkout, process.pid, token);
+}

package/src/domains/dispatch/contract.ts

@@ -15,6 +15,30 @@ import type { RunEnvelope, RunLineage, RunNodeIdentity, RunPhaseDurations, RunRe
 import type { DispatchFailoverCandidate, JobSpec } from "./validation.js";
 
 export interface DispatchRequest extends JobSpec {
+	/** Coordinator-owned result contract override for a fleet plan step. */
+	resultContractOverride?: ResultContract;
+	/** Gate path whose post-run hash is sealed into this step's receipt. */
+	fleetGateReceipt?: { path: string };
+	/** Orchestrator-prepared task worktree state. Model arguments cannot author it. */
+	taskWorktree?: {
+		root: string;
+		runId: string;
+		path: string;
+		branch: string;
+		base: string;
+		ownerToken: string;
+	};
+	/** Run identity allocated before task worktree creation. Model arguments cannot author it. */
+	runIdHint?: string;
+	/** Parent checkout frozen by plan approval for task worktree application. */
+	taskWorktreeDestination?: string;
+	/** Admission-resolved commands. Model text never enters these argv vectors. */
+	resolvedVerification?: ReadonlyArray<{
+		check: string;
+		argv: ReadonlyArray<string>;
+		cwd: string;
+		timeoutMs: number;
+	}>;
 	/**
 	 * Semantic role this request's first attempt runs under. Derived once by
 	 * `execution-role.ts` at request construction, never authored by a model, and
@@ -212,12 +236,36 @@ export interface DispatchContract {
 		finalPromise: Promise<ReadonlyArray<RunReceipt>>;
 	}>;
 
+	/** Seal a coordinator-only council synthesis receipt without invoking a model. */
+	sealCouncilSynthesis?(input: {
+		group: string;
+		round: number;
+		kind: "none" | "vote" | "judge";
+		text: string;
+		subjects: ReadonlyArray<{ runId: string; digest: string | null }>;
+		template: RunReceipt;
+	}): Promise<RunReceipt>;
+
 	/** List runs from the ledger. */
 	listRuns(status?: RunStatus): ReadonlyArray<RunEnvelope>;
 
 	/** Get a specific immutable attempt envelope. */
 	getRun(runId: string): RunEnvelope | null;
 
+	/**
+	 * Absolute paths this run's own successful tool calls aimed a mutation at,
+	 * or null when the run kept no usable record: an unknown or evicted run, a
+	 * runtime that publishes no tool telemetry, telemetry that came back
+	 * incomplete, or a run that called a tool able to write a path its arguments
+	 * do not name. Null is not an empty list, and a caller that cannot tell them
+	 * apart will read "wrote nothing" off a run nobody watched.
+	 *
+	 * The write boundary reads this to separate what a step changed from what
+	 * changed under it, so the answer must stay a record of observation rather
+	 * than an inference from the checkout.
+	 */
+	observedRunWrites?(runId: string): ReadonlyArray<string> | null;
+
 	/** In-memory logical assignment state and complete finalized-attempt history. */
 	readonly assignments?: {
 		/** Live assignment, including its terminal promise and detailed attempt refs. */