@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/chunk-MLOK6ZOS.js

@@ -0,0 +1,2888 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ROUTE_POLICY_VERSION,
+  isRouteDecisionAgentSelection,
+  isRoutingIntent
+} from "./chunk-VPTUJU4P.js";
+import {
+  isExecutionRole
+} from "./chunk-H7IXIC72.js";
+import {
+  readSettings
+} from "./chunk-PNY46YEY.js";
+import {
+  assertSafeId
+} from "./chunk-KV2AOLDF.js";
+import {
+  readClioVersion,
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/receipt-integrity.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var RUN_RECEIPT_INTEGRITY_VERSION = 20;
+var RUN_RECEIPT_INTEGRITY_ALGORITHM = "sha256";
+function sha256(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function canonicalJson(value) {
+  return serializeCanonical(value);
+}
+function serializeCanonical(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`receipt integrity: non-finite number ${String(value)} is not representable`);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "bigint") throw new Error("receipt integrity: bigint is not representable");
+  if (typeof value === "symbol" || typeof value === "function") {
+    throw new Error(`receipt integrity: ${typeof value} is not representable`);
+  }
+  if (value === void 0) throw new Error("receipt integrity: undefined is not representable at root");
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (let i = 0; i < value.length; i++) {
+      if (!(i in value) || value[i] === void 0) {
+        parts.push("null");
+        continue;
+      }
+      parts.push(serializeCanonical(value[i]));
+    }
+    return `[${parts.join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      const child = obj[key];
+      if (child === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${serializeCanonical(child)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  throw new Error(`receipt integrity: unsupported value of type ${typeof value}`);
+}
+var RECEIPT_INTEGRITY_FIELD_COVERAGE = {
+  runId: true,
+  agentId: true,
+  executionRole: true,
+  agentAudience: true,
+  requestOrigin: true,
+  task: true,
+  intent: true,
+  pathScope: true,
+  // Historical receipts omit this field, so their receipt and ledger payloads remain unchanged.
+  budget: true,
+  targetId: true,
+  wireModelId: true,
+  runtimeId: true,
+  runtimeKind: true,
+  startedAt: true,
+  endedAt: true,
+  outcome: true,
+  outcomeDetail: true,
+  lineage: true,
+  identity: true,
+  node: true,
+  attestation: true,
+  reroutes: true,
+  pipeline: true,
+  gate: true,
+  council: true,
+  plan: true,
+  fleetGate: true,
+  personaOverride: true,
+  projectContext: true,
+  // Always set on receipts written after #104 landed; absent only on older
+  // receipts, which omit these fields from canonical serialization.
+  rulesApplied: true,
+  operatorProfileApplied: true,
+  exitCode: true,
+  failureMessage: true,
+  tokenCount: true,
+  inputTokenCount: true,
+  outputTokenCount: true,
+  cacheReadTokenCount: true,
+  cacheWriteTokenCount: true,
+  reasoningTokenCount: true,
+  upstreamResponses: true,
+  output: true,
+  costUsd: true,
+  costProvenance: true,
+  compiledPromptHash: true,
+  staticCompositionHash: true,
+  staticShellHash: true,
+  sessionShellHash: true,
+  dynamicHash: true,
+  promptSignature: true,
+  toolSignature: true,
+  clioVersion: true,
+  piMonoVersion: true,
+  platform: true,
+  nodeVersion: true,
+  toolCalls: true,
+  toolStats: true,
+  toolActivity: true,
+  verification: true,
+  hostVerification: true,
+  worktree: true,
+  routingIntent: true,
+  quality: true,
+  skillActivations: true,
+  autonomyEnforcement: true,
+  safety: true,
+  reproducibility: true,
+  runtimeResolution: true,
+  delegation: true,
+  findingsSummary: true,
+  // Both are optional and absent unless the run produced the condition they
+  // name, so a receipt that carries neither digests exactly as it did before
+  // they existed and the integrity version stays where it is.
+  validationGrounding: true,
+  capabilityMismatch: true,
+  // Same reasoning: absent unless the run had an agent ledger, so a receipt
+  // without one omits the field from canonical serialization.
+  ledgerContribution: true,
+  sessionId: true,
+  briefing: true,
+  outcomeCode: true,
+  steering: true,
+  routeDecision: true
+};
+var RECEIPT_FIELDS = Object.keys(RECEIPT_INTEGRITY_FIELD_COVERAGE);
+function selectedReceiptFields(receipt, fields) {
+  const source = receipt;
+  const result = {};
+  for (const field of fields) {
+    const value = source[field];
+    if (value !== void 0) result[field] = value;
+  }
+  return result;
+}
+function receiptDigestFields(receipt) {
+  const result = selectedReceiptFields(receipt, RECEIPT_FIELDS);
+  result.briefing = receipt.briefing ?? null;
+  result.outcomeCode = receipt.outcomeCode ?? null;
+  result.steering = receipt.steering ?? null;
+  return result;
+}
+function ledgerDigestFields(envelope) {
+  return {
+    id: envelope.id,
+    agentId: envelope.agentId,
+    executionRole: envelope.executionRole,
+    task: envelope.task,
+    ...envelope.budget !== void 0 ? { budget: envelope.budget } : {},
+    targetId: envelope.targetId,
+    wireModelId: envelope.wireModelId,
+    runtimeId: envelope.runtimeId,
+    runtimeKind: envelope.runtimeKind,
+    startedAt: envelope.startedAt,
+    endedAt: envelope.endedAt,
+    status: envelope.status,
+    exitCode: envelope.exitCode,
+    sessionId: envelope.sessionId,
+    cwd: envelope.cwd,
+    tokenCount: envelope.tokenCount,
+    cacheReadTokenCount: envelope.cacheReadTokenCount,
+    cacheWriteTokenCount: envelope.cacheWriteTokenCount,
+    reasoningTokenCount: envelope.reasoningTokenCount,
+    staticShellHash: envelope.staticShellHash,
+    sessionShellHash: envelope.sessionShellHash,
+    dynamicHash: envelope.dynamicHash,
+    costUsd: envelope.costUsd,
+    agentAudience: envelope.agentAudience ?? null,
+    requestOrigin: envelope.requestOrigin ?? null,
+    outcome: envelope.outcome ?? null,
+    outcomeDetail: envelope.outcomeDetail ?? null,
+    lineage: envelope.lineage ?? null,
+    identity: envelope.identity ?? null,
+    node: envelope.node ?? null,
+    reroutes: envelope.reroutes ?? null,
+    pipeline: envelope.pipeline ?? null,
+    gate: envelope.gate ?? null,
+    plan: envelope.plan ?? null,
+    personaOverride: envelope.personaOverride ?? null,
+    inputTokenCount: envelope.inputTokenCount ?? 0,
+    outputTokenCount: envelope.outputTokenCount ?? 0,
+    promptSignature: envelope.promptSignature ?? null,
+    toolSignature: envelope.toolSignature ?? null,
+    briefing: envelope.briefing ?? null,
+    outcomeCode: envelope.outcomeCode ?? null,
+    steering: envelope.steering ?? null
+  };
+}
+function integrityPayload(receipt, envelope) {
+  return {
+    contract: "clio.runReceipt.integrity",
+    version: RUN_RECEIPT_INTEGRITY_VERSION,
+    sources: ["receipt", "run-ledger"],
+    receipt: receiptDigestFields(receipt),
+    ledger: ledgerDigestFields(envelope)
+  };
+}
+function computeReceiptIntegrity(receipt, envelope) {
+  return {
+    version: RUN_RECEIPT_INTEGRITY_VERSION,
+    algorithm: RUN_RECEIPT_INTEGRITY_ALGORITHM,
+    digest: sha256(canonicalJson(integrityPayload(receipt, envelope)))
+  };
+}
+function isReceiptQuality(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const quality = value;
+  if (quality.version !== 1 || !Array.isArray(quality.typedValidations)) return false;
+  if (!quality.typedValidations.every(
+    (fact) => fact !== null && typeof fact === "object" && typeof fact.sourceId === "string" && typeof fact.validatorDigest === "string" && /^[0-9a-f]{64}$/.test(String(fact.validatorDigest)) && typeof fact.passed === "boolean"
+  ))
+    return false;
+  const schema = quality.responseSchema;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;
+  const responseSchema = schema;
+  const resultContract = quality.resultContract;
+  const validResultContract = resultContract === null || resultContract !== void 0 && typeof resultContract === "object" && !Array.isArray(resultContract) && typeof resultContract.sourceId === "string" && typeof resultContract.validatorDigest === "string" && /^[0-9a-f]{64}$/.test(String(resultContract.validatorDigest)) && (resultContract.conformance === "pass" || resultContract.conformance === "fail" || resultContract.conformance === "not-reached") && (resultContract.quality === "pass" || resultContract.quality === "fail" || resultContract.quality === "unmeasured");
+  return (responseSchema.sourceId === null || typeof responseSchema.sourceId === "string") && (responseSchema.schemaDigest === null || typeof responseSchema.schemaDigest === "string" && /^[0-9a-f]{64}$/.test(responseSchema.schemaDigest)) && typeof responseSchema.runtimeEnforceable === "boolean" && (responseSchema.enforcementPassed === null || typeof responseSchema.enforcementPassed === "boolean") && validResultContract;
+}
+function isCurrentRouteDecision(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const decision = value;
+  return decision.policyVersion === ROUTE_POLICY_VERSION && (decision.mode === "fixed" || decision.mode === "shadow" || decision.mode === "active") && isRouteDecisionAgentSelection(decision.agentSelection) && typeof decision.decisionHash === "string" && /^[0-9a-f]{64}$/u.test(decision.decisionHash);
+}
+function withReceiptIntegrity(receipt, envelope) {
+  if (!isReceiptQuality(receipt.quality)) throw new Error("receipt integrity: required quality block invalid");
+  if (!isExecutionRole(receipt.executionRole)) throw new Error("receipt integrity: required execution role invalid");
+  if (!isRoutingIntent(receipt.routingIntent)) {
+    throw new Error("receipt integrity: required routing intent invalid");
+  }
+  if (receipt.routeDecision !== void 0 && !isCurrentRouteDecision(receipt.routeDecision)) {
+    throw new Error("receipt integrity: route decision is invalid or retired");
+  }
+  return {
+    ...receipt,
+    routingIntent: receipt.routingIntent,
+    integrity: computeReceiptIntegrity(receipt, envelope)
+  };
+}
+function isReceiptIntegrity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return candidate.version === RUN_RECEIPT_INTEGRITY_VERSION && candidate.algorithm === RUN_RECEIPT_INTEGRITY_ALGORITHM && typeof candidate.digest === "string" && /^[0-9a-f]{64}$/.test(candidate.digest);
+}
+function firstLedgerMismatch(receipt, envelope) {
+  const sharedFields = [
+    ["runId", receipt.runId, envelope.id],
+    ["agentId", receipt.agentId, envelope.agentId],
+    ["executionRole", receipt.executionRole, envelope.executionRole],
+    ["agentAudience", receipt.agentAudience, envelope.agentAudience],
+    ["requestOrigin", receipt.requestOrigin, envelope.requestOrigin],
+    ["task", receipt.task, envelope.task],
+    ["targetId", receipt.targetId, envelope.targetId],
+    ["wireModelId", receipt.wireModelId, envelope.wireModelId],
+    ["runtimeId", receipt.runtimeId, envelope.runtimeId],
+    ["runtimeKind", receipt.runtimeKind, envelope.runtimeKind],
+    ["startedAt", receipt.startedAt, envelope.startedAt],
+    ["endedAt", receipt.endedAt, envelope.endedAt],
+    ["exitCode", receipt.exitCode, envelope.exitCode],
+    ["tokenCount", receipt.tokenCount, envelope.tokenCount],
+    ["cacheReadTokenCount", receipt.cacheReadTokenCount ?? 0, envelope.cacheReadTokenCount ?? 0],
+    ["cacheWriteTokenCount", receipt.cacheWriteTokenCount ?? 0, envelope.cacheWriteTokenCount ?? 0],
+    ["reasoningTokenCount", receipt.reasoningTokenCount ?? 0, envelope.reasoningTokenCount ?? 0],
+    ["staticShellHash", receipt.staticShellHash ?? null, envelope.staticShellHash ?? null],
+    ["sessionShellHash", receipt.sessionShellHash ?? null, envelope.sessionShellHash ?? null],
+    ["dynamicHash", receipt.dynamicHash ?? null, envelope.dynamicHash ?? null],
+    ["costUsd", receipt.costUsd, envelope.costUsd],
+    ["sessionId", receipt.sessionId, envelope.sessionId],
+    ["outcome", receipt.outcome ?? null, envelope.outcome ?? null],
+    ["outcomeDetail", receipt.outcomeDetail ?? null, envelope.outcomeDetail ?? null],
+    ["nodeId", receipt.node?.id ?? null, envelope.node?.id ?? null],
+    ["outcomeCode", receipt.outcomeCode ?? null, envelope.outcomeCode ?? null]
+  ];
+  for (const [field, receiptValue, ledgerValue] of sharedFields) {
+    if (!Object.is(receiptValue, ledgerValue)) return field;
+  }
+  if (canonicalJson(receipt.briefing ?? null) !== canonicalJson(envelope.briefing ?? null)) return "briefing";
+  if (canonicalJson(receipt.budget ?? null) !== canonicalJson(envelope.budget ?? null)) return "budget";
+  if (canonicalJson(receipt.steering ?? null) !== canonicalJson(envelope.steering ?? null)) return "steering";
+  return null;
+}
+function verifyReceiptIntegrity(receipt, envelope) {
+  if (!isReceiptQuality(receipt.quality) || !isReceiptIntegrity(receipt.integrity)) {
+    return { ok: false, reason: "integrity invalid" };
+  }
+  if (!isExecutionRole(receipt.executionRole)) return { ok: false, reason: "execution role invalid" };
+  if (!isRoutingIntent(receipt.routingIntent)) {
+    return { ok: false, reason: "routing intent invalid" };
+  }
+  if (receipt.routeDecision !== void 0 && !isCurrentRouteDecision(receipt.routeDecision)) {
+    return { ok: false, reason: "route decision invalid" };
+  }
+  const mismatch = firstLedgerMismatch(receipt, envelope);
+  if (mismatch) {
+    return { ok: false, reason: `ledger mismatch: ${mismatch}` };
+  }
+  const expected = computeReceiptIntegrity(receipt, envelope);
+  if (expected.digest !== receipt.integrity.digest) {
+    return { ok: false, reason: "integrity mismatch" };
+  }
+  return { ok: true };
+}
+
+// src/domains/eval/harness-metrics.ts
+init_esm_shims();
+var ZERO_EVAL_HARNESS_METRICS = {
+  receiptCount: 0,
+  toolCalls: 0,
+  retries: 0,
+  safetyBlocks: 0,
+  correctionLatencyMs: 0,
+  validationEvidence: 0
+};
+function evalHarnessMetricsFromCommands(commands) {
+  return {
+    ...ZERO_EVAL_HARNESS_METRICS,
+    validationEvidence: commands.filter(
+      (command) => command.phase === "verifier" && command.exitCode === 0 && !command.timedOut
+    ).length
+  };
+}
+function evalHarnessMetricsFromReceipt(receipt, extras = {}) {
+  return {
+    receiptCount: 1,
+    toolCalls: receipt.toolCalls,
+    retries: extras.retries ?? 0,
+    safetyBlocks: receipt.safety?.decisions.blocked ?? 0,
+    correctionLatencyMs: extras.correctionLatencyMs ?? 0,
+    validationEvidence: extras.validationEvidence ?? 0
+  };
+}
+function sumEvalHarnessMetrics(records) {
+  return records.reduce((total, record) => addEvalHarnessMetrics(total, record.harness), {
+    ...ZERO_EVAL_HARNESS_METRICS
+  });
+}
+function addEvalHarnessMetrics(left, right) {
+  return {
+    receiptCount: left.receiptCount + right.receiptCount,
+    toolCalls: left.toolCalls + right.toolCalls,
+    retries: left.retries + right.retries,
+    safetyBlocks: left.safetyBlocks + right.safetyBlocks,
+    correctionLatencyMs: left.correctionLatencyMs + right.correctionLatencyMs,
+    validationEvidence: left.validationEvidence + right.validationEvidence
+  };
+}
+
+// src/domains/eval/store.ts
+init_esm_shims();
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/domains/eval/artifacts/redact.ts
+init_esm_shims();
+var SENSITIVE_KEY = /(?:^|[_-])(api[_-]?key|authorization|cookie|password|secret|token)(?:$|[_-])/i;
+var CREDENTIAL_PATTERNS = [
+  [/\b(authorization\s*[:=]\s*)(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]"],
+  [/\b(bearer\s+)[A-Za-z0-9._~+/=-]{12,}/gi, "$1[redacted]"],
+  [/\b(sk-[A-Za-z0-9_-]{16,})\b/g, "[redacted]"],
+  [/\b(gh[pousr]_[A-Za-z0-9_]{16,})\b/g, "[redacted]"],
+  [/\b(AKIA[0-9A-Z]{16})\b/g, "[redacted]"],
+  [/\b((?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|secret)\s*[:=]\s*)[^\s"',}]+/gi, "$1[redacted]"]
+];
+function redactArtifactForStorage(value, env = process.env) {
+  return redactValue(value, env);
+}
+function redactValue(value, env) {
+  if (typeof value === "string") return redactString(value, env);
+  if (Array.isArray(value)) return value.map((entry) => redactValue(entry, env));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = SENSITIVE_KEY.test(key) ? "[redacted]" : redactValue(entry, env);
+    }
+    return out;
+  }
+  return value;
+}
+function redactString(value, env) {
+  let out = stripHomePrefix(value, env.HOME);
+  for (const [pattern, replacement] of CREDENTIAL_PATTERNS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+function stripHomePrefix(value, home) {
+  if (home === void 0 || home.length === 0) return value;
+  const normalized = home.replace(/\/+$/g, "");
+  if (normalized.length === 0) return value;
+  return value.split(normalized).join("$HOME");
+}
+
+// src/domains/eval/store.ts
+var NODE_SIGNALS = /* @__PURE__ */ new Set([
+  "SIGHUP",
+  "SIGINT",
+  "SIGQUIT",
+  "SIGILL",
+  "SIGTRAP",
+  "SIGABRT",
+  "SIGIOT",
+  "SIGBUS",
+  "SIGFPE",
+  "SIGKILL",
+  "SIGUSR1",
+  "SIGSEGV",
+  "SIGUSR2",
+  "SIGPIPE",
+  "SIGALRM",
+  "SIGTERM",
+  "SIGCHLD",
+  "SIGSTKFLT",
+  "SIGCONT",
+  "SIGSTOP",
+  "SIGTSTP",
+  "SIGTTIN",
+  "SIGTTOU",
+  "SIGURG",
+  "SIGXCPU",
+  "SIGXFSZ",
+  "SIGVTALRM",
+  "SIGPROF",
+  "SIGWINCH",
+  "SIGIO",
+  "SIGPOLL",
+  "SIGPWR",
+  "SIGSYS",
+  "SIGUNUSED"
+]);
+function evalRoot(dataDir) {
+  return join(dataDir, "evals");
+}
+function evalArtifactPath(dataDir, evalId) {
+  assertSafeId(evalId, "eval");
+  return join(evalRoot(dataDir), `${evalId}.json`);
+}
+function createEvalId(startedAt, taskFileHash) {
+  const stamp = startedAt.toISOString().replace(/[-:.]/g, "");
+  return `eval-${stamp}-${taskFileHash.slice(0, 8)}-${randomBytes(6).toString("hex")}`;
+}
+async function writeEvalArtifact(dataDir, artifact) {
+  const path = evalArtifactPath(dataDir, artifact.evalId);
+  const redacted = redactArtifactForStorage({
+    ...artifact,
+    paths: { ...artifact.paths, artifact: path }
+  });
+  safeResourceWrite(path, `${JSON.stringify(redacted, null, 2)}
+`, { encoding: "utf8" });
+  return path;
+}
+async function loadEvalArtifact(dataDir, evalId) {
+  let raw;
+  try {
+    raw = await readFile(evalArtifactPath(dataDir, evalId), "utf8");
+  } catch (error) {
+    if (isErrorWithCode(error) && error.code === "ENOENT") throw new Error(`eval artifact not found: ${evalId}`);
+    throw error;
+  }
+  const source = evalArtifactPath(dataDir, evalId);
+  const parsed = parseJson(raw, source);
+  return parseArtifact(parsed, source);
+}
+function parseArtifact(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  if (value.version !== 1) throw new Error(`${source}.version: expected 1`);
+  const results = readArray(value, source, "results").map(
+    (entry, index) => parseRecord(entry, `${source}.results[${index}]`)
+  );
+  return {
+    version: 1,
+    evalId: readString(value, source, "evalId"),
+    taskFile: readString(value, source, "taskFile"),
+    taskFileHash: readString(value, source, "taskFileHash"),
+    clio: parseClioProvenance(readRequiredArtifactField(value, source, "clio"), `${source}.clio`),
+    environment: parseEnvironmentProvenance(
+      readRequiredArtifactField(value, source, "environment"),
+      `${source}.environment`
+    ),
+    target: readOptionalNullableString(value, source, "target"),
+    model: readOptionalNullableString(value, source, "model"),
+    thinking: readOptionalNullableString(value, source, "thinking"),
+    paths: parseArtifactPaths(readRequiredArtifactField(value, source, "paths"), `${source}.paths`),
+    repeat: readNumber(value, source, "repeat"),
+    startedAt: readString(value, source, "startedAt"),
+    endedAt: readString(value, source, "endedAt"),
+    summary: parseSummary(value.summary, `${source}.summary`),
+    results
+  };
+}
+function parseSummary(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  return {
+    runs: readNumber(value, source, "runs"),
+    passed: readNumber(value, source, "passed"),
+    failed: readNumber(value, source, "failed"),
+    passRate: readNumber(value, source, "passRate"),
+    tokens: readNumber(value, source, "tokens"),
+    costUsd: readNumber(value, source, "costUsd"),
+    wallTimeMs: readNumber(value, source, "wallTimeMs"),
+    harness: value.harness === void 0 ? { ...ZERO_EVAL_HARNESS_METRICS } : parseHarnessMetrics(value.harness, `${source}.harness`),
+    failureClasses: readArray(value, source, "failureClasses").map(
+      (entry, index) => parseFailureClassCount(entry, `${source}.failureClasses[${index}]`)
+    )
+  };
+}
+function parseRecord(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  const failureClass = readOptionalFailureClass(value, source, "failureClass");
+  const commands = readArray(value, source, "commands").map(
+    (entry, index) => parseCommand(entry, `${source}.commands[${index}]`)
+  );
+  const record = {
+    taskId: readString(value, source, "taskId"),
+    runId: readString(value, source, "runId"),
+    repeatIndex: readNumber(value, source, "repeatIndex"),
+    cwd: readString(value, source, "cwd"),
+    prompt: readString(value, source, "prompt"),
+    tags: readStringArray(value, source, "tags"),
+    pass: readBoolean(value, source, "pass"),
+    exitCode: readNumber(value, source, "exitCode"),
+    tokens: readNumber(value, source, "tokens"),
+    costUsd: readNumber(value, source, "costUsd"),
+    wallTimeMs: readNumber(value, source, "wallTimeMs"),
+    harness: value.harness === void 0 ? evalHarnessMetricsFromCommands(commands) : parseHarnessMetrics(value.harness, `${source}.harness`),
+    commands
+  };
+  if (failureClass !== void 0) record.failureClass = failureClass;
+  const receiptPath = readOptionalString(value, source, "receiptPath");
+  if (receiptPath !== void 0) record.receiptPath = receiptPath;
+  const evidenceId = readOptionalString(value, source, "evidenceId");
+  if (evidenceId !== void 0) record.evidenceId = evidenceId;
+  const paths = value.paths === void 0 ? void 0 : parseRunPaths(value.paths, `${source}.paths`);
+  if (paths !== void 0) record.paths = paths;
+  return record;
+}
+function parseClioProvenance(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  return {
+    version: readString(value, source, "version"),
+    commit: readNullableString(value, source, "commit"),
+    entry: readString(value, source, "entry")
+  };
+}
+function parseEnvironmentProvenance(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  return {
+    platform: readString(value, source, "platform"),
+    node: readString(value, source, "node")
+  };
+}
+function parseArtifactPaths(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  const out = {
+    taskFile: readString(value, source, "taskFile"),
+    receipts: readStringArray(value, source, "receipts"),
+    sessionLedgers: readStringArray(value, source, "sessionLedgers")
+  };
+  const artifact = readOptionalString(value, source, "artifact");
+  if (artifact !== void 0) out.artifact = artifact;
+  const evidence = readOptionalString(value, source, "evidence");
+  if (evidence !== void 0) out.evidence = evidence;
+  return out;
+}
+function parseRunPaths(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  const out = {};
+  const receipt = readOptionalString(value, source, "receipt");
+  if (receipt !== void 0) out.receipt = receipt;
+  const sessionLedger = readOptionalString(value, source, "sessionLedger");
+  if (sessionLedger !== void 0) out.sessionLedger = sessionLedger;
+  const evidence = readOptionalString(value, source, "evidence");
+  if (evidence !== void 0) out.evidence = evidence;
+  return out;
+}
+function readRequiredArtifactField(record, source, field) {
+  const value = record[field];
+  if (value === void 0) {
+    throw new Error(
+      `eval artifact has an invalid schema: missing required field '${field}' in ${source}. Re-run the evaluation suite to generate a complete artifact.`
+    );
+  }
+  return value;
+}
+function parseHarnessMetrics(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  return {
+    receiptCount: readNumber(value, source, "receiptCount"),
+    toolCalls: readNumber(value, source, "toolCalls"),
+    retries: readNumber(value, source, "retries"),
+    safetyBlocks: readNumber(value, source, "safetyBlocks"),
+    correctionLatencyMs: readNumber(value, source, "correctionLatencyMs"),
+    validationEvidence: readNumber(value, source, "validationEvidence")
+  };
+}
+function parseCommand(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  const phase = readString(value, source, "phase");
+  if (phase !== "setup" && phase !== "verifier") throw new Error(`${source}.phase: expected setup or verifier`);
+  return {
+    phase,
+    index: readNumber(value, source, "index"),
+    command: readString(value, source, "command"),
+    exitCode: readNumber(value, source, "exitCode"),
+    signal: readSignal(value.signal, `${source}.signal`),
+    timedOut: readBoolean(value, source, "timedOut"),
+    wallTimeMs: readNumber(value, source, "wallTimeMs"),
+    stdout: readStringAllowEmpty(value, source, "stdout"),
+    stderr: readStringAllowEmpty(value, source, "stderr")
+  };
+}
+function readSignal(value, source) {
+  if (value === null) return null;
+  if (typeof value === "string" && NODE_SIGNALS.has(value)) return value;
+  throw new Error(`${source}: expected signal or null`);
+}
+function parseFailureClassCount(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: expected object`);
+  return {
+    failureClass: readFailureClass(value, source, "failureClass"),
+    count: readNumber(value, source, "count")
+  };
+}
+function readFailureClass(record, source, field) {
+  const value = record[field];
+  if (value === "setup_failed" || value === "verifier_failed" || value === "timeout" || value === "cwd_missing" || value === "command_error") {
+    return value;
+  }
+  throw new Error(`${source}.${field}: expected failure class`);
+}
+function readOptionalFailureClass(record, source, field) {
+  if (record[field] === void 0) return void 0;
+  return readFailureClass(record, source, field);
+}
+function readString(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string`);
+  return value;
+}
+function readStringAllowEmpty(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "string") throw new Error(`${source}.${field}: expected string`);
+  return value;
+}
+function readOptionalString(record, source, field) {
+  const value = record[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string`);
+  return value;
+}
+function readNullableString(record, source, field) {
+  const value = record[field];
+  if (value === null) return null;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string or null`);
+  return value;
+}
+function readOptionalNullableString(record, source, field) {
+  const value = record[field];
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string or null`);
+  return value;
+}
+function readStringArray(record, source, field) {
+  const value = readArray(record, source, field);
+  const out = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const entry = value[index];
+    if (typeof entry !== "string") throw new Error(`${source}.${field}[${index}]: expected string`);
+    out.push(entry);
+  }
+  return out;
+}
+function readNumber(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${source}.${field}: expected number`);
+  return value;
+}
+function readBoolean(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "boolean") throw new Error(`${source}.${field}: expected boolean`);
+  return value;
+}
+function readArray(record, source, field) {
+  const value = record[field];
+  if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);
+  return value;
+}
+function parseJson(raw, source) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${source}: invalid JSON: ${message}`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isErrorWithCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string";
+}
+
+// src/domains/eval/artifacts/store.ts
+init_esm_shims();
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/domains/eval/schema/behavioral.ts
+init_esm_shims();
+import { createHash as createHash3 } from "node:crypto";
+
+// src/domains/eval/schema/verdict.ts
+init_esm_shims();
+var EVAL_VERDICT_SCHEMA_V1 = "clio.eval.verdict.v1";
+var EVAL_TRACKED_METRIC_NAMES = [
+  "modelCalls",
+  "uncachedPrefillTokens",
+  "cacheReadTokens",
+  "generatedTokens",
+  "reasoningTokens",
+  "toolCalls",
+  "toolErrors",
+  "ttftMsFirstCall",
+  "wallClockMs",
+  "contextTokensAtEnd",
+  "compactions"
+];
+function parseEvalVerdictEnvelopeV1(value, source = "verdict") {
+  const record = asRecord(value, source);
+  if (record.schema !== EVAL_VERDICT_SCHEMA_V1) {
+    throw new Error(`${source}.schema: expected ${EVAL_VERDICT_SCHEMA_V1}`);
+  }
+  const scenarioId = readNonEmptyString(record, source, "scenarioId");
+  const trialIndex = readNonNegativeInteger(record, source, "trialIndex");
+  const outcome = readOutcome(record.outcome, `${source}.outcome`);
+  const machinery = readMachinery(record.machinery, `${source}.machinery`);
+  if (machinery === "infrastructure_failure" && outcome === "pass") {
+    throw new Error(`${source}: infrastructure_failure cannot carry a pass outcome`);
+  }
+  if (record.behavioral !== null) throw new Error(`${source}.behavioral: expected null in verdict v1`);
+  const evidence = parseEvidence(record.evidence, `${source}.evidence`);
+  const reason = record.reason === void 0 ? legacyVerdictReason(outcome, machinery, evidence) : readNullableNonEmptyString(record, source, "reason");
+  if (outcome === "fail" && reason === null) throw new Error(`${source}.reason: failed outcome requires a reason`);
+  if (outcome !== "fail" && reason !== null) {
+    throw new Error(`${source}.reason: only a failed outcome can carry a reason`);
+  }
+  return {
+    schema: EVAL_VERDICT_SCHEMA_V1,
+    scenarioId,
+    trialIndex,
+    outcome,
+    machinery,
+    reason,
+    trackedMetrics: parseTrackedMetrics(record.trackedMetrics, `${source}.trackedMetrics`),
+    behavioral: null,
+    evidence
+  };
+}
+function parseTrackedMetrics(value, source) {
+  const record = asRecord(value, source);
+  const expectedColdReasons = asRecord(record.expectedColdReasons, `${source}.expectedColdReasons`);
+  return {
+    modelCalls: readSourcedNumber(record.modelCalls, `${source}.modelCalls`),
+    uncachedPrefillTokens: readSourcedNumber(record.uncachedPrefillTokens, `${source}.uncachedPrefillTokens`),
+    cacheReadTokens: readSourcedNumber(record.cacheReadTokens, `${source}.cacheReadTokens`),
+    generatedTokens: readSourcedNumber(record.generatedTokens, `${source}.generatedTokens`),
+    reasoningTokens: readSourcedNullableNumber(record.reasoningTokens, `${source}.reasoningTokens`),
+    toolCalls: readSourcedNumber(record.toolCalls, `${source}.toolCalls`),
+    toolErrors: readSourcedNumber(record.toolErrors, `${source}.toolErrors`),
+    ttftMsFirstCall: readSourcedNumber(record.ttftMsFirstCall, `${source}.ttftMsFirstCall`),
+    wallClockMs: readSourcedNumber(record.wallClockMs, `${source}.wallClockMs`),
+    contextTokensAtEnd: readSourcedNumber(record.contextTokensAtEnd, `${source}.contextTokensAtEnd`),
+    compactions: readSourcedNumber(record.compactions, `${source}.compactions`),
+    expectedColdReasons: Object.fromEntries(
+      Object.entries(expectedColdReasons).map(([reason, metric]) => {
+        if (reason.trim().length === 0) throw new Error(`${source}.expectedColdReasons: expected non-empty reason`);
+        return [reason, readSourcedNumber(metric, `${source}.expectedColdReasons.${reason}`)];
+      })
+    )
+  };
+}
+function parseEvidence(value, source) {
+  const record = asRecord(value, source);
+  const terminalReceiptDigest = readNullableString2(record, source, "terminalReceiptDigest");
+  if (terminalReceiptDigest !== null && !/^[a-f0-9]{64}$/u.test(terminalReceiptDigest)) {
+    throw new Error(`${source}.terminalReceiptDigest: expected sha256 digest or null`);
+  }
+  const graderExitCode = record.graderExitCode;
+  if (graderExitCode !== null && (!Number.isInteger(graderExitCode) || !Number.isFinite(graderExitCode))) {
+    throw new Error(`${source}.graderExitCode: expected integer or null`);
+  }
+  return {
+    assignmentId: readNullableString2(record, source, "assignmentId"),
+    terminalReceiptDigest,
+    graderExitCode
+  };
+}
+function legacyVerdictReason(outcome, machinery, evidence) {
+  if (outcome !== "fail") return null;
+  if (machinery === "infrastructure_failure") return "infrastructure_failure";
+  if (evidence.graderExitCode !== null && evidence.graderExitCode !== 0) return "grader_failed";
+  return "outcome_failed";
+}
+function readSourcedNumber(value, source) {
+  const record = asRecord(value, source);
+  return {
+    value: readNonNegativeNumber(record.value, `${source}.value`),
+    source: readMetricSource(record.source, source)
+  };
+}
+function readSourcedNullableNumber(value, source) {
+  const record = asRecord(value, source);
+  return {
+    value: record.value === null ? null : readNonNegativeNumber(record.value, `${source}.value`),
+    source: readMetricSource(record.source, source)
+  };
+}
+function readMetricSource(value, source) {
+  if (value === "ledger" || value === "receipt" || value === "estimated") return value;
+  throw new Error(`${source}.source: expected ledger, receipt, or estimated`);
+}
+function readOutcome(value, source) {
+  if (value === "pass" || value === "fail" || value === "unmeasured") return value;
+  throw new Error(`${source}: expected pass, fail, or unmeasured`);
+}
+function readMachinery(value, source) {
+  if (value === "ok" || value === "infrastructure_failure") return value;
+  throw new Error(`${source}: expected ok or infrastructure_failure`);
+}
+function readNonNegativeNumber(value, source) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${source}: expected non-negative number`);
+  }
+  return value;
+}
+function readNonNegativeInteger(record, source, field) {
+  const value = record[field];
+  if (!Number.isInteger(value) || typeof value !== "number" || value < 0) {
+    throw new Error(`${source}.${field}: expected non-negative integer`);
+  }
+  return value;
+}
+function readNonEmptyString(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${source}.${field}: expected string`);
+  return value;
+}
+function readNullableString2(record, source, field) {
+  const value = record[field];
+  if (value === null) return null;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string or null`);
+  return value;
+}
+function readNullableNonEmptyString(record, source, field) {
+  const value = readNullableString2(record, source, field);
+  if (value !== null && value.trim().length === 0) {
+    throw new Error(`${source}.${field}: expected non-empty string or null`);
+  }
+  return value;
+}
+function asRecord(value, source) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+
+// src/domains/eval/schema/behavioral.ts
+var EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1 = "clio.eval.scenario.v1";
+var EVAL_BEHAVIOR_SCHEMA_V1 = "clio.eval.behavior.v1";
+var EVAL_BEHAVIOR_CATEGORIES = [
+  "tool_choice",
+  "exploration",
+  "delegation",
+  "safety_comprehension",
+  "claim_grounding",
+  "denied_tool_recovery",
+  "completion_behavior",
+  "task_correctness"
+];
+var MAX_RULES = 64;
+var MAX_FACTS = 128;
+var MAX_EVIDENCE_PER_LABEL = 8;
+var MAX_ID_CHARS = 128;
+var MAX_TEXT_CHARS = 1e3;
+var MAX_EXPLANATION_CHARS = 2e3;
+function parseEvalBehaviorScenarioV1(value, source = "behavioral scenario") {
+  const record = asRecord2(value, source);
+  if (record.schema !== EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1) {
+    throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1}`);
+  }
+  const corpus = asRecord2(record.corpus, `${source}.corpus`);
+  const execution = asRecord2(record.execution, `${source}.execution`);
+  const subject = asRecord2(execution.subject, `${source}.execution.subject`);
+  const mode = execution.mode;
+  if (mode !== "machinery-only" && mode !== "model-required") {
+    throw new Error(`${source}.execution.mode: expected machinery-only or model-required`);
+  }
+  const subjectKind = subject.kind;
+  if (subjectKind !== "main-agent" && subjectKind !== "worker") {
+    throw new Error(`${source}.execution.subject.kind: expected main-agent or worker`);
+  }
+  const toolTarget = execution.toolTarget;
+  if (toolTarget !== "available" && toolTarget !== "none") {
+    throw new Error(`${source}.execution.toolTarget: expected available or none`);
+  }
+  const expectedBehavior = parseRules(record.expectedBehavior, `${source}.expectedBehavior`);
+  const forbiddenBehavior = parseRules(record.forbiddenBehavior, `${source}.forbiddenBehavior`);
+  const ruleIds = /* @__PURE__ */ new Set();
+  for (const rule of [...expectedBehavior, ...forbiddenBehavior]) {
+    if (ruleIds.has(rule.id)) throw new Error(`${source}: duplicate behavioral rule id ${rule.id}`);
+    ruleIds.add(rule.id);
+  }
+  if (ruleIds.size === 0) throw new Error(`${source}: expected at least one behavioral rule`);
+  const judge = asRecord2(record.judge, `${source}.judge`);
+  const maxEvidenceItems = readBoundedInteger(judge.maxEvidenceItems, `${source}.judge.maxEvidenceItems`, 1, MAX_FACTS);
+  const maxExplanationChars = readBoundedInteger(
+    judge.maxExplanationChars,
+    `${source}.judge.maxExplanationChars`,
+    1,
+    MAX_EXPLANATION_CHARS
+  );
+  return {
+    schema: EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1,
+    corpus: {
+      id: readId(corpus.id, `${source}.corpus.id`),
+      version: readText(corpus.version, `${source}.corpus.version`, MAX_ID_CHARS)
+    },
+    execution: {
+      mode,
+      subject: { kind: subjectKind, role: readId(subject.role, `${source}.execution.subject.role`) },
+      toolTarget
+    },
+    expectedBehavior,
+    forbiddenBehavior,
+    judge: { maxEvidenceItems, maxExplanationChars }
+  };
+}
+function canonicalizeEvalBehaviorJudgeInputV1(value, scenario, source = "behavioral judge input") {
+  const record = asRecord2(value, source);
+  if (!Array.isArray(record.facts)) throw new Error(`${source}.facts: expected array`);
+  if (record.facts.length > scenario.judge.maxEvidenceItems || record.facts.length > MAX_FACTS) {
+    throw new Error(`${source}.facts: exceeds bounded evidence limit`);
+  }
+  const facts = record.facts.map((fact, index) => parseFact(fact, `${source}.facts[${index}]`));
+  const factIds = /* @__PURE__ */ new Set();
+  const factKeys = /* @__PURE__ */ new Set();
+  for (const fact of facts) {
+    if (factIds.has(fact.id)) throw new Error(`${source}: duplicate fact id ${fact.id}`);
+    const key = `${fact.source}\0${fact.key}`;
+    if (factKeys.has(key)) throw new Error(`${source}: conflicting fact ${fact.source}.${fact.key}`);
+    factIds.add(fact.id);
+    factKeys.add(key);
+  }
+  const unavailableSources = parseSources(record.unavailableSources, `${source}.unavailableSources`);
+  const infrastructureFailure = record.infrastructureFailure;
+  if (typeof infrastructureFailure !== "boolean") {
+    throw new Error(`${source}.infrastructureFailure: expected boolean`);
+  }
+  const input = {
+    facts: facts.sort((left, right) => left.source.localeCompare(right.source) || left.key.localeCompare(right.key)),
+    unavailableSources: [...new Set(unavailableSources)].sort(),
+    infrastructureFailure
+  };
+  return { input, digest: sha2562(stableJson(input)) };
+}
+function judgeEvalBehaviorV1(scenarioValue, verdict, inputValue) {
+  const scenario = parseEvalBehaviorScenarioV1(scenarioValue);
+  const { input, digest } = canonicalizeEvalBehaviorJudgeInputV1(inputValue, scenario);
+  const labels = EVAL_BEHAVIOR_CATEGORIES.map(
+    (category) => judgeCategory(category, scenario, input, scenario.judge.maxExplanationChars)
+  );
+  const outcome = input.infrastructureFailure ? "infrastructure_failure" : labels.some((label) => label.label === "violated") ? "behavioral_failure" : labels.some((label) => label.label === "unknown") ? "unknown" : labels.every((label) => label.label === "unmeasured") ? "unmeasured" : "pass";
+  return parseEvalBehaviorVerdictV1({
+    schema: EVAL_BEHAVIOR_SCHEMA_V1,
+    verdictRef: {
+      schema: verdict.schema,
+      scenarioId: verdict.scenarioId,
+      trialIndex: verdict.trialIndex
+    },
+    corpus: scenario.corpus,
+    judgeInputDigest: digest,
+    outcome,
+    labels
+  });
+}
+function parseEvalBehaviorVerdictV1(value, source = "behavioral verdict") {
+  const record = asRecord2(value, source);
+  if (record.schema !== EVAL_BEHAVIOR_SCHEMA_V1)
+    throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_SCHEMA_V1}`);
+  const verdictRef = asRecord2(record.verdictRef, `${source}.verdictRef`);
+  if (verdictRef.schema !== EVAL_VERDICT_SCHEMA_V1) {
+    throw new Error(`${source}.verdictRef.schema: expected ${EVAL_VERDICT_SCHEMA_V1}`);
+  }
+  const corpus = asRecord2(record.corpus, `${source}.corpus`);
+  const outcome = readOutcome2(record.outcome, `${source}.outcome`);
+  if (!Array.isArray(record.labels)) throw new Error(`${source}.labels: expected array`);
+  const labels = record.labels.map((label, index) => parseLabel(label, `${source}.labels[${index}]`));
+  const categories = labels.map((label) => label.category);
+  if (labels.length !== EVAL_BEHAVIOR_CATEGORIES.length || new Set(categories).size !== EVAL_BEHAVIOR_CATEGORIES.length) {
+    throw new Error(`${source}.labels: expected every behavioral category exactly once`);
+  }
+  for (const category of EVAL_BEHAVIOR_CATEGORIES) {
+    if (!categories.includes(category)) throw new Error(`${source}.labels: missing category ${category}`);
+  }
+  const derived = deriveOutcome(labels, outcome === "infrastructure_failure");
+  if (outcome !== derived) throw new Error(`${source}.outcome: ${outcome} conflicts with labels (expected ${derived})`);
+  return {
+    schema: EVAL_BEHAVIOR_SCHEMA_V1,
+    verdictRef: {
+      schema: EVAL_VERDICT_SCHEMA_V1,
+      scenarioId: readId(verdictRef.scenarioId, `${source}.verdictRef.scenarioId`),
+      trialIndex: readBoundedInteger(verdictRef.trialIndex, `${source}.verdictRef.trialIndex`, 0, Number.MAX_SAFE_INTEGER)
+    },
+    corpus: {
+      id: readId(corpus.id, `${source}.corpus.id`),
+      version: readText(corpus.version, `${source}.corpus.version`, MAX_ID_CHARS)
+    },
+    judgeInputDigest: readDigest(record.judgeInputDigest, `${source}.judgeInputDigest`),
+    outcome,
+    labels
+  };
+}
+function assertEvalBehaviorReferencesVerdictV1(behavior, verdict, source = "behavioral verdict") {
+  if (behavior.verdictRef.scenarioId !== verdict.scenarioId || behavior.verdictRef.trialIndex !== verdict.trialIndex) {
+    throw new Error(`${source}.verdictRef: conflicts with result verdict identity`);
+  }
+  if (verdict.machinery === "infrastructure_failure" && behavior.outcome !== "infrastructure_failure") {
+    throw new Error(`${source}.outcome: machinery failure must remain infrastructure_failure`);
+  }
+  if (behavior.outcome === "pass" && verdict.outcome !== "pass") {
+    throw new Error(`${source}.outcome: behavioral pass cannot override a failed or unmeasured result`);
+  }
+}
+function judgeCategory(category, scenario, input, maxExplanationChars) {
+  const expected = scenario.expectedBehavior.filter((rule) => rule.category === category);
+  const forbidden = scenario.forbiddenBehavior.filter((rule) => rule.category === category);
+  const rules = [...expected, ...forbidden];
+  if (input.infrastructureFailure)
+    return labelResult(category, "unknown", rules, [], "infrastructure failure", maxExplanationChars);
+  if (rules.length === 0) return labelResult(category, "unmeasured", [], [], null, maxExplanationChars);
+  const unavailable = rules.some((rule) => input.unavailableSources.includes(rule.fact.source));
+  if (unavailable)
+    return labelResult(category, "unmeasured", rules, [], "required evidence source unavailable", maxExplanationChars);
+  const evaluations = rules.map((rule) => {
+    const fact = input.facts.find(
+      (candidate) => candidate.source === rule.fact.source && candidate.key === rule.fact.key
+    );
+    if (fact === void 0) return { rule, fact: null, holds: null };
+    const matches = compare(fact.value, rule.fact.op, rule.fact.value);
+    return { rule, fact, holds: expected.includes(rule) ? matches : !matches };
+  });
+  const evidence = evaluations.flatMap(({ fact }) => fact === null ? [] : [toEvidence(fact)]).slice(0, MAX_EVIDENCE_PER_LABEL);
+  if (evaluations.some(({ holds }) => holds === false)) {
+    return labelResult(category, "violated", rules, evidence, "one or more declared rules failed", maxExplanationChars);
+  }
+  if (evaluations.some(({ holds }) => holds === null)) {
+    return labelResult(category, "unknown", rules, evidence, "required observable fact missing", maxExplanationChars);
+  }
+  return labelResult(category, "satisfied", rules, evidence, null, maxExplanationChars);
+}
+function labelResult(category, label, rules, evidence, explanation, maxExplanationChars) {
+  return {
+    category,
+    label,
+    ruleIds: rules.map((rule) => rule.id).sort(),
+    evidence,
+    explanation: explanation === null ? null : explanation.slice(0, maxExplanationChars)
+  };
+}
+function deriveOutcome(labels, infrastructure) {
+  if (infrastructure) return "infrastructure_failure";
+  if (labels.some((label) => label.label === "violated")) return "behavioral_failure";
+  if (labels.some((label) => label.label === "unknown")) return "unknown";
+  if (labels.every((label) => label.label === "unmeasured")) return "unmeasured";
+  return "pass";
+}
+function parseRules(value, source) {
+  if (!Array.isArray(value)) throw new Error(`${source}: expected array`);
+  if (value.length > MAX_RULES) throw new Error(`${source}: exceeds ${MAX_RULES} rules`);
+  return value.map((entry, index) => {
+    const record = asRecord2(entry, `${source}[${index}]`);
+    const fact = asRecord2(record.fact, `${source}[${index}].fact`);
+    const rationale = record.rationale === void 0 ? void 0 : readText(record.rationale, `${source}[${index}].rationale`, MAX_TEXT_CHARS);
+    return {
+      id: readId(record.id, `${source}[${index}].id`),
+      category: readCategory(record.category, `${source}[${index}].category`),
+      fact: {
+        source: readSource(fact.source, `${source}[${index}].fact.source`),
+        key: readText(fact.key, `${source}[${index}].fact.key`, MAX_TEXT_CHARS),
+        op: readOp(fact.op, `${source}[${index}].fact.op`),
+        value: readScalar(fact.value, `${source}[${index}].fact.value`)
+      },
+      ...rationale === void 0 ? {} : { rationale }
+    };
+  });
+}
+function parseFact(value, source) {
+  const record = asRecord2(value, source);
+  const evidence = asRecord2(record.evidence, `${source}.evidence`);
+  return {
+    id: readId(record.id, `${source}.id`),
+    source: readSource(record.source, `${source}.source`),
+    key: readText(record.key, `${source}.key`, MAX_TEXT_CHARS),
+    value: readScalar(record.value, `${source}.value`),
+    evidence: {
+      locator: readText(evidence.locator, `${source}.evidence.locator`, MAX_TEXT_CHARS),
+      digest: readDigest(evidence.digest, `${source}.evidence.digest`),
+      excerpt: evidence.excerpt === null ? null : readText(evidence.excerpt, `${source}.evidence.excerpt`, MAX_TEXT_CHARS)
+    }
+  };
+}
+function parseLabel(value, source) {
+  const record = asRecord2(value, source);
+  const label = record.label;
+  if (label !== "satisfied" && label !== "violated" && label !== "unknown" && label !== "unmeasured") {
+    throw new Error(`${source}.label: expected satisfied, violated, unknown, or unmeasured`);
+  }
+  if (!Array.isArray(record.ruleIds) || !Array.isArray(record.evidence)) {
+    throw new Error(`${source}: expected ruleIds and evidence arrays`);
+  }
+  if (record.evidence.length > MAX_EVIDENCE_PER_LABEL) throw new Error(`${source}.evidence: exceeds bounded limit`);
+  if ((label === "satisfied" || label === "violated") && (record.ruleIds.length === 0 || record.evidence.length === 0)) {
+    throw new Error(`${source}: ${label} label requires a rule and observable evidence`);
+  }
+  const explanation = record.explanation;
+  if (explanation !== null && (typeof explanation !== "string" || explanation.length > MAX_EXPLANATION_CHARS)) {
+    throw new Error(`${source}.explanation: expected bounded string or null`);
+  }
+  return {
+    category: readCategory(record.category, `${source}.category`),
+    label,
+    ruleIds: record.ruleIds.map((id, index) => readId(id, `${source}.ruleIds[${index}]`)),
+    evidence: record.evidence.map((entry, index) => {
+      const evidence = asRecord2(entry, `${source}.evidence[${index}]`);
+      return {
+        factId: readId(evidence.factId, `${source}.evidence[${index}].factId`),
+        source: readSource(evidence.source, `${source}.evidence[${index}].source`),
+        locator: readText(evidence.locator, `${source}.evidence[${index}].locator`, MAX_TEXT_CHARS),
+        digest: readDigest(evidence.digest, `${source}.evidence[${index}].digest`),
+        excerpt: evidence.excerpt === null ? null : readText(evidence.excerpt, `${source}.evidence[${index}].excerpt`, MAX_TEXT_CHARS)
+      };
+    }),
+    explanation
+  };
+}
+function toEvidence(fact) {
+  return { factId: fact.id, source: fact.source, ...fact.evidence };
+}
+function compare(actual, op, expected) {
+  if (op === "eq") return actual === expected;
+  if (op === "neq") return actual !== expected;
+  if (typeof actual !== "number" || typeof expected !== "number") return false;
+  if (op === "lt") return actual < expected;
+  if (op === "lte") return actual <= expected;
+  if (op === "gt") return actual > expected;
+  return actual >= expected;
+}
+function parseSources(value, source) {
+  if (!Array.isArray(value)) throw new Error(`${source}: expected array`);
+  return value.map((entry, index) => readSource(entry, `${source}[${index}]`));
+}
+function readOutcome2(value, source) {
+  if (value === "pass" || value === "behavioral_failure" || value === "unknown" || value === "unmeasured" || value === "infrastructure_failure")
+    return value;
+  throw new Error(`${source}: expected a closed behavioral outcome`);
+}
+function readCategory(value, source) {
+  if (typeof value === "string" && EVAL_BEHAVIOR_CATEGORIES.includes(value)) {
+    return value;
+  }
+  throw new Error(`${source}: expected a closed behavioral category`);
+}
+function readSource(value, source) {
+  if (value === "transcript" || value === "tool" || value === "receipt" || value === "grader") return value;
+  throw new Error(`${source}: expected transcript, tool, receipt, or grader`);
+}
+function readOp(value, source) {
+  if (value === "eq" || value === "neq" || value === "lt" || value === "lte" || value === "gt" || value === "gte") {
+    return value;
+  }
+  throw new Error(`${source}: expected eq, neq, lt, lte, gt, or gte`);
+}
+function readScalar(value, source) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.length <= MAX_TEXT_CHARS) return value;
+  throw new Error(`${source}: expected bounded string, finite number, or boolean`);
+}
+function readId(value, source) {
+  const id = readText(value, source, MAX_ID_CHARS);
+  if (!/^[A-Za-z0-9._-]+$/u.test(id)) throw new Error(`${source}: expected stable id`);
+  return id;
+}
+function readText(value, source, maxChars) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > maxChars) {
+    throw new Error(`${source}: expected non-empty string no longer than ${maxChars} characters`);
+  }
+  return value;
+}
+function readDigest(value, source) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) throw new Error(`${source}: expected sha256 digest`);
+  return value;
+}
+function readBoundedInteger(value, source, min, max) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${source}: expected integer from ${min} through ${max}`);
+  }
+  return value;
+}
+function asRecord2(value, source) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function sha2562(value) {
+  return createHash3("sha256").update(value, "utf8").digest("hex");
+}
+
+// src/domains/eval/schema/behavioral-metrics.ts
+init_esm_shims();
+var EVAL_BEHAVIOR_METRICS_SCHEMA_V1 = "clio.eval.behavior.metrics.v1";
+var EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1 = [
+  {
+    name: "correctness.taskSolved",
+    family: "correctness",
+    direction: "higher",
+    hardGate: true,
+    source: "grader"
+  },
+  {
+    name: "safety.violations",
+    family: "safety",
+    direction: "lower",
+    hardGate: true,
+    source: "behavioral-label"
+  },
+  {
+    name: "behavior.labelViolations",
+    family: "behavior",
+    direction: "lower",
+    hardGate: false,
+    source: "behavioral-label"
+  },
+  {
+    name: "efficiency.toolCalls",
+    family: "efficiency",
+    direction: "lower",
+    hardGate: false,
+    source: "tool-event"
+  },
+  {
+    name: "exploration.unnecessaryReads",
+    family: "exploration",
+    direction: "lower",
+    hardGate: false,
+    source: "tool-event"
+  },
+  {
+    name: "delegation.quality",
+    family: "delegation",
+    direction: "higher",
+    hardGate: false,
+    source: "behavioral-label"
+  },
+  {
+    name: "claims.unsupported",
+    family: "claims",
+    direction: "lower",
+    hardGate: false,
+    source: "grader"
+  },
+  {
+    name: "tokens.total",
+    family: "tokens",
+    direction: "lower",
+    hardGate: false,
+    source: "runner"
+  },
+  {
+    name: "latency.wallMs",
+    family: "latency",
+    direction: "lower",
+    hardGate: false,
+    source: "runner"
+  },
+  {
+    name: "cost.usd",
+    family: "cost",
+    direction: "lower",
+    hardGate: false,
+    source: "receipt"
+  }
+];
+function buildEvalBehaviorMetricsV1(result, role) {
+  const label = (category) => result.behavioral?.labels.find((entry) => entry.category === category)?.label ?? null;
+  const observedLabels = result.behavioral?.labels.filter(
+    (entry) => entry.label === "satisfied" || entry.label === "violated"
+  );
+  const values = {
+    "correctness.taskSolved": booleanMetric(result.metrics["task.solved"]),
+    "safety.violations": violationMetric(label("safety_comprehension")),
+    "behavior.labelViolations": observedLabels === void 0 || observedLabels.length !== result.behavioral?.labels.length ? null : observedLabels.filter((entry) => entry.label === "violated").length,
+    "efficiency.toolCalls": numberMetric(result.metrics["tools.totalCalls"]),
+    "exploration.unnecessaryReads": numberMetric(result.metrics["tools.read.outsideAllowed"]),
+    "delegation.quality": qualityMetric(label("delegation")),
+    "claims.unsupported": numberMetric(result.metrics["claims.unsupported"]),
+    "tokens.total": numberMetric(result.metrics["tokens.total"]),
+    "latency.wallMs": numberMetric(result.metrics["latency.wallMs"]),
+    "cost.usd": numberMetric(result.metrics["cost.usd"])
+  };
+  const metrics = Object.fromEntries(
+    EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1.map((definition) => [
+      definition.name,
+      { value: values[definition.name], source: definition.source }
+    ])
+  );
+  return {
+    schema: EVAL_BEHAVIOR_METRICS_SCHEMA_V1,
+    scenarioId: result.taskId,
+    role,
+    target: { id: result.target.id, model: result.target.model },
+    metrics
+  };
+}
+function parseEvalBehaviorMetricsV1(value, source = "behavioral metrics") {
+  const record = asRecord3(value, source);
+  if (record.schema !== EVAL_BEHAVIOR_METRICS_SCHEMA_V1) {
+    throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_METRICS_SCHEMA_V1}`);
+  }
+  const target = asRecord3(record.target, `${source}.target`);
+  const rawMetrics = asRecord3(record.metrics, `${source}.metrics`);
+  const expectedMetricNames = new Set(EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1.map((definition) => definition.name));
+  for (const metricName of Object.keys(rawMetrics)) {
+    if (!expectedMetricNames.has(metricName)) {
+      throw new Error(`${source}.metrics.${metricName}: unknown behavioral metric`);
+    }
+  }
+  const metrics = Object.fromEntries(
+    EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1.map((definition) => {
+      const observation = asRecord3(rawMetrics[definition.name], `${source}.metrics.${definition.name}`);
+      const metricSource = observation.source;
+      if (metricSource !== definition.source) {
+        throw new Error(`${source}.metrics.${definition.name}.source: expected ${definition.source}`);
+      }
+      const metricValue = observation.value;
+      if (metricValue !== null && (typeof metricValue !== "number" || !Number.isFinite(metricValue))) {
+        throw new Error(`${source}.metrics.${definition.name}.value: expected finite number or null`);
+      }
+      return [definition.name, { value: metricValue, source: metricSource }];
+    })
+  );
+  return {
+    schema: EVAL_BEHAVIOR_METRICS_SCHEMA_V1,
+    scenarioId: readString2(record.scenarioId, `${source}.scenarioId`),
+    role: readString2(record.role, `${source}.role`),
+    target: {
+      id: readString2(target.id, `${source}.target.id`),
+      model: target.model === null ? null : readString2(target.model, `${source}.target.model`)
+    },
+    metrics
+  };
+}
+function numberMetric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function booleanMetric(value) {
+  return typeof value === "boolean" ? value ? 1 : 0 : null;
+}
+function violationMetric(label) {
+  if (label === "violated") return 1;
+  if (label === "satisfied") return 0;
+  return null;
+}
+function qualityMetric(label) {
+  if (label === "satisfied") return 1;
+  if (label === "violated") return 0;
+  return null;
+}
+function asRecord3(value, source) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+function readString2(value, source) {
+  if (typeof value === "string" && value.length > 0) return value;
+  throw new Error(`${source}: expected non-empty string`);
+}
+
+// src/domains/eval/schema/execution-envelope.ts
+init_esm_shims();
+var EVAL_EXECUTION_ENVELOPE_SCHEMA_V1 = "clio.eval.execution-envelope.v1";
+var EVAL_EXECUTION_MATRIX_DIMENSIONS_V1 = [
+  "prompt",
+  "recipe",
+  "target",
+  "wireModel",
+  "runtime",
+  "thinkingLevel",
+  "toolSignature",
+  "autonomy",
+  "policy",
+  "projectContext",
+  "corpus"
+];
+function parseEvalExecutionEnvelopeV1(value, source = "execution envelope") {
+  const record = asRecord4(value, source);
+  if (record.schema !== EVAL_EXECUTION_ENVELOPE_SCHEMA_V1) {
+    throw new Error(`${source}.schema: expected ${EVAL_EXECUTION_ENVELOPE_SCHEMA_V1}`);
+  }
+  const prompt = asRecord4(record.prompt, `${source}.prompt`);
+  if (!Array.isArray(prompt.fragments)) throw new Error(`${source}.prompt.fragments: expected array`);
+  const fragments = prompt.fragments.map((entry, index) => {
+    const fragment = asRecord4(entry, `${source}.prompt.fragments[${index}]`);
+    const version = fragment.version;
+    if (version !== "unversioned" && (!Number.isInteger(version) || typeof version !== "number" || version <= 0)) {
+      throw new Error(`${source}.prompt.fragments[${index}].version: expected positive integer or unversioned`);
+    }
+    return {
+      id: readString3(fragment.id, `${source}.prompt.fragments[${index}].id`),
+      version,
+      contentHash: readDigest2(fragment.contentHash, `${source}.prompt.fragments[${index}].contentHash`)
+    };
+  });
+  const fragmentIds = fragments.map((fragment) => fragment.id);
+  if (new Set(fragmentIds).size !== fragmentIds.length) {
+    throw new Error(`${source}.prompt.fragments: duplicate fragment id`);
+  }
+  const recipe = record.recipe === null ? null : (() => {
+    const value2 = asRecord4(record.recipe, `${source}.recipe`);
+    const version = value2.version;
+    if (!Number.isInteger(version) || typeof version !== "number" || version <= 0) {
+      throw new Error(`${source}.recipe.version: expected positive integer`);
+    }
+    return {
+      id: readString3(value2.id, `${source}.recipe.id`),
+      version,
+      contentHash: readDigest2(value2.contentHash, `${source}.recipe.contentHash`)
+    };
+  })();
+  const policyHashes = asRecord4(record.policyHashes, `${source}.policyHashes`);
+  const projectContext = asRecord4(record.projectContext, `${source}.projectContext`);
+  const projectKind = projectContext.kind;
+  if (projectKind !== "none" && projectKind !== "session" && projectKind !== "worker") {
+    throw new Error(`${source}.projectContext.kind: expected none, session, or worker`);
+  }
+  const corpus = asRecord4(record.corpus, `${source}.corpus`);
+  return {
+    schema: EVAL_EXECUTION_ENVELOPE_SCHEMA_V1,
+    prompt: {
+      fragments,
+      compositionHash: readNullableDigest(prompt.compositionHash, `${source}.prompt.compositionHash`)
+    },
+    recipe,
+    target: readString3(record.target, `${source}.target`),
+    wireModel: readNullableString3(record.wireModel, `${source}.wireModel`),
+    runtime: readNullableString3(record.runtime, `${source}.runtime`),
+    thinkingLevel: readNullableString3(record.thinkingLevel, `${source}.thinkingLevel`),
+    toolSignature: readNullableDigest(record.toolSignature, `${source}.toolSignature`),
+    autonomy: readNullableString3(record.autonomy, `${source}.autonomy`),
+    policyHashes: {
+      rulePack: readNullableDigest(policyHashes.rulePack, `${source}.policyHashes.rulePack`),
+      project: readNullableDigest(policyHashes.project, `${source}.policyHashes.project`)
+    },
+    projectContext: {
+      kind: projectKind,
+      tier: readNullableString3(projectContext.tier, `${source}.projectContext.tier`),
+      contentHash: readNullableDigest(projectContext.contentHash, `${source}.projectContext.contentHash`),
+      chars: readNullableNonNegativeInteger(projectContext.chars, `${source}.projectContext.chars`),
+      sections: readStringArray2(projectContext.sections, `${source}.projectContext.sections`),
+      rulesApplied: readStringArray2(projectContext.rulesApplied, `${source}.projectContext.rulesApplied`),
+      operatorProfileApplied: readNullableBoolean(
+        projectContext.operatorProfileApplied,
+        `${source}.projectContext.operatorProfileApplied`
+      )
+    },
+    corpus: {
+      id: readString3(corpus.id, `${source}.corpus.id`),
+      version: readString3(corpus.version, `${source}.corpus.version`)
+    }
+  };
+}
+function parseEvalExecutionMatrixDimensionsV1(value, source) {
+  if (!Array.isArray(value)) throw new Error(`${source}: expected array`);
+  const allowed = new Set(EVAL_EXECUTION_MATRIX_DIMENSIONS_V1);
+  const dimensions = value.map((entry, index) => {
+    if (typeof entry !== "string" || !allowed.has(entry)) {
+      throw new Error(`${source}[${index}]: expected a declared execution-envelope dimension`);
+    }
+    return entry;
+  });
+  if (new Set(dimensions).size !== dimensions.length) throw new Error(`${source}: duplicate matrix dimension`);
+  return dimensions;
+}
+function readString3(value, source) {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}: expected non-empty string`);
+  return value;
+}
+function readNullableString3(value, source) {
+  if (value === null) return null;
+  return readString3(value, source);
+}
+function readDigest2(value, source) {
+  const digest = readString3(value, source);
+  if (!/^[a-f0-9]{64}$/u.test(digest)) throw new Error(`${source}: expected sha256 digest`);
+  return digest;
+}
+function readNullableDigest(value, source) {
+  return value === null ? null : readDigest2(value, source);
+}
+function readNullableNonNegativeInteger(value, source) {
+  if (value === null) return null;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${source}: expected non-negative integer or null`);
+  }
+  return value;
+}
+function readNullableBoolean(value, source) {
+  if (value === null || typeof value === "boolean") return value;
+  throw new Error(`${source}: expected boolean or null`);
+}
+function readStringArray2(value, source) {
+  if (!Array.isArray(value)) throw new Error(`${source}: expected array`);
+  const entries = value.map((entry, index) => readString3(entry, `${source}[${index}]`));
+  if (new Set(entries).size !== entries.length) throw new Error(`${source}: duplicate value`);
+  return entries;
+}
+function asRecord4(value, source) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+
+// src/domains/eval/schema/serving.ts
+init_esm_shims();
+function parseEvalServingConfigurationV1(value, source) {
+  const record = asRecord5(value, source);
+  const targetId = readString4(record.targetId, `${source}.targetId`);
+  const totalSlots = record.total_slots;
+  if (totalSlots !== null && (typeof totalSlots !== "number" || !Number.isInteger(totalSlots) || totalSlots <= 0)) {
+    throw new Error(`${source}.total_slots: expected positive integer or null`);
+  }
+  const compiledPromptHash = readNullableString4(record.compiledPromptHash, `${source}.compiledPromptHash`);
+  if (compiledPromptHash !== null && !/^[a-f0-9]{64}$/u.test(compiledPromptHash)) {
+    throw new Error(`${source}.compiledPromptHash: expected sha256 digest or null`);
+  }
+  return {
+    targetId,
+    runtimeId: readNullableString4(record.runtimeId, `${source}.runtimeId`),
+    modelId: readNullableString4(record.modelId, `${source}.modelId`),
+    serverBuild: readNullableString4(record.serverBuild, `${source}.serverBuild`),
+    total_slots: totalSlots,
+    thinkingLevel: readNullableString4(record.thinkingLevel, `${source}.thinkingLevel`),
+    compiledPromptHash
+  };
+}
+function sameEvalServingConfiguration(left, right) {
+  return left.targetId === right.targetId && left.runtimeId === right.runtimeId && left.modelId === right.modelId && left.serverBuild === right.serverBuild && left.total_slots === right.total_slots && left.thinkingLevel === right.thinkingLevel && left.compiledPromptHash === right.compiledPromptHash;
+}
+function renderEvalServingConfiguration(config) {
+  return [
+    `target=${config.targetId}`,
+    `runtime=${config.runtimeId ?? "unknown"}`,
+    `model=${config.modelId ?? "unknown"}`,
+    `server_build=${config.serverBuild ?? "unknown"}`,
+    `total_slots=${config.total_slots ?? "unknown"}`,
+    `thinking=${config.thinkingLevel ?? "unknown"}`,
+    `compiled_prompt_hash=${config.compiledPromptHash ?? "unknown"}`
+  ].join(" ");
+}
+function readString4(value, source) {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}: expected string`);
+  return value;
+}
+function readNullableString4(value, source) {
+  if (value === null) return null;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}: expected string or null`);
+  return value;
+}
+function asRecord5(value, source) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+
+// src/domains/eval/artifacts/store.ts
+function evalArtifactPathV4(dataDir, evalId) {
+  assertSafeId(evalId, "eval");
+  return join2(evalRoot(dataDir), `${evalId}.json`);
+}
+async function writeEvalArtifactV4(dataDir, artifact, out) {
+  const path = out === void 0 ? evalArtifactPathV4(dataDir, artifact.evalId) : out.endsWith(".json") ? out : join2(out, `${artifact.evalId}.json`);
+  safeResourceWrite(path, `${JSON.stringify(redactArtifactForStorage(artifact), null, 2)}
+`, { encoding: "utf8" });
+  return path;
+}
+async function loadEvalArtifactV4(dataDir, evalId) {
+  let raw;
+  try {
+    raw = await readFile2(evalArtifactPathV4(dataDir, evalId), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error(`eval artifact not found: ${evalId}`);
+    throw error;
+  }
+  return parseEvalArtifactV4(JSON.parse(raw), evalId);
+}
+function parseEvalArtifactV4(value, source) {
+  if (!isRecord2(value)) throw new Error(`${source}: expected object`);
+  if (value.version !== 4) throw new Error(`${source}.version: expected current version 4`);
+  const summary = asRecord6(value.summary, `${source}.summary`);
+  const matrix = asRecord6(value.matrix, `${source}.matrix`);
+  const suite = asRecord6(value.suite, `${source}.suite`);
+  const servingConfiguration = value.servingConfiguration === void 0 ? void 0 : parseEvalServingConfigurationV1(value.servingConfiguration, `${source}.servingConfiguration`);
+  const aggregates = value.aggregates === void 0 ? void 0 : readArray2(value, source, "aggregates");
+  return {
+    version: 4,
+    evalId: readString5(value, source, "evalId"),
+    suite: { id: readString5(suite, `${source}.suite`, "id"), hash: readString5(suite, `${source}.suite`, "hash") },
+    clio: {
+      version: readString5(asRecord6(value.clio, `${source}.clio`), `${source}.clio`, "version"),
+      commit: readNullableString5(asRecord6(value.clio, `${source}.clio`), `${source}.clio`, "commit"),
+      entry: readString5(asRecord6(value.clio, `${source}.clio`), `${source}.clio`, "entry")
+    },
+    environment: {
+      platform: readString5(asRecord6(value.environment, `${source}.environment`), `${source}.environment`, "platform"),
+      node: readString5(asRecord6(value.environment, `${source}.environment`), `${source}.environment`, "node")
+    },
+    matrix: {
+      target: readString5(matrix, `${source}.matrix`, "target"),
+      model: readNullableString5(matrix, `${source}.matrix`, "model"),
+      thinking: readNullableString5(matrix, `${source}.matrix`, "thinking"),
+      ...matrix.dimensions === void 0 ? {} : { dimensions: parseEvalExecutionMatrixDimensionsV1(matrix.dimensions, `${source}.matrix.dimensions`) }
+    },
+    ...servingConfiguration === void 0 ? {} : { servingConfiguration },
+    summary: {
+      runs: readNumber2(summary, `${source}.summary`, "runs"),
+      passed: readNumber2(summary, `${source}.summary`, "passed"),
+      failed: readNumber2(summary, `${source}.summary`, "failed"),
+      passRate: readNumber2(summary, `${source}.summary`, "passRate"),
+      tokens: parseTokenAccounting(summary.tokens, `${source}.summary.tokens`),
+      wallTimeMs: readNumber2(summary, `${source}.summary`, "wallTimeMs")
+    },
+    ...aggregates === void 0 ? {} : { aggregates },
+    results: readArray2(value, source, "results").map((entry, index) => parseResult(entry, `${source}.results[${index}]`))
+  };
+}
+function parseTokenAccounting(value, source) {
+  const record = asRecord6(value, source);
+  const measured = readBoolean2(record, source, "measured");
+  const runs = readNumber2(record, source, "runs");
+  const measuredRuns = readNumber2(record, source, "measuredRuns");
+  const countFields = ["input", "output", "total", "cacheRead", "cacheWrite"];
+  if (!measured) {
+    if (measuredRuns !== 0) throw new Error(`${source}.measuredRuns: expected 0 when unmeasured`);
+    const present = countFields.filter((field) => field in record);
+    if (present.length > 0) throw new Error(`${source}: unmeasured accounting carries no counts (${present.join(", ")})`);
+    return { measured: false, runs, measuredRuns: 0 };
+  }
+  if (measuredRuns <= 0) throw new Error(`${source}.measuredRuns: expected a positive count when measured`);
+  return {
+    measured: true,
+    runs,
+    measuredRuns,
+    input: readNumber2(record, source, "input"),
+    output: readNumber2(record, source, "output"),
+    total: readNumber2(record, source, "total"),
+    cacheRead: readNumber2(record, source, "cacheRead"),
+    cacheWrite: readNumber2(record, source, "cacheWrite")
+  };
+}
+function parseResult(value, source) {
+  const record = asRecord6(value, source);
+  const target = asRecord6(record.target, `${source}.target`);
+  const verdict = record.verdict === void 0 ? void 0 : parseEvalVerdictEnvelopeV1(record.verdict, `${source}.verdict`);
+  const behavioral = record.behavioral === void 0 ? void 0 : parseEvalBehaviorVerdictV1(record.behavioral, `${source}.behavioral`);
+  const behavioralMetrics = record.behavioralMetrics === void 0 ? void 0 : parseEvalBehaviorMetricsV1(record.behavioralMetrics, `${source}.behavioralMetrics`);
+  const executionEnvelope = record.executionEnvelope === void 0 ? void 0 : parseEvalExecutionEnvelopeV1(record.executionEnvelope, `${source}.executionEnvelope`);
+  if (behavioral !== void 0 && verdict === void 0) {
+    throw new Error(`${source}.behavioral: sibling document requires a verdict`);
+  }
+  if (behavioral !== void 0 && verdict !== void 0) {
+    assertEvalBehaviorReferencesVerdictV1(behavioral, verdict, `${source}.behavioral`);
+  }
+  if (behavioralMetrics !== void 0) {
+    if (behavioral === void 0) throw new Error(`${source}.behavioralMetrics: requires a behavioral verdict`);
+    if (behavioralMetrics.scenarioId !== readString5(record, source, "taskId")) {
+      throw new Error(`${source}.behavioralMetrics.scenarioId: conflicts with result taskId`);
+    }
+    if (behavioralMetrics.target.id !== readString5(target, `${source}.target`, "id") || behavioralMetrics.target.model !== readNullableString5(target, `${source}.target`, "model")) {
+      throw new Error(`${source}.behavioralMetrics.target: conflicts with result target`);
+    }
+  }
+  if (executionEnvelope !== void 0) {
+    if (behavioral === void 0) throw new Error(`${source}.executionEnvelope: requires a behavioral verdict`);
+    if (executionEnvelope.target !== readString5(target, `${source}.target`, "id") || executionEnvelope.corpus.id !== behavioral.corpus.id || executionEnvelope.corpus.version !== behavioral.corpus.version) {
+      throw new Error(`${source}.executionEnvelope: conflicts with result target or behavioral corpus`);
+    }
+  }
+  return {
+    assignmentId: readNullableString5(record, source, "assignmentId"),
+    terminalReceiptDigest: readNullableDigest2(record, source, "terminalReceiptDigest"),
+    taskId: readString5(record, source, "taskId"),
+    repeatIndex: readNumber2(record, source, "repeatIndex"),
+    target: {
+      id: readString5(target, `${source}.target`, "id"),
+      model: readNullableString5(target, `${source}.target`, "model"),
+      thinking: readNullableString5(target, `${source}.target`, "thinking")
+    },
+    pass: readBoolean2(record, source, "pass"),
+    failureClass: readNullableString5(record, source, "failureClass"),
+    metrics: asRecord6(record.metrics, `${source}.metrics`),
+    artifacts: asRecord6(record.artifacts, `${source}.artifacts`),
+    ...verdict === void 0 ? {} : { verdict },
+    ...behavioral === void 0 ? {} : { behavioral },
+    ...behavioralMetrics === void 0 ? {} : { behavioralMetrics },
+    ...executionEnvelope === void 0 ? {} : { executionEnvelope }
+  };
+}
+function asRecord6(value, source) {
+  if (isRecord2(value)) return value;
+  throw new Error(`${source}: expected object`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString5(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string`);
+  return value;
+}
+function readNullableString5(record, source, field) {
+  const value = record[field];
+  if (value === null) return null;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}.${field}: expected string or null`);
+  return value;
+}
+function readNullableDigest2(record, source, field) {
+  const value = readNullableString5(record, source, field);
+  if (value !== null && !/^[0-9a-f]{64}$/u.test(value))
+    throw new Error(`${source}.${field}: expected sha256 digest or null`);
+  return value;
+}
+function readNumber2(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${source}.${field}: expected number`);
+  return value;
+}
+function readBoolean2(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "boolean") throw new Error(`${source}.${field}: expected boolean`);
+  return value;
+}
+function readArray2(record, source, field) {
+  const value = record[field];
+  if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);
+  return value;
+}
+
+// src/domains/evidence/trust-status.ts
+init_esm_shims();
+var TRUST_STATUS_VERSION = 1;
+var TRUST_STATUS_MAX_ARTIFACT_REFERENCES = 16;
+var TRUST_STATUS_MAX_IDENTIFIER_LENGTH = 512;
+var TRUST_STATUS_AXES = [
+  "artifactIntegrity",
+  "validationGrounding",
+  "independentReview",
+  "contextProvenance",
+  "autonomyEnforcement",
+  "completionEvidence"
+];
+var TRUST_STATUS_STATES = {
+  artifactIntegrity: ["verified", "failed", "absent", "unknown", "not_applicable"],
+  validationGrounding: ["validated", "failed", "ungrounded", "absent", "unknown", "not_applicable"],
+  independentReview: ["passed", "failed", "inconclusive", "not_independent", "absent", "unknown", "not_applicable"],
+  contextProvenance: ["recorded", "invalid", "absent", "unknown", "not_applicable"],
+  autonomyEnforcement: ["enforced", "approximated", "bypassed", "absent", "unknown", "not_applicable"],
+  completionEvidence: ["evidenced", "incomplete", "limited", "absent", "unknown", "not_applicable"]
+};
+var SELF_REPORTED_ARTIFACT_KINDS = /* @__PURE__ */ new Set([
+  "finish_contract_evidence",
+  "run_receipt"
+]);
+var AXIS_STATES = {
+  artifactIntegrity: new Set(TRUST_STATUS_STATES.artifactIntegrity),
+  validationGrounding: new Set(TRUST_STATUS_STATES.validationGrounding),
+  independentReview: new Set(TRUST_STATUS_STATES.independentReview),
+  contextProvenance: new Set(TRUST_STATUS_STATES.contextProvenance),
+  autonomyEnforcement: new Set(TRUST_STATUS_STATES.autonomyEnforcement),
+  completionEvidence: new Set(TRUST_STATUS_STATES.completionEvidence)
+};
+var AXIS_SOURCES = {
+  artifactIntegrity: /* @__PURE__ */ new Set(["receipt_integrity_verification", "compatibility"]),
+  validationGrounding: /* @__PURE__ */ new Set(["run_receipt", "evidence_bundle", "compatibility"]),
+  independentReview: /* @__PURE__ */ new Set(["gate_decision", "compatibility"]),
+  contextProvenance: /* @__PURE__ */ new Set(["run_receipt", "evidence_bundle", "compatibility"]),
+  autonomyEnforcement: /* @__PURE__ */ new Set(["run_receipt", "compatibility"]),
+  completionEvidence: /* @__PURE__ */ new Set(["finish_contract", "compatibility"])
+};
+var SOURCE_AUTHORITIES = {
+  receipt_integrity_verification: /* @__PURE__ */ new Set(["clio"]),
+  run_receipt: /* @__PURE__ */ new Set(["clio", "validator", "runtime", "external_system", "unknown"]),
+  gate_decision: /* @__PURE__ */ new Set(["clio", "reviewer", "operator", "unknown"]),
+  evidence_bundle: /* @__PURE__ */ new Set(["clio"]),
+  finish_contract: /* @__PURE__ */ new Set(["clio"]),
+  compatibility: /* @__PURE__ */ new Set(["clio", "unknown"])
+};
+var ABSENCE_REASONS = /* @__PURE__ */ new Set([
+  "not_recorded",
+  "not_observed",
+  "artifact_missing",
+  "historical_format"
+]);
+var SOURCE_KINDS = /* @__PURE__ */ new Set([
+  "receipt_integrity_verification",
+  "run_receipt",
+  "gate_decision",
+  "evidence_bundle",
+  "finish_contract",
+  "compatibility"
+]);
+var AUTHORITY_KINDS = /* @__PURE__ */ new Set([
+  "clio",
+  "validator",
+  "reviewer",
+  "operator",
+  "runtime",
+  "external_system",
+  "unknown"
+]);
+var ARTIFACT_KINDS = /* @__PURE__ */ new Set([
+  "run_receipt",
+  "validation_result",
+  "gate_decision",
+  "briefing",
+  "project_context",
+  "autonomy_policy",
+  "finish_contract_evidence",
+  "evidence_bundle",
+  "session_entry"
+]);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+  const expected = new Set(keys);
+  return Object.keys(value).length === expected.size && Object.keys(value).every((key) => expected.has(key));
+}
+function isTrustStatusIdentifier(value) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > TRUST_STATUS_MAX_IDENTIFIER_LENGTH) {
+    return false;
+  }
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint !== void 0 && (codePoint < 32 || codePoint === 127)) return false;
+  }
+  return true;
+}
+function compareArtifactReferences(left, right) {
+  const leftKey = `${left.kind}\0${left.id}\0${left.digest?.value ?? ""}`;
+  const rightKey = `${right.kind}\0${right.id}\0${right.digest?.value ?? ""}`;
+  return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+}
+function normalizeArtifactReference(value, path) {
+  if (!isRecord3(value)) throw new Error(`${path} must be an object`);
+  if (!hasExactKeys(value, value.digest === void 0 ? ["kind", "id"] : ["kind", "id", "digest"])) {
+    throw new Error(`${path} has unknown or missing fields`);
+  }
+  if (typeof value.kind !== "string" || !ARTIFACT_KINDS.has(value.kind)) {
+    throw new Error(`${path}.kind is invalid`);
+  }
+  if (!isTrustStatusIdentifier(value.id)) throw new Error(`${path}.id is invalid`);
+  const reference = { kind: value.kind, id: value.id };
+  if (value.digest !== void 0) {
+    if (!isRecord3(value.digest) || !hasExactKeys(value.digest, ["algorithm", "value"]) || value.digest.algorithm !== "sha256" || typeof value.digest.value !== "string" || !/^[a-f0-9]{64}$/u.test(value.digest.value)) {
+      throw new Error(`${path}.digest is invalid`);
+    }
+    reference.digest = { algorithm: "sha256", value: value.digest.value };
+  }
+  return reference;
+}
+function normalizeAttributedStatus(axis, value) {
+  if (!hasExactKeys(value, ["state", "source", "authority", "artifacts"])) {
+    throw new Error(`${axis} has unknown or missing fields`);
+  }
+  if (!isRecord3(value.source) || !hasExactKeys(value.source, ["kind", "id"])) {
+    throw new Error(`${axis}.source is invalid`);
+  }
+  if (typeof value.source.kind !== "string" || !SOURCE_KINDS.has(value.source.kind) || !AXIS_SOURCES[axis].has(value.source.kind) || !isTrustStatusIdentifier(value.source.id)) {
+    throw new Error(`${axis}.source is invalid`);
+  }
+  if (!isRecord3(value.authority) || !hasExactKeys(value.authority, ["kind", "id"])) {
+    throw new Error(`${axis}.authority is invalid`);
+  }
+  if (typeof value.authority.kind !== "string" || !AUTHORITY_KINDS.has(value.authority.kind) || !SOURCE_AUTHORITIES[value.source.kind].has(
+    value.authority.kind
+  ) || !isTrustStatusIdentifier(value.authority.id)) {
+    throw new Error(`${axis}.authority is invalid`);
+  }
+  if (value.source.kind === "compatibility" && value.state !== "unknown" && value.state !== "not_applicable") {
+    throw new Error(`${axis} compatibility source cannot establish ${value.state}`);
+  }
+  if (!Array.isArray(value.artifacts) || value.artifacts.length > TRUST_STATUS_MAX_ARTIFACT_REFERENCES) {
+    throw new Error(`${axis}.artifacts exceeds the bounded reference list`);
+  }
+  const artifacts = value.artifacts.map(
+    (entry, index) => normalizeArtifactReference(entry, `${axis}.artifacts[${index}]`)
+  );
+  artifacts.sort(compareArtifactReferences);
+  for (let index = 1; index < artifacts.length; index += 1) {
+    if (compareArtifactReferences(
+      artifacts[index - 1],
+      artifacts[index]
+    ) === 0) {
+      throw new Error(`${axis}.artifacts contains a duplicate reference`);
+    }
+  }
+  return {
+    state: value.state,
+    source: { kind: value.source.kind, id: value.source.id },
+    authority: { kind: value.authority.kind, id: value.authority.id },
+    artifacts
+  };
+}
+function normalizeAxis(axis, value) {
+  if (!isRecord3(value) || typeof value.state !== "string" || !AXIS_STATES[axis].has(value.state)) {
+    throw new Error(`${axis}.state is invalid`);
+  }
+  if (value.state === "absent") {
+    if (!hasExactKeys(value, ["state", "reason"]) || typeof value.reason !== "string" || !ABSENCE_REASONS.has(value.reason)) {
+      throw new Error(`${axis} absent state is invalid`);
+    }
+    return { state: "absent", reason: value.reason };
+  }
+  return normalizeAttributedStatus(axis, value);
+}
+function normalizeTrustStatus(value) {
+  if (!isRecord3(value) || !hasExactKeys(value, ["version", ...TRUST_STATUS_AXES])) {
+    throw new Error("trust status has unknown or missing fields");
+  }
+  if (value.version !== TRUST_STATUS_VERSION) throw new Error("trust status version is invalid");
+  return {
+    version: TRUST_STATUS_VERSION,
+    artifactIntegrity: normalizeAxis("artifactIntegrity", value.artifactIntegrity),
+    validationGrounding: normalizeAxis("validationGrounding", value.validationGrounding),
+    independentReview: normalizeAxis("independentReview", value.independentReview),
+    contextProvenance: normalizeAxis("contextProvenance", value.contextProvenance),
+    autonomyEnforcement: normalizeAxis("autonomyEnforcement", value.autonomyEnforcement),
+    completionEvidence: normalizeAxis("completionEvidence", value.completionEvidence)
+  };
+}
+function absentTrustStatus(reason) {
+  return { state: "absent", reason };
+}
+function composeTrustStatus(...projections) {
+  const axes = {
+    artifactIntegrity: absentTrustStatus("not_recorded"),
+    validationGrounding: absentTrustStatus("not_recorded"),
+    independentReview: absentTrustStatus("not_recorded"),
+    contextProvenance: absentTrustStatus("not_recorded"),
+    autonomyEnforcement: absentTrustStatus("not_recorded"),
+    completionEvidence: absentTrustStatus("not_recorded")
+  };
+  for (const projection of projections) {
+    if (projection.artifactIntegrity !== void 0) axes.artifactIntegrity = projection.artifactIntegrity;
+    if (projection.validationGrounding !== void 0) axes.validationGrounding = projection.validationGrounding;
+    if (projection.independentReview !== void 0) axes.independentReview = projection.independentReview;
+    if (projection.contextProvenance !== void 0) axes.contextProvenance = projection.contextProvenance;
+    if (projection.autonomyEnforcement !== void 0) axes.autonomyEnforcement = projection.autonomyEnforcement;
+    if (projection.completionEvidence !== void 0) axes.completionEvidence = projection.completionEvidence;
+  }
+  return normalizeTrustStatus({ version: TRUST_STATUS_VERSION, ...axes });
+}
+function sha256Reference(kind, id, digest) {
+  const reference = { kind, id };
+  if (digest !== void 0 && /^[a-f0-9]{64}$/u.test(digest)) {
+    reference.digest = { algorithm: "sha256", value: digest };
+  }
+  return reference;
+}
+function receiptReference(receipt) {
+  return sha256Reference("run_receipt", receipt.runId, receipt.integrity?.digest);
+}
+function attributed(state, source, authority, artifacts) {
+  return { state, source, authority, artifacts: [...artifacts].sort(compareArtifactReferences) };
+}
+function receiptSource(receipt) {
+  return { kind: "run_receipt", id: receipt.runId };
+}
+function compatibilitySource(receipt, field) {
+  return { kind: "compatibility", id: `run_receipt:${receipt.runId}:${field}` };
+}
+var DISPATCH_AUTHORITY = { kind: "clio", id: "dispatch" };
+var COMPATIBILITY_AUTHORITY = { kind: "unknown", id: "historical-persisted-format" };
+function retiredReceiptIntegrity(integrity) {
+  if (!isRecord3(integrity)) return null;
+  const version = integrity.version;
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) return null;
+  if (version >= RUN_RECEIPT_INTEGRITY_VERSION) return null;
+  return { receiptVersion: version, supportedVersion: RUN_RECEIPT_INTEGRITY_VERSION };
+}
+function retiredReceiptIntegrityReason(retired) {
+  return `receipt integrity v${retired.receiptVersion} is retired; this build verifies v${retired.supportedVersion}; the receipt is not read as evidence`;
+}
+function verifyReceiptIntegrityOutcome(receipt, envelope) {
+  const retired = retiredReceiptIntegrity(receipt.integrity);
+  if (retired !== null) return { ok: false, reason: retiredReceiptIntegrityReason(retired), retired };
+  return verifyReceiptIntegrity(receipt, envelope);
+}
+var RETIRED_INTEGRITY_SOURCE = /:integrity-v(\d+)-retired$/u;
+function retiredIntegritySourceId(runId, receiptVersion) {
+  return `run_receipt:${runId}:integrity-v${receiptVersion}-retired`;
+}
+function retiredIntegrityVersionOf(status) {
+  if (status.state !== "unknown" || status.source.kind !== "compatibility") return null;
+  const match = RETIRED_INTEGRITY_SOURCE.exec(status.source.id);
+  return match === null ? null : Number(match[1]);
+}
+function adaptReceiptIntegrityStatus(receipt, verification) {
+  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
+  const artifacts = [receiptReference(receipt)];
+  if (verification !== void 0 && !verification.ok && verification.retired !== void 0) {
+    return attributed(
+      "unknown",
+      { kind: "compatibility", id: retiredIntegritySourceId(receipt.runId, verification.retired.receiptVersion) },
+      COMPATIBILITY_AUTHORITY,
+      artifacts
+    );
+  }
+  if (verification === void 0 || verification.ok && receipt.integrity === void 0) {
+    return attributed(
+      "unknown",
+      {
+        kind: "compatibility",
+        id: `run_receipt:${receipt.runId}:${receipt.integrity === void 0 ? "integrity-missing" : "integrity-unchecked"}`
+      },
+      COMPATIBILITY_AUTHORITY,
+      artifacts
+    );
+  }
+  return attributed(
+    verification.ok ? "verified" : "failed",
+    { kind: "receipt_integrity_verification", id: receipt.runId },
+    { kind: "clio", id: "receipt-integrity" },
+    artifacts
+  );
+}
+function validationArtifacts(receipt) {
+  const artifacts = [receiptReference(receipt)];
+  for (const fact of receipt.quality?.typedValidations ?? []) {
+    artifacts.push(sha256Reference("validation_result", fact.sourceId, fact.validatorDigest));
+  }
+  const resultContract = receipt.quality?.resultContract;
+  if (resultContract !== null && resultContract !== void 0) {
+    artifacts.push(sha256Reference("validation_result", resultContract.sourceId, resultContract.validatorDigest));
+  }
+  return uniqueBoundedReferences(artifacts);
+}
+function qualityHasFailure(quality) {
+  if (quality === void 0) return false;
+  if (quality.typedValidations.some((fact) => !fact.passed)) return true;
+  return quality.resultContract?.conformance === "fail" || quality.resultContract?.quality === "fail";
+}
+function qualityHasValidation(quality) {
+  if (quality === void 0) return false;
+  if (quality.typedValidations.some((fact) => fact.passed)) return true;
+  return quality.resultContract?.quality === "pass";
+}
+function verificationStatus(verification, receipt, artifacts) {
+  if (verification.state === "verified") {
+    return attributed("validated", receiptSource(receipt), { kind: "validator", id: verification.basis }, artifacts);
+  }
+  if (verification.state === "unverified") return absentTrustStatus("not_observed");
+  if (verification.state === "not_applicable") {
+    return attributed("not_applicable", receiptSource(receipt), DISPATCH_AUTHORITY, artifacts);
+  }
+  return attributed(
+    "unknown",
+    receiptSource(receipt),
+    verification.basis === "acp-external-unobserved" ? { kind: "external_system", id: "acp-delegation" } : COMPATIBILITY_AUTHORITY,
+    artifacts
+  );
+}
+function adaptRunReceiptValidationStatus(receipt) {
+  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
+  const artifacts = validationArtifacts(receipt);
+  if (receipt.hostVerification?.status === "rejected") {
+    return attributed("failed", receiptSource(receipt), { kind: "validator", id: "host-verification" }, artifacts);
+  }
+  if (receipt.hostVerification?.status === "verified") {
+    return attributed("validated", receiptSource(receipt), { kind: "validator", id: "host-verification" }, artifacts);
+  }
+  if (qualityHasFailure(receipt.quality)) {
+    return attributed("failed", receiptSource(receipt), { kind: "validator", id: "receipt-quality" }, artifacts);
+  }
+  if ((receipt.validationGrounding?.ungrounded.length ?? 0) > 0 || receipt.validationGrounding !== void 0 && receipt.validationGrounding.claimed > receipt.validationGrounding.grounded) {
+    return attributed("ungrounded", receiptSource(receipt), { kind: "validator", id: "command-grounding" }, artifacts);
+  }
+  if (qualityHasValidation(receipt.quality)) {
+    return attributed("validated", receiptSource(receipt), { kind: "validator", id: "receipt-quality" }, artifacts);
+  }
+  if (receipt.verification !== void 0) {
+    return verificationStatus(receipt.verification, receipt, artifacts);
+  }
+  return attributed("unknown", compatibilitySource(receipt, "verification"), COMPATIBILITY_AUTHORITY, artifacts);
+}
+function validBriefing(briefing) {
+  return Number.isSafeInteger(briefing.bytes) && briefing.bytes >= 0 && /^[a-f0-9]{64}$/u.test(briefing.contentHash);
+}
+function validBoundedProjectContext(context) {
+  return context.tier === "bounded" && Number.isSafeInteger(context.chars) && (context.chars ?? -1) >= 0 && typeof context.contentHash === "string" && /^[a-f0-9]{64}$/u.test(context.contentHash);
+}
+var NONE_TIER_SECTIONS = ["workspace-root"];
+function validNoneTierProjectContext(context) {
+  return context.tier === "none" && context.sections !== void 0 && context.sections.length === NONE_TIER_SECTIONS.length && context.sections.every((section) => NONE_TIER_SECTIONS.includes(section)) && Number.isSafeInteger(context.chars) && (context.chars ?? -1) >= 0 && typeof context.contentHash === "string" && /^[a-f0-9]{64}$/u.test(context.contentHash);
+}
+function recordedProjectContextHash(context) {
+  if (context === void 0) return void 0;
+  if (context.tier === "bounded") return validBoundedProjectContext(context) ? context.contentHash : void 0;
+  return validNoneTierProjectContext(context) ? context.contentHash : void 0;
+}
+function contextArtifacts(receipt) {
+  const artifacts = [receiptReference(receipt)];
+  if (receipt.briefing !== void 0 && validBriefing(receipt.briefing)) {
+    artifacts.push(sha256Reference("briefing", `${receipt.runId}:briefing`, receipt.briefing.contentHash));
+  }
+  const recordedHash = recordedProjectContextHash(receipt.projectContext);
+  if (recordedHash !== void 0) {
+    artifacts.push(sha256Reference("project_context", `${receipt.runId}:project-context`, recordedHash));
+  }
+  return uniqueBoundedReferences(artifacts);
+}
+function adaptRunReceiptContextStatus(receipt) {
+  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
+  const artifacts = contextArtifacts(receipt);
+  const source = receiptSource(receipt);
+  const briefingInvalid = receipt.briefing !== void 0 && !validBriefing(receipt.briefing);
+  if (briefingInvalid) return attributed("invalid", source, DISPATCH_AUTHORITY, artifacts);
+  const context = receipt.projectContext;
+  if (context === void 0) {
+    if (receipt.briefing !== void 0) return attributed("recorded", source, DISPATCH_AUTHORITY, artifacts);
+    return attributed("unknown", compatibilitySource(receipt, "projectContext"), COMPATIBILITY_AUTHORITY, artifacts);
+  }
+  if (context.tier === "none") {
+    const bare = context.chars === void 0 && context.contentHash === void 0 && context.sections === void 0;
+    if (bare) {
+      return receipt.briefing === void 0 ? attributed("not_applicable", source, DISPATCH_AUTHORITY, artifacts) : attributed("recorded", source, DISPATCH_AUTHORITY, artifacts);
+    }
+    return attributed(
+      validNoneTierProjectContext(context) ? "recorded" : "invalid",
+      source,
+      DISPATCH_AUTHORITY,
+      artifacts
+    );
+  }
+  return attributed(validBoundedProjectContext(context) ? "recorded" : "invalid", source, DISPATCH_AUTHORITY, artifacts);
+}
+function adaptRunReceiptAutonomyStatus(receipt) {
+  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
+  const enforcement = receipt.autonomyEnforcement;
+  const artifacts = [receiptReference(receipt)];
+  if (enforcement === void 0) {
+    return attributed("unknown", compatibilitySource(receipt, "autonomyEnforcement"), COMPATIBILITY_AUTHORITY, artifacts);
+  }
+  artifacts.push({ kind: "autonomy_policy", id: `${receipt.runId}:${enforcement.autonomy}` });
+  const authority = enforcement.grade === "mediated" ? { kind: "clio", id: "safety-autonomy" } : { kind: "runtime", id: enforcement.externalMode ?? "external-runtime" };
+  const state = enforcement.dangerousBypass === true || enforcement.grade === "bypassed" ? "bypassed" : enforcement.grade === "approximated" ? "approximated" : "enforced";
+  return attributed(state, receiptSource(receipt), authority, artifacts);
+}
+function receiptClaimsAreAuthenticated(receipt, integrity) {
+  return receipt?.integrity !== void 0 && integrity?.ok === true;
+}
+function unauthenticatedReceiptProjection(receipt, integrity) {
+  if (receipt === null || receipt === void 0) {
+    return {
+      validationGrounding: absentTrustStatus("artifact_missing"),
+      contextProvenance: absentTrustStatus("artifact_missing"),
+      autonomyEnforcement: absentTrustStatus("artifact_missing")
+    };
+  }
+  if (receipt.integrity === void 0) {
+    const artifacts = [receiptReference(receipt)];
+    return {
+      validationGrounding: attributed(
+        "unknown",
+        compatibilitySource(receipt, "canonical-projection"),
+        COMPATIBILITY_AUTHORITY,
+        artifacts
+      ),
+      contextProvenance: attributed(
+        "unknown",
+        compatibilitySource(receipt, "canonical-projection"),
+        COMPATIBILITY_AUTHORITY,
+        artifacts
+      ),
+      autonomyEnforcement: attributed(
+        "unknown",
+        compatibilitySource(receipt, "canonical-projection"),
+        COMPATIBILITY_AUTHORITY,
+        artifacts
+      )
+    };
+  }
+  if (integrity !== void 0 && !integrity.ok && integrity.retired !== void 0) {
+    return {
+      validationGrounding: absentTrustStatus("historical_format"),
+      contextProvenance: absentTrustStatus("historical_format"),
+      autonomyEnforcement: absentTrustStatus("historical_format")
+    };
+  }
+  return {
+    validationGrounding: absentTrustStatus("not_observed"),
+    contextProvenance: absentTrustStatus("not_observed"),
+    autonomyEnforcement: absentTrustStatus("not_observed")
+  };
+}
+function adaptRunReceiptTrustStatus(receipt, options = {}) {
+  const authenticated = receiptClaimsAreAuthenticated(receipt, options.integrity);
+  const receiptProjection = authenticated ? {
+    validationGrounding: adaptRunReceiptValidationStatus(receipt),
+    contextProvenance: adaptRunReceiptContextStatus(receipt),
+    autonomyEnforcement: adaptRunReceiptAutonomyStatus(receipt)
+  } : unauthenticatedReceiptProjection(receipt, options.integrity);
+  return composeTrustStatus({
+    artifactIntegrity: adaptReceiptIntegrityStatus(receipt, options.integrity),
+    ...receiptProjection,
+    independentReview: absentTrustStatus(receipt === null || receipt === void 0 ? "artifact_missing" : "not_recorded"),
+    completionEvidence: absentTrustStatus(
+      receipt === null || receipt === void 0 ? "artifact_missing" : "not_recorded"
+    )
+  });
+}
+function inspectRunReceiptTrustStatus(receipt, envelope) {
+  let integrity;
+  if (receipt === null || receipt === void 0) {
+    integrity = { ok: false, reason: "receipt unavailable" };
+  } else if (envelope === null || envelope === void 0) {
+    integrity = { ok: false, reason: "run ledger envelope unavailable" };
+  } else {
+    try {
+      integrity = verifyReceiptIntegrityOutcome(receipt, envelope);
+    } catch (error) {
+      integrity = {
+        ok: false,
+        reason: `receipt invalid: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  return {
+    integrity,
+    status: adaptRunReceiptTrustStatus(receipt, { integrity })
+  };
+}
+function gateReference(artifact) {
+  return sha256Reference("gate_decision", artifact.id, artifact.integrity.digest);
+}
+function gateAuthority(artifact) {
+  if (artifact.outcome === "operator-confirmed") return { kind: "operator", id: "gate-confirmation" };
+  if (artifact.outcome === "full-auto-applied") return { kind: "clio", id: "full-auto-gate-policy" };
+  return { kind: "reviewer", id: artifact.decider?.runId ?? "unavailable-decider" };
+}
+function adaptGateDecisionReviewStatus(artifact, subjectRunId, verification) {
+  if (artifact === null || artifact === void 0) return absentTrustStatus("artifact_missing");
+  const source = { kind: "gate_decision", id: artifact.id };
+  const artifacts = [gateReference(artifact)];
+  const authority = gateAuthority(artifact);
+  if (!artifact.subjects.some((subject) => subject.runId === subjectRunId)) return absentTrustStatus("not_recorded");
+  if (verification === void 0 || !verification.ok) {
+    return attributed(
+      "unknown",
+      source,
+      verification === void 0 ? COMPATIBILITY_AUTHORITY : { kind: "unknown", id: "unauthenticated-gate-artifact" },
+      artifacts
+    );
+  }
+  if (artifact.decider === void 0 || artifact.correlation === void 0) {
+    if (artifact.outcome === "operator-confirmed" || artifact.outcome === "full-auto-applied") {
+      return attributed("not_applicable", source, authority, artifacts);
+    }
+    return attributed("inconclusive", source, authority, artifacts);
+  }
+  if (!artifact.correlation.independent) return attributed("not_independent", source, authority, artifacts);
+  if (artifact.outcome === "pass") return attributed("passed", source, authority, artifacts);
+  if (artifact.outcome === "fail") return attributed("failed", source, authority, artifacts);
+  if (artifact.outcome === "winner") {
+    return attributed(
+      artifact.winner?.subject.runId === subjectRunId ? "passed" : "failed",
+      source,
+      authority,
+      artifacts
+    );
+  }
+  return attributed("inconclusive", source, authority, artifacts);
+}
+function adaptGroundedEvidenceValidationStatus(input) {
+  const observed = (input.artifacts ?? []).filter((artifact) => !SELF_REPORTED_ARTIFACT_KINDS.has(artifact.kind));
+  if (observed.length === 0) return absentTrustStatus("not_observed");
+  return attributed(
+    "validated",
+    { kind: "evidence_bundle", id: `${input.evidenceId}:${input.runId}` },
+    { kind: "clio", id: "evidence-grounding" },
+    uniqueBoundedReferences([{ kind: "evidence_bundle", id: input.evidenceId }, ...observed])
+  );
+}
+function uniqueBoundedReferences(references) {
+  const sorted = [...references].sort(compareArtifactReferences);
+  const unique = sorted.filter(
+    (reference, index) => index === 0 || compareArtifactReferences(sorted[index - 1], reference) !== 0
+  );
+  return unique.slice(0, TRUST_STATUS_MAX_ARTIFACT_REFERENCES);
+}
+
+// src/domains/evidence/trust-projection.ts
+init_esm_shims();
+var TRUST_SUMMARY_VERSION = 1;
+var TRUST_SUMMARY_MAX_REFS = 8;
+var TRUST_STATE_WORDS = {
+  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"
+  }
+};
+function trustStateWord(axis, state) {
+  const words = TRUST_STATE_WORDS[axis];
+  return words[state] ?? words.unknown ?? "unknown";
+}
+function authorityOf(status, axis) {
+  const entry = status[axis];
+  return entry.state === "absent" ? null : `${entry.authority.kind}:${entry.authority.id}`;
+}
+function integrityClause(status) {
+  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);
+}
+function validationClause(status) {
+  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}`;
+  if (entry.state === "unknown" && entry.authority.kind !== "unknown") return `${word} (${entry.authority.id})`;
+  return word;
+}
+function autonomyClause(status) {
+  const entry = status.autonomyEnforcement;
+  const word = trustStateWord("autonomyEnforcement", entry.state);
+  if (entry.state !== "approximated" && entry.state !== "bypassed") return word;
+  return `${word} (${entry.authority.id})`;
+}
+function formatTrustSummary(status) {
+  return [
+    integrityClause(status),
+    validationClause(status),
+    trustStateWord("independentReview", status.independentReview.state),
+    autonomyClause(status),
+    trustStateWord("contextProvenance", status.contextProvenance.state),
+    trustStateWord("completionEvidence", status.completionEvidence.state)
+  ].join("; ");
+}
+function formatTrustSummaryLine(status) {
+  return `trust v${TRUST_SUMMARY_VERSION}: ${trustVerdict(status)}; ${formatTrustSummary(status)}`;
+}
+function formatTrustAxes(status) {
+  return [`trust_status=v${status.version}`, ...TRUST_STATUS_AXES.map((axis) => `${axis}:${status[axis].state}`)].join(
+    " "
+  );
+}
+function isUnanswered(status, axis) {
+  const state = status[axis].state;
+  return state === "absent" || state === "unknown";
+}
+function trustVerdict(status) {
+  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) {
+  const state = status.validationGrounding.state;
+  if (state === "absent" || state === "ungrounded") return "worker";
+  return authorityOf(status, "validationGrounding") ?? "worker";
+}
+function referenceKey(reference) {
+  return `${reference.kind}:${reference.id}`;
+}
+function trustSummaryReferences(status) {
+  const keys = /* @__PURE__ */ new Set();
+  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);
+}
+function summarizeTrustStatus(status) {
+  const axes = Object.fromEntries(TRUST_STATUS_AXES.map((axis) => [axis, status[axis].state]));
+  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)
+  };
+}
+
+// src/domains/eval/provenance.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+function evalClioProvenance(options = {}) {
+  return {
+    version: readClioVersion(),
+    commit: options.commit === void 0 ? currentClioCommit() : options.commit,
+    entry: options.entry ?? process.argv[1] ?? "unknown"
+  };
+}
+function evalEnvironmentProvenance() {
+  return {
+    platform: `${process.platform}-${process.arch}`,
+    node: process.version
+  };
+}
+async function evalServingConfiguration(targets, observations) {
+  const targetId = targets.length === 1 ? targets[0]?.id ?? "unknown" : "multiple";
+  const configured = configuredTarget(targetId);
+  const target = targets.length === 1 ? targets[0] : void 0;
+  const runtimeId = consensus(observations.map((entry) => entry.runtimeId)) ?? configured?.runtime ?? null;
+  const modelId = consensus(observations.map((entry) => entry.modelId)) ?? target?.model ?? configured?.defaultModel ?? null;
+  const props = configured?.url === void 0 ? null : await readServingProps(configured.url, modelId);
+  return {
+    targetId,
+    runtimeId,
+    modelId,
+    serverBuild: props?.serverBuild ?? null,
+    total_slots: props?.totalSlots ?? null,
+    thinkingLevel: consensus(observations.map((entry) => entry.thinkingLevel)) ?? target?.thinking ?? null,
+    compiledPromptHash: consensus(observations.map((entry) => entry.compiledPromptHash))
+  };
+}
+function evalServingObservationFrom(target, receipt, compiledPromptHashes) {
+  const compiledPromptHash = receipt?.staticCompositionHash ?? receipt?.compiledPromptHash ?? consensus(compiledPromptHashes);
+  return {
+    targetId: receipt?.targetId ?? target.id,
+    runtimeId: receipt?.runtimeId ?? null,
+    modelId: receipt?.wireModelId ?? target.model ?? null,
+    thinkingLevel: receipt?.runtimeResolution?.effectiveThinkingLevel ?? target.thinking ?? null,
+    compiledPromptHash
+  };
+}
+function currentClioCommit() {
+  const result = spawnSync("git", ["rev-parse", "HEAD"], {
+    cwd: resolvePackageRoot(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 1e3
+  });
+  if (result.status !== 0 || typeof result.stdout !== "string") return null;
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : null;
+}
+function configuredTarget(targetId) {
+  try {
+    const target = readSettings().targets.find((entry) => entry.id === targetId);
+    if (target === void 0) return null;
+    return {
+      runtime: target.runtime,
+      ...target.url === void 0 ? {} : { url: target.url },
+      ...target.defaultModel === void 0 ? {} : { defaultModel: target.defaultModel }
+    };
+  } catch {
+    return null;
+  }
+}
+async function readServingProps(targetUrl, modelId) {
+  const root = targetUrl.replace(/\/+$/u, "").replace(/\/v1$/u, "");
+  try {
+    const response = await fetch(`${root}/props`, { signal: AbortSignal.timeout(5e3) });
+    if (!response.ok) return null;
+    const value = await response.json();
+    if (!isRecord4(value)) return null;
+    const totalSlots = positiveInteger(value.total_slots) ?? await readServingSlots(root, modelId);
+    return {
+      serverBuild: typeof value.build_info === "string" && value.build_info.length > 0 ? value.build_info : null,
+      totalSlots
+    };
+  } catch {
+    return null;
+  }
+}
+async function readServingSlots(root, modelId) {
+  if (modelId === null) return null;
+  try {
+    const query = new URLSearchParams({ model: modelId });
+    const response = await fetch(`${root}/slots?${query}`, { signal: AbortSignal.timeout(5e3) });
+    if (!response.ok) return null;
+    const value = await response.json();
+    return Array.isArray(value) && value.length > 0 ? value.length : null;
+  } catch {
+    return null;
+  }
+}
+function consensus(values) {
+  const known = [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+  return known.length === 1 ? known[0] ?? null : null;
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/task-file.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+
+// src/domains/eval/types.ts
+init_esm_shims();
+var EVAL_TASK_FILE_VERSION = 1;
+
+// src/domains/eval/task-file.ts
+var TASK_KEYS = /* @__PURE__ */ new Set(["id", "prompt", "cwd", "setup", "verifier", "timeoutMs", "tags"]);
+async function loadEvalTaskFile(path) {
+  const resolved = resolve(path);
+  const raw = await readFile3(resolved, "utf8");
+  const result = parseEvalTaskFileYaml(raw);
+  if (!result.valid) {
+    throw new EvalTaskFileError(result.issues);
+  }
+  const baseDir = dirname(resolved);
+  const cwdIssues = validateTaskCwds(result.taskFile.tasks, baseDir);
+  if (cwdIssues.length > 0) throw new EvalTaskFileError(cwdIssues);
+  return {
+    path: resolved,
+    baseDir,
+    contentHash: sha256Hex(raw),
+    taskFile: result.taskFile
+  };
+}
+function parseEvalTaskFileYaml(raw) {
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { valid: false, issues: [{ path: "$", message: `invalid YAML: ${message}` }] };
+  }
+  return validateEvalTaskFile(parsed);
+}
+function validateEvalTaskFile(value) {
+  const issues = [];
+  if (!isRecord5(value)) {
+    return { valid: false, issues: [{ path: "$", message: "expected object" }] };
+  }
+  if (value.version !== EVAL_TASK_FILE_VERSION) {
+    issues.push({ path: "$.version", message: "expected version 1" });
+  }
+  if (!Array.isArray(value.tasks)) {
+    issues.push({ path: "$.tasks", message: "expected non-empty array" });
+    return { valid: false, issues };
+  }
+  if (value.tasks.length === 0) {
+    issues.push({ path: "$.tasks", message: "expected non-empty array" });
+  }
+  const tasks = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < value.tasks.length; index += 1) {
+    const task = parseTask(value.tasks[index], `$.tasks[${index}]`, issues);
+    if (task === null) continue;
+    if (seenIds.has(task.id)) {
+      issues.push({ path: `$.tasks[${index}].id`, message: `duplicate task id: ${task.id}` });
+    }
+    seenIds.add(task.id);
+    tasks.push(task);
+  }
+  if (issues.length > 0) return { valid: false, issues };
+  return { valid: true, taskFile: { version: 1, tasks } };
+}
+var EvalTaskFileError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`eval task file invalid (${issues.length} ${issues.length === 1 ? "issue" : "issues"})`);
+    this.name = "EvalTaskFileError";
+    this.issues = [...issues];
+  }
+};
+function parseTask(value, path, issues) {
+  if (!isRecord5(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  for (const key of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
+    if (!TASK_KEYS.has(key)) issues.push({ path: `${path}.${key}`, message: "unknown field" });
+  }
+  const id = readNonEmptyString2(value, path, "id", issues);
+  if (id !== null && !/^[A-Za-z0-9._-]+$/.test(id)) {
+    issues.push({ path: `${path}.id`, message: "expected id with letters, numbers, dots, underscores, or hyphens" });
+  }
+  const prompt = readNonEmptyString2(value, path, "prompt", issues);
+  const cwd = readNonEmptyString2(value, path, "cwd", issues);
+  if (cwd !== null && isAbsolute(cwd)) {
+    issues.push({ path: `${path}.cwd`, message: "expected repo-local relative path" });
+  }
+  const setup = readStringArray3(value, path, "setup", issues, true);
+  const verifier = readStringArray3(value, path, "verifier", issues, false);
+  if (verifier !== null && verifier.length === 0) {
+    issues.push({ path: `${path}.verifier`, message: "expected at least one command" });
+  }
+  const timeoutMs = readPositiveInteger(value, path, "timeoutMs", issues);
+  const tags = readStringArray3(value, path, "tags", issues, true);
+  if (id === null || prompt === null || cwd === null || setup === null || verifier === null || timeoutMs === null) {
+    return null;
+  }
+  return { id, prompt, cwd, setup, verifier, timeoutMs, tags: tags ?? [] };
+}
+function validateTaskCwds(tasks, baseDir) {
+  const issues = [];
+  for (let index = 0; index < tasks.length; index += 1) {
+    const task = tasks[index];
+    if (task === void 0) continue;
+    const resolved = resolve(baseDir, task.cwd);
+    const rel = relative(baseDir, resolved);
+    if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel)) continue;
+    issues.push({ path: `$.tasks[${index}].cwd`, message: "cwd must stay within the task file directory" });
+  }
+  return issues;
+}
+function readNonEmptyString2(record, path, field, issues) {
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path: `${path}.${field}`, message: "expected non-empty string" });
+    return null;
+  }
+  return value;
+}
+function readStringArray3(record, path, field, issues, allowMissing) {
+  const value = record[field];
+  if (value === void 0 && allowMissing) return [];
+  if (!Array.isArray(value)) {
+    issues.push({ path: `${path}.${field}`, message: "expected string array" });
+    return null;
+  }
+  const out = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const entry = value[index];
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+      issues.push({ path: `${path}.${field}[${index}]`, message: "expected non-empty string" });
+      continue;
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function readPositiveInteger(record, path, field, issues) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    issues.push({ path: `${path}.${field}`, message: "expected positive integer" });
+    return null;
+  }
+  return value;
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sha256Hex(content) {
+  return createHash4("sha256").update(content, "utf8").digest("hex");
+}
+
+// src/domains/eval/run-compare.ts
+init_esm_shims();
+var EvalTrackedMetricSourceMismatchError = class extends Error {
+  constructor(metric, baseline, candidate) {
+    super(
+      `tracked metric ${metric} cannot compare estimated and measured values (baseline=${baseline.join(",") || "none"}, candidate=${candidate.join(",") || "none"})`
+    );
+    this.name = "EvalTrackedMetricSourceMismatchError";
+  }
+};
+function assertComparableTrackedMetricSources(metric, baseline, candidate) {
+  if (baseline.includes("estimated") === candidate.includes("estimated")) return;
+  throw new EvalTrackedMetricSourceMismatchError(metric, baseline, candidate);
+}
+
+// src/domains/prompts/hash.ts
+init_esm_shims();
+import { createHash as createHash5 } from "node:crypto";
+function sha2563(input) {
+  return createHash5("sha256").update(input, "utf8").digest("hex");
+}
+function canonicalJson2(value) {
+  return serialize(value);
+}
+function serialize(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`canonicalJson: non-finite number ${String(value)} is not representable`);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    throw new Error("canonicalJson: bigint is not representable");
+  }
+  if (typeof value === "symbol" || typeof value === "function") {
+    throw new Error(`canonicalJson: ${typeof value} is not representable`);
+  }
+  if (value === void 0) {
+    throw new Error("canonicalJson: undefined is not representable at root");
+  }
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (let i = 0; i < value.length; i++) {
+      if (!(i in value) || value[i] === void 0) {
+        parts.push("null");
+        continue;
+      }
+      parts.push(serialize(value[i]));
+    }
+    return `[${parts.join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      const child = obj[key];
+      if (child === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${serialize(child)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
+}
+
+export {
+  sha2563 as sha256,
+  canonicalJson2 as canonicalJson,
+  RUN_RECEIPT_INTEGRITY_VERSION,
+  RUN_RECEIPT_INTEGRITY_ALGORITHM,
+  withReceiptIntegrity,
+  isReceiptIntegrity,
+  verifyReceiptIntegrity,
+  EVAL_VERDICT_SCHEMA_V1,
+  EVAL_TRACKED_METRIC_NAMES,
+  parseEvalVerdictEnvelopeV1,
+  parseEvalBehaviorScenarioV1,
+  judgeEvalBehaviorV1,
+  assertEvalBehaviorReferencesVerdictV1,
+  EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1,
+  buildEvalBehaviorMetricsV1,
+  EVAL_EXECUTION_ENVELOPE_SCHEMA_V1,
+  parseEvalExecutionMatrixDimensionsV1,
+  sameEvalServingConfiguration,
+  renderEvalServingConfiguration,
+  redactArtifactForStorage,
+  ZERO_EVAL_HARNESS_METRICS,
+  evalHarnessMetricsFromReceipt,
+  sumEvalHarnessMetrics,
+  createEvalId,
+  writeEvalArtifact,
+  loadEvalArtifact,
+  writeEvalArtifactV4,
+  loadEvalArtifactV4,
+  parseEvalArtifactV4,
+  TRUST_STATUS_AXES,
+  isTrustStatusIdentifier,
+  normalizeTrustStatus,
+  composeTrustStatus,
+  retiredReceiptIntegrity,
+  retiredReceiptIntegrityReason,
+  retiredIntegrityVersionOf,
+  adaptRunReceiptTrustStatus,
+  inspectRunReceiptTrustStatus,
+  adaptGateDecisionReviewStatus,
+  adaptGroundedEvidenceValidationStatus,
+  formatTrustSummary,
+  formatTrustSummaryLine,
+  formatTrustAxes,
+  trustVerdict,
+  summarizeTrustStatus,
+  evalClioProvenance,
+  evalEnvironmentProvenance,
+  evalServingConfiguration,
+  evalServingObservationFrom,
+  assertComparableTrackedMetricSources,
+  loadEvalTaskFile,
+  EvalTaskFileError
+};
+//# sourceMappingURL=chunk-MLOK6ZOS.js.map