@iowarp/clio-coder 0.3.7 → 0.3.8

package/src/domains/evidence/build.ts

@@ -29,8 +29,8 @@ import { extractRunProvenance, provenanceTranscriptLines } from "./provenance.js
 import { createRedactionTally, redactSecretsDeep, redactSecretsText } from "./redact.js";
 import { buildEvidenceTrustStatusFile } from "./run-trust.js";
 import { EVIDENCE_FILES, evidenceDirectory, findingsFile } from "./store.js";
-import type { TrustArtifactReference } from "./trust-status.js";
-import { inspectRunReceiptTrustStatus } from "./trust-status.js";
+import type { CanonicalTrustStatus, TrustArtifactReference } from "./trust-status.js";
+import { inspectRunReceiptTrustStatus, retiredIntegrityVersionOf } from "./trust-status.js";
 import {
 	EVIDENCE_VERSION,
 	type EvidenceAuditLinkedRow,
@@ -45,6 +45,7 @@ import {
 	type EvidenceReceiptFile,
 	type EvidenceRunLink,
 	type EvidenceRunSource,
+	type EvidenceSeverity,
 	type EvidenceTag,
 	type EvidenceToolEvent,
 	type EvidenceTrustStatusFile,
@@ -195,7 +196,10 @@ export async function buildEvidence(options: BuildEvidenceOptions): Promise<Evid
 		redactedToolEvents,
 		protectedArtifacts,
 	);
-	const transcript = redactSecretsText(renderTranscript(overview, redactedRunSources, sessionLinks), tally);
+	const transcript = redactSecretsText(
+		renderTranscript(overview, redactedRunSources, sessionLinks, trustStatusRaw),
+		tally,
+	);
 	const finalOverview: EvidenceOverview = { ...overview, redactionCount: tally.count };
 	await writeEvidenceFiles(
 		directory,
@@ -285,8 +289,14 @@ function buildFindings(
 		const status = trustByRun.get(source.envelope.id);
 		if (status === undefined) throw new Error(`canonical trust status missing for run ${source.envelope.id}`);
 		if (source.receiptError !== null) {
-			const tag = source.receiptIntegrityFailed ? "receipt-integrity" : "unknown";
-			findings.push(finding(findings.length, "warn", tag, source.envelope.id, source.receiptError));
+			// The canonical axis, not the raw reason string, says whether the seal
+			// was retired: `receipt-retired` is the expected state of every run
+			// that predates an integrity bump and is an info row, while
+			// `receipt-integrity` stays the warning for a seal that was checked
+			// and rejected.
+			const retired = retiredIntegrityVersionOf(status.artifactIntegrity) !== null;
+			const tag = retired ? "receipt-retired" : source.receiptIntegrityFailed ? "receipt-integrity" : "unknown";
+			findings.push(finding(findings.length, retired ? "info" : "warn", tag, source.envelope.id, source.receiptError));
 		}
 		if (
 			isSuccessfulRun(source) &&
@@ -359,6 +369,13 @@ function buildFindings(
 				),
 			);
 		}
+		// The remaining axes were never read here, so a run could finish with
+		// no independent review, a contradictory context record, or a mutation
+		// nobody validated, and findings.md said nothing. Each finding is
+		// selected from the canonical state the way the validation and
+		// autonomy findings above are, with the detailed record left in
+		// trust-status.json.
+		findings.push(...axisFindings(findings.length, source, status));
 		if (source.envelope.status === "stale" || source.envelope.status === "dead") {
 			findings.push(
 				finding(findings.length, "warn", "timeout", source.envelope.id, `run status ${source.envelope.status}`),
@@ -601,7 +618,7 @@ async function writeEvidenceFiles(
 	await writeJson(join(directory, "overview.json"), overview);
 	await writeFile(
 		join(directory, "transcript.md"),
-		transcript ?? renderTranscript(overview, runSources, sessionLinks),
+		transcript ?? renderTranscript(overview, runSources, sessionLinks, trustStatus),
 		"utf8",
 	);
 	await writeJsonl(join(directory, "trace.raw.jsonl"), rawTraceRows(runSources));
@@ -636,9 +653,11 @@ function cleanedTraceRows(
 	const rows: EvidenceCleanTraceRow[] = [];
 	for (const source of runSources) {
 		const envelope = source.envelope;
-		// Clean trace rows project only provenance carried by the sealed receipt.
+		// Clean trace rows project only provenance carried by an authenticated
+		// receipt: a rejected or retired seal contributes none of its fields.
 		// Runs without receipt provenance keep the standard row shape.
-		const provenance = source.receipt === null ? {} : extractRunProvenance(source.receipt);
+		const receipt = authenticatedReceipt(source);
+		const provenance = receipt === null ? {} : extractRunProvenance(receipt);
 		rows.push({
 			kind: "run",
 			runId: envelope.id,
@@ -1258,7 +1277,9 @@ function renderTranscript(
 	overview: EvidenceOverview,
 	runSources: ReadonlyArray<EvidenceRunSource>,
 	sessionLinks: SessionLinkResult,
+	trustStatus: EvidenceTrustStatusFile,
 ): string {
+	const trustByRun = new Map(trustStatus.runs.map((entry) => [entry.runId, entry.status]));
 	const lines = [
 		`# Evidence ${overview.evidenceId}`,
 		"",
@@ -1274,10 +1295,11 @@ function renderTranscript(
 			`- ${envelope.id} status=${envelope.status} exit=${exitCode ?? "?"} agent=${envelope.agentId} target=${envelope.targetId}`,
 		);
 		lines.push(`  task: ${truncateText(envelope.task, MAX_TASK_CHARS)}`);
-		// Run section rendering reads provenance from the sealed receipt and adds
-		// sentences only for fields that are present.
+		// Run section rendering adds a sentence per provenance field the
+		// canonical projection admits; a rejected or retired seal adds none.
 		if (source.receipt !== null) {
-			for (const line of provenanceTranscriptLines(extractRunProvenance(source.receipt))) {
+			const status = trustByRun.get(envelope.id);
+			for (const line of provenanceTranscriptLines(extractRunProvenance(source.receipt), status)) {
 				lines.push(`  ${line}`);
 			}
 		}
@@ -1438,6 +1460,39 @@ function renderSessionTranscriptEntry(linked: LinkedSessionEntry): string[] {
 	return [`${prefix} ${String(_exhaustive)}`];
 }
 
+/** Independent review, context provenance, and completion evidence, read off the canonical axes. */
+function axisFindings(offset: number, source: EvidenceRunSource, status: CanonicalTrustStatus): EvidenceFinding[] {
+	const out: EvidenceFinding[] = [];
+	const runId = source.envelope.id;
+	const next = (severity: EvidenceSeverity, tag: EvidenceTag, message: string): void => {
+		out.push(finding(offset + out.length, severity, tag, runId, message));
+	};
+	const review = status.independentReview.state;
+	if (review === "failed") {
+		next("warn", "independent-review", "independent review failed for this run");
+	} else if (review === "not_independent") {
+		next("warn", "independent-review", "review was not independent of the run it judged");
+	} else if (review === "inconclusive") {
+		next("info", "independent-review", "independent review was inconclusive");
+	} else if (isSuccessfulRun(source) && (review === "absent" || review === "unknown")) {
+		next("info", "independent-review", "run was not independently reviewed; its result rests on its own receipt");
+	}
+	if (status.contextProvenance.state === "invalid") {
+		next("warn", "context-provenance", "context provenance record is contradictory; see trust-status.json");
+	}
+	const completion = status.completionEvidence.state;
+	if (completion === "incomplete") {
+		next(
+			"warn",
+			"completion-evidence",
+			"run mutated the workspace and finished without validation evidence at the completion boundary",
+		);
+	} else if (completion === "limited") {
+		next("info", "completion-evidence", "run finished with an explicit limitation instead of validation evidence");
+	}
+	return out;
+}
+
 function renderFindings(findings: ReadonlyArray<EvidenceFinding>): string {
 	if (findings.length === 0) return "# Findings\n\nNo findings.\n";
 	const lines = ["# Findings", ""];
@@ -1507,6 +1562,9 @@ async function readReceipt(
 	}
 	const integrity = inspectRunReceiptTrustStatus(receipt, envelope).integrity;
 	if (!integrity.ok) {
+		// A retired seal is set aside unread, the way a missing receipt is; it
+		// is not a failed one, and its reason already names both versions.
+		if (integrity.retired !== undefined) return { receipt, error: integrity.reason, integrityFailed: false };
 		return { receipt, error: `receipt integrity: ${integrity.reason}`, integrityFailed: true };
 	}
 	return { receipt, error: null, integrityFailed: false };

package/src/domains/evidence/index.ts

@@ -5,6 +5,7 @@ export { buildEvalEvidence, evalEvidenceId } from "./eval.js";
 export { FINISH_CONTRACT_EVIDENCE_TAGS, finishContractEvidenceTags } from "./finish-contract-map.js";
 export type { RunEscalationCounts, RunProvenanceView } from "./provenance.js";
 export {
+	admitRunProvenance,
 	extractRunProvenance,
 	hasRunProvenance,
 	PERSONA_HASH_PREFIX_CHARS,
@@ -22,6 +23,20 @@ export {
 	loadEvidenceRunProvenance,
 	loadEvidenceTrustStatus,
 } from "./store.js";
+export type { TrustSummaryProjection, TrustVerdict } from "./trust-projection.js";
+export {
+	formatTrustAxes,
+	formatTrustSummary,
+	formatTrustSummaryLine,
+	summarizeTrustStatus,
+	TRUST_STATE_WORDS,
+	TRUST_SUMMARY_MAX_REFS,
+	TRUST_SUMMARY_VERSION,
+	TRUST_VERDICTS,
+	trustStateWord,
+	trustSummaryReferences,
+	trustVerdict,
+} from "./trust-projection.js";
 export type {
 	AbsentTrustStatus,
 	AdaptFinishContractTrustOptions,
@@ -35,6 +50,8 @@ export type {
 	GroundedEvidenceValidationInput,
 	IndependentReviewStatus,
 	PersistedRunReceiptTrustFacts,
+	ReceiptIntegrityOutcome,
+	RetiredReceiptIntegrity,
 	RunReceiptTrustInspection,
 	TrustAbsenceReason,
 	TrustArtifactKind,
@@ -63,12 +80,16 @@ export {
 	inspectRunReceiptTrustStatus,
 	normalizeTrustStatus,
 	projectTrustStatus,
+	retiredIntegrityVersionOf,
+	retiredReceiptIntegrity,
+	retiredReceiptIntegrityReason,
 	TRUST_STATUS_AXES,
 	TRUST_STATUS_MAX_ARTIFACT_REFERENCES,
 	TRUST_STATUS_MAX_IDENTIFIER_LENGTH,
 	TRUST_STATUS_STATES,
 	TRUST_STATUS_VERSION,
 	validateTrustStatus,
+	verifyReceiptIntegrityOutcome,
 } from "./trust-status.js";
 export type {
 	EvidenceAuditLinkedRow,

package/src/domains/evidence/provenance.ts

@@ -4,6 +4,7 @@ import type {
 	RunReceipt,
 	RunReceiptAutonomyEnforcement,
 } from "../dispatch/types.js";
+import type { CanonicalTrustStatus } from "./trust-status.js";
 
 /**
  * Worker permission-escalation counters projected from sealed receipt
@@ -50,6 +51,33 @@ export function extractRunProvenance(receipt: ProvenanceReceipt): RunProvenanceV
 	return view;
 }
 
+/**
+ * The slice of a provenance view the canonical projection admits. The
+ * projection is the only thing that decides whether an axis is reported, so
+ * the autonomy detail (`autonomy=`, `mode=`, `dangerousBypass=`) is kept only
+ * when the projection reports the autonomy axis in a recorded state, and the
+ * non-axis provenance (pipeline, persona override, escalations) only when the
+ * seal that carries it verified. With no projection at hand no axis detail is
+ * admitted at all, whatever the receipt says; the non-axis provenance passes
+ * through for a caller that prints it beside its own integrity banner.
+ */
+export function admitRunProvenance(view: RunProvenanceView, status?: CanonicalTrustStatus): RunProvenanceView {
+	const admitted: RunProvenanceView = {};
+	if (status === undefined || status.artifactIntegrity.state === "verified") {
+		if (view.pipeline !== undefined) admitted.pipeline = view.pipeline;
+		if (view.personaOverride !== undefined) admitted.personaOverride = view.personaOverride;
+		if (view.escalation !== undefined) admitted.escalation = view.escalation;
+	}
+	const autonomy = status?.autonomyEnforcement.state;
+	if (
+		view.autonomyEnforcement !== undefined &&
+		(autonomy === "enforced" || autonomy === "approximated" || autonomy === "bypassed")
+	) {
+		admitted.autonomyEnforcement = view.autonomyEnforcement;
+	}
+	return admitted;
+}
+
 /** True when at least one provenance field set is present. */
 export function hasRunProvenance(view: RunProvenanceView): boolean {
 	return (
@@ -144,10 +172,15 @@ function formatPersonaHashPrefix(promptHash: string): string {
 }
 
 /**
- * Human transcript sentences for each present provenance field set.
- * An empty view adds no lines to the transcript run section.
+ * Human transcript sentences for each admitted provenance field set, gated
+ * through {@link admitRunProvenance}. The autonomy line carries only the
+ * detail the canonical projection does not: the policy name, the external
+ * mode, and the bypass flag. The axis itself (mediated, approximated,
+ * bypassed) is printed by the trust summary and nowhere else, so one
+ * autonomy fact never appears in two vocabularies on one screen.
  */
-export function provenanceTranscriptLines(view: RunProvenanceView): string[] {
+export function provenanceTranscriptLines(source: RunProvenanceView, status?: CanonicalTrustStatus): string[] {
+	const view = admitRunProvenance(source, status);
 	const lines: string[] = [];
 	if (view.pipeline !== undefined) {
 		const { fromRunId, position, inputBytes, inputTruncated } = view.pipeline;
@@ -163,20 +196,22 @@ export function provenanceTranscriptLines(view: RunProvenanceView): string[] {
 		lines.push(`escalations: ${requested} requested, ${approved} approved, ${denied} denied, ${timedOut} timed out`);
 	}
 	if (view.autonomyEnforcement !== undefined) {
-		const { grade, autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
+		const { autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
 		const mode = externalMode !== undefined ? ` mode=${externalMode}` : "";
 		const bypass = dangerousBypass === true ? " dangerousBypass=true" : "";
-		lines.push(`autonomy enforcement: ${grade} autonomy=${autonomy}${mode}${bypass}`);
+		lines.push(`autonomy: ${autonomy}${mode}${bypass}`);
 	}
 	return lines;
 }
 
 /**
- * Compact ` key=value` suffix for the dispatch tool's per-run and CLI lines.
- * The leading space lets callers append it directly. An empty provenance view
- * returns an empty string.
+ * Compact ` key=value` suffix for the dispatch tool's per-run and CLI lines,
+ * gated through {@link admitRunProvenance} on the same terms as the
+ * transcript lines. The leading space lets callers append it directly. An
+ * empty admitted view returns an empty string.
  */
-export function provenanceCompactSuffix(view: RunProvenanceView): string {
+export function provenanceCompactSuffix(source: RunProvenanceView, status?: CanonicalTrustStatus): string {
+	const view = admitRunProvenance(source, status);
 	const parts: string[] = [];
 	if (view.pipeline !== undefined) {
 		const { fromRunId, position, inputBytes, inputTruncated } = view.pipeline;
@@ -191,10 +226,10 @@ export function provenanceCompactSuffix(view: RunProvenanceView): string {
 		parts.push(`escalations=${requested}req/${approved}appr/${denied}deny/${timedOut}timeout`);
 	}
 	if (view.autonomyEnforcement !== undefined) {
-		const { grade, autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
+		const { autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
 		const mode = externalMode !== undefined ? `/${externalMode}` : "";
 		const bypass = dangerousBypass === true ? "/bypass" : "";
-		parts.push(`enforcement=${grade}:${autonomy}${mode}${bypass}`);
+		parts.push(`autonomy=${autonomy}${mode}${bypass}`);
 	}
 	return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
 }

package/src/domains/evidence/trust-projection.ts

@@ -0,0 +1,274 @@
+import { RUN_RECEIPT_INTEGRITY_VERSION } from "../dispatch/receipt-integrity.js";
+import {
+	type CanonicalTrustStatus,
+	retiredIntegrityVersionOf,
+	TRUST_STATUS_AXES,
+	type TRUST_STATUS_STATES,
+	type TrustArtifactReference,
+	type TrustStatusAxis,
+} from "./trust-status.js";
+
+/**
+ * The one projection of the canonical trust status every operator surface
+ * renders. The six-axis model stays the source of truth and is never
+ * collapsed into a score here; this module only fixes the words each state is
+ * called and the order the axes are read in, so the dispatch line, the
+ * monitor block, `evidence inspect`, `findings.md`, the Alt+W board, the
+ * receipt view, the eval bridge, and the ACP wire cannot each spell the same
+ * fact differently.
+ *
+ * Two shapes leave this module. `formatTrustSummary` is the compact human
+ * line: it answers who claims the result, what was observed, what was
+ * independently checked, and what is still unknown, without receipt
+ * internals. `summarizeTrustStatus` is the bounded, versioned machine record
+ * behind that line, carrying the axis states and typed references back to
+ * the artifacts the detailed model cites.
+ */
+
+export const TRUST_SUMMARY_VERSION = 1 as const;
+
+/** Reference cap for the machine projection; the canonical model keeps up to 16 per axis. */
+export const TRUST_SUMMARY_MAX_REFS = 8;
+
+/**
+ * How much the run's result can be leaned on, read off the axes in a fixed
+ * order. It is a presentation tier for styling and sorting, never a score:
+ * `reviewed` is the only tier that may be styled as independently verified.
+ */
+export type TrustVerdict = "reviewed" | "grounded" | "unverified" | "compromised" | "unknown";
+
+export const TRUST_VERDICTS: ReadonlyArray<TrustVerdict> = [
+	"reviewed",
+	"grounded",
+	"unverified",
+	"compromised",
+	"unknown",
+];
+
+/** Bounded, versioned machine projection with references to the detailed artifacts. */
+export interface TrustSummaryProjection {
+	version: typeof TRUST_SUMMARY_VERSION;
+	verdict: TrustVerdict;
+	/** The compact human line, byte-identical to what the text surfaces print. */
+	text: string;
+	/** Every axis state, in canonical vocabulary, for machine consumers. */
+	axes: Record<TrustStatusAxis, string>;
+	/** Who asserts the validation fact: `<authority kind>:<id>`, or `worker` when only the run's own prose exists. */
+	claimant: string;
+	/** Axes that answer nothing, so a consumer knows what remains unknown. */
+	unknown: TrustStatusAxis[];
+	/** `<artifact kind>:<id>` pointers to the detailed records, sorted, unique, capped. */
+	refs: string[];
+}
+
+type AxisStates = { [Axis in TrustStatusAxis]: (typeof TRUST_STATUS_STATES)[Axis][number] };
+
+/**
+ * The standardized word for every state. A word is what an operator reads;
+ * the state id is what a machine reads. `mediated` names the `enforced`
+ * autonomy state because that is the receipt grade and the documented
+ * meaning: Clio's own safety gate mediated the run. `inferred` names an
+ * ungrounded validation claim: the worker said it validated, nothing was
+ * observed to have run.
+ */
+export const TRUST_STATE_WORDS: { [Axis in TrustStatusAxis]: Record<AxisStates[Axis], string> } = {
+	artifactIntegrity: {
+		verified: "sealed",
+		failed: "seal broken",
+		absent: "no receipt",
+		unknown: "seal unchecked",
+		not_applicable: "seal not applicable",
+	},
+	validationGrounding: {
+		validated: "grounded",
+		failed: "validation failed",
+		ungrounded: "inferred: validation claimed, none observed",
+		absent: "no validation observed",
+		unknown: "validation unknown",
+		not_applicable: "validation not applicable",
+	},
+	independentReview: {
+		passed: "independently reviewed: pass",
+		failed: "independently reviewed: fail",
+		inconclusive: "independent review inconclusive",
+		not_independent: "review not independent",
+		absent: "not independently reviewed",
+		unknown: "independent review unknown",
+		not_applicable: "independent review not applicable",
+	},
+	contextProvenance: {
+		recorded: "context recorded",
+		invalid: "context record invalid",
+		absent: "context not recorded",
+		unknown: "context unknown",
+		not_applicable: "context not applicable",
+	},
+	autonomyEnforcement: {
+		enforced: "mediated",
+		approximated: "approximated",
+		bypassed: "bypassed",
+		absent: "autonomy not recorded",
+		unknown: "autonomy unknown",
+		not_applicable: "autonomy not applicable",
+	},
+	completionEvidence: {
+		evidenced: "completion evidenced",
+		incomplete: "completion unevidenced",
+		limited: "completion limited",
+		absent: "completion not recorded",
+		unknown: "completion unknown",
+		not_applicable: "completion not applicable",
+	},
+};
+
+/** The word for one axis state; unknown input never throws, it reads as unknown. */
+export function trustStateWord<Axis extends TrustStatusAxis>(axis: Axis, state: string): string {
+	const words = TRUST_STATE_WORDS[axis] as Record<string, string>;
+	return words[state] ?? words.unknown ?? "unknown";
+}
+
+function authorityOf(status: CanonicalTrustStatus, axis: TrustStatusAxis): string | null {
+	const entry = status[axis];
+	return entry.state === "absent" ? null : `${entry.authority.kind}:${entry.authority.id}`;
+}
+
+/**
+ * A seal this build does not verify because its version is retired names
+ * that version and the one in force, so an intact receipt from the previous
+ * release never reads as "seal broken" or as merely unchecked. The state
+ * behind the clause is `unknown`, which is what it is: nothing was checked.
+ */
+function integrityClause(status: CanonicalTrustStatus): string {
+	const retired = retiredIntegrityVersionOf(status.artifactIntegrity);
+	if (retired !== null) return `seal v${retired} retired (this build verifies v${RUN_RECEIPT_INTEGRITY_VERSION})`;
+	return trustStateWord("artifactIntegrity", status.artifactIntegrity.state);
+}
+
+/**
+ * The validation clause names its claimant, because "grounded" alone hides
+ * the difference between a host-run check and a self-reported one.
+ */
+function validationClause(status: CanonicalTrustStatus): string {
+	const entry = status.validationGrounding;
+	const word = trustStateWord("validationGrounding", entry.state);
+	if (entry.state === "absent") return word;
+	if (entry.state === "validated" || entry.state === "failed") return `${word} by ${entry.authority.id}`;
+	// A named external system that could not observe the run is worth naming;
+	// the historical-format placeholder is not an authority anyone can ask.
+	if (entry.state === "unknown" && entry.authority.kind !== "unknown") return `${word} (${entry.authority.id})`;
+	return word;
+}
+
+/** External runtimes name themselves on the autonomy clause so approximation is never anonymous. */
+function autonomyClause(status: CanonicalTrustStatus): string {
+	const entry = status.autonomyEnforcement;
+	const word = trustStateWord("autonomyEnforcement", entry.state);
+	if (entry.state !== "approximated" && entry.state !== "bypassed") return word;
+	return `${word} (${entry.authority.id})`;
+}
+
+/**
+ * The compact human body. Clause order is fixed: integrity, validation with
+ * its claimant, independent review, autonomy, context, completion. Every
+ * surface prints this body verbatim, so two surfaces can only disagree by
+ * reading different canonical input.
+ */
+export function formatTrustSummary(status: CanonicalTrustStatus): string {
+	return [
+		integrityClause(status),
+		validationClause(status),
+		trustStateWord("independentReview", status.independentReview.state),
+		autonomyClause(status),
+		trustStateWord("contextProvenance", status.contextProvenance.state),
+		trustStateWord("completionEvidence", status.completionEvidence.state),
+	].join("; ");
+}
+
+/** The body under its versioned label, for surfaces that print one line per run. */
+export function formatTrustSummaryLine(status: CanonicalTrustStatus): string {
+	return `trust v${TRUST_SUMMARY_VERSION}: ${formatTrustSummary(status)}`;
+}
+
+/**
+ * The drill-down token line: every axis in canonical state ids. This is the
+ * one machine-readable text form; `evidence inspect` and the dispatch and
+ * monitor labels all print it from here.
+ */
+export function formatTrustAxes(status: CanonicalTrustStatus): string {
+	return [`trust_status=v${status.version}`, ...TRUST_STATUS_AXES.map((axis) => `${axis}:${status[axis].state}`)].join(
+		" ",
+	);
+}
+
+function isUnanswered(status: CanonicalTrustStatus, axis: TrustStatusAxis): boolean {
+	const state = status[axis].state;
+	return state === "absent" || state === "unknown";
+}
+
+/**
+ * Read the tier off the axes in priority order. A broken seal, a bypassed
+ * gate, a failed or inferred validation, a failed or correlated review, or a
+ * contradictory context record compromises the result whatever else holds.
+ * An unchecked or missing seal leaves it unknown. Only an authenticated
+ * independent pass is `reviewed`; observed validation without one is
+ * `grounded`; a sealed receipt with nothing observed is `unverified`.
+ */
+export function trustVerdict(status: CanonicalTrustStatus): TrustVerdict {
+	const integrity = status.artifactIntegrity.state;
+	const validation = status.validationGrounding.state;
+	const review = status.independentReview.state;
+	const autonomy = status.autonomyEnforcement.state;
+	if (
+		integrity === "failed" ||
+		autonomy === "bypassed" ||
+		validation === "failed" ||
+		validation === "ungrounded" ||
+		review === "failed" ||
+		review === "not_independent" ||
+		status.contextProvenance.state === "invalid"
+	) {
+		return "compromised";
+	}
+	if (integrity !== "verified") return "unknown";
+	if (review === "passed") return "reviewed";
+	if (validation === "validated") return "grounded";
+	return "unverified";
+}
+
+function claimantOf(status: CanonicalTrustStatus): string {
+	const state = status.validationGrounding.state;
+	if (state === "absent" || state === "ungrounded") return "worker";
+	return authorityOf(status, "validationGrounding") ?? "worker";
+}
+
+function referenceKey(reference: TrustArtifactReference): string {
+	return `${reference.kind}:${reference.id}`;
+}
+
+/** Every artifact the axes cite, as bounded pointers a consumer can resolve. */
+export function trustSummaryReferences(status: CanonicalTrustStatus): string[] {
+	const keys = new Set<string>();
+	for (const axis of TRUST_STATUS_AXES) {
+		const entry = status[axis];
+		if (entry.state === "absent") continue;
+		for (const reference of entry.artifacts) keys.add(referenceKey(reference));
+	}
+	return [...keys].sort().slice(0, TRUST_SUMMARY_MAX_REFS);
+}
+
+/** The bounded machine projection. Flat by design so a depth-capped wire keeps it whole. */
+export function summarizeTrustStatus(status: CanonicalTrustStatus): TrustSummaryProjection {
+	const axes = Object.fromEntries(TRUST_STATUS_AXES.map((axis) => [axis, status[axis].state])) as Record<
+		TrustStatusAxis,
+		string
+	>;
+	return {
+		version: TRUST_SUMMARY_VERSION,
+		verdict: trustVerdict(status),
+		text: formatTrustSummary(status),
+		axes,
+		claimant: claimantOf(status),
+		unknown: TRUST_STATUS_AXES.filter((axis) => isUnanswered(status, axis)),
+		refs: trustSummaryReferences(status),
+	};
+}