@iowarp/clio-coder 0.3.7 → 0.3.8

package/src/domains/dispatch/index.ts

@@ -21,7 +21,7 @@ export type {
 	AttemptRef,
 	DispatchAssignment,
 } from "./assignment.js";
-export type { DurableAssignmentRecord } from "./assignment-store.js";
+export type { AssignmentVerdictOwner, DurableAssignmentRecord } from "./assignment-store.js";
 export type { CodeStepOutcome, CodeStepRecord, CodeStepRunInput } from "./code-step.js";
 export {
 	canonicalCodeReport,
@@ -160,10 +160,12 @@ export {
 } from "./validation.js";
 export type {
 	WorkspaceSnapshot,
+	WriteBoundaryAttribution,
 	WriteBoundaryStatus,
 	WriteBoundaryVerdict,
 } from "./write-boundary.js";
 export {
+	assertWriteBoundaryVisibleToGit,
 	captureWorkspaceSnapshot,
 	diffWorkspace,
 	enforceWriteBoundary,

package/src/domains/dispatch/intent-requirements.ts

@@ -0,0 +1,40 @@
+import type { DispatchIntent } from "./intent.js";
+
+/** Render intent fields that describe required results rather than observed facts. */
+export function renderDispatchIntentRequirements(intent: DispatchIntent | undefined): string | null {
+	if (intent === undefined || (intent.expectedOutputs.length === 0 && intent.verification.length === 0)) return null;
+	const lines = [
+		"# Declared Result Requirements",
+		"These entries are requirements to satisfy and verify. They are not evidence that an output exists or a check passed.",
+	];
+	if (intent.expectedOutputs.length > 0) {
+		lines.push("", "Expected outputs:", ...intent.expectedOutputs.map((output) => `- ${output}`));
+	}
+	if (intent.verification.length > 0) {
+		lines.push(
+			"",
+			"Verification requirements:",
+			...intent.verification.map(
+				(entry) => `- ${entry.check} must pass within its declared timeout of ${entry.timeoutMs}ms`,
+			),
+		);
+	}
+	return lines.join("\n");
+}
+
+/** Build the reviewer assignment from the same requirements the builder received. */
+export function renderDispatchReviewerTask(
+	originalTask: string,
+	builderRunId: string,
+	cycle: number,
+	intent: DispatchIntent | undefined,
+): string {
+	const requirements = renderDispatchIntentRequirements(intent);
+	return [
+		`Review the work of builder run ${builderRunId} (review cycle ${cycle}).`,
+		"The builder's final answer is provided as input data; verify it against the workspace, do not trust it blindly.",
+		"Original task the builder was given:",
+		originalTask,
+		...(requirements === null ? [] : [requirements]),
+	].join("\n\n");
+}

package/src/domains/dispatch/intent.ts

@@ -1,6 +1,8 @@
 import path from "node:path";
+import { normalizePathBoundaryEntry, PATH_BOUNDARY_MAX_ENTRIES, PathBoundaryError } from "../../core/path-boundary.js";
+import { type DispatchPathProvenanceEntry, declaredIntentPathProvenance } from "./path-scope.js";
 
-export const DISPATCH_INTENT_PATH_LIST_CAP = 32;
+export const DISPATCH_INTENT_PATH_LIST_CAP = PATH_BOUNDARY_MAX_ENTRIES;
 export const DISPATCH_INTENT_PATH_ENTRY_BYTES_CAP = 512;
 export const DISPATCH_INTENT_VERIFICATION_CAP = 8;
 export const DISPATCH_INTENT_TIMEOUT_MIN_MS = 1_000;
@@ -11,10 +13,12 @@ export interface DispatchIntentVerification {
 }
 
 export interface DispatchIntent {
-	version: 1;
+	version: 2;
 	readRoots: string[];
 	writeRoots: string[];
 	relevantPaths: string[];
+	/** Integrity-sealed source and confidence for every policy-bearing path. */
+	pathProvenance: DispatchPathProvenanceEntry[];
 	expectedOutputs: string[];
 	verification: DispatchIntentVerification[];
 }
@@ -42,7 +46,7 @@ function fail(reason: string, message: string): DispatchIntentNormalizationResul
 	return { ok: false, reason, message };
 }
 
-function normalizePathEntry(value: unknown, field: string, index: number): string | DispatchIntentNormalizationResult {
+function checkedPathText(value: unknown, field: string, index: number): string | DispatchIntentNormalizationResult {
 	if (typeof value !== "string" || value.trim().length === 0) {
 		return fail("intent_path_malformed", `${field}[${index}] must be a non-empty repository-relative POSIX path`);
 	}
@@ -53,6 +57,42 @@ function normalizePathEntry(value: unknown, field: string, index: number): strin
 			`${field}[${index}] exceeds the ${DISPATCH_INTENT_PATH_ENTRY_BYTES_CAP}-byte cap`,
 		);
 	}
+	return trimmed;
+}
+
+function normalizeScopePathEntry(
+	value: unknown,
+	field: string,
+	index: number,
+): string | DispatchIntentNormalizationResult {
+	const checked = checkedPathText(value, field, index);
+	if (typeof checked !== "string") return checked;
+	try {
+		return normalizePathBoundaryEntry(checked);
+	} catch (error) {
+		if (error instanceof PathBoundaryError) {
+			if (error.code === "absolute") {
+				return fail("intent_path_absolute", `${field}[${index}] must be a repository-relative POSIX path`);
+			}
+			if (error.code === "parent") {
+				return fail("intent_path_escapes_root", `${field}[${index}] escapes the repository root`);
+			}
+		}
+		return fail(
+			"intent_path_malformed",
+			`${field}[${index}] does not follow the repository path boundary grammar: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+}
+
+function normalizeExpectedOutputEntry(
+	value: unknown,
+	field: string,
+	index: number,
+): string | DispatchIntentNormalizationResult {
+	const checked = checkedPathText(value, field, index);
+	if (typeof checked !== "string") return checked;
+	const trimmed = checked;
 	if (trimmed.includes("\\") || path.posix.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed)) {
 		return fail("intent_path_absolute", `${field}[${index}] must be a repository-relative POSIX path`);
 	}
@@ -66,7 +106,15 @@ function normalizePathEntry(value: unknown, field: string, index: number): strin
 	return normalized;
 }
 
-function normalizePathList(value: unknown, field: string): string[] | DispatchIntentNormalizationResult {
+function normalizePathList(
+	value: unknown,
+	field: string,
+	normalizeEntry: (
+		value: unknown,
+		field: string,
+		index: number,
+	) => string | DispatchIntentNormalizationResult = normalizeScopePathEntry,
+): string[] | DispatchIntentNormalizationResult {
 	if (value === undefined) return [];
 	if (!Array.isArray(value)) return fail("intent_path_malformed", `${field} must be an array`);
 	if (value.length > DISPATCH_INTENT_PATH_LIST_CAP) {
@@ -74,7 +122,7 @@ function normalizePathList(value: unknown, field: string): string[] | DispatchIn
 	}
 	const normalized: string[] = [];
 	for (const [index, entry] of value.entries()) {
-		const result = normalizePathEntry(entry, field, index);
+		const result = normalizeEntry(entry, field, index);
 		if (typeof result !== "string") return result;
 		normalized.push(result);
 	}
@@ -82,10 +130,26 @@ function normalizePathList(value: unknown, field: string): string[] | DispatchIn
 }
 
 export function isDispatchIntent(value: unknown): value is DispatchIntent {
-	if (!isRecord(value) || value.version !== 1) return false;
+	if (!isRecord(value) || value.version !== 2) return false;
 	for (const field of ["readRoots", "writeRoots", "relevantPaths", "expectedOutputs"] as const) {
 		if (!Array.isArray(value[field]) || !value[field].every((entry) => typeof entry === "string")) return false;
 	}
+	const readRoots = value.readRoots as string[];
+	const writeRoots = value.writeRoots as string[];
+	const relevantPaths = value.relevantPaths as string[];
+	if (
+		!Array.isArray(value.pathProvenance) ||
+		JSON.stringify(value.pathProvenance) !==
+			JSON.stringify(
+				declaredIntentPathProvenance({
+					readRoots,
+					writeRoots,
+					relevantPaths,
+				}),
+			)
+	) {
+		return false;
+	}
 	return (
 		Array.isArray(value.verification) &&
 		value.verification.every(
@@ -115,7 +179,11 @@ export function normalizeDispatchIntent(
 	if (!Array.isArray(writeRoots)) return writeRoots;
 	const relevantPaths = normalizePathList(raw.relevant_paths, "intent.relevant_paths");
 	if (!Array.isArray(relevantPaths)) return relevantPaths;
-	const expectedOutputs = normalizePathList(raw.expected_outputs, "intent.expected_outputs");
+	const expectedOutputs = normalizePathList(
+		raw.expected_outputs,
+		"intent.expected_outputs",
+		normalizeExpectedOutputEntry,
+	);
 	if (!Array.isArray(expectedOutputs)) return expectedOutputs;
 	const rawVerification = raw.verification ?? [];
 	if (!Array.isArray(rawVerification)) {
@@ -154,6 +222,14 @@ export function normalizeDispatchIntent(
 	}
 	return {
 		ok: true,
-		intent: { version: 1, readRoots, writeRoots, relevantPaths, expectedOutputs, verification },
+		intent: {
+			version: 2,
+			readRoots,
+			writeRoots,
+			relevantPaths,
+			pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+			expectedOutputs,
+			verification,
+		},
 	};
 }

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"] = 19;
+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";
@@ -77,6 +77,7 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	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,

package/src/domains/dispatch/types.ts

@@ -15,6 +15,7 @@ import type { CostProvenance, RuntimeTargetSnapshot } from "../providers/index.j
 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";
 
@@ -125,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";
@@ -321,7 +326,7 @@ export interface RunPhaseDurations {
  * bumping one without the other is a compile error.
  */
 export interface RunReceiptIntegrity {
-	version: 19;
+	version: 20;
 	algorithm: "sha256";
 	digest: string;
 }
@@ -714,6 +719,8 @@ export interface RunReceipt {
 	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. */

package/src/domains/dispatch/validation.ts

@@ -7,6 +7,7 @@
 
 import path from "node:path";
 import { THINKING_LEVELS, type ThinkingLevel } from "../../core/defaults.js";
+import { asDirectoryPathBoundary, resolvePathBoundary } from "../../core/path-boundary.js";
 import { cloneValidatedResponseSchema } from "../../core/response-schema.js";
 import { isToolProfileName, type ToolProfileName } from "../../tools/profiles.js";
 import type { AgentProduct } from "../agents/spec.js";
@@ -482,8 +483,8 @@ export function validateJobSpec(spec: unknown): Validated {
 	}
 	if (isDispatchIntent(spec.intent) && spec.intent.writeRoots.length > 0 && Array.isArray(spec.writeRoots)) {
 		const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
-		const legacy = [...new Set(spec.writeRoots.map((root) => path.resolve(jobCwd, String(root))))].sort();
-		const declared = [...new Set(spec.intent.writeRoots.map((root) => path.resolve(jobCwd, root)))].sort();
+		const legacy = [...new Set(spec.writeRoots.map((root) => resolvePathBoundary(jobCwd, String(root))))].sort();
+		const declared = [...new Set(spec.intent.writeRoots.map((root) => resolvePathBoundary(jobCwd, root)))].sort();
 		if (JSON.stringify(legacy) !== JSON.stringify(declared)) errors.push("intent_write_roots_contradiction");
 	}
 
@@ -597,7 +598,9 @@ export function validateJobSpec(spec: unknown): Validated {
 				: undefined;
 	if (effectiveWriteRoots !== undefined) {
 		const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
-		out.writeRoots = effectiveWriteRoots.map((root) => path.resolve(jobCwd, String(root)));
+		out.writeRoots = isDispatchIntent(spec.intent)
+			? effectiveWriteRoots.map((root) => resolvePathBoundary(jobCwd, String(root)))
+			: effectiveWriteRoots.map((root) => asDirectoryPathBoundary(path.resolve(jobCwd, String(root))));
 	}
 	if (typeof spec.requestOrigin === "string" && VALID_REQUEST_ORIGINS.has(spec.requestOrigin)) {
 		out.requestOrigin = spec.requestOrigin as DispatchRequestOrigin;