@iowarp/clio-coder 0.3.7 → 0.3.8

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,
@@ -246,6 +247,33 @@ function safeField(value: string): string {
 	return result;
 }
 
+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 lines;
+}
+
 function taskViews(args: Record<string, unknown>): DispatchPlanTaskView[] {
 	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
 	const sharedAgent = str(args.agent) ?? "coder";
@@ -417,6 +445,7 @@ function renderPlanText(
 			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/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/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.