harnery 0.23.0 → 0.25.0

package/src/core/harnesses/attestation.ts

@@ -0,0 +1,231 @@
+/**
+ * Durable record of what an installed vendor CLI was actually observed doing
+ * (ADR 0038).
+ *
+ * The conformance bench proves Harnery's own planner and normalizer against a
+ * committed fixture. That is an adapter check, not a vendor check
+ * (ADR 0037). An attestation is the other half: one bounded live turn, its
+ * observations, and the vendor version they were observed on.
+ *
+ * A record stores structural facts only. No prompt text, no completion text,
+ * no host paths. It lives under the host's coordination directory and is never
+ * published.
+ */
+
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { resolve } from "node:path";
+import { monorepoRoot } from "../agents/coord-client.ts";
+import { stableDigest } from "../workflow/durable-record.ts";
+import type { CapabilitySupport, HarnessId, HarnessProfile } from "./types.ts";
+
+export const ATTESTATION_SCHEMA_VERSION = 1;
+
+/** Dimensions one minimal live turn can honestly establish. Everything else
+ * needs a purpose-built scenario and stays outside the record rather than
+ * being guessed at. */
+export const ATTESTABLE_DIMENSIONS = ["invocation", "finalResult", "sessionId", "cost"] as const;
+
+export type AttestableDimension = (typeof ATTESTABLE_DIMENSIONS)[number];
+
+export interface HarnessAttestation {
+  schema_version: number;
+  harness: HarnessId;
+  /** What the vendor binary reported when this was recorded. Staleness is
+   * keyed on this, so a vendor upgrade invalidates the record automatically. */
+  binary_version: string;
+  /** Digest of the capability declaration at record time, so an edited
+   * declaration also invalidates the record. */
+  profile_digest: string;
+  observed_at: string;
+  /** Only what the probe actually saw. A dimension absent from this map was
+   * not observed, which is not the same as unsupported. */
+  observations: Partial<Record<AttestableDimension, CapabilitySupport>>;
+  /** Over every field above. A hand-edited record fails to load. */
+  record_digest: string;
+}
+
+export interface AttestationStoreOptions {
+  /** Test seam and alternate host. Defaults to the resolved coord root. */
+  coordRoot?: string;
+}
+
+export function attestationsDir(opts: AttestationStoreOptions = {}): string {
+  const root = opts.coordRoot ?? monorepoRoot();
+  if (!root) throw new Error("Not in a coord-aware repo (coord root resolved to null).");
+  return resolve(root, ".harnery", "harnesses", "attestations");
+}
+
+/** Stable identity of a declaration, so editing a claim invalidates the
+ * attestation that was recorded against the old one. */
+export function profileDigest(profile: HarnessProfile): string {
+  return stableDigest({
+    id: profile.id,
+    binary: profile.binary,
+    capabilities: profile.capabilities,
+  });
+}
+
+function digestOf(record: Omit<HarnessAttestation, "record_digest">): string {
+  return stableDigest(record);
+}
+
+export function sealAttestation(
+  record: Omit<HarnessAttestation, "record_digest">,
+): HarnessAttestation {
+  return { ...record, record_digest: digestOf(record) };
+}
+
+function attestationPath(harness: HarnessId, opts: AttestationStoreOptions): string {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(harness)) {
+    throw new Error(`unsafe harness id for an attestation path: ${harness}`);
+  }
+  return resolve(attestationsDir(opts), `${harness}.json`);
+}
+
+/** Replace-in-place write. Unlike a workflow record an attestation is meant to
+ * be re-recorded, so this is a mutable atomic swap rather than an immutable
+ * create. */
+export function writeAttestation(
+  record: HarnessAttestation,
+  opts: AttestationStoreOptions = {},
+): string {
+  const path = attestationPath(record.harness, opts);
+  mkdirSync(attestationsDir(opts), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.tmp-${process.pid}`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+    renameSync(temporary, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+      // The temp file may never have been created; the original error wins.
+    }
+    throw error;
+  }
+  return path;
+}
+
+/** Null for absent, unreadable, malformed, wrong-schema, or tampered records.
+ * A record that fails its own digest is discarded rather than trusted, because
+ * the whole point of the file is that it was not hand-written. */
+export function readAttestation(
+  harness: HarnessId,
+  opts: AttestationStoreOptions = {},
+): HarnessAttestation | null {
+  let raw: string;
+  try {
+    raw = readFileSync(attestationPath(harness, opts), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return validateAttestation(parsed, harness);
+}
+
+export function validateAttestation(
+  value: unknown,
+  harness?: HarnessId,
+): HarnessAttestation | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as HarnessAttestation;
+  if (record.schema_version !== ATTESTATION_SCHEMA_VERSION) return null;
+  if (typeof record.harness !== "string" || (harness && record.harness !== harness)) return null;
+  if (typeof record.binary_version !== "string" || typeof record.profile_digest !== "string") {
+    return null;
+  }
+  if (typeof record.observed_at !== "string" || typeof record.record_digest !== "string")
+    return null;
+  if (!record.observations || typeof record.observations !== "object") return null;
+
+  const { record_digest, ...body } = record;
+  if (digestOf(body) !== record_digest) return null;
+  return record;
+}
+
+/** An attestation speaks only for the vendor version and declaration it was
+ * recorded against. */
+export function isAttestationCurrent(
+  record: HarnessAttestation | null,
+  binaryVersion: string | null,
+  profile: HarnessProfile,
+): record is HarnessAttestation {
+  if (!record || !binaryVersion) return false;
+  if (record.binary_version !== binaryVersion) return false;
+  return record.profile_digest === profileDigest(profile);
+}
+
+export function listAttestations(opts: AttestationStoreOptions = {}): HarnessAttestation[] {
+  let names: string[];
+  try {
+    names = readdirSync(attestationsDir(opts));
+  } catch {
+    return [];
+  }
+  const records: HarnessAttestation[] = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const record = readAttestation(name.slice(0, -".json".length), opts);
+    if (record) records.push(record);
+  }
+  return records.sort((a, b) => a.harness.localeCompare(b.harness));
+}
+
+/** Both harness-derived proof inputs, read once, for a workflow run
+ * (ADR 0038). Callers inject the result so the engine performs no capability
+ * lookups of its own. A harness with no current attestation simply has no
+ * citation; that absence is not a proof unknown. */
+export function harnessProofInputs(
+  profiles: readonly HarnessProfile[],
+  opts: AttestationStoreOptions & {
+    versionProbe: (binary: string) => string | null;
+  },
+): {
+  harnessEvidence: Record<string, { toolEvidence: HarnessProfile["capabilities"]["toolEvidence"] }>;
+  harnessAttestations: Record<
+    string,
+    { binary_version: string; observed_at: string; record_digest: string }
+  >;
+} {
+  const harnessEvidence: Record<
+    string,
+    { toolEvidence: HarnessProfile["capabilities"]["toolEvidence"] }
+  > = {};
+  const harnessAttestations: Record<
+    string,
+    { binary_version: string; observed_at: string; record_digest: string }
+  > = {};
+
+  for (const profile of profiles) {
+    harnessEvidence[profile.id] = { toolEvidence: profile.capabilities.toolEvidence };
+    let record: HarnessAttestation | null = null;
+    try {
+      record = readAttestation(profile.id, opts);
+    } catch {
+      // No coord root or unreadable store: run unattested rather than fail.
+      continue;
+    }
+    if (!isAttestationCurrent(record, opts.versionProbe(profile.binary), profile)) continue;
+    harnessAttestations[profile.id] = {
+      binary_version: record.binary_version,
+      observed_at: record.observed_at,
+      record_digest: record.record_digest,
+    };
+  }
+  return { harnessEvidence, harnessAttestations };
+}

package/src/core/harnesses/bench.ts

@@ -1,6 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { HARNESS_SPECS } from "../hooks/harness/events.ts";
 import type { SpawnRequest, SpawnResult } from "../workflow/types.ts";
+import type { AttestableDimension, HarnessAttestation } from "./attestation.ts";
+import { isAttestationCurrent, readAttestation } from "./attestation.ts";
 import type { HarnessRegistry } from "./registry.ts";
 import type {
   CapabilitySupport,
@@ -19,7 +21,16 @@ export type BenchVerdict =
   | "skipped"
   | "drift";
 
-export type BenchDimension = "registration" | "binary" | HarnessCapabilityDimension;
+export type BenchDimension = "registration" | "binary" | "contract" | HarnessCapabilityDimension;
+
+/** How a result was established (ADR 0037). Orthogonal to the verdict: this
+ * answers "how do we know", not "what is true".
+ *
+ * - `adapter`: checked against Harnery's own planner, normalizer, or fixture.
+ *   Proves the adapter contract, says nothing about the installed vendor CLI.
+ * - `attested`: checked by observing the installed vendor CLI on this host.
+ * - `declared`: not checked. The value is the declaration, repeated. */
+export type BenchBasis = "adapter" | "attested" | "declared";
 
 export interface BenchResult {
   harness: HarnessId;
@@ -27,6 +38,7 @@ export interface BenchResult {
   declared: CapabilitySupport | "not_applicable";
   observed: BenchVerdict;
   verdict: BenchVerdict;
+  basis: BenchBasis;
   note?: string;
 }
 
@@ -36,6 +48,9 @@ export interface HarnessBenchReport {
   harnesses: HarnessId[];
   results: BenchResult[];
   summary: Record<BenchVerdict, number>;
+  /** Result counts per basis, so a caller can tell a clean report from an
+   * unmeasured one without walking every result. */
+  basisSummary: Record<BenchBasis, number>;
   drift: boolean;
   skipped: boolean;
 }
@@ -45,6 +60,11 @@ export interface HarnessBenchOptions {
   dimensions?: readonly HarnessCapabilityDimension[];
   /** Test seam and alternate host probe. A null version means unavailable. */
   versionProbe?: (binary: string) => string | null;
+  /** Where to look for live attestations (ADR 0038). Defaults to the coord
+   * root. Reading them never runs a model turn. */
+  coordRoot?: string;
+  /** Test seam. Defaults to reading the attestation store. */
+  attestationReader?: (harness: HarnessId) => HarnessAttestation | null;
 }
 
 const EMPTY_SUMMARY: Record<BenchVerdict, number> = {
@@ -57,6 +77,42 @@ const EMPTY_SUMMARY: Record<BenchVerdict, number> = {
   drift: 0,
 };
 
+const EMPTY_BASIS_SUMMARY: Record<BenchBasis, number> = {
+  adapter: 0,
+  attested: 0,
+  declared: 0,
+};
+
+/** A stored attestation only counts when it still matches the installed
+ * version and the current declaration. A stale one is ignored rather than
+ * trusted, so an upgraded vendor CLI silently drops back to adapter basis. */
+function loadAttestation(
+  id: HarnessId,
+  version: string | null,
+  adapter: HarnessAdapter,
+  opts: HarnessBenchOptions,
+): HarnessAttestation | null {
+  let record: HarnessAttestation | null = null;
+  try {
+    record = opts.attestationReader
+      ? opts.attestationReader(id)
+      : readAttestation(id, { coordRoot: opts.coordRoot });
+  } catch {
+    // No coord root, unreadable store: the bench still runs, just unattested.
+    return null;
+  }
+  return isAttestationCurrent(record, version, adapter.profile) ? record : null;
+}
+
+/** First version-shaped token in a string, or null when there is none.
+ * Tolerates the vendor prefixes and suffixes real CLIs print, so
+ * `codex-cli 0.144.5` and `2.1.197 (Claude Code)` both reduce to a token. */
+function versionToken(value: string | null | undefined): string | null {
+  if (!value) return null;
+  const match = value.match(/\d+(?:\.\d+)+(?:[-.][0-9a-z]+)*/i);
+  return match ? match[0].toLowerCase() : null;
+}
+
 export function runHarnessBench(
   registry: HarnessRegistry,
   opts: HarnessBenchOptions = {},
@@ -65,7 +121,7 @@ export function runHarnessBench(
   const dimensions = opts.dimensions?.length
     ? [...new Set(opts.dimensions)]
     : [...HARNESS_CAPABILITY_DIMENSIONS];
-  const versionProbe = opts.versionProbe ?? probeVersion;
+  const versionProbe = opts.versionProbe ?? probeBinaryVersion;
   const results: BenchResult[] = [];
 
   for (const id of ids) {
@@ -76,6 +132,7 @@ export function runHarnessBench(
       declared: "supported",
       observed: "supported",
       verdict: "supported",
+      basis: "adapter",
       note: `${adapter.profile.integrationMode}; ${adapter.profile.authModel}`,
     });
 
@@ -86,38 +143,125 @@ export function runHarnessBench(
       declared: "supported",
       observed: version ? "supported" : "skipped",
       verdict: version ? "supported" : "skipped",
+      // A skip establishes nothing about the vendor, so it is not an attestation.
+      basis: version ? "attested" : "declared",
       note: version ?? `${adapter.profile.binary} not found on PATH`,
     });
 
+    results.push(contractResult(id, adapter, version));
+
     const observations = observeAdapter(adapter);
+    const attestation = loadAttestation(id, version, adapter, opts);
     for (const dimension of dimensions) {
       const claim = adapter.profile.capabilities[dimension];
-      const observed = observations[dimension];
+      const live = attestation?.observations[dimension as AttestableDimension];
+      // A live observation of the installed CLI outranks a fixture check of
+      // Harnery's own normalizer. Everything else keeps its adapter basis.
+      const { observed, basis }: DimensionObservation = live
+        ? { observed: live, basis: "attested" }
+        : observations[dimension];
       results.push({
         harness: id,
         dimension,
         declared: claim.support,
         observed,
         verdict: reconcile(claim.support, observed),
-        note: claim.note,
+        basis,
+        note: live ? `attested on ${attestation?.binary_version}` : claim.note,
       });
     }
   }
 
   const summary = { ...EMPTY_SUMMARY };
-  for (const result of results) summary[result.verdict]++;
+  const basisSummary = { ...EMPTY_BASIS_SUMMARY };
+  for (const result of results) {
+    summary[result.verdict]++;
+    basisSummary[result.basis]++;
+  }
   return {
     generatedAt: new Date().toISOString(),
     mode: "offline",
     harnesses: ids,
     results,
     summary,
+    basisSummary,
     drift: summary.drift > 0,
     skipped: summary.skipped > 0,
   };
 }
 
-function observeAdapter(adapter: HarnessAdapter): Record<HarnessCapabilityDimension, BenchVerdict> {
+/** Compare the vendor contract a declaration was validated against with the
+ * one actually installed (ADR 0037). This is the only dimension attested
+ * without a model turn, because a version string costs nothing to read.
+ *
+ * A mismatch is `drift`, not failure: a newer vendor CLI is not automatically
+ * broken, but the declaration is no longer backed by an observation. An
+ * unrecorded or unparseable declared version stays `unknown` rather than being
+ * inferred from the installed one. */
+function contractResult(
+  id: HarnessId,
+  adapter: HarnessAdapter,
+  version: string | null,
+): BenchResult {
+  const recorded = adapter.profile.verified;
+  const base = { harness: id, dimension: "contract" as const, declared: "supported" as const };
+
+  if (!version) {
+    return {
+      ...base,
+      observed: "skipped",
+      verdict: "skipped",
+      basis: "declared",
+      note: `${adapter.profile.binary} not found on PATH; installed contract unobservable`,
+    };
+  }
+  const declaredToken = versionToken(recorded?.version);
+  if (!declaredToken) {
+    return {
+      ...base,
+      observed: "unknown",
+      verdict: "unknown",
+      basis: "declared",
+      note: recorded
+        ? `verified.version "${recorded.version}" is not a version; installed ${version}`
+        : `no verified vendor contract recorded; installed ${version}`,
+    };
+  }
+  const installedToken = versionToken(version) ?? version.trim().toLowerCase();
+  if (installedToken === declaredToken) {
+    return {
+      ...base,
+      observed: "supported",
+      verdict: "supported",
+      basis: "attested",
+      note: `declaration validated against ${recorded?.version} on ${recorded?.date}`,
+    };
+  }
+  return {
+    ...base,
+    observed: "drift",
+    verdict: "drift",
+    basis: "attested",
+    note: `declaration validated against ${recorded?.version} (${recorded?.date}); installed ${version}`,
+  };
+}
+
+interface DimensionObservation {
+  observed: BenchVerdict;
+  basis: BenchBasis;
+}
+
+/** Checked against Harnery's planner, normalizer, or fixture. */
+function fromAdapter(observed: BenchVerdict): DimensionObservation {
+  return { observed, basis: "adapter" };
+}
+
+/** No check exists for this dimension yet. */
+const NOT_CHECKED: DimensionObservation = { observed: "unknown", basis: "declared" };
+
+function observeAdapter(
+  adapter: HarnessAdapter,
+): Record<HarnessCapabilityDimension, DimensionObservation> {
   const profile = adapter.profile;
   const effort = profile.effortValues[0];
   const request: SpawnRequest = {
@@ -154,49 +298,57 @@ function observeAdapter(adapter: HarnessAdapter): Record<HarnessCapabilityDimens
   const hookSubcommands = new Set(hookSpec?.events.map((event) => event.subcommand) ?? []);
 
   return {
-    invocation:
+    invocation: fromAdapter(
       !planningFailed && argv[0] === profile.binary && argv.includes(request.prompt)
         ? "supported"
         : "unsupported",
-    modelSelection:
+    ),
+    modelSelection: fromAdapter(
       !planningFailed && argv.includes(request.model ?? "") ? "supported" : "unsupported",
-    effortSelection:
+    ),
+    effortSelection: fromAdapter(
       effort === undefined
         ? "unsupported"
         : !planningFailed && argv.some((arg) => arg.includes(effort))
           ? "supported"
           : "unsupported",
-    maxTurns:
+    ),
+    maxTurns: fromAdapter(
       !planningFailed && argv.includes(String(request.maxTurns)) ? "supported" : "unsupported",
-    finalResult: finalMatches ? "supported" : "unsupported",
-    sessionId:
+    ),
+    finalResult: fromAdapter(finalMatches ? "supported" : "unsupported"),
+    sessionId: fromAdapter(
       sessionObserved === "supported" && normalized?.sessionId !== fixture.sessionId
         ? "unsupported"
         : sessionObserved,
-    cost:
+    ),
+    cost: fromAdapter(
       costObserved === "supported" && normalized?.costUsd !== fixture.costUsd
         ? "unsupported"
         : costObserved,
-    toolEvidence: normalized && "toolEvidence" in normalized ? "supported" : "unsupported",
-    policyMapping: "unknown",
-    interruption: "unknown",
-    streaming: "unknown",
-    steering: "unknown",
-    resume: "unknown",
-    images: "unknown",
-    contextTelemetry: "unknown",
+    ),
+    toolEvidence: fromAdapter(
+      normalized && "toolEvidence" in normalized ? "supported" : "unsupported",
+    ),
+    policyMapping: NOT_CHECKED,
+    interruption: NOT_CHECKED,
+    streaming: NOT_CHECKED,
+    steering: NOT_CHECKED,
+    resume: NOT_CHECKED,
+    images: NOT_CHECKED,
+    contextTelemetry: NOT_CHECKED,
     preCompactionSignal: hookSpec
-      ? hookSubcommands.has("pre-compact")
-        ? "supported"
-        : "unsupported"
-      : "unknown",
+      ? fromAdapter(hookSubcommands.has("pre-compact") ? "supported" : "unsupported")
+      : NOT_CHECKED,
     postCompactionSignal: hookSpec
-      ? hookSubcommands.has("post-compact") ||
-        (adapter.profile.id === "claude-code" && hookSubcommands.has("session-start"))
-        ? "supported"
-        : "unsupported"
-      : "unknown",
-    compaction: "unknown",
+      ? fromAdapter(
+          hookSubcommands.has("post-compact") ||
+            (adapter.profile.id === "claude-code" && hookSubcommands.has("session-start"))
+            ? "supported"
+            : "unsupported",
+        )
+      : NOT_CHECKED,
+    compaction: NOT_CHECKED,
   };
 }
 
@@ -207,7 +359,10 @@ function reconcile(declared: CapabilitySupport, observed: BenchVerdict): BenchVe
   return declared === observed ? observed : "drift";
 }
 
-function probeVersion(binary: string): string | null {
+/** Ask an installed vendor CLI what version it is. Null when it is absent or
+ * refuses to answer. Shared with the live attestation probe so both halves of
+ * the capability story key on the same string. */
+export function probeBinaryVersion(binary: string): string | null {
   const result = spawnSync(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
   if (result.error || result.status !== 0) return null;
   return (result.stdout || result.stderr).trim().split("\n")[0] || "installed";

package/src/core/harnesses/index.ts

@@ -1,12 +1,37 @@
 export type { Spawner, SpawnRequest, SpawnResult } from "../workflow/types.ts";
 export type {
+  AttestationOutcome,
+  HarnessAttestationReport,
+  HarnessAttestationResult,
+  RunHarnessAttestationOptions,
+} from "./attest.ts";
+export { ATTESTATION_PROMPT, runHarnessAttestation } from "./attest.ts";
+export type {
+  AttestableDimension,
+  AttestationStoreOptions,
+  HarnessAttestation,
+} from "./attestation.ts";
+export {
+  ATTESTABLE_DIMENSIONS,
+  ATTESTATION_SCHEMA_VERSION,
+  attestationsDir,
+  harnessProofInputs,
+  isAttestationCurrent,
+  listAttestations,
+  profileDigest,
+  readAttestation,
+  validateAttestation,
+  writeAttestation,
+} from "./attestation.ts";
+export type {
+  BenchBasis,
   BenchDimension,
   BenchResult,
   BenchVerdict,
   HarnessBenchOptions,
   HarnessBenchReport,
 } from "./bench.ts";
-export { runHarnessBench } from "./bench.ts";
+export { probeBinaryVersion, runHarnessBench } from "./bench.ts";
 export type { BuiltinHarnessId } from "./profiles.ts";
 export {
   BUILTIN_HARNESS_IDS,

package/src/core/workflow/engine.ts

@@ -316,6 +316,7 @@ async function executeWorkflow(
         agents: [],
         evidence: [],
         harnessEvidence: opts.harnessEvidence,
+        harnessAttestations: opts.harnessAttestations,
         policy: policy
           ? {
               config: policy,
@@ -1054,6 +1055,7 @@ async function executeWorkflow(
         agents: Array.from(agentProofs.values()),
         evidence: evidenceRecords,
         harnessEvidence: opts.harnessEvidence,
+        harnessAttestations: opts.harnessAttestations,
         policy: policy
           ? {
               config: policy,
@@ -1133,6 +1135,7 @@ async function executeWorkflow(
         agents: Array.from(agentProofs.values()),
         evidence: evidenceRecords,
         harnessEvidence: opts.harnessEvidence,
+        harnessAttestations: opts.harnessAttestations,
         policy: policy
           ? {
               config: policy,

package/src/core/workflow/index.ts

@@ -149,6 +149,7 @@ export {
   cleanupWorkspace,
   createLocalGitWorktreeProvider,
   deriveWorkspaceLifecycle,
+  IntegrationPrepareParkedError,
   inspectWorkflowWorkspace,
   isWorkspaceLifecycleState,
   listWorkflowWorkspaceInspections,

package/src/core/workflow/proof.ts

@@ -16,6 +16,7 @@ import type {
   AcceptanceCriterion,
   AcceptanceResult,
   AcceptanceSummary,
+  HarnessAttestationCitation,
   HarnessEvidenceCapability,
   HarnessEvidenceCoverage,
   ResultDigest,
@@ -81,6 +82,9 @@ export interface BuildWorkflowProofInput {
   agents: WorkflowAgentProof[];
   evidence: WorkflowEvidenceRecord[];
   harnessEvidence?: Readonly<Record<string, HarnessEvidenceCapability | undefined>>;
+  /** Live attestations backing each harness's claims (ADR 0038). Injected by
+   * the caller so proof stays free of filesystem lookups. */
+  harnessAttestations?: Readonly<Record<string, HarnessAttestationCitation | undefined>>;
   policy?: {
     config: Readonly<NormalizedPolicy>;
     decisions: readonly PolicyDecision[];
@@ -222,7 +226,7 @@ export function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProo
     session_id: clippedOptional(agent.session_id, MAX_REF_CHARS),
     error: clippedOptional(agent.error, MAX_SUMMARY_CHARS),
   }));
-  const harnesses = buildHarnessCoverage(agents, input.harnessEvidence);
+  const harnesses = buildHarnessCoverage(agents, input.harnessEvidence, input.harnessAttestations);
   const unknowns = buildUnknowns(agents, harnesses, repository);
   const journal = readFileSync(input.journalPath);
   return {
@@ -455,6 +459,7 @@ function normalizeRepoSnapshot(snapshot: RepoSnapshot): WorkflowRepoSnapshot {
 function buildHarnessCoverage(
   agents: WorkflowAgentProof[],
   claims: Readonly<Record<string, HarnessEvidenceCapability | undefined>> | undefined,
+  attestations: Readonly<Record<string, HarnessAttestationCitation | undefined>> | undefined,
 ): HarnessEvidenceCoverage[] {
   return [...new Set(agents.map((agent) => agent.harness))].map((harness) => {
     const harnessAgents = agents.filter((agent) => agent.harness === harness);
@@ -469,6 +474,7 @@ function buildHarnessCoverage(
         session_ids: harnessAgents.filter((agent) => agent.session_id).length,
         costs: harnessAgents.filter((agent) => agent.cost_usd !== undefined).length,
       },
+      ...(attestations?.[harness] ? { attestation: attestations[harness] } : {}),
     };
   });
 }