harnery 0.24.0 → 0.26.0

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,14 @@ 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;
+  /** Only cite attestations recorded under this billing mode. Omitted means
+   * any mode is acceptable for reporting purposes. */
+  subscriptionOnly?: boolean;
 }
 
 const EMPTY_SUMMARY: Record<BenchVerdict, number> = {
@@ -57,6 +80,44 @@ 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, opts.subscriptionOnly)
+    ? 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 +126,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 +137,7 @@ export function runHarnessBench(
       declared: "supported",
       observed: "supported",
       verdict: "supported",
+      basis: "adapter",
       note: `${adapter.profile.integrationMode}; ${adapter.profile.authModel}`,
     });
 
@@ -86,38 +148,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 +303,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 +364,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/harnesses/profiles.ts

@@ -43,7 +43,7 @@ export const BUILTIN_HARNESS_PROFILES = {
     authModel: "own-auth",
     modelFamily: "claude",
     effortValues: ["low", "medium", "high", "xhigh", "max"],
-    verified: { date: "2026-07-20", version: "current CLI contract" },
+    verified: { date: "2026-07-25", version: "2.1.197 (Claude Code)" },
     capabilities: capabilities({
       effortSelection: supported("Mapped to `--effort <level>`."),
       maxTurns: supported("Mapped to `--max-turns <n>`."),
@@ -69,7 +69,7 @@ export const BUILTIN_HARNESS_PROFILES = {
     authModel: "own-auth",
     modelFamily: "gpt",
     effortValues: ["none", "minimal", "low", "medium", "high", "xhigh"],
-    verified: { date: "2026-07-21", version: "codex-cli 0.145.0-alpha.18" },
+    verified: { date: "2026-07-25", version: "codex-cli 0.144.5" },
     capabilities: capabilities({
       effortSelection: supported('Mapped to `-c model_reasoning_effort="<level>"`.'),
       maxTurns: unsupported("codex exec exposes no turn-ceiling flag."),
@@ -95,7 +95,7 @@ export const BUILTIN_HARNESS_PROFILES = {
     authModel: "own-auth",
     modelFamily: "multi",
     effortValues: [],
-    verified: { date: "2026-07-21", version: "2026.07.16-899851b" },
+    verified: { date: "2026-07-25", version: "2026.07.23-e383d2b" },
     capabilities: capabilities({
       effortSelection: unsupported(
         "Cursor embeds effort in some parameterized model ids; Harnery does not rewrite model 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/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] } : {}),
     };
   });
 }

package/src/core/workflow/spawn-claude.ts

@@ -23,6 +23,7 @@ import { validateHarnessEffort } from "../harnesses/profiles.ts";
 import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.ts";
 import { buildChildEnv } from "./child-env.ts";
 import { notFoundError } from "./harnesses.ts";
+import { vendorFailureText } from "./spawn-failure.ts";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.ts";
 
 interface ClaudeEnvelope {
@@ -65,7 +66,7 @@ export function normalizeClaudeResult(raw: HarnessRawResult): SpawnResult {
       ok: false,
       text: "",
       durationMs: raw.durationMs,
-      error: `claude exited ${raw.exitCode}: ${(raw.stderr || raw.stdout).slice(0, 500)}`,
+      error: `claude exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
     };
   }
 

package/src/core/workflow/spawn-codex.ts

@@ -24,6 +24,7 @@ import { validateHarnessEffort } from "../harnesses/profiles.ts";
 import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.ts";
 import { buildChildEnv } from "./child-env.ts";
 import { notFoundError } from "./harnesses.ts";
+import { vendorFailureText } from "./spawn-failure.ts";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.ts";
 
 export function buildCodexInvocation(req: SpawnRequest, resultFile?: string): HarnessInvocation {
@@ -53,7 +54,7 @@ export function normalizeCodexResult(raw: HarnessRawResult): SpawnResult {
       ok: false,
       text: "",
       durationMs: raw.durationMs,
-      error: `codex exited ${raw.exitCode}: ${(raw.stderr || raw.stdout).slice(0, 500)}`,
+      error: `codex exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
     };
   }
   return {

package/src/core/workflow/spawn-cursor.ts

@@ -24,6 +24,7 @@ import { validateHarnessEffort } from "../harnesses/profiles.ts";
 import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.ts";
 import { buildChildEnv } from "./child-env.ts";
 import { notFoundError } from "./harnesses.ts";
+import { vendorFailureText } from "./spawn-failure.ts";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.ts";
 
 interface CursorEnvelope {
@@ -72,7 +73,7 @@ export function normalizeCursorResult(raw: HarnessRawResult): SpawnResult {
       ok: false,
       text: "",
       durationMs: raw.durationMs,
-      error: `cursor-agent exited ${raw.exitCode}: ${(raw.stderr || raw.stdout).slice(0, 500)}`,
+      error: `cursor-agent exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
     };
   }
 

package/src/core/workflow/spawn-failure.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared failure-text extraction for the harness spawn adapters.
+ *
+ * A vendor CLI prints its banner, resolved config, and startup warnings first,
+ * and the reason it actually failed last. Every adapter used to keep the FIRST
+ * 500 characters of the transcript, which reliably preserved the banner and
+ * discarded the answer: a child that died with "your workspace is out of
+ * credits" reported a cosmetic startup warning instead.
+ *
+ * Two rules follow. Keep the tail. Include both streams, because which one
+ * carries the reason varies by vendor and by failure.
+ */
+
+const DEFAULT_MAX_CHARS = 500;
+
+/** Bounded failure text from a finished child, tail-preserving. */
+export function vendorFailureText(
+  raw: { stdout?: string; stderr?: string },
+  maxChars = DEFAULT_MAX_CHARS,
+): string {
+  const parts = [raw.stderr, raw.stdout]
+    .map((part) => part?.trim())
+    .filter((part): part is string => !!part);
+  if (parts.length === 0) return "";
+  // Both streams, stderr first, so a reason on the unexpected stream survives.
+  const combined = parts.join("\n");
+  return combined.length > maxChars ? `…${combined.slice(-maxChars)}` : combined;
+}

package/src/core/workflow/types.ts

@@ -126,6 +126,14 @@ export interface WorkflowRepoEvidence {
   };
 }
 
+/** Bounded pointer to the live attestation backing a harness's claims
+ * (ADR 0038). Structural facts only: no prompt text, no host paths. */
+export interface HarnessAttestationCitation {
+  binary_version: string;
+  observed_at: string;
+  record_digest: string;
+}
+
 export interface HarnessEvidenceCoverage {
   harness: HarnessName;
   tool_evidence: {
@@ -137,6 +145,10 @@ export interface HarnessEvidenceCoverage {
     session_ids: number;
     costs: number;
   };
+  /** What backs this harness's capability claims (ADR 0038). Absent when the
+   * host recorded no live attestation, which is the common case and is not by
+   * itself a proof unknown. */
+  attestation?: HarnessAttestationCitation;
 }
 
 export interface WorkflowProofUnknown {
@@ -429,6 +441,9 @@ export interface EngineOpts {
   /** Capability claims used to state whether adapter-native tool evidence was
    * available. Missing claims remain unknown. */
   harnessEvidence?: Readonly<Record<HarnessName, HarnessEvidenceCapability | undefined>>;
+  /** Live attestations backing each harness's claims (ADR 0038). Read once by
+   * the host and injected, so the engine performs no capability lookups. */
+  harnessAttestations?: Readonly<Record<HarnessName, HarnessAttestationCitation | undefined>>;
   /** Immutable host policy. Workflow scripts and model prompts cannot replace it. */
   policy?: PolicySpec | NormalizedPolicy;
   /** Host callback for ASK. Missing, invalid, throwing, or timed-out resolution denies. */