@iowarp/clio-coder 0.3.7 → 0.3.9

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/ask-user.ts

@@ -40,13 +40,27 @@ export interface AskUserQuestion {
 
 export interface AskUserAnswer {
 	question: string;
+	/** The whole answer on one line: the chosen labels, then the typed text. */
 	answer: string;
+	/**
+	 * The option labels the operator chose, in list order. Absent when they only
+	 * typed. Present with no {@link value} is a label-only answer, which is how a
+	 * reader tells "they picked the option" from "they picked it and typed a
+	 * figure" (issue #228).
+	 */
+	options?: string[];
+	/** The operator's typed text, exactly as submitted. Absent when they only chose. */
+	value?: string;
 }
 
 export interface AskUserDecision {
 	key: string;
 	value: string;
 	label?: string;
+	/** The chosen labels behind `value`; derived by the harness, not model-supplied. */
+	options?: string[];
+	/** The typed text behind `value`; derived by the harness, not model-supplied. */
+	text?: string;
 	/** Question that produced this decision; derived by the harness, not model-supplied. */
 	source_question?: string;
 }
@@ -299,6 +313,13 @@ export function cancelledAskUserResult(): AskUserResult {
 	return { answers: [], cancelled: true };
 }
 
+/** The chosen labels, dropped when the surface supplied nothing usable. */
+function normalizeAnswerOptions(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const labels = value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0);
+	return labels.length > 0 ? labels : undefined;
+}
+
 function normalizeAskUserResult(questions: ReadonlyArray<AskUserQuestion>, result: AskUserResult): AskUserResult {
 	if (result.cancelled === true) return cancelledAskUserResult();
 	const answers: AskUserAnswer[] = [];
@@ -308,7 +329,18 @@ function normalizeAskUserResult(questions: ReadonlyArray<AskUserQuestion>, resul
 		if (!raw) continue;
 		const question = typeof raw.question === "string" && raw.question.trim().length > 0 ? raw.question : fallbackQuestion;
 		const answer = typeof raw.answer === "string" ? raw.answer.trim() : "";
-		if (question.length > 0 && answer.length > 0) answers.push({ question, answer });
+		if (question.length === 0 || answer.length === 0) continue;
+		// The typed text keeps every byte the operator submitted. The one-line
+		// `answer` is a rendering of the same decision and is trimmed like any
+		// other display string; `value` is the record.
+		const options = normalizeAnswerOptions(raw.options);
+		const value = typeof raw.value === "string" && raw.value.length > 0 ? raw.value : undefined;
+		answers.push({
+			question,
+			answer,
+			...(options ? { options } : {}),
+			...(value !== undefined ? { value } : {}),
+		});
 	}
 	return { answers };
 }
@@ -363,7 +395,12 @@ function transcriptQuestions(questions: ReadonlyArray<AskUserQuestion>): AskUser
 }
 
 function transcriptAnswers(answers: ReadonlyArray<AskUserAnswer>): AskUserTranscriptAnswer[] {
-	return answers.map((answer) => ({ question: answer.question, answer: answer.answer }));
+	return answers.map((answer) => ({
+		question: answer.question,
+		answer: answer.answer,
+		...(answer.options && answer.options.length > 0 ? { options: [...answer.options] } : {}),
+		...(answer.value !== undefined ? { value: answer.value } : {}),
+	}));
 }
 
 function toDecisionKey(value: string): string {
@@ -397,6 +434,8 @@ function decisionFromAnswer(
 		key,
 		value: answer.answer,
 		...(label ? { label } : {}),
+		...(answer.options && answer.options.length > 0 ? { options: [...answer.options] } : {}),
+		...(answer.value !== undefined ? { text: answer.value } : {}),
 		source_question: answer.question,
 	};
 }
@@ -406,6 +445,8 @@ function toTranscriptDecision(decision: AskUserDecision): AskUserTranscriptDecis
 		key: toDecisionKey(decision.key),
 		value: decision.value,
 		...(decision.label ? { label: decision.label } : {}),
+		...(decision.options && decision.options.length > 0 ? { options: [...decision.options] } : {}),
+		...(decision.text !== undefined ? { text: decision.text } : {}),
 		...(decision.source_question ? { source_question: decision.source_question } : {}),
 	};
 }

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 };

package/src/tools/dispatch-plan.ts

@@ -21,6 +21,7 @@ import { AGENT_AUTOMATION_AUTHORITIES, type AgentAutomationAuthority } from "../
 import type { DispatchRequest } from "../domains/dispatch/contract.js";
 import { type ExecutionRole, isExecutionRole } from "../domains/dispatch/execution-role.js";
 import { type DispatchIntent, isDispatchIntent } from "../domains/dispatch/intent.js";
+import { resolveDispatchPathScope } from "../domains/dispatch/path-scope.js";
 import {
 	type ApprovedAssignmentRoute,
 	cloneApprovedAssignmentRoute,
@@ -235,15 +236,46 @@ function str(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
-/** Keep terminal control bytes and line breaks out of approval artifacts. */
-function safeField(value: string): string {
+/** Keep terminal control bytes and line breaks out of approval artifacts without losing their identity. */
+function safeField(value: string, bindChangedValue = true): string {
 	let result = "";
 	for (const character of value) {
 		const code = character.codePointAt(0) ?? 0;
 		result += code < 32 || (code >= 127 && code <= 159) ? "?" : character;
-		if (result.length >= 256) return `${result.slice(0, 255)}…`;
+		if (result.length >= 256) {
+			result = `${result.slice(0, 255)}…`;
+			break;
+		}
+	}
+	if (!bindChangedValue || result === value) return result;
+	return `${result}{sha256=${createHash("sha256").update(value, "utf8").digest("hex")}}`;
+}
+
+function renderLegacyPathScope(task: DispatchPlanTaskView): string[] {
+	if (task.intent !== undefined) return [];
+	const scope = resolveDispatchPathScope({
+		agentId: task.agent,
+		executionRole: task.executionRole,
+		task: task.task,
+		...(task.briefing !== undefined ? { briefing: task.briefing } : {}),
+	});
+	const lines = ["    scope mode=legacy-inferred"];
+	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) {
+				lines.push(
+					`    scope ${policy} path=${JSON.stringify(safeField(entry.path))} provenance=${evidence.provenance} source=${evidence.source} confidence=${evidence.confidence} reason=${evidence.reason}`,
+				);
+			}
+		}
+	}
+	if (scope.provenance.workingContextPaths.length === 0 && scope.provenance.writeBoundaries.length === 0) {
+		lines.push("    scope policy_paths=none");
 	}
-	return result;
+	return lines;
 }
 
 function taskViews(args: Record<string, unknown>): DispatchPlanTaskView[] {
@@ -365,7 +397,7 @@ function renderPlanText(
 				? ""
 				: ` posture=${routing.posture} maxCostUsd=${routing.maxCostUsd ?? "none"} deadlineMs=${routing.deadlineMs ?? "none"} minimumQuality=${routing.minimumQuality ?? "none"} locality=${routing.locality}`;
 		lines.push(
-			`  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task=${JSON.stringify(safeField(task.task))}`,
+			`  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task_bytes=${Buffer.byteLength(task.task, "utf8")} task_sha256=${createHash("sha256").update(task.task, "utf8").digest("hex")} task_preview=${JSON.stringify(safeField(task.task, false))}`,
 		);
 		if (task.council !== undefined) {
 			lines.push(
@@ -392,31 +424,36 @@ function renderPlanText(
 		}
 		if (task.agentSelection !== null) {
 			lines.push(
-				`    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map(safeField).join(",")} basis=${task.agentSelection.authorityBasis}`,
+				`    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map((authority) => safeField(authority)).join(",")} basis=${task.agentSelection.authorityBasis}`,
 			);
 		}
 		if (task.stepId !== null) {
 			lines.push(
-				`    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map(safeField).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`,
+				`    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map((dependency) => safeField(dependency)).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`,
 			);
 			const agentReasons = task.agentDecision?.agentSelection.evaluations
 				.filter((evaluation) => evaluation.rejections.length > 0)
 				.slice(0, 8)
 				.map(
-					(evaluation) => `${safeField(evaluation.agentId)}:${evaluation.rejections.slice(0, 4).map(safeField).join(",")}`,
+					(evaluation) =>
+						`${safeField(evaluation.agentId)}:${evaluation.rejections
+							.slice(0, 4)
+							.map((rejection) => safeField(rejection))
+							.join(",")}`,
 				);
 			if (agentReasons !== undefined && agentReasons.length > 0)
 				lines.push(`    agent-exclusions=${agentReasons.join(";")}`);
 		}
 		if (task.briefing !== undefined) {
 			lines.push(
-				`    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing))}`,
+				`    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing, false))}`,
 			);
 		}
 		if (task.intent !== undefined) {
 			const serialized = JSON.stringify(task.intent);
 			lines.push(`    intent_sha256=${createHash("sha256").update(serialized, "utf8").digest("hex")}`);
 		}
+		lines.push(...renderLegacyPathScope(task));
 		for (const check of task.resolvedVerification ?? []) {
 			lines.push(
 				`    verification check=${safeField(check.check)} argv=${JSON.stringify(check.argv)} cwd=${JSON.stringify(check.cwd)} timeout_ms=${check.timeoutMs}`,

package/src/tools/dispatch-runner.ts

@@ -38,12 +38,15 @@ import {
 	type CompeteStance,
 	JUDGE_GATE_PROMPT,
 	REVIEWER_GATE_PROMPT,
+	renderCouncilVoteMemberTask,
 } from "../domains/dispatch/gate-role-prompts.js";
+import { renderDispatchReviewerTask } from "../domains/dispatch/intent-requirements.js";
 import { UNVERIFIABLE_RECEIPT_VERIFICATION } from "../domains/dispatch/receipt-findings.js";
 import { type ReceiptIntegrityResult, verifyReceiptIntegrity } from "../domains/dispatch/receipt-integrity.js";
 import { explainRouteDecision } from "../domains/dispatch/routing-intent.js";
 import type { RunGateProvenance, RunGateSubjectRef, RunPlanProvenance, RunReceipt } from "../domains/dispatch/types.js";
 import { extractRunProvenance, provenanceCompactSuffix } from "../domains/evidence/provenance.js";
+import { summarizeTrustStatus } from "../domains/evidence/trust-projection.js";
 import { adaptRunReceiptTrustStatus } from "../domains/evidence/trust-status.js";
 import type { AutonomyLevel } from "../domains/safety/autonomy.js";
 import {
@@ -580,6 +583,10 @@ function dispatchDetails(
 				hostVerification: integrity.ok ? (receipt.hostVerification ?? null) : null,
 				receiptIntegrity: integrity,
 				trustStatus,
+				// The bounded projection sits shallow and flat on purpose: a
+				// depth-capped wire (ACP rawOutput) keeps it whole while the
+				// canonical status's nested references fall off the end.
+				trust: summarizeTrustStatus(trustStatus),
 				...(receipt.outcome !== undefined && receipt.outcome !== "succeeded"
 					? { outcome: receipt.outcome, outcomeDetail: receipt.outcomeDetail ?? null }
 					: {}),
@@ -632,15 +639,6 @@ function competeCorrelation(
 	return gateCorrelationOf(subject, decider);
 }
 
-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");
-}
-
 type ReviewGateSettings = DispatchReviewSettings;
 
 const REVIEW_SINGLE_TASK_MESSAGE =
@@ -787,7 +785,7 @@ async function runReviewGated(
 			const reviewerRequest: DispatchRequest = {
 				agentId: gateDeciderAgentId(review.reviewer),
 				executionRole: "reviewer",
-				task: reviewerTask(base.task, builder.receipt.runId, cycle),
+				task: renderDispatchReviewerTask(base.task, builder.receipt.runId, cycle, base.intent),
 				systemPrompt: REVIEWER_GATE_PROMPT,
 				autonomy: "read-only",
 				gate: { role: "reviewer", group, cycle, subjects: [subjectRef(builder.receipt)] },
@@ -1797,10 +1795,19 @@ function competeResult(
 const COUNCIL_BRIEFING_MAX_BYTES = 8 * 1024;
 const COUNCIL_BRIEFING_TRUNCATION = "\n[council peer briefing truncated]";
 
+/**
+ * The verdict a council answer casts, lower-cased.
+ *
+ * A tally groups by the exact string, so folding case is the difference
+ * between two members who both said yes agreeing and splitting into a
+ * `no_majority` the operator has to read past. Folding happens here, at the one
+ * place a verdict is ever read, so the reported member verdict and the tally
+ * key can never disagree.
+ */
 function councilVerdict(text: string): string | undefined {
 	const parsed = parseJsonObjectPayload(text);
 	return parsed.ok && typeof parsed.value.verdict === "string" && parsed.value.verdict.trim().length > 0
-		? parsed.value.verdict.trim()
+		? parsed.value.verdict.trim().toLowerCase()
 		: undefined;
 }
 
@@ -1866,11 +1873,32 @@ async function runCouncil(
 				}
 				const position = (round - 1) * council.members.length + index + 1;
 				const pinned = council.resolvedTasks?.find((task) => task.role === "member" && task.position === position);
+				let voteTask = base.task;
+				if (council.synthesis === "vote") {
+					if (pinned !== undefined) voteTask = pinned.task;
+					else if (council.resolvedTasks !== undefined)
+						throw new Error(`dispatch: resolved council plan has no member task at position ${position}`);
+					else voteTask = renderCouncilVoteMemberTask(base.task);
+				}
 				const request: DispatchRequest = {
 					...base,
 					executionRole: "researcher",
 					autonomy: "read-only",
 					toolProfile: "council-read-only",
+					// A vote is a majority over the members' verdict fields, so a vote
+					// council asks each member for one and seals the ballot it asked
+					// for. The seated recipe is untouched: the ask is a task suffix and
+					// the postcondition is an override, so the member is still the
+					// agent the operator seated, and any recipe can be voted with.
+					// Admission already composed the suffix into each resolved member
+					// task, so reuse its exact bytes. The fallback supports dispatch
+					// contracts that have no resolved admission artifact.
+					...(council.synthesis === "vote"
+						? {
+								task: voteTask,
+								resultContractOverride: { kind: "council-ballot" as const },
+							}
+						: {}),
 					target: member.target,
 					...(member.model ? { model: member.model } : {}),
 					...(member.thinking ? { thinkingLevel: member.thinking as NonNullable<DispatchRequest["thinkingLevel"]> } : {}),
@@ -1911,7 +1939,11 @@ async function runCouncil(
 			label: run.receipt.council?.label ?? "member",
 			runId: run.receipt.runId,
 			round: run.receipt.council?.round ?? 1,
-			answer: text,
+			// A ballot's prose lives in its `text` field, so the report carries the
+			// member's answer rather than its wire envelope, the same way the judge
+			// line already does. A member answering any other shape has no `text`
+			// key and keeps its whole answer.
+			answer: councilJudgeText(text),
 			...(verdict !== undefined ? { verdict } : {}),
 			...(failed ? { failed: { reason: pipelineFailureReason(run.receipt) } } : {}),
 		};
@@ -1967,13 +1999,16 @@ async function runCouncil(
 			judgeRunId: judgeRun.receipt.runId,
 		};
 	}
-	if (council.synthesis !== "judge" && prior.size > 0 && deps.dispatch.sealCouncilSynthesis !== undefined) {
+	if (prior.size > 0 && deps.dispatch.sealCouncilSynthesis !== undefined) {
 		const finalRuns = [...prior.values()];
 		const template = finalRuns[0];
 		if (template === undefined) throw new Error("council synthesis has no final member receipt");
 		// The sealed text is the whole council-report, not the synthesis alone:
 		// /share <synthesis runId> reads this receipt to bring every final
 		// member's labelled answer and the synthesis line into the main context.
+		// A judge council seals it on the same terms: the judge run's own
+		// receipt holds only its {"verdict","text"} payload, which carries no
+		// member answers and no roster labels for the main agent to act on.
 		const text = JSON.stringify({ members, synthesis } satisfies CouncilReport);
 		const receipt = await deps.dispatch.sealCouncilSynthesis({
 			group,

package/src/tools/dispatch-scout.ts

@@ -256,7 +256,7 @@ export async function runScoutContinuationPlan<T, S>(input: {
 				};
 			},
 			cancel: (assignmentId) => input.dispatch.abort(assignmentId),
-			release: (ownerId) => input.dispatch.reservations?.rollbackUnconsumed(ownerId),
+			release: (ownerId) => input.dispatch.reservations?.release(ownerId),
 			releaseUnconsumed: (ownerId) => input.dispatch.reservations?.rollbackUnconsumed(ownerId),
 		},
 		input.signal,

package/src/tools/monitor.ts

@@ -17,6 +17,7 @@ import {
 	type RunReceipt,
 	type RunReceiptVerification,
 } from "../domains/dispatch/types.js";
+import { summarizeTrustStatus } from "../domains/evidence/trust-projection.js";
 import {
 	adaptRunReceiptTrustStatus,
 	type CanonicalTrustStatus,
@@ -389,6 +390,7 @@ function runReceipt(deps: MonitorToolDeps, runId: string): ToolResult {
 			receiptPath: run.receiptPath,
 			receiptIntegrity,
 			trustStatus,
+			trust: summarizeTrustStatus(trustStatus),
 			...(receipt !== null && receiptIntegrity.ok
 				? {
 						evidenceVerification: receipt.verification,
@@ -455,6 +457,17 @@ function durableRunEvidence(run: RunEnvelope | null): DurableRunEvidence {
 	const inspection = inspectRunReceiptTrustStatus(receipt, run);
 	const integrity = inspection.integrity;
 	if (!integrity.ok) {
+		// A retired seal is set aside unread, as a missing receipt is. It is
+		// not a failed one, so it never reads as tampering here either.
+		if (integrity.retired !== undefined) {
+			return {
+				...unavailableRunEvidence(
+					integrity.reason,
+					`${integrity.reason}; worker text is unavailable and validation is unknown.`,
+				),
+				trustStatus: inspection.status,
+			};
+		}
 		return {
 			...unavailableRunEvidence(
 				integrity.reason,

package/src/tools/registry.ts

@@ -234,13 +234,29 @@ export interface AskUserTranscriptQuestion {
 
 export interface AskUserTranscriptAnswer {
 	question: string;
+	/** The whole answer on one line: the chosen labels, then the typed text. */
 	answer: string;
+	/**
+	 * The option labels the operator chose, in list order. Absent when they only
+	 * typed. Present with no {@link value} is a label-only answer.
+	 */
+	options?: string[];
+	/**
+	 * The operator's typed text, exactly as submitted. Absent when they only
+	 * chose. Recording an option label without this is what lost the figures in
+	 * issue #228.
+	 */
+	value?: string;
 }
 
 export interface AskUserTranscriptDecision {
 	key: string;
 	value: string;
 	label?: string;
+	/** The chosen labels behind {@link value}, when the answer had any. Harness-derived. */
+	options?: string[];
+	/** The typed text behind {@link value}, when the answer had any. Harness-derived. */
+	text?: string;
 	source_question?: string;
 }
 

package/src/tools/worker-evidence.ts

@@ -7,6 +7,7 @@ import {
 } from "../domains/dispatch/budget-envelope.js";
 import type { ReceiptIntegrityResult } from "../domains/dispatch/receipt-integrity.js";
 import type { RunReceipt, RunReceiptVerification } from "../domains/dispatch/types.js";
+import { formatTrustAxes, formatTrustSummary } from "../domains/evidence/trust-projection.js";
 import { adaptRunReceiptTrustStatus, type CanonicalTrustStatus } from "../domains/evidence/trust-status.js";
 import { receiptResponseModelIdObservationLabel } from "./dispatch-event-text.js";
 
@@ -128,9 +129,9 @@ export function receiptEvidenceLabels(
 	integrity: ReceiptIntegrityResult,
 ): string[] {
 	const status = adaptRunReceiptTrustStatus({ ...receipt, verification: verification }, { integrity });
-	const canonical = canonicalTrustLabel(status);
+	const canonical = canonicalTrustLabels(status);
 	if (!integrity.ok) {
-		return [canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
+		return [...canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
 	}
 	const briefing =
 		receipt.briefing === undefined
@@ -154,7 +155,7 @@ export function receiptEvidenceLabels(
 					`budget_reason=${JSON.stringify(formatBudgetReasons(receipt.budget))}`,
 				];
 	return [
-		canonical,
+		...canonical,
 		`receipt_integrity=verified/v${receipt.integrity.version}/${receipt.integrity.algorithm}`,
 		`evidence_verification=${verification.state}/${verification.basis}`,
 		`host_verification=${receipt.hostVerification?.status ?? "not_requested"}`,
@@ -167,16 +168,13 @@ export function receiptEvidenceLabels(
 	];
 }
 
-function canonicalTrustLabel(status: CanonicalTrustStatus): string {
-	return [
-		`trust_status=v${status.version}`,
-		`artifactIntegrity:${status.artifactIntegrity.state}`,
-		`validationGrounding:${status.validationGrounding.state}`,
-		`independentReview:${status.independentReview.state}`,
-		`contextProvenance:${status.contextProvenance.state}`,
-		`autonomyEnforcement:${status.autonomyEnforcement.state}`,
-		`completionEvidence:${status.completionEvidence.state}`,
-	].join(" ");
+/**
+ * The compact projection first, then the canonical axis line, both from the
+ * shared projection so the dispatch and monitor text can never spell a state
+ * differently from `evidence inspect` or the board.
+ */
+function canonicalTrustLabels(status: CanonicalTrustStatus): string[] {
+	return [`trust=${JSON.stringify(formatTrustSummary(status))}`, formatTrustAxes(status)];
 }
 
 /**
@@ -192,6 +190,14 @@ export function workerTextLabel(status: CanonicalTrustStatus): string {
 			return "reconnaissance output (advisory leads, not validation evidence):";
 		case "unknown":
 			return "worker claims (validation not observable at this layer):";
+		// The three remaining states were one label. The evidence bundle tells
+		// a failed check, an inferred claim, and no validation at all apart, so
+		// the terminal must too or it hands the operator a coarser verdict than
+		// the report for the same run.
+		case "failed":
+			return "worker claims (validation failed; a check ran and did not pass):";
+		case "ungrounded":
+			return "worker claims (inferred; validation claimed, none observed):";
 		default:
 			return "worker claims (unverified prose):";
 	}

package/src/worker/spec-contract.ts

@@ -162,7 +162,8 @@ interface WorkerSpecFields {
 	 */
 	autonomy?: AutonomyLevel;
 	/**
-	 * Absolute directories write-class tool calls are confined to for this run.
+	 * Absolute path boundaries write-class tool calls are confined to for this run.
+	 * Exact files omit a trailing slash and subtrees retain one.
 	 * Enforced at the shared worker safety seam so a write/edit target outside
 	 * every root is a final block. Only set on runtimes that mediate per-tool
 	 * calls (native, claude-sdk); dispatch refuses it on subprocess runtimes.