@iowarp/clio-coder 0.3.7 → 0.3.8

package/src/interactive/overlays/settings.ts

@@ -593,6 +593,13 @@ function delegationAgentsAffordance(
 type SubmenuTitle = string | ((width: number) => string);
 
 export class SubmenuWrapper implements Component {
+	/**
+	 * Why the last submission was refused, or null while nothing is wrong. The
+	 * editor sets it instead of closing, so the operator corrects the value with
+	 * the reason on screen rather than back at the row list with no reason.
+	 */
+	private problem: string | null = null;
+
 	constructor(
 		private readonly title: SubmenuTitle,
 		private readonly child: Component,
@@ -600,6 +607,10 @@ export class SubmenuWrapper implements Component {
 		private readonly note?: string,
 	) {}
 
+	setProblem(problem: string | null): void {
+		this.problem = problem;
+	}
+
 	render(width: number): string[] {
 		const theme = clioTheme();
 		const lines: string[] = [];
@@ -619,6 +630,11 @@ export class SubmenuWrapper implements Component {
 		// two columns off each one and marked the cut, so every entry wore a
 		// trailing … it had not earned.
 		lines.push(...this.child.render(Math.max(1, width - 2)).map((line) => `  ${line}`));
+		if (this.problem !== null) {
+			for (const line of wrapTextWithAnsi(this.problem, Math.max(1, width - 2))) {
+				lines.push(theme.fg("error", `  ${line}`));
+			}
+		}
 		lines.push("");
 		lines.push(theme.fg("dim", `  ${this.hint}`));
 		return lines;
@@ -693,33 +709,108 @@ function editTextSubmenu(title: string, note?: string): SettingSubmenuBuilder {
 	return textInputSubmenu(title, note);
 }
 
-function editNumberSubmenu(title: string, options: { min?: number; allowBlank?: boolean } = {}): SettingSubmenuBuilder {
-	const min = options.min ?? 0;
+/**
+ * The bound a number row enforces, shared by the editor and the apply path so
+ * the two cannot drift: whatever the editor forwards, the apply path stores.
+ * The bounds mirror the config validator's, so a value the Settings Center
+ * refuses is one settings.yaml would have refused too, in the same words.
+ */
+interface NumberSettingRule {
+	readonly min: number;
+	readonly max?: number;
+	readonly integer: boolean;
+	/** A blank submission clears the key instead of being a parse failure. */
+	readonly allowBlank?: boolean;
+}
+
+const NUMBER_SETTING_RULES = {
+	"budget.sessionCeilingUsd": { min: 0, integer: false },
+	"watchdog.cadenceToolCalls": { min: 1, integer: true, allowBlank: true },
+	"delegation.defaults.connectTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+	"delegation.defaults.turnTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+	"delegation.defaults.permissionTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+} as const satisfies Partial<Record<EditableSettingId, NumberSettingRule>>;
+
+export type NumberSettingId = keyof typeof NUMBER_SETTING_RULES;
+
+export const NUMBER_SETTING_IDS = Object.keys(NUMBER_SETTING_RULES) as readonly NumberSettingId[];
+
+type NumberSettingOutcome = { readonly value: number | null } | { readonly refusal: string };
+
+function describeSubmittedText(value: string): string {
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? "an empty string" : JSON.stringify(trimmed);
+}
+
+/**
+ * Parse one submitted number-row value under its rule. A null value means the
+ * operator cleared an optional key. The refusal is worded like the config
+ * validator's issue for the same key ("expected an integer >= 1, got 0"), with
+ * a "Not applied:" prefix so it reads as the outcome of this submission.
+ */
+function parseNumberSetting(value: string, rule: NumberSettingRule): NumberSettingOutcome {
+	const trimmed = value.trim();
+	const noun = rule.integer ? "an integer" : "a number";
+	if (trimmed.length === 0 && rule.allowBlank === true) return { value: null };
+	const parsed = trimmed.length === 0 ? Number.NaN : Number(trimmed);
+	if (!Number.isFinite(parsed) || (rule.integer && !Number.isInteger(parsed))) {
+		const shown = Number.isFinite(parsed) ? String(parsed) : describeSubmittedText(value);
+		return { refusal: `Not applied: expected ${noun}, got ${shown}.` };
+	}
+	if (parsed < rule.min) return { refusal: `Not applied: expected ${noun} >= ${rule.min}, got ${parsed}.` };
+	if (rule.max !== undefined && parsed > rule.max) {
+		return { refusal: `Not applied: expected ${noun} <= ${rule.max}, got ${parsed}.` };
+	}
+	return { value: parsed };
+}
+
+/**
+ * The reason a number row would refuse `value`, or null when it would apply.
+ * This is the same check the editor and `applySettingChange` run, exposed so a
+ * caller that bypasses the editor can still name the bound it hit.
+ */
+export function describeNumberSettingRefusal(id: NumberSettingId, value: string): string | null {
+	const outcome = parseNumberSetting(value, NUMBER_SETTING_RULES[id]);
+	return "refusal" in outcome ? outcome.refusal : null;
+}
+
+function numberSettingNote(rule: NumberSettingRule): string {
+	const noun = rule.integer ? "a whole number" : "a number";
+	const clears = rule.allowBlank === true ? "; blank clears it" : "";
+	if (rule.min > 0 && rule.max !== undefined) return `Use ${noun} from ${rule.min} to ${rule.max}${clears}.`;
+	if (rule.min > 0) return `Use ${noun} of at least ${rule.min}${clears}.`;
+	return `Use a non-negative ${rule.integer ? "whole number" : "number"}${clears}.`;
+}
+
+/**
+ * A number editor that stays open on a refused submission. Closing with no
+ * value looked like a successful edit that changed nothing, so the reason is
+ * rendered under the input and the operator corrects the text in place; Esc
+ * still leaves without applying.
+ */
+function editNumberSubmenu(title: string, id: NumberSettingId): SettingSubmenuBuilder {
+	const rule = NUMBER_SETTING_RULES[id];
 	return (currentValue: string, done: (val?: string) => void) => {
 		const input = new Input();
 		input.setValue(currentValue);
 		input.focused = true;
+		const wrapper = new SubmenuWrapper(
+			title,
+			input,
+			buildHint([{ key: "Enter", verb: "confirm" }], "back"),
+			numberSettingNote(rule),
+		);
 		input.onSubmit = (val) => {
-			if (options.allowBlank === true && val.trim().length === 0) {
-				done("");
+			const outcome = parseNumberSetting(val, rule);
+			if ("refusal" in outcome) {
+				wrapper.setProblem(outcome.refusal);
 				return;
 			}
-			const num = Number(val);
-			if (Number.isFinite(num) && num >= min) {
-				done(val);
-			} else {
-				done();
-			}
+			wrapper.setProblem(null);
+			done(outcome.value === null ? "" : val.trim());
 		};
 		input.onEscape = () => done();
-		return new SubmenuWrapper(
-			title,
-			input,
-			buildHint([{ key: "Enter", verb: "confirm" }], "back"),
-			min > 0
-				? `Use a whole number of at least ${min}${options.allowBlank === true ? "; blank clears it" : ""}.`
-				: "Use a non-negative number.",
-		);
+		return wrapper;
 	};
 }
 
@@ -1412,7 +1503,7 @@ export function buildSettingItems(
 			readOnly: true,
 		}),
 		settingItem("budget.sessionCeilingUsd", String(settings.budget.sessionCeilingUsd), {
-			submenu: editNumberSubmenu("Edit session cost ceiling USD"),
+			submenu: editNumberSubmenu("Edit session cost ceiling USD", "budget.sessionCeilingUsd"),
 			affordance: "free text",
 		}),
 		settingItem("defaults.maxTokens", String(settings.defaults.maxTokens), {
@@ -1479,10 +1570,10 @@ export function buildSettingItems(
 			"watchdog.cadenceToolCalls",
 			watchdog.cadenceToolCalls === undefined ? "(turn end only)" : String(watchdog.cadenceToolCalls),
 			{
-				submenu: editNumberSubmenu("Edit watchdog cadence in tool calls; blank fires at turn end only", {
-					min: 1,
-					allowBlank: true,
-				}),
+				submenu: editNumberSubmenu(
+					"Edit watchdog cadence in tool calls; blank fires at turn end only",
+					"watchdog.cadenceToolCalls",
+				),
 				affordance: "free text",
 				editValue: watchdog.cadenceToolCalls === undefined ? "" : String(watchdog.cadenceToolCalls),
 			},
@@ -1503,15 +1594,15 @@ export function buildSettingItems(
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.connectTimeoutMs", String(settings.delegation.defaults.connectTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate connect timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate connect timeout (ms)", "delegation.defaults.connectTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.turnTimeoutMs", String(settings.delegation.defaults.turnTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate turn timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate turn timeout (ms)", "delegation.defaults.turnTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.permissionTimeoutMs", String(settings.delegation.defaults.permissionTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate permission timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate permission timeout (ms)", "delegation.defaults.permissionTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("keybindings", keybindingCount > 0 ? `${keybindingCount} override(s)` : "(defaults)", {
@@ -1819,9 +1910,15 @@ function applyNonNegativeInteger(value: string, set: (next: number) => void): vo
 	if (Number.isFinite(parsed) && parsed >= 0) set(Math.floor(parsed));
 }
 
-function applyPositiveInteger(value: string, set: (next: number) => void): void {
-	const parsed = Number(value);
-	if (Number.isInteger(parsed) && parsed >= 1 && parsed <= MAX_TIMER_DELAY_MS) set(parsed);
+/**
+ * Store a number-row submission under the row's shared rule. A refused value
+ * leaves the setting alone; the editor has already shown the operator why, and
+ * `describeNumberSettingRefusal` names the reason for any other caller.
+ */
+function applyNumberSetting(id: NumberSettingId, value: string, set: (next: number | null) => void): void {
+	const outcome = parseNumberSetting(value, NUMBER_SETTING_RULES[id]);
+	if ("refusal" in outcome) return;
+	set(outcome.value);
 }
 
 /**
@@ -1986,15 +2083,12 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 			else delete settings.watchdog.target;
 			return;
 		}
-		case "watchdog.cadenceToolCalls": {
-			if (value.trim().length === 0) {
-				delete settings.watchdog.cadenceToolCalls;
-				return;
-			}
-			const parsed = Number(value);
-			if (Number.isFinite(parsed) && Math.floor(parsed) >= 1) settings.watchdog.cadenceToolCalls = Math.floor(parsed);
+		case "watchdog.cadenceToolCalls":
+			applyNumberSetting("watchdog.cadenceToolCalls", value, (next) => {
+				if (next === null) delete settings.watchdog.cadenceToolCalls;
+				else settings.watchdog.cadenceToolCalls = next;
+			});
 			return;
-		}
 		case "terminal.smoothStreaming":
 			if (value === "off" || value === "auto" || value === "on") settings.terminal.smoothStreaming = value;
 			return;
@@ -2005,18 +2099,18 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 				.filter(Boolean);
 			return;
 		case "delegation.defaults.connectTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.connectTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.connectTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.connectTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.turnTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.turnTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.turnTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.turnTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.permissionTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.permissionTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.permissionTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.permissionTimeoutMs = next;
 			});
 			return;
 		case "orchestrator.target": {
@@ -2067,11 +2161,11 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 					.map((v) => v.trim())
 					.filter(Boolean);
 			return;
-		case "budget.sessionCeilingUsd": {
-			const parsed = Number(value);
-			if (Number.isFinite(parsed) && parsed >= 0) settings.budget.sessionCeilingUsd = parsed;
+		case "budget.sessionCeilingUsd":
+			applyNumberSetting("budget.sessionCeilingUsd", value, (next) => {
+				if (next !== null) settings.budget.sessionCeilingUsd = next;
+			});
 			return;
-		}
 	}
 }
 

package/src/interactive/slash-commands.ts

@@ -6,9 +6,9 @@ import type { AgentSpec } from "../domains/agents/spec.js";
 import type { ContextInitOptions } from "../domains/context/init-options.js";
 import type { DispatchContract, DispatchRequest } from "../domains/dispatch/contract.js";
 import { type AgentRoleFactsResolver, requestExecutionRole } from "../domains/dispatch/execution-role.js";
-import type { ReceiptIntegrityResult } from "../domains/dispatch/receipt-integrity.js";
 import type { RunReceipt } from "../domains/dispatch/types.js";
 import type { JobThinkingLevel } from "../domains/dispatch/validation.js";
+import type { ReceiptIntegrityOutcome } from "../domains/evidence/trust-status.js";
 import type { InstalledExtension } from "../domains/extensions/index.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
 import type { ProvidersContract, ResolvedModelRef } from "../domains/providers/index.js";
@@ -665,7 +665,7 @@ export interface SlashCommandContext {
 	 * and emit a single status line. Kept on the context so the registry does
 	 * not import the overlay module.
 	 */
-	verifyReceipt: (runId: string) => ReceiptIntegrityResult;
+	verifyReceipt: (runId: string) => ReceiptIntegrityOutcome;
 	/**
 	 * Handles the "unknown" case: append the text to the chat panel as a user
 	 * turn, submit to the chat loop, and schedule a re-render. Handlers for
@@ -1507,6 +1507,11 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			const result = ctx.verifyReceipt(command.runId);
 			if (result.ok) {
 				ctx.notice("success", `verify ok ${command.runId}`);
+			} else if (result.retired !== undefined) {
+				// A retired seal is the expected state of a run from the previous
+				// release, so it is a warning that names the versions, never the
+				// failure a tampered receipt gets.
+				ctx.notice("warn", `verify retired ${command.runId} ${result.reason}`);
 			} else {
 				ctx.notice("error", `verify fail ${command.runId} ${result.reason}`);
 			}

package/src/interactive/view/artifacts.ts

@@ -2,13 +2,16 @@ import { createReadStream, readFileSync, statSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import type { DispatchContract } from "../../domains/dispatch/contract.js";
-import {
-	isReceiptIntegrity,
-	type ReceiptIntegrityResult,
-	verifyReceiptIntegrity,
-} from "../../domains/dispatch/receipt-integrity.js";
+import { isReceiptIntegrity, verifyReceiptIntegrity } from "../../domains/dispatch/receipt-integrity.js";
 import type { RunEnvelope, RunReceipt } from "../../domains/dispatch/types.js";
 import { evidenceDirectory, inspectEvidence, listEvidenceOverviews } from "../../domains/evidence/store.js";
+import { formatTrustSummaryLine } from "../../domains/evidence/trust-projection.js";
+import {
+	inspectRunReceiptTrustStatus,
+	type ReceiptIntegrityOutcome,
+	retiredReceiptIntegrity,
+	retiredReceiptIntegrityReason,
+} from "../../domains/evidence/trust-status.js";
 import type { EvidenceFinding, EvidenceOverview, EvidenceSource } from "../../domains/evidence/types.js";
 import { type AccountabilitySummary, readAccountabilitySummary } from "../../domains/observability/index.js";
 import type {
@@ -72,7 +75,7 @@ export interface ViewArtifact {
 	toolName?: string;
 	searchText?: readonly string[];
 	load(): Promise<ViewArtifactLoadResult>;
-	verify?(): Promise<{ ok: boolean; detail: string }>;
+	verify?(): Promise<ViewArtifactVerification>;
 }
 
 export interface ArtifactProvider {
@@ -108,7 +111,14 @@ const ACCOUNTABILITY_TOP_CAUSES = 8;
 export const VIEW_ARTIFACT_LINE_CAP = 50_000;
 const JSON_PRETTY_MAX_BYTES = 10 * 1024 * 1024;
 
-export type ReceiptVerifyResult = ReceiptIntegrityResult;
+export type ReceiptVerifyResult = ReceiptIntegrityOutcome;
+
+/**
+ * What a verify action reports. `retired` marks a seal this build does not
+ * verify because its integrity version was retired: not a pass, and not the
+ * failure a tampered receipt reports.
+ */
+export type ViewArtifactVerification = { ok: true; detail: string } | { ok: false; detail: string; retired?: true };
 
 const RECEIPT_REQUIRED_KEYS = [
 	"runId",
@@ -286,6 +296,21 @@ function validateToolStats(value: unknown): ReceiptVerifyResult {
 
 type ReadLedgerResult = { ok: true; envelope: RunEnvelope } | { ok: false; reason: string };
 
+/**
+ * The canonical trust line for a receipt the integrity verifier just accepted:
+ * the same file and ledger row, projected through the shared boundary so the
+ * receipt view spells its verdict exactly as the board and the CLI do.
+ */
+export function receiptTrustDetail(stateDir: string, runId: string): string {
+	try {
+		const receipt = JSON.parse(readFileSync(receiptFilePath(stateDir, runId), "utf8")) as RunReceipt;
+		const ledger = readRunEnvelope(stateDir, runId);
+		return formatTrustSummaryLine(inspectRunReceiptTrustStatus(receipt, ledger.ok ? ledger.envelope : null).status);
+	} catch {
+		return "integrity verified; trust status unreadable";
+	}
+}
+
 function readRunEnvelope(stateDir: string, runId: string): ReadLedgerResult {
 	const runs = readRunLedger(stateDir);
 	for (const entry of runs) {
@@ -398,6 +423,10 @@ export function verifyReceiptFile(stateDir: string, runId: string): ReceiptVerif
 	if (!isNullableString(r.sessionId)) {
 		return { ok: false, reason: `sessionId invalid: ${String(r.sessionId)}` };
 	}
+	// A retired seal is diagnosed ahead of the shape check, which would
+	// otherwise report the older version as an invalid integrity block.
+	const retired = retiredReceiptIntegrity(r.integrity);
+	if (retired !== null) return { ok: false, reason: retiredReceiptIntegrityReason(retired), retired };
 	if (!isReceiptIntegrity(r.integrity)) {
 		return { ok: false, reason: "integrity invalid" };
 	}
@@ -673,8 +702,12 @@ export class ReceiptArtifactProvider implements ArtifactProvider {
 					load: () => loadJsonFileLines(path),
 					verify: async () => {
 						const result = verifyReceiptFile(this.deps.stateDir, env.id);
-						if (!result.ok) return { ok: false, detail: result.reason };
-						return { ok: true, detail: "integrity verified" };
+						if (!result.ok) {
+							return { ok: false, detail: result.reason, ...(result.retired !== undefined ? { retired: true } : {}) };
+						}
+						// "integrity verified" alone read as a verified result. The
+						// canonical line says what the seal proves and what it does not.
+						return { ok: true, detail: receiptTrustDetail(this.deps.stateDir, env.id) };
 					},
 				};
 			});

package/src/interactive/view/view-overlay.ts

@@ -51,7 +51,9 @@ export type ViewVerificationState =
 	| { status: "idle" }
 	| { status: "running" }
 	| { status: "ok"; detail: string }
-	| { status: "fail"; detail: string };
+	| { status: "fail"; detail: string }
+	/** A seal this build does not verify because its version was retired: neither a pass nor a tampered-receipt failure. */
+	| { status: "retired"; detail: string };
 
 export type ViewScrollAction =
 	| "line-up"
@@ -327,6 +329,7 @@ function verificationText(state: ViewVerificationState | undefined): string {
 	if (!state || state.status === "idle") return "";
 	if (state.status === "running") return `${GLYPH.running} verify running`;
 	if (state.status === "ok") return `${GLYPH.ok} verify ok ${state.detail}`;
+	if (state.status === "retired") return `${GLYPH.warn} verify retired ${state.detail}`;
 	return `${GLYPH.error} verify fail ${state.detail}`;
 }
 
@@ -343,7 +346,14 @@ export function buildArtifactHeader(
 	if (size.length > 0) parts.push(theme.fg("dim", size));
 	const verify = verificationText(verification);
 	if (verify.length > 0) {
-		const token = verification?.status === "ok" ? "success" : verification?.status === "fail" ? "error" : "info";
+		const token =
+			verification?.status === "ok"
+				? "success"
+				: verification?.status === "fail"
+					? "error"
+					: verification?.status === "retired"
+						? "warning"
+						: "info";
 		parts.push(theme.fg(token, verify));
 	}
 	return padAnsi(parts.join("  "), width, ELLIPSIS);
@@ -689,7 +699,9 @@ export class ViewOverlayView implements Component {
 			.then((result) => {
 				this.verifications.set(
 					key,
-					result.ok ? { status: "ok", detail: result.detail } : { status: "fail", detail: result.detail },
+					result.ok
+						? { status: "ok", detail: result.detail }
+						: { status: result.retired === true ? "retired" : "fail", detail: result.detail },
 				);
 			})
 			.catch((err) => {

package/src/interactive/worker-receipts.ts

@@ -16,6 +16,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { clioStateDir } from "../core/xdg.js";
+import type { RunEnvelope, RunReceipt } from "../domains/dispatch/types.js";
+import { inspectRunReceiptTrustStatus } from "../domains/evidence/trust-status.js";
 import { receiptFilePath } from "./view/artifacts.js";
 import type { WorkerReceiptFacts, WorkerResultContract } from "./worker-stream.js";
 
@@ -86,12 +88,22 @@ export function workerReceiptFacts(receipt: Record<string, unknown>): WorkerRece
 
 /** Read and project `<state>/receipts/<runId>.json` alone; null when it is absent or unreadable. */
 function readReceiptFileFacts(runId: string, stateDir: string): WorkerReceiptFacts | null {
+	let parsed: unknown;
 	try {
-		const parsed: unknown = JSON.parse(readFileSync(receiptFilePath(stateDir, runId), "utf8"));
-		return isRecord(parsed) ? workerReceiptFacts(parsed) : null;
+		parsed = JSON.parse(readFileSync(receiptFilePath(stateDir, runId), "utf8"));
 	} catch {
 		return null;
 	}
+	if (!isRecord(parsed)) return null;
+	const facts = workerReceiptFacts(parsed);
+	if (facts === null) return null;
+	// The trust verdict is an authenticated read-back: the receipt file
+	// against the ledger row it was sealed from. Without the row there is no
+	// authentication, and no verdict is better than a guessed one.
+	const row = findRunRow(runId, stateDir);
+	if (row === null) return facts;
+	const trust = inspectRunReceiptTrustStatus(parsed as unknown as RunReceipt, row as unknown as RunEnvelope).status;
+	return { ...facts, trust };
 }
 
 /** Read and project `<state>/receipts/<runId>.json`; null when it is absent or unreadable. */

package/src/interactive/worker-stream.ts

@@ -42,6 +42,7 @@ import type {
 	RunAbortedPayload,
 } from "../core/bus-events.js";
 import type { RunKind } from "../domains/dispatch/types.js";
+import type { CanonicalTrustStatus } from "../domains/evidence/trust-status.js";
 import type { WorkerRunOrigin, WorkerRunRuntime, WorkerRunRuntimeKind } from "../domains/session/index.js";
 import { createWorkerProgressFold, type WorkerProgressFold, type WorkerProgressSnapshot } from "./worker-progress.js";
 
@@ -88,6 +89,13 @@ export interface WorkerReceiptSummary {
 /** A receipt's projection: the summary plus the answer it sealed. */
 export interface WorkerReceiptFacts extends WorkerReceiptSummary {
 	text?: string;
+	/**
+	 * The canonical trust status of the persisted receipt, authenticated
+	 * against the persisted ledger row it was sealed from. Present only when
+	 * both could be read back, so a surface that shows it shows an
+	 * authenticated verdict and never the sealing process's own claim.
+	 */
+	trust?: CanonicalTrustStatus;
 }
 
 /** Reads `receipts/<runId>.json` and projects it; null when it is absent or unreadable. */

package/src/tools/dispatch-admission.ts

@@ -6,8 +6,10 @@ import {
 	COUNCIL_JUDGE_PROMPT,
 	JUDGE_GATE_PROMPT,
 	REVIEWER_GATE_PROMPT,
+	renderCouncilVoteMemberTask,
 } from "../domains/dispatch/gate-role-prompts.js";
 import { normalizeDispatchIntent } from "../domains/dispatch/intent.js";
+import { renderDispatchReviewerTask } from "../domains/dispatch/intent-requirements.js";
 import { approvedRouteCandidates } from "../domains/dispatch/route-approval.js";
 import { defaultRoutingIntent } from "../domains/dispatch/routing-intent.js";
 import type { DispatchFailoverMode } from "../domains/dispatch/validation.js";
@@ -139,15 +141,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function reviewerTask(originalTask: string, builderRunId: string, cycle: number): string {
-	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,
-	].join("\n\n");
-}
-
 function reviewSettingsFromArgs(
 	args: Record<string, unknown>,
 ): { ok: true; review: DispatchReviewSettings | undefined } | { ok: false; message: string } {
@@ -534,9 +527,6 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 			if (parsed.requests.length !== 1 || parsed.requests[0] === undefined) {
 				return shapeRejection(args, REVIEW_SINGLE_TASK_MESSAGE);
 			}
-			if (parsed.requests.some((request) => (request.resolvedVerification?.length ?? 0) > 0)) {
-				return shapeRejection(args, "verification_unsupported_for_mode: review requests cannot run host verification");
-			}
 		}
 		if (mode === "compete" && (parsed.requests.length !== 1 || parsed.requests[0] === undefined)) {
 			return shapeRejection(args, COMPETE_SINGLE_TASK_MESSAGE);
@@ -587,7 +577,7 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 							{
 								agentId: gateDeciderAgentId(reviewResult.review.reviewer),
 								executionRole: "reviewer",
-								task: reviewerTask(base.task, subject.runId, cycle),
+								task: renderDispatchReviewerTask(base.task, subject.runId, cycle, base.intent),
 								systemPrompt: REVIEWER_GATE_PROMPT,
 								autonomy: "read-only",
 								gate: { role: "reviewer", group: "plan-preview", cycle, subjects: [subject] },
@@ -648,6 +638,15 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 							executionRole: "researcher",
 							autonomy: "read-only",
 							toolProfile: "council-read-only",
+							// The runner reuses this composed task from the resolved plan, so
+							// the approval artifact the plan hash binds shows the operator the
+							// exact ballot the member is asked to cast.
+							...(council.synthesis === "vote"
+								? {
+										task: renderCouncilVoteMemberTask(base.task),
+										resultContractOverride: { kind: "council-ballot" as const },
+									}
+								: {}),
 							target: member.target,
 							...(member.model ? { model: member.model } : {}),
 							...(member.thinking ? { thinkingLevel: member.thinking as NonNullable<DispatchRequest["thinkingLevel"]> } : {}),

package/src/tools/dispatch-arguments.ts

@@ -1,5 +1,6 @@
 /** Pure model-argument parsing; every returned DispatchRequest has a concrete agent id. */
 
+import { pathBoundaryCovers } from "../core/path-boundary.js";
 import type { AgentAutomationAuthority } from "../domains/agents/spec.js";
 import { type AgentTaskType, classifyAgentTask } from "../domains/dispatch/agent-candidates.js";
 import { cloneDispatchBudgetRequest } from "../domains/dispatch/budget-envelope.js";
@@ -261,8 +262,34 @@ export function dispatchRequestsFromArgs(
 	for (let index = 0; index < tasks.length; index += 1) {
 		const item = tasks[index];
 		const itemArgs: Record<string, unknown> = isRecord(item) ? { ...shared, ...item } : { ...shared, task: item };
+		const sharedIntent = isRecord(shared.intent) ? shared.intent : null;
+		const itemIntent = isRecord(item) && Object.hasOwn(item, "intent") && isRecord(item.intent) ? item.intent : null;
+		if (sharedIntent !== null && itemIntent !== null) itemArgs.intent = { ...sharedIntent, ...itemIntent };
 		const parsed = dispatchRequestFromArgs(itemArgs, options);
 		if (!parsed.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${parsed.message}` };
+		if (sharedIntent !== null && itemIntent !== null) {
+			if (options.resolveIntent === undefined) {
+				return { ok: false, message: `dispatch: task ${index + 1}: intent resolver is unavailable` };
+			}
+			const ceiling = options.resolveIntent(sharedIntent, parsed.request.cwd);
+			if (!ceiling.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${ceiling.message}` };
+			const pathCeilings = {
+				readRoots: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots],
+				writeRoots: ceiling.intent.writeRoots,
+				relevantPaths: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots, ...ceiling.intent.relevantPaths],
+			};
+			for (const field of ["readRoots", "writeRoots", "relevantPaths"] as const) {
+				const outside = parsed.request.intent?.[field].find(
+					(candidate) => !pathBoundaryCovers(pathCeilings[field], candidate),
+				);
+				if (outside !== undefined) {
+					return {
+						ok: false,
+						message: `dispatch: task ${index + 1}: intent_scope_widening: ${field} entry '${outside}' is outside the top-level intent ceiling`,
+					};
+				}
+			}
+		}
 		requests.push(parsed.request);
 	}
 	return { ok: true, requests };