@iowarp/clio-coder 0.3.6 → 0.3.8

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,
@@ -123,6 +124,11 @@ function runStatus(deps: MonitorToolDeps, runId: string): ToolResult {
 		`started=${run.startedAt} ended=${run.endedAt ?? "n/a"} exit=${run.exitCode ?? "n/a"}`,
 		`tokens=${run.tokenCount} cost=${formatCostAggregate(costAggregateForAmount(run.costUsd, run.costProvenance)) ?? COST_NOT_MEASURED} receipt=${run.receiptPath ?? "n/a"}`,
 	];
+	if (run.council !== undefined || run.gate?.role === "synthesis") {
+		lines.push(
+			`council: role=${run.gate?.role === "synthesis" ? "synthesis" : "member"} group=${run.council?.group ?? run.gate?.group ?? "unknown"}${run.council?.label ? ` label=${run.council.label}` : ""}`,
+		);
+	}
 	if (run.budget !== undefined) {
 		lines.push(
 			`recipe policy: ${formatBudgetPolicy(run.budget)}`,
@@ -158,6 +164,15 @@ function runStatus(deps: MonitorToolDeps, runId: string): ToolResult {
 			costUsd: run.costUsd,
 			costProvenance: run.costProvenance ?? "unknown",
 			budget: run.budget ?? null,
+			...(run.council !== undefined || run.gate?.role === "synthesis"
+				? {
+						council: {
+							role: run.gate?.role === "synthesis" ? "synthesis" : "member",
+							group: run.council?.group ?? run.gate?.group ?? null,
+							...(run.council !== undefined ? { label: run.council.label, round: run.council.round } : {}),
+						},
+					}
+				: {}),
 			receiptPath: run.receiptPath,
 			running: live !== null,
 		},
@@ -375,9 +390,11 @@ function runReceipt(deps: MonitorToolDeps, runId: string): ToolResult {
 			receiptPath: run.receiptPath,
 			receiptIntegrity,
 			trustStatus,
+			trust: summarizeTrustStatus(trustStatus),
 			...(receipt !== null && receiptIntegrity.ok
 				? {
 						evidenceVerification: receipt.verification,
+						hostVerification: receipt.hostVerification ?? null,
 						briefing: receipt.briefing ?? null,
 						projectContext: receipt.projectContext ?? null,
 					}
@@ -440,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,
@@ -717,6 +745,7 @@ async function runCollect(
 					receiptIntegrity: row.evidence.integrity,
 					trustStatus: row.evidence.trustStatus,
 					evidenceVerification: row.evidence.verification,
+					hostVerification: row.evidence.receipt?.hostVerification ?? null,
 					briefing: row.evidence.receipt?.briefing ?? null,
 					projectContext: row.evidence.receipt?.projectContext ?? null,
 					...(output ? { output: { state: output.state, bytes: output.bytes, truncated: output.truncated } } : {}),

package/src/tools/profiles.ts

@@ -1,8 +1,13 @@
 import { type BuiltinToolName, isBuiltinToolName, type ToolName, ToolNames } from "../core/tool-names.js";
 
-export type ToolProfileName = "minimal-local" | "science-local" | "full-agent";
+export type ToolProfileName = "minimal-local" | "science-local" | "full-agent" | "council-read-only";
 
-export const TOOL_PROFILE_NAMES: ReadonlyArray<ToolProfileName> = ["minimal-local", "science-local", "full-agent"];
+export const TOOL_PROFILE_NAMES: ReadonlyArray<Exclude<ToolProfileName, "council-read-only">> = [
+	"minimal-local",
+	"science-local",
+	"full-agent",
+];
+const ALL_TOOL_PROFILE_NAMES: ReadonlyArray<ToolProfileName> = [...TOOL_PROFILE_NAMES, "council-read-only"];
 const CODEWIKI_TOOL_NAMES: ReadonlyArray<BuiltinToolName> = [ToolNames.CodeNav];
 
 export interface ToolProfileContext {
@@ -24,14 +29,23 @@ const MINIMAL_LOCAL_TOOLS: ReadonlyArray<BuiltinToolName> = [
 ];
 
 const SCIENCE_LOCAL_TOOLS: ReadonlyArray<BuiltinToolName> = [...MINIMAL_LOCAL_TOOLS, ToolNames.Verify];
+const COUNCIL_READ_ONLY_TOOLS: ReadonlyArray<BuiltinToolName> = [
+	ToolNames.Read,
+	ToolNames.Grep,
+	ToolNames.Find,
+	ToolNames.Ls,
+	ToolNames.CodeNav,
+	ToolNames.Context,
+];
 
 const NARROW_TOOL_PROFILES: Readonly<Record<Exclude<ToolProfileName, "full-agent">, ReadonlySet<BuiltinToolName>>> = {
 	"minimal-local": new Set(MINIMAL_LOCAL_TOOLS),
 	"science-local": new Set(SCIENCE_LOCAL_TOOLS),
+	"council-read-only": new Set(COUNCIL_READ_ONLY_TOOLS),
 };
 
 export function isToolProfileName(value: string): value is ToolProfileName {
-	return (TOOL_PROFILE_NAMES as ReadonlyArray<string>).includes(value);
+	return (ALL_TOOL_PROFILE_NAMES as ReadonlyArray<string>).includes(value);
 }
 
 /**
@@ -72,7 +86,7 @@ export function applyToolProfile(
 		const allowed = NARROW_TOOL_PROFILES[profile];
 		profiled = unique.filter((tool): tool is BuiltinToolName => isBuiltinToolName(tool) && allowed.has(tool));
 	}
-	return applyCodewikiWorkerPolicy(profiled, context);
+	return profile === "council-read-only" ? profiled : applyCodewikiWorkerPolicy(profiled, context);
 }
 
 function uniquePreservingOrder(tools: ReadonlyArray<ToolName>): ToolName[] {

package/src/tools/task-worktree.ts

@@ -0,0 +1,238 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+export type TaskWorktreeApply = "merge" | "preserve";
+
+export interface TaskWorktree {
+	root: string;
+	runId: string;
+	path: string;
+	branch: string;
+	base: string;
+	ownerToken: string;
+}
+
+export interface TaskWorktreeReceipt {
+	path: string;
+	branch: string;
+	diffHash: string;
+	apply: TaskWorktreeApply;
+	applied: boolean;
+	reason?: string;
+}
+
+const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const OWNER_FILE_SUFFIX = ".task-owner.json";
+const COMMIT_IDENTITY = "clio-task";
+
+function gitBytes(root: string, args: string[]): Buffer {
+	return execFileSync("git", ["-C", root, ...args], {
+		stdio: ["ignore", "pipe", "pipe"],
+		timeout: 30_000,
+	});
+}
+
+function git(root: string, args: string[]): string {
+	return gitBytes(root, args).toString("utf8").trim();
+}
+
+export function isCanonicalWorktreePathInside(parent: string, candidate: string): boolean {
+	let canonicalParent: string;
+	let canonicalCandidate: string;
+	try {
+		canonicalParent = realpathSync(parent);
+	} catch {
+		canonicalParent = resolve(parent);
+	}
+	try {
+		canonicalCandidate = realpathSync(candidate);
+	} catch {
+		canonicalCandidate = resolve(candidate);
+	}
+	const rel = relative(canonicalParent, canonicalCandidate);
+	return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+
+export function commitWorktreePath(path: string, identity: string, message: string): boolean {
+	git(path, ["add", "-A"]);
+	if (git(path, ["status", "--porcelain"]).length === 0) return false;
+	git(path, [
+		"-c",
+		`user.name=${identity}`,
+		"-c",
+		`user.email=${identity}@local`,
+		"commit",
+		"-m",
+		message,
+		"--no-verify",
+	]);
+	return true;
+}
+
+export function worktreeBranchDiffStat(root: string, branch: string): string {
+	try {
+		return git(root, ["diff", "--shortstat", `HEAD...${branch}`]) || "no changes";
+	} catch {
+		return "diff unavailable";
+	}
+}
+
+export function protectedPathsChangedByWorktreeBranch(
+	root: string,
+	branch: string,
+	protectedPaths: ReadonlyArray<string>,
+): string[] {
+	const canonical = realpathSync(root);
+	const protectedInside = protectedPaths
+		.map((path) => resolve(path))
+		.filter((path) => {
+			const rel = relative(canonical, path);
+			return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+		});
+	if (protectedInside.length === 0) return [];
+	const changed = git(canonical, ["diff", "--name-only", "-z", "--no-renames", `HEAD...${branch}`])
+		.split("\0")
+		.filter((path) => path.length > 0)
+		.map((path) => resolve(canonical, path));
+	const blocked = new Set<string>();
+	for (const candidate of changed) {
+		for (const protectedPath of protectedInside) {
+			const rel = relative(protectedPath, candidate);
+			if (
+				candidate === protectedPath ||
+				(rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
+			) {
+				blocked.add(protectedPath);
+			}
+		}
+	}
+	return [...blocked].sort();
+}
+
+export function mergeWorktreeBranch(
+	root: string,
+	branch: string,
+	identity: string,
+): { ok: true } | { ok: false; reason: string } {
+	try {
+		git(root, [
+			"-c",
+			`user.name=${identity}`,
+			"-c",
+			`user.email=${identity}@local`,
+			"merge",
+			"--no-edit",
+			"--no-verify",
+			branch,
+		]);
+		return { ok: true };
+	} catch (error) {
+		try {
+			git(root, ["merge", "--abort"]);
+		} catch {
+			// No merge remains to abort.
+		}
+		return {
+			ok: false,
+			reason: error instanceof Error ? (error.message.split("\n")[0] ?? "merge failed") : String(error),
+		};
+	}
+}
+
+function validateRunId(runId: string): void {
+	if (!SAFE_RUN_ID.test(runId) || runId === "." || runId === "..")
+		throw new Error(`invalid task worktree run id '${runId}'`);
+}
+
+export function gitCheckoutRoot(cwd: string): string | null {
+	try {
+		return realpathSync(git(cwd, ["rev-parse", "--show-toplevel"]));
+	} catch {
+		return null;
+	}
+}
+
+export function createTaskWorktree(root: string, runId: string, base?: string): TaskWorktree {
+	validateRunId(runId);
+	const canonical = realpathSync(root);
+	const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
+	const parent = join(canonical, ".clio-coder", "worktrees");
+	const path = join(parent, runId);
+	const branch = `clio/task/${runId}`;
+	mkdirSync(parent, { recursive: true });
+	if (!isCanonicalWorktreePathInside(parent, path))
+		throw new Error(`task worktree path escapes its parent for run ${runId}`);
+	git(canonical, ["worktree", "add", "-b", branch, path, resolvedBase]);
+	const ownerToken = randomBytes(16).toString("hex");
+	writeFileSync(
+		`${path}${OWNER_FILE_SUFFIX}`,
+		`${JSON.stringify({ version: 1, kind: "clio-task-worktree", root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}\n`,
+		{ encoding: "utf8", flag: "wx" },
+	);
+	return { root: canonical, runId, path, branch, base: resolvedBase, ownerToken };
+}
+
+function assertOwnership(worktree: TaskWorktree): void {
+	const expected = join(worktree.root, ".clio-coder", "worktrees", worktree.runId);
+	if (
+		resolve(worktree.path) !== resolve(expected) ||
+		!isCanonicalWorktreePathInside(join(worktree.root, ".clio-coder", "worktrees"), worktree.path)
+	) {
+		throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
+	}
+	if (!existsSync(`${worktree.path}${OWNER_FILE_SUFFIX}`))
+		throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+}
+
+function commitTaskWorktree(worktree: TaskWorktree, message = `Clio task ${worktree.runId}`): boolean {
+	assertOwnership(worktree);
+	return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
+}
+
+function taskWorktreeDiffHash(worktree: Pick<TaskWorktree, "root" | "base" | "branch">): string {
+	const bytes = gitBytes(worktree.root, ["diff", `${worktree.base}..${worktree.branch}`]);
+	return createHash("sha256").update(bytes).digest("hex");
+}
+
+function protectedPathsChangedByTaskBranch(
+	worktree: Pick<TaskWorktree, "root" | "branch">,
+	protectedPaths: ReadonlyArray<string>,
+): string[] {
+	return protectedPathsChangedByWorktreeBranch(worktree.root, worktree.branch, protectedPaths);
+}
+
+export function applyTaskWorktree(input: {
+	worktree: TaskWorktree;
+	apply: TaskWorktreeApply;
+	protectedPaths?: ReadonlyArray<string>;
+}): TaskWorktreeReceipt {
+	assertOwnership(input.worktree);
+	commitTaskWorktree(input.worktree);
+	const receipt: TaskWorktreeReceipt = {
+		path: input.worktree.path,
+		branch: input.worktree.branch,
+		diffHash: taskWorktreeDiffHash(input.worktree),
+		apply: input.apply,
+		applied: false,
+	};
+	if (input.apply === "preserve") return receipt;
+	const protectedChanges = protectedPathsChangedByTaskBranch(input.worktree, input.protectedPaths ?? []);
+	if (protectedChanges.length > 0) return { ...receipt, reason: "protected_artifact_changed" };
+	const merged = mergeWorktreeBranch(input.worktree.root, input.worktree.branch, COMMIT_IDENTITY);
+	if (!merged.ok) return { ...receipt, reason: "worktree_merge_conflict" };
+	return { ...receipt, applied: true };
+}
+
+export function cleanupTaskWorktree(worktree: TaskWorktree, deleteBranch: boolean): void {
+	assertOwnership(worktree);
+	try {
+		git(worktree.root, ["worktree", "remove", "--force", worktree.path]);
+	} catch {
+		if (existsSync(worktree.path)) rmSync(worktree.path, { recursive: true, force: true });
+		git(worktree.root, ["worktree", "prune"]);
+	}
+	if (deleteBranch) git(worktree.root, ["branch", "-D", worktree.branch]);
+	rmSync(`${worktree.path}${OWNER_FILE_SUFFIX}`, { force: true });
+}

package/src/tools/verify/authoring.ts

@@ -24,7 +24,7 @@ import {
 	parseProjectVerifierCatalogText,
 } from "./catalog.js";
 import { verifyTool } from "./index.js";
-import { discoverDeclaredChecksAtRoot } from "./scripts.js";
+import { discoverDeclaredChecksAtRoot, discoverDeclaredProjectEntriesAtRoot } from "./scripts.js";
 
 export type VerifierProposalAuthority = "project-declared" | "toolchain-defined";
 
@@ -34,6 +34,8 @@ export type VerifierSignalKind =
 	| "cargo"
 	| "cmake-preset"
 	| "python-runner"
+	| "just-recipe"
+	| "make-target"
 	| "go-module"
 	| "validation-contract"
 	| "manual-entry";
@@ -149,6 +151,12 @@ export interface VerifierAuthoringWorkflowOptions {
 	runCheck?: (id: string) => Promise<ToolResult>;
 }
 
+export interface DeclaredProjectCommand {
+	id: string;
+	command: string[];
+	provenance: VerifierProvenance;
+}
+
 interface RawProposal {
 	preferredId: string;
 	description: string;
@@ -466,6 +474,58 @@ function pythonProposals(workspaceRoot: string, diagnostics: string[]): RawPropo
 	return proposals;
 }
 
+/**
+ * Discover exact invocation vectors from project declarations for fleet command
+ * authoring. This shares the verifier authoring readers and provenance model,
+ * while retaining entries that are not verification-family names.
+ */
+export function discoverDeclaredProjectCommands(workspaceRoot = process.cwd()): DeclaredProjectCommand[] {
+	const commands: DeclaredProjectCommand[] = [];
+	const add = (id: string, command: string[], pathValue: string, detail: string, kind: VerifierSignalKind): void => {
+		commands.push({
+			id,
+			command,
+			provenance: { kind, path: pathValue, detail, authority: "project-declared" },
+		});
+	};
+	for (const entry of discoverDeclaredProjectEntriesAtRoot(workspaceRoot)) {
+		add(entry.id, entry.command, entry.path, entry.detail, entry.kind);
+	}
+	const pyprojectText = regularFileText(path.join(workspaceRoot, "pyproject.toml"), workspaceRoot);
+	if (typeof pyprojectText === "string") {
+		const document = parseTomlDocument(pyprojectText);
+		if (document !== null) {
+			for (const [tablePath, label] of [
+				[["project", "scripts"], "project.scripts"],
+				[["tool", "poetry", "scripts"], "tool.poetry.scripts"],
+			] as const) {
+				const scripts = tomlTableAt(document, tablePath);
+				if (scripts === null) continue;
+				for (const [name, target] of Object.entries(scripts).sort(([left], [right]) => compareCodepoints(left, right))) {
+					if (typeof target === "string") add(name, [name], "pyproject.toml", `[${label}] entry '${name}'`, "python-runner");
+				}
+			}
+			for (const [tablePath, module, id, label] of [
+				[["tool", "pytest", "ini_options"], "pytest", "pytest", "tool.pytest.ini_options"],
+				[["tool", "tox"], "tox", "tox", "tool.tox"],
+				[["tool", "nox"], "nox", "nox", "tool.nox"],
+			] as const) {
+				if (tomlTableAt(document, tablePath) !== null)
+					add(id, ["python", "-m", module], "pyproject.toml", `[${label}]`, "python-runner");
+			}
+		}
+	}
+	const seen = new Set<string>();
+	return commands.filter((entry) => {
+		let id = slug(entry.id, "command");
+		let suffix = 2;
+		while (seen.has(id)) id = `${slug(entry.id, "command")}-${suffix++}`;
+		seen.add(id);
+		entry.id = id;
+		return true;
+	});
+}
+
 function goProposals(workspaceRoot: string, diagnostics: string[]): RawProposal[] {
 	const relative = "go.mod";
 	const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);

package/src/tools/verify/scripts.ts

@@ -21,6 +21,14 @@ import {
 
 export type DeclaredCheckDiscoveryResult = { ok: true; sources: DeclaredCheckSource[] } | { ok: false; reason: string };
 
+export interface DeclaredProjectEntry {
+	id: string;
+	command: string[];
+	path: string;
+	detail: string;
+	kind: "package-script" | "just-recipe" | "make-target";
+}
+
 function repositoryRelativeCwd(workspaceRoot: string, resolved: string): string {
 	const relative = path.relative(workspaceRoot, resolved);
 	return relative.length === 0 ? "." : relative.split(path.sep).join("/");
@@ -43,6 +51,60 @@ function packageCheckSource(packageRoot: string, workspaceRoot: string): Declare
 	return { kind: "package.json", path: packagePath, checks };
 }
 
+/** Discover every exact project-declared entry without promoting it to a verifier check. */
+export function discoverDeclaredProjectEntriesAtRoot(workspaceRoot: string): DeclaredProjectEntry[] {
+	const entries: DeclaredProjectEntry[] = [];
+	const packagePath = path.join(workspaceRoot, "package.json");
+	if (existsSync(packagePath)) {
+		const pkg = parsePackageJson(packagePath);
+		if (pkg.ok) {
+			for (const name of Object.keys(pkg.scripts).sort()) {
+				if (typeof pkg.scripts[name] !== "string") continue;
+				entries.push({
+					id: name,
+					command: ["npm", "run", name],
+					path: "package.json",
+					detail: `package.json script '${name}'`,
+					kind: "package-script",
+				});
+			}
+		}
+	}
+	for (const relative of ["justfile", "Justfile"] as const) {
+		const filePath = path.join(workspaceRoot, relative);
+		if (!existsSync(filePath)) continue;
+		const text = readFileSync(filePath, "utf8");
+		for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_-]*)\s*(?:[^:=\n]*)?:\s*(?:#.*)?$/gmu)) {
+			const name = match[1];
+			if (name === undefined || name.startsWith("_")) continue;
+			entries.push({
+				id: name,
+				command: ["just", name],
+				path: relative,
+				detail: `just recipe '${name}'`,
+				kind: "just-recipe",
+			});
+		}
+		break;
+	}
+	const makePath = path.join(workspaceRoot, "Makefile");
+	if (existsSync(makePath)) {
+		const text = readFileSync(makePath, "utf8");
+		for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\s*:(?![=])[^\n]*$/gmu)) {
+			const name = match[1];
+			if (name === undefined || name.startsWith(".")) continue;
+			entries.push({
+				id: name,
+				command: ["make", name],
+				path: "Makefile",
+				detail: `Makefile target '${name}'`,
+				kind: "make-target",
+			});
+		}
+	}
+	return entries;
+}
+
 function providerCollision(sources: ReadonlyArray<DeclaredCheckSource>): string | null {
 	const seen = new Map<string, DeclaredCheck>();
 	for (const source of sources) {

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";
 
@@ -127,10 +128,10 @@ export function receiptEvidenceLabels(
 	verification: RunReceiptVerification,
 	integrity: ReceiptIntegrityResult,
 ): string[] {
-	const status = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity });
-	const canonical = canonicalTrustLabel(status);
+	const status = adaptRunReceiptTrustStatus({ ...receipt, verification: verification }, { integrity });
+	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,9 +155,10 @@ 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"}`,
 		...(responseModelIdObservation ? [responseModelIdObservation] : []),
 		...budget,
 		...receiptAdmissionLabels(receipt),
@@ -166,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)];
 }
 
 /**
@@ -191,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.
@@ -225,6 +226,7 @@ const TOOL_PROFILE_NAMES = [
 	"minimal-local",
 	"science-local",
 	"full-agent",
+	"council-read-only",
 ] as const satisfies ReadonlyArray<ToolProfileName>;
 const WORKER_PRODUCTS = ["orientation"] as const satisfies ReadonlyArray<AgentProduct>;
 const TARGET_LIFECYCLES = ["user-managed", "clio-managed"] as const;

package/dist/chunk-HC4CLZ2Y.js

@@ -1,68 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  withStateFileLock
-} from "./chunk-IKCO5N3L.js";
-import {
-  safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
-import {
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/domains/observability/evidence-index.ts
-init_esm_shims();
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-var MAX_EVIDENCE_INDEX_ROWS = 1e3;
-var EVIDENCE_INDEX_FILE = "evidence-index.json";
-var evidenceIndexWriteQueue = Promise.resolve();
-function indexPath(stateDir) {
-  return join(stateDir, EVIDENCE_INDEX_FILE);
-}
-function isEvidenceIndexRow(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const row = value;
-  return typeof row.runId === "string" && typeof row.evidenceId === "string" && Array.isArray(row.tags) && row.tags.every((tag) => typeof tag === "string") && typeof row.firstPassSuccess === "boolean" && typeof row.findingCount === "number" && typeof row.generatedAt === "string";
-}
-function readEvidenceIndex(stateDir) {
-  let raw;
-  try {
-    raw = readFileSync(indexPath(stateDir), "utf8");
-  } catch {
-    return [];
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return [];
-  }
-  if (!Array.isArray(parsed)) return [];
-  return parsed.filter(isEvidenceIndexRow);
-}
-async function writeEvidenceIndexRow(stateDir, row) {
-  let bounded = [];
-  await withStateFileLock(indexPath(stateDir), () => {
-    const existing = readEvidenceIndex(stateDir).filter((entry) => entry.runId !== row.runId);
-    existing.push(row);
-    bounded = existing.length > MAX_EVIDENCE_INDEX_ROWS ? existing.slice(-MAX_EVIDENCE_INDEX_ROWS) : existing;
-    safeResourceWrite(indexPath(stateDir), `${JSON.stringify(bounded, null, 2)}
-`, { encoding: "utf8" });
-  });
-  return bounded;
-}
-async function writeEvidenceIndexRowQueued(stateDir, row) {
-  let written = [];
-  const write = evidenceIndexWriteQueue.then(async () => {
-    written = await writeEvidenceIndexRow(stateDir, row);
-  });
-  evidenceIndexWriteQueue = write.catch(() => void 0);
-  await write;
-  return written;
-}
-
-export {
-  readEvidenceIndex,
-  writeEvidenceIndexRowQueued
-};
-//# sourceMappingURL=chunk-HC4CLZ2Y.js.map