@iowarp/clio-coder 0.3.3 → 0.3.4

package/src/domains/evidence/build.ts

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { rawDurationMs } from "../../core/timers.js";
-import { isVerificationScriptName } from "../../core/verification-scripts.js";
+import { isProjectVerifierCheckId, isVerificationScriptName } from "../../core/verification-scripts.js";
 import type {
 	RunEnvelope,
 	RunKind,
@@ -10,12 +10,7 @@ import type {
 	RunStatus,
 	ToolCallStat,
 } from "../dispatch/index.js";
-import {
-	type ExecutionRole,
-	isExecutionRole,
-	readGateDecisionArtifactsForRunIds,
-	verifyReceiptIntegrity,
-} from "../dispatch/index.js";
+import { type ExecutionRole, isExecutionRole, readGateDecisionArtifactsForRunIds } from "../dispatch/index.js";
 import { detectValidationCommand } from "../safety/protected-artifacts.js";
 import {
 	type AuditJsonRow,
@@ -29,9 +24,13 @@ import {
 	type SessionEntry,
 } from "../session/index.js";
 import { attributeEvidenceFailure } from "./failure-attribution.js";
+import { compareCodepoints as compareStrings } from "./ordering.js";
 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 {
 	EVIDENCE_VERSION,
 	type EvidenceAuditLinkedRow,
@@ -48,6 +47,7 @@ import {
 	type EvidenceRunSource,
 	type EvidenceTag,
 	type EvidenceToolEvent,
+	type EvidenceTrustStatusFile,
 } from "./types.js";
 
 const MAX_TASK_CHARS = 500;
@@ -153,7 +153,15 @@ export async function buildEvidence(options: BuildEvidenceOptions): Promise<Evid
 	const auditLinks = await linkAuditRows(options.stateDir, source, runSources, sessionLinks);
 	const toolEventRows = toolEvents(runSources, sessionLinks, auditLinks);
 	const protectedArtifactsRaw = protectedArtifactsFile(sessionLinks);
-	const findings = buildFindings(runSources, sessionLinks, auditLinks, protectedArtifactsRaw);
+	const validationEvidence = validationEvidenceByRun(sessionLinks.entries, runSources);
+	const trustStatusRaw = buildEvidenceTrustStatusFile({
+		evidenceId,
+		runSources,
+		gateDecisions: gateDecisions.decisions,
+		auditRows: auditLinks.rows,
+		validationEvidence,
+	});
+	const findings = buildFindings(runSources, trustStatusRaw, sessionLinks, auditLinks, protectedArtifactsRaw);
 	// Export-boundary redaction (cold path): secret-shaped values are scrubbed
 	// from everything the bundle serializes: envelopes, receipts (including
 	// delegation toolCallLog arguments), tool-event previews, audit rows,
@@ -176,6 +184,7 @@ export async function buildEvidence(options: BuildEvidenceOptions): Promise<Evid
 		readErrors: auditLinks.readErrors,
 	};
 	const protectedArtifacts = redactSecretsDeep(protectedArtifactsRaw, tally);
+	const trustStatus = redactSecretsDeep(trustStatusRaw, tally);
 	const overview = buildOverview(
 		evidenceId,
 		source,
@@ -197,10 +206,11 @@ export async function buildEvidence(options: BuildEvidenceOptions): Promise<Evid
 		redactedAuditLinks,
 		redactedToolEvents,
 		gateDecisions,
+		trustStatus,
 		protectedArtifacts,
 		transcript,
 	);
-	return { evidenceId, directory, overview: finalOverview, findings };
+	return { evidenceId, directory, overview: finalOverview, findings, trustStatus };
 }
 
 function buildOverview(
@@ -264,18 +274,24 @@ function buildOverview(
 
 function buildFindings(
 	runSources: ReadonlyArray<EvidenceRunSource>,
+	trustStatus: EvidenceTrustStatusFile,
 	sessionLinks: SessionLinkResult,
 	auditLinks: AuditLinkResult,
 	protectedArtifacts: EvidenceProtectedArtifactsFile,
 ): EvidenceFinding[] {
 	const findings: EvidenceFinding[] = [];
-	const validationRunIds = validationEvidenceRunIds(sessionLinks.entries, runSources, auditLinks.rows);
+	const trustByRun = new Map(trustStatus.runs.map((entry) => [entry.runId, entry.status]));
 	for (const source of runSources) {
+		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));
 		}
-		if (isSuccessfulRun(source) && !validationRunIds.has(source.envelope.id)) {
+		if (
+			isSuccessfulRun(source) &&
+			(status.validationGrounding.state === "absent" || status.validationGrounding.state === "unknown")
+		) {
 			findings.push(
 				finding(
 					findings.length,
@@ -286,10 +302,21 @@ function buildFindings(
 				),
 			);
 		}
+		if (status.validationGrounding.state === "ungrounded") {
+			findings.push(
+				finding(
+					findings.length,
+					"warn",
+					"proxy-validation",
+					source.envelope.id,
+					"run claimed validation that was not grounded in an observed execution",
+				),
+			);
+		}
 		if (source.envelope.cwd.trim().length === 0) {
 			findings.push(finding(findings.length, "warn", "cwd-missing", source.envelope.id, "run ledger cwd is empty"));
 		}
-		const receipt = source.receipt;
+		const receipt = authenticatedReceipt(source);
 		const blocked = receipt?.toolStats.reduce((total, stat) => total + stat.blocked, 0) ?? 0;
 		if (blocked > 0) {
 			findings.push(
@@ -311,15 +338,17 @@ function buildFindings(
 				),
 			);
 		}
-		const autonomyEnforcement = receipt?.autonomyEnforcement;
-		if (autonomyEnforcement?.dangerousBypass === true) {
+		if (status.autonomyEnforcement.state === "bypassed") {
 			const message =
-				autonomyEnforcement.externalMode === "agent-managed"
+				status.autonomyEnforcement.authority.id === "agent-managed"
 					? "run used external agent-managed governance; Clio safety blocks were not enforced"
 					: "run executed with external permission bypass (CLIO_CODER_ALLOW_EXTERNAL_FULL_ACCESS=1); Clio safety blocks were not enforced";
 			findings.push(finding(findings.length, "warn", "external-bypass", source.envelope.id, message));
-		} else if (autonomyEnforcement?.grade === "approximated") {
-			const mode = autonomyEnforcement.externalMode ? ` via ${autonomyEnforcement.externalMode}` : "";
+		} else if (status.autonomyEnforcement.state === "approximated") {
+			const mode =
+				status.autonomyEnforcement.authority.id === "external-runtime"
+					? ""
+					: ` via ${status.autonomyEnforcement.authority.id}`;
 			findings.push(
 				finding(
 					findings.length,
@@ -410,25 +439,28 @@ function buildFindings(
 interface ValidationToolCallCandidate {
 	toolCallId: string;
 	runId: string | null;
+	artifact: TrustArtifactReference;
 }
 
-function validationEvidenceRunIds(
+function validationEvidenceByRun(
 	entries: ReadonlyArray<LinkedSessionEntry>,
 	runSources: ReadonlyArray<EvidenceRunSource>,
-	auditRows: ReadonlyArray<EvidenceAuditLinkedRow>,
-): Set<string> {
-	const runIds = new Set<string>();
-	const sourceRunIds = new Set(runSources.map((source) => source.envelope.id));
+): Map<string, TrustArtifactReference[]> {
+	const evidence = new Map<string, TrustArtifactReference[]>();
 	const calls = new Map<string, ValidationToolCallCandidate>();
 	for (const linked of entries) {
 		const runId = validationRunIdFor(linked, runSources);
 		const entry = linked.entry;
 		if (entry.kind === "bashExecution") {
-			if (runId !== null && isSuccessfulValidationBashExecution(entry)) runIds.add(runId);
+			if (runId !== null && isSuccessfulValidationBashExecution(entry)) {
+				addValidationEvidence(evidence, runId, { kind: "session_entry", id: entry.turnId });
+			}
 			continue;
 		}
 		if (entry.kind === "protectedArtifact") {
-			if (runId !== null && isValidationProtectedArtifact(entry)) runIds.add(runId);
+			if (runId !== null && isValidationProtectedArtifact(entry)) {
+				addValidationEvidence(evidence, runId, { kind: "session_entry", id: entry.turnId });
+			}
 			continue;
 		}
 		if (entry.kind !== "message") continue;
@@ -441,16 +473,21 @@ function validationEvidenceRunIds(
 		const result = extractSessionToolResult(entry, linked);
 		if (result.id === null || !isSuccessfulSessionToolResult(result)) continue;
 		const candidate = calls.get(result.id);
-		if (candidate?.runId !== null && candidate?.runId !== undefined) runIds.add(candidate.runId);
-	}
-	for (const linked of auditRows) {
-		if (linked.auditKind !== "completion_contract") continue;
-		if (linked.runId === null || !sourceRunIds.has(linked.runId)) continue;
-		if (readOptionalString(linked.row.decision) !== "ok") continue;
-		if (readOptionalString(linked.row.reason) !== "validation_evidence") continue;
-		runIds.add(linked.runId);
+		if (candidate?.runId !== null && candidate?.runId !== undefined) {
+			addValidationEvidence(evidence, candidate.runId, candidate.artifact);
+		}
 	}
-	return runIds;
+	return evidence;
+}
+
+function addValidationEvidence(
+	evidence: Map<string, TrustArtifactReference[]>,
+	runId: string,
+	reference: TrustArtifactReference,
+): void {
+	const current = evidence.get(runId) ?? [];
+	current.push(reference);
+	evidence.set(runId, current);
 }
 
 function validationRunIdFor(linked: LinkedSessionEntry, runSources: ReadonlyArray<EvidenceRunSource>): string | null {
@@ -463,12 +500,19 @@ function validationRunIdFor(linked: LinkedSessionEntry, runSources: ReadonlyArra
 }
 
 function isSuccessfulRun(source: EvidenceRunSource): boolean {
-	const outcome = source.receipt?.outcome ?? source.envelope.outcome ?? null;
+	const receipt = authenticatedReceipt(source);
+	const outcome = receipt?.outcome ?? source.envelope.outcome ?? null;
 	if (outcome !== null) return outcome === "succeeded";
-	const exitCode = source.receipt?.exitCode ?? source.envelope.exitCode;
+	const exitCode = receipt?.exitCode ?? source.envelope.exitCode;
 	return source.envelope.status === "completed" && exitCode === 0;
 }
 
+function authenticatedReceipt(source: EvidenceRunSource): RunReceipt | null {
+	return source.receipt !== null && source.receiptError === null && !source.receiptIntegrityFailed
+		? source.receipt
+		: null;
+}
+
 function isSuccessfulValidationBashExecution(entry: BashExecutionEntry): boolean {
 	if (entry.cancelled || entry.exitCode !== 0) return false;
 	return detectValidationCommand(entry.command).kind === "validation";
@@ -490,6 +534,7 @@ function validationToolCallCandidate(
 	return {
 		toolCallId: call.id,
 		runId: validationRunIdFor(linked, runSources),
+		artifact: { kind: "session_entry", id: entry.turnId },
 	};
 }
 
@@ -508,8 +553,10 @@ function validationToolCallSummary(toolName: string, args: unknown): string | nu
 			const target = readOptionalString(argRecord?.path) ?? "artifact";
 			return `verify frontend ${target}`;
 		}
-		if (check === null || !isVerificationScriptName(check)) return null;
-		return `npm run ${check}`;
+		if (check === null) return null;
+		if (isVerificationScriptName(check)) return `npm run ${check}`;
+		if (isProjectVerifierCheckId(check)) return `verify ${check}`;
+		return null;
 	}
 	return null;
 }
@@ -546,6 +593,7 @@ async function writeEvidenceFiles(
 	auditLinks: AuditLinkResult,
 	toolEventRows: ReadonlyArray<EvidenceToolEvent>,
 	gateDecisions: EvidenceGateDecisionsFile,
+	trustStatus: EvidenceTrustStatusFile,
 	protectedArtifacts: EvidenceProtectedArtifactsFile,
 	transcript?: string,
 ): Promise<void> {
@@ -562,6 +610,7 @@ async function writeEvidenceFiles(
 	await writeJsonl(join(directory, "audit-linked.jsonl"), auditLinks.rows);
 	await writeJson(join(directory, "receipt.json"), receiptsFile(runSources));
 	await writeJson(join(directory, "gate-decisions.json"), gateDecisions);
+	await writeJson(join(directory, "trust-status.json"), trustStatus);
 	await writeJson(join(directory, "protected-artifacts.json"), protectedArtifacts);
 	await writeJson(join(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
 	await writeFile(join(directory, "findings.md"), renderFindings(findings), "utf8");
@@ -1151,7 +1200,7 @@ function compareAuditLinkedRows(a: EvidenceAuditLinkedRow, b: EvidenceAuditLinke
 	const aCorrelation = readOptionalString(a.row.correlationId) ?? "";
 	const bCorrelation = readOptionalString(b.row.correlationId) ?? "";
 	if (aCorrelation !== bCorrelation) return compareStrings(aCorrelation, bCorrelation);
-	return JSON.stringify(a.row).localeCompare(JSON.stringify(b.row));
+	return compareStrings(JSON.stringify(a.row), JSON.stringify(b.row));
 }
 
 function receiptsFile(runSources: ReadonlyArray<EvidenceRunSource>): EvidenceReceiptFile {
@@ -1372,6 +1421,19 @@ function renderSessionTranscriptEntry(linked: LinkedSessionEntry): string[] {
 		];
 	}
 	if (entry.kind === "custom") return [`${prefix} custom:${entry.customType} ${previewUnknown(entry.data)}`];
+	if (entry.kind === "contextEviction") {
+		const pressure = entry.pressureBefore === null ? "" : ` pressure=${entry.pressureBefore.toFixed(3)}`;
+		return [
+			`${prefix} contextEviction policy=${entry.policyId} trigger=${entry.trigger} items=${entry.evicted.length} tokens=${entry.tokensBefore}->${entry.tokensAfter}${pressure}`,
+			...entry.evicted.map(
+				(item) =>
+					`  evicted ref=${item.ref.entry} reason=${item.reason}${item.by === undefined ? "" : ` by=${item.by}`} freed=${item.tokensFreed}`,
+			),
+		];
+	}
+	if (entry.kind === "contextRecall") {
+		return [`${prefix} contextRecall ref=${entry.ref.entry} trigger=${entry.trigger} tokens=${entry.tokensReadmitted}`];
+	}
 	const _exhaustive: never = entry;
 	return [`${prefix} ${String(_exhaustive)}`];
 }
@@ -1432,9 +1494,18 @@ async function readReceipt(
 		}
 		return { receipt: null, error: `receipt read error: ${err.message ?? String(err)}`, integrityFailed: false };
 	}
-	const parsed = parseJson(raw, receiptPath);
-	const receipt = parseRunReceipt(parsed, receiptPath);
-	const integrity = verifyReceiptIntegrity(receipt, envelope);
+	let receipt: RunReceipt;
+	try {
+		const parsed = parseJson(raw, receiptPath);
+		receipt = parseRunReceipt(parsed, receiptPath);
+	} catch (error) {
+		return {
+			receipt: null,
+			error: `receipt invalid: ${error instanceof Error ? error.message : String(error)}`,
+			integrityFailed: true,
+		};
+	}
+	const integrity = inspectRunReceiptTrustStatus(receipt, envelope).integrity;
 	if (!integrity.ok) {
 		return { receipt, error: `receipt integrity: ${integrity.reason}`, integrityFailed: true };
 	}
@@ -1709,10 +1780,6 @@ function uniqueTags(values: ReadonlyArray<EvidenceTag>): EvidenceTag[] {
 	return [...new Set(values)].sort(compareStrings);
 }
 
-function compareStrings(a: string, b: string): number {
-	return a.localeCompare(b);
-}
-
 function compareNullableStrings(a: string | null, b: string | null): number {
 	if (a === b) return 0;
 	if (a === null) return 1;

package/src/domains/evidence/eval.ts

@@ -5,6 +5,8 @@ import { readGateDecisionArtifactsForRunIds } from "../dispatch/index.js";
 import { redactArtifactForStorage } from "../eval/artifacts/redact.js";
 import type { EvalCommandResult, EvalRunArtifact, EvalRunRecord } from "../eval/index.js";
 import { loadEvalArtifact } from "../eval/index.js";
+import { compareCodepoints as compareStrings } from "./ordering.js";
+import { buildEvidenceTrustStatusFile } from "./run-trust.js";
 import { evidenceDirectory, findingsFile } from "./store.js";
 import {
 	EVIDENCE_VERSION,
@@ -21,6 +23,7 @@ import {
 	type EvidenceReceiptFile,
 	type EvidenceTag,
 	type EvidenceToolEvent,
+	type EvidenceTrustStatusFile,
 } from "./types.js";
 
 const EVAL_EVIDENCE_FILES = [
@@ -32,6 +35,7 @@ const EVAL_EVIDENCE_FILES = [
 	"audit-linked.jsonl",
 	"receipt.json",
 	"gate-decisions.json",
+	"trust-status.json",
 	"protected-artifacts.json",
 	"eval-result.json",
 	"findings.json",
@@ -87,8 +91,23 @@ export async function buildEvalEvidence(options: BuildEvalEvidenceOptions): Prom
 						options.stateDir,
 					).map((entry) => entry.artifact),
 	};
-	await writeEvalEvidenceFiles(directory, artifact, overview, findings, toolEventRows, linkedRuns, gateDecisions);
-	return { evidenceId, directory, overview, findings };
+	const trustStatus = buildEvidenceTrustStatusFile({
+		evidenceId,
+		runSources: linkedRuns.runSources,
+		gateDecisions: gateDecisions.decisions,
+		auditRows: linkedRuns.auditRows,
+	});
+	await writeEvalEvidenceFiles(
+		directory,
+		artifact,
+		overview,
+		findings,
+		toolEventRows,
+		linkedRuns,
+		gateDecisions,
+		trustStatus,
+	);
+	return { evidenceId, directory, overview, findings, trustStatus };
 }
 
 export function evalEvidenceId(evalId: string): string {
@@ -218,6 +237,7 @@ async function writeEvalEvidenceFiles(
 	toolEventRows: ReadonlyArray<EvidenceToolEvent>,
 	linkedRuns: EvalLinkedRuns,
 	gateDecisions: EvidenceGateDecisionsFile,
+	trustStatus: EvidenceTrustStatusFile,
 ): Promise<void> {
 	const emptyProtected: EvidenceProtectedArtifactsFile = { version: EVIDENCE_VERSION, artifacts: [], events: [] };
 	const receiptsFile: EvidenceReceiptFile = {
@@ -234,6 +254,7 @@ async function writeEvalEvidenceFiles(
 	await writeJsonl(join(directory, "audit-linked.jsonl"), linkedRuns.auditRows);
 	await writeJson(join(directory, "receipt.json"), receiptsFile);
 	await writeJson(join(directory, "gate-decisions.json"), gateDecisions);
+	await writeJson(join(directory, "trust-status.json"), trustStatus);
 	await writeJson(join(directory, "protected-artifacts.json"), emptyProtected);
 	await writeJson(join(directory, "eval-result.json"), redactedArtifact);
 	await writeJson(join(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
@@ -576,7 +597,7 @@ function compareAuditRows(a: EvidenceAuditLinkedRow, b: EvidenceAuditLinkedRow):
 	return (
 		compareNullableStrings(a.ts, b.ts) ||
 		compareNullableStrings(a.runId, b.runId) ||
-		JSON.stringify(a.row).localeCompare(JSON.stringify(b.row))
+		compareStrings(JSON.stringify(a.row), JSON.stringify(b.row))
 	);
 }
 
@@ -596,10 +617,6 @@ function sanitizeEvidenceId(value: string): string {
 	return sanitized.length === 0 ? "unknown" : sanitized;
 }
 
-function compareStrings(a: string, b: string): number {
-	return a.localeCompare(b);
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/domains/evidence/index.ts

@@ -20,7 +20,56 @@ export {
 	listEvidenceOverviews,
 	loadEvidenceGateDecisions,
 	loadEvidenceRunProvenance,
+	loadEvidenceTrustStatus,
 } from "./store.js";
+export type {
+	AbsentTrustStatus,
+	AdaptFinishContractTrustOptions,
+	AdaptRunReceiptTrustOptions,
+	ArtifactIntegrityStatus,
+	AttributedTrustStatus,
+	AutonomyEnforcementStatus,
+	CanonicalTrustStatus,
+	CompletionEvidenceStatus,
+	ContextProvenanceStatus,
+	GroundedEvidenceValidationInput,
+	IndependentReviewStatus,
+	PersistedRunReceiptTrustFacts,
+	RunReceiptTrustInspection,
+	TrustAbsenceReason,
+	TrustArtifactKind,
+	TrustArtifactReference,
+	TrustStatusAuthority,
+	TrustStatusAuthorityKind,
+	TrustStatusAxes,
+	TrustStatusAxis,
+	TrustStatusProjection,
+	TrustStatusSource,
+	TrustStatusSourceKind,
+	TrustStatusValidation,
+	ValidationGroundingStatus,
+} from "./trust-status.js";
+export {
+	absentTrustStatus,
+	adaptFinishContractCompletionStatus,
+	adaptGateDecisionReviewStatus,
+	adaptGroundedEvidenceValidationStatus,
+	adaptReceiptIntegrityStatus,
+	adaptRunReceiptAutonomyStatus,
+	adaptRunReceiptContextStatus,
+	adaptRunReceiptTrustStatus,
+	adaptRunReceiptValidationStatus,
+	composeTrustStatus,
+	inspectRunReceiptTrustStatus,
+	normalizeTrustStatus,
+	projectTrustStatus,
+	TRUST_STATUS_AXES,
+	TRUST_STATUS_MAX_ARTIFACT_REFERENCES,
+	TRUST_STATUS_MAX_IDENTIFIER_LENGTH,
+	TRUST_STATUS_STATES,
+	TRUST_STATUS_VERSION,
+	validateTrustStatus,
+} from "./trust-status.js";
 export type {
 	EvidenceAuditLinkedRow,
 	EvidenceBuildResult,
@@ -39,13 +88,17 @@ export type {
 	EvidenceRawTraceRow,
 	EvidenceReceiptFile,
 	EvidenceRunSource,
+	EvidenceRunTrustStatus,
 	EvidenceSeverity,
 	EvidenceSource,
 	EvidenceTag,
 	EvidenceToolEvent,
 	EvidenceToolEventSource,
 	EvidenceTotals,
+	EvidenceTrustStatusFile,
+	EvidenceTrustStatusView,
 	FailureCauseTag,
+	HistoricalEvidenceTrustStatus,
 } from "./types.js";
 export {
 	EVIDENCE_TAGS,

package/src/domains/evidence/ordering.ts

@@ -0,0 +1,12 @@
+/**
+ * Ordinal string comparison for determinism-critical orderings.
+ *
+ * `String.prototype.localeCompare` collates through ICU, so its answer depends
+ * on the process locale and the ICU build. Evidence rows, "latest" selectors,
+ * and verifier catalogs must order identically on every machine that rebuilds
+ * them, so they compare UTF-16 code units instead. That order is the code
+ * point order for all BMP text and never reads the environment.
+ */
+export function compareCodepoints(left: string, right: string): number {
+	return left < right ? -1 : left > right ? 1 : 0;
+}