@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-IWT4SF4R.js → chunk-6CDNRHWH.js}

@@ -3,34 +3,200 @@ import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent
-} from "./chunk-EKCHAPYA.js";
+} from "./chunk-K2HL3GBL.js";
 import {
   isExecutionRole
-} from "./chunk-H7IXIC72.js";
+} from "./chunk-LY4N4TTL.js";
 import {
   readSettings
-} from "./chunk-GHS5EBTQ.js";
+} from "./chunk-FKIOX6DS.js";
 import {
   readClioVersion,
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
-// src/domains/dispatch/receipt-integrity.ts
+// src/domains/context/codewiki/digest.ts
+init_esm_shims();
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function topTwoSegments(path2) {
+  const parts = path2.split("/").slice(0, -1);
+  if (parts.length === 0) return ".";
+  return parts.slice(0, 2).join("/");
+}
+function sourceFiles(codewiki) {
+  return codewiki.files.filter((file) => file.lang !== "config").sort((a, b) => a.path.localeCompare(b.path));
+}
+function countBy(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) counts.set(item, (counts.get(item) ?? 0) + 1);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+function entryPoints(codewiki, limit) {
+  const files = sourceFiles(codewiki);
+  const tagged = files.filter((file) => file.role === "entry");
+  if (tagged.length >= limit) return tagged.slice(0, limit);
+  const fileById = new Map(files.map((file) => [file.id, file]));
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    if ("toFileId" in edge) inDegree.set(edge.toFileId, (inDegree.get(edge.toFileId) ?? 0) + 1);
+  }
+  const taggedIds = new Set(tagged.map((file) => file.id));
+  const ranked = [...inDegree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([id]) => fileById.get(id)).filter((file) => file !== void 0 && !taggedIds.has(file.id));
+  return [...tagged, ...ranked].slice(0, limit);
+}
+function keySymbols(codewiki, limit) {
+  const rank = /* @__PURE__ */ new Map([
+    ["class", 0],
+    ["trait", 1],
+    ["iface", 2],
+    ["type", 3],
+    ["func", 4],
+    ["method", 5],
+    ["const", 6],
+    ["var", 7]
+  ]);
+  return [...codewiki.symbols].sort((a, b) => {
+    const rankCmp = (rank.get(a.kind) ?? 99) - (rank.get(b.kind) ?? 99);
+    return rankCmp || a.name.localeCompare(b.name) || a.fileId.localeCompare(b.fileId) || a.line - b.line;
+  }).slice(0, limit);
+}
+function dependencyLines(codewiki, limit) {
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    const deps = byFile.get(edge.fileId) ?? { internal: [], external: [] };
+    if ("toFileId" in edge) {
+      const target = fileById.get(edge.toFileId);
+      if (target) deps.internal.push(target.path);
+    } else {
+      deps.external.push(edge.externalModule);
+    }
+    byFile.set(edge.fileId, deps);
+  }
+  return [...byFile.entries()].map(([fileId, deps]) => {
+    const file = fileById.get(fileId);
+    if (!file) return "";
+    const internal = [...new Set(deps.internal)].sort(compareStrings).slice(0, 4);
+    const external = [...new Set(deps.external)].sort(compareStrings).slice(0, 4);
+    return `- ${file.path}: internal=[${internal.join(", ")}] external=[${external.join(", ")}]`;
+  }).filter((line) => line.length > 0).sort(compareStrings).slice(0, limit);
+}
+function fitLines(lines, tokenBudget) {
+  const maxChars = Math.max(256, Math.floor(tokenBudget * 4));
+  const out = [];
+  let used = 0;
+  for (const line of lines) {
+    const next = used + line.length + 1;
+    if (next > maxChars) {
+      out.push("[digest truncated]");
+      break;
+    }
+    out.push(line);
+    used = next;
+  }
+  return out.join("\n");
+}
+function entryPointLine(file) {
+  const base = `- ${file.path} (${file.lang}, ${file.loc} loc)`;
+  return file.summary ? `${base}: ${file.summary.slice(0, 160)}` : base;
+}
+function renderCodewikiDigest(codewiki, tokenBudget = 1200) {
+  const files = sourceFiles(codewiki);
+  const areaCounts = countBy(files.map((file) => topTwoSegments(file.path))).slice(0, 10).map(([area, count]) => `${area}=${count}`);
+  const languageCounts = countBy(files.map((file) => file.lang)).map(([language, count]) => `${language}=${count}`).join(", ");
+  const roleCounts = countBy(files.map((file) => file.role)).map(([role, count]) => `${role}=${count}`).join(", ");
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const lines = [
+    `codewiki v${codewiki.version} language=${codewiki.language} files=${files.length} configs=${codewiki.files.length - files.length} symbols=${codewiki.symbols.length} edges=${codewiki.edges.length}`,
+    `languages: ${languageCounts || "none"}`,
+    `roles: ${roleCounts || "none"}`,
+    `areas: ${areaCounts.join(", ") || "none"}`,
+    "entry points:",
+    ...entryPoints(codewiki, 12).map(entryPointLine),
+    "key symbols:",
+    ...keySymbols(codewiki, 40).map((symbol) => {
+      const file = fileById.get(symbol.fileId);
+      const location = file ? `${file.path}:${symbol.line}` : `${symbol.fileId}:${symbol.line}`;
+      return `- ${symbol.name} ${symbol.kind} ${location}`;
+    }),
+    "dependencies:",
+    ...dependencyLines(codewiki, 24)
+  ];
+  return fitLines(lines, tokenBudget);
+}
+
+// src/domains/prompts/hash.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 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}`);
+}
+
+// src/domains/dispatch/receipt-integrity.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+var RUN_RECEIPT_INTEGRITY_VERSION = 20;
+var RUN_RECEIPT_INTEGRITY_ALGORITHM = "sha256";
+function sha2562(input) {
+  return createHash2("sha256").update(input, "utf8").digest("hex");
+}
+function canonicalJson2(value) {
   return serializeCanonical(value);
 }
 function serializeCanonical(value) {
@@ -101,6 +267,9 @@ var RECEIPT_INTEGRITY_FIELD_COVERAGE = {
   plan: true,
   fleetGate: true,
   personaOverride: true,
+  // Absent unless the parent board held decisions, so older receipts and
+  // decision-free runs digest exactly as before.
+  decisionRefs: true,
   projectContext: true,
   // Always set on receipts written after #104 landed; absent only on older
   // receipts, which omit these fields from canonical serialization.
@@ -188,6 +357,7 @@ function ledgerDigestFields(envelope) {
     executionRole: envelope.executionRole,
     task: envelope.task,
     ...envelope.budget !== void 0 ? { budget: envelope.budget } : {},
+    ...envelope.decisionRefs !== void 0 ? { decisionRefs: envelope.decisionRefs } : {},
     targetId: envelope.targetId,
     wireModelId: envelope.wireModelId,
     runtimeId: envelope.runtimeId,
@@ -240,7 +410,7 @@ function computeReceiptIntegrity(receipt, envelope, legacyNaming = false) {
   return {
     version: RUN_RECEIPT_INTEGRITY_VERSION,
     algorithm: RUN_RECEIPT_INTEGRITY_ALGORITHM,
-    digest: sha256(canonicalJson(integrityPayload(receipt, envelope, legacyNaming)))
+    digest: sha2562(canonicalJson2(integrityPayload(receipt, envelope, legacyNaming)))
   };
 }
 function isReceiptQuality(value) {
@@ -315,9 +485,9 @@ function firstLedgerMismatch(receipt, envelope) {
   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";
+  if (canonicalJson2(receipt.briefing ?? null) !== canonicalJson2(envelope.briefing ?? null)) return "briefing";
+  if (canonicalJson2(receipt.budget ?? null) !== canonicalJson2(envelope.budget ?? null)) return "budget";
+  if (canonicalJson2(receipt.steering ?? null) !== canonicalJson2(envelope.steering ?? null)) return "steering";
   return null;
 }
 function verifyReceiptIntegrity(receipt, envelope) {
@@ -448,19 +618,19 @@ function compareArtifactReferences(left, right) {
   const rightKey = `${right.kind}\0${right.id}\0${right.digest?.value ?? ""}`;
   return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
 }
-function normalizeArtifactReference(value, path) {
-  if (!isRecord(value)) throw new Error(`${path} must be an object`);
+function normalizeArtifactReference(value, path2) {
+  if (!isRecord(value)) throw new Error(`${path2} 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`);
+    throw new Error(`${path2} has unknown or missing fields`);
   }
   if (typeof value.kind !== "string" || !ARTIFACT_KINDS.has(value.kind)) {
-    throw new Error(`${path}.kind is invalid`);
+    throw new Error(`${path2}.kind is invalid`);
   }
-  if (!isTrustStatusIdentifier(value.id)) throw new Error(`${path}.id is invalid`);
+  if (!isTrustStatusIdentifier(value.id)) throw new Error(`${path2}.id is invalid`);
   const reference = { kind: value.kind, id: value.id };
   if (value.digest !== void 0) {
     if (!isRecord(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`);
+      throw new Error(`${path2}.digest is invalid`);
     }
     reference.digest = { algorithm: "sha256", value: value.digest.value };
   }
@@ -536,6 +706,13 @@ function normalizeTrustStatus(value) {
     completionEvidence: normalizeAxis("completionEvidence", value.completionEvidence)
   };
 }
+function validateTrustStatus(value) {
+  try {
+    return { ok: true, status: normalizeTrustStatus(value) };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
 function absentTrustStatus(reason) {
   return { state: "absent", reason };
 }
@@ -558,6 +735,18 @@ function composeTrustStatus(...projections) {
   }
   return normalizeTrustStatus({ version: TRUST_STATUS_VERSION, ...axes });
 }
+function projectTrustStatus(status, axes) {
+  const normalized = normalizeTrustStatus(status);
+  const projection = {};
+  const requested = new Set(axes);
+  if (requested.has("artifactIntegrity")) projection.artifactIntegrity = normalized.artifactIntegrity;
+  if (requested.has("validationGrounding")) projection.validationGrounding = normalized.validationGrounding;
+  if (requested.has("independentReview")) projection.independentReview = normalized.independentReview;
+  if (requested.has("contextProvenance")) projection.contextProvenance = normalized.contextProvenance;
+  if (requested.has("autonomyEnforcement")) projection.autonomyEnforcement = normalized.autonomyEnforcement;
+  if (requested.has("completionEvidence")) projection.completionEvidence = normalized.completionEvidence;
+  return projection;
+}
 function sha256Reference(kind, id, digest) {
   const reference = { kind, id };
   if (digest !== void 0 && /^[a-f0-9]{64}$/u.test(digest)) {
@@ -892,6 +1081,20 @@ function adaptGroundedEvidenceValidationStatus(input) {
     uniqueBoundedReferences([{ kind: "evidence_bundle", id: input.evidenceId }, ...observed])
   );
 }
+function adaptFinishContractCompletionStatus(assessment, options = {}) {
+  const artifacts = uniqueBoundedReferences(
+    options.artifacts ?? assessment.evidence.map((evidence, index) => ({
+      kind: evidence.turnId === void 0 ? "finish_contract_evidence" : "session_entry",
+      id: evidence.turnId ?? `${evidence.kind}:${index + 1}`
+    }))
+  );
+  const source = { kind: "finish_contract", id: options.sourceId ?? assessment.reason };
+  const authority = { kind: "clio", id: "finish-contract" };
+  if (assessment.reason === "no_mutation") return attributed("not_applicable", source, authority, artifacts);
+  if (assessment.reason === "validation_evidence") return attributed("evidenced", source, authority, artifacts);
+  if (assessment.reason === "explicit_limitation") return attributed("limited", source, authority, artifacts);
+  return attributed("incomplete", source, authority, artifacts);
+}
 function uniqueBoundedReferences(references) {
   const sorted = [...references].sort(compareArtifactReferences);
   const unique = sorted.filter(
@@ -904,6 +1107,13 @@ function uniqueBoundedReferences(references) {
 init_esm_shims();
 var TRUST_SUMMARY_VERSION = 1;
 var TRUST_SUMMARY_MAX_REFS = 8;
+var TRUST_VERDICTS = [
+  "reviewed",
+  "grounded",
+  "unverified",
+  "compromised",
+  "unknown"
+];
 var TRUST_STATE_WORDS = {
   artifactIntegrity: {
     verified: "sealed",
@@ -1154,7 +1364,7 @@ function isRecord2(value) {
 // src/domains/eval/task-file.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 
@@ -1164,8 +1374,8 @@ 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);
+async function loadEvalTaskFile(path2) {
+  const resolved = resolve(path2);
   const raw = await readFile(resolved, "utf8");
   const result = parseEvalTaskFileYaml(raw);
   if (!result.valid) {
@@ -1228,30 +1438,30 @@ var EvalTaskFileError = class extends Error {
     this.issues = [...issues];
   }
 };
-function parseTask(value, path, issues) {
+function parseTask(value, path2, issues) {
   if (!isRecord3(value)) {
-    issues.push({ path, message: "expected object" });
+    issues.push({ path: path2, 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" });
+    if (!TASK_KEYS.has(key)) issues.push({ path: `${path2}.${key}`, message: "unknown field" });
   }
-  const id = readNonEmptyString(value, path, "id", issues);
+  const id = readNonEmptyString(value, path2, "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" });
+    issues.push({ path: `${path2}.id`, message: "expected id with letters, numbers, dots, underscores, or hyphens" });
   }
-  const prompt = readNonEmptyString(value, path, "prompt", issues);
-  const cwd = readNonEmptyString(value, path, "cwd", issues);
+  const prompt = readNonEmptyString(value, path2, "prompt", issues);
+  const cwd = readNonEmptyString(value, path2, "cwd", issues);
   if (cwd !== null && isAbsolute(cwd)) {
-    issues.push({ path: `${path}.cwd`, message: "expected repo-local relative path" });
+    issues.push({ path: `${path2}.cwd`, message: "expected repo-local relative path" });
   }
-  const setup = readStringArray(value, path, "setup", issues, true);
-  const verifier = readStringArray(value, path, "verifier", issues, false);
+  const setup = readStringArray(value, path2, "setup", issues, true);
+  const verifier = readStringArray(value, path2, "verifier", issues, false);
   if (verifier !== null && verifier.length === 0) {
-    issues.push({ path: `${path}.verifier`, message: "expected at least one command" });
+    issues.push({ path: `${path2}.verifier`, message: "expected at least one command" });
   }
-  const timeoutMs = readPositiveInteger(value, path, "timeoutMs", issues);
-  const tags = readStringArray(value, path, "tags", issues, true);
+  const timeoutMs = readPositiveInteger(value, path2, "timeoutMs", issues);
+  const tags = readStringArray(value, path2, "tags", issues, true);
   if (id === null || prompt === null || cwd === null || setup === null || verifier === null || timeoutMs === null) {
     return null;
   }
@@ -1269,36 +1479,36 @@ function validateTaskCwds(tasks, baseDir) {
   }
   return issues;
 }
-function readNonEmptyString(record, path, field, issues) {
+function readNonEmptyString(record, path2, field, issues) {
   const value = record[field];
   if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push({ path: `${path}.${field}`, message: "expected non-empty string" });
+    issues.push({ path: `${path2}.${field}`, message: "expected non-empty string" });
     return null;
   }
   return value;
 }
-function readStringArray(record, path, field, issues, allowMissing) {
+function readStringArray(record, path2, 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" });
+    issues.push({ path: `${path2}.${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" });
+      issues.push({ path: `${path2}.${field}[${index}]`, message: "expected non-empty string" });
       continue;
     }
     out.push(entry);
   }
   return out;
 }
-function readPositiveInteger(record, path, field, issues) {
+function readPositiveInteger(record, path2, field, issues) {
   const value = record[field];
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    issues.push({ path: `${path}.${field}`, message: "expected positive integer" });
+    issues.push({ path: `${path2}.${field}`, message: "expected positive integer" });
     return null;
   }
   return value;
@@ -1307,7 +1517,7 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sha256Hex(content) {
-  return createHash2("sha256").update(content, "utf8").digest("hex");
+  return createHash3("sha256").update(content, "utf8").digest("hex");
 }
 
 // src/domains/eval/run-compare.ts
@@ -1325,84 +1535,145 @@ function assertComparableTrackedMetricSources(metric, baseline, candidate) {
   throw new EvalTrackedMetricSourceMismatchError(metric, baseline, candidate);
 }
 
-// src/domains/prompts/hash.ts
+// src/domains/prompts/fragment-loader.ts
 init_esm_shims();
-import { createHash as createHash3 } from "node:crypto";
-function sha2562(input) {
-  return createHash3("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`);
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+var frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var fragmentIdRegex = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+function defaultRootDir() {
+  return path.join(resolvePackageRoot(), "src", "domains", "prompts", "fragments");
+}
+function walk(root) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walk(full));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(full);
     }
-    return JSON.stringify(value);
   }
-  if (typeof value === "string" || typeof value === "boolean") {
-    return JSON.stringify(value);
+  return out.sort((left, right) => left.localeCompare(right));
+}
+function parseFragment(filePath, rootDir) {
+  const raw = readFileSync(filePath, "utf8");
+  const rawRel = path.relative(rootDir, filePath);
+  const relPath = rawRel.split(path.sep).join("/");
+  const match = raw.match(frontmatterRegex);
+  if (!match) {
+    throw new Error(`fragment-loader: ${relPath}: missing or malformed YAML frontmatter`);
   }
-  if (typeof value === "bigint") {
-    throw new Error("canonicalJson: bigint is not representable");
+  const frontmatterText = match[1] ?? "";
+  const body = match[2] ?? "";
+  let parsed;
+  try {
+    parsed = import_yaml2.default.parse(frontmatterText);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`fragment-loader: ${relPath}: invalid YAML frontmatter (${reason})`);
   }
-  if (typeof value === "symbol" || typeof value === "function") {
-    throw new Error(`canonicalJson: ${typeof value} is not representable`);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter must be a YAML object`);
   }
-  if (value === void 0) {
-    throw new Error("canonicalJson: undefined is not representable at root");
+  const fm = parsed;
+  const id = fm.id;
+  if (typeof id !== "string" || !fragmentIdRegex.test(id)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.id must be a dot-separated namespace`);
   }
-  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(",")}]`;
+  const version = fm.version;
+  if (version !== 1) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.version must be 1`);
   }
-  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)}`);
+  const description = fm.description;
+  if (typeof description !== "string" || description.trim() === "") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.description must be a non-empty string`);
+  }
+  const dynamicRaw = fm.dynamic;
+  if (dynamicRaw !== void 0 && typeof dynamicRaw !== "boolean") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.dynamic must be a boolean when present`);
+  }
+  return {
+    path: filePath,
+    relPath,
+    id,
+    version,
+    description,
+    dynamic: dynamicRaw === true,
+    body,
+    contentHash: sha256(raw)
+  };
+}
+function loadFragments(options) {
+  const rootDir = typeof options === "string" ? options : options?.rootDir;
+  const resolvedRoot = rootDir ? path.resolve(rootDir) : defaultRootDir();
+  const files = walk(resolvedRoot);
+  const byId = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const fragment = parseFragment(file, resolvedRoot);
+    const existing = byId.get(fragment.id);
+    if (existing) {
+      throw new Error(
+        `fragment-loader: duplicate fragment id "${fragment.id}" in ${existing.relPath} and ${fragment.relPath}`
+      );
     }
-    return `{${parts.join(",")}}`;
+    byId.set(fragment.id, fragment);
   }
-  throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
+  return { byId, rootDir: resolvedRoot };
 }
 
 export {
-  sha2562 as sha256,
-  canonicalJson2 as canonicalJson,
+  renderCodewikiDigest,
+  sha256,
+  canonicalJson,
   RUN_RECEIPT_INTEGRITY_VERSION,
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   withReceiptIntegrity,
   isReceiptIntegrity,
   verifyReceiptIntegrity,
+  TRUST_STATUS_VERSION,
+  TRUST_STATUS_MAX_ARTIFACT_REFERENCES,
+  TRUST_STATUS_MAX_IDENTIFIER_LENGTH,
   TRUST_STATUS_AXES,
+  TRUST_STATUS_STATES,
   isTrustStatusIdentifier,
   normalizeTrustStatus,
+  validateTrustStatus,
+  absentTrustStatus,
   composeTrustStatus,
+  projectTrustStatus,
   retiredReceiptIntegrity,
   retiredReceiptIntegrityReason,
+  verifyReceiptIntegrityOutcome,
   retiredIntegrityVersionOf,
+  adaptReceiptIntegrityStatus,
+  adaptRunReceiptValidationStatus,
+  adaptRunReceiptContextStatus,
+  adaptRunReceiptAutonomyStatus,
   adaptRunReceiptTrustStatus,
   inspectRunReceiptTrustStatus,
   adaptGateDecisionReviewStatus,
   adaptGroundedEvidenceValidationStatus,
+  adaptFinishContractCompletionStatus,
+  TRUST_SUMMARY_VERSION,
+  TRUST_SUMMARY_MAX_REFS,
+  TRUST_VERDICTS,
+  TRUST_STATE_WORDS,
   trustStateWord,
   formatTrustSummary,
   formatTrustSummaryLine,
   formatTrustAxes,
   trustVerdict,
+  trustSummaryReferences,
   summarizeTrustStatus,
   evalClioProvenance,
   evalEnvironmentProvenance,
@@ -1410,6 +1681,7 @@ export {
   evalServingObservationFrom,
   assertComparableTrackedMetricSources,
   loadEvalTaskFile,
-  EvalTaskFileError
+  EvalTaskFileError,
+  loadFragments
 };
-//# sourceMappingURL=chunk-IWT4SF4R.js.map
+//# sourceMappingURL=chunk-6CDNRHWH.js.map

package/dist/{chunk-EBY63B7G.js → chunk-6EXUUOSN.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/timers.ts
 init_esm_shims();
@@ -23,4 +23,4 @@ export {
   sleep,
   rawDurationMs
 };
-//# sourceMappingURL=chunk-EBY63B7G.js.map
+//# sourceMappingURL=chunk-6EXUUOSN.js.map