harnery 0.30.0 → 0.31.0

package/src/commands/workflow.ts

@@ -2,12 +2,12 @@ import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
-import { resolveBinName, workflowSubscriptionOnly } from "../core/config.ts";
 import {
-  createBuiltinHarnessRegistry,
-  harnessProofInputs,
+  adapterProofInputs,
+  createBuiltinAdapterRegistry,
   probeBinaryVersion,
-} from "../core/harnesses/index.ts";
+} from "../core/adapters/index.ts";
+import { resolveBinName, workflowSubscriptionOnly } from "../core/config.ts";
 import { findCoordRoot } from "../core/hooks/resolve/coord-root.ts";
 import type { PolicyIsolation } from "../core/policy/index.ts";
 import { loadPolicyFile } from "../core/policy/index.ts";
@@ -17,7 +17,7 @@ import type { WorkspaceProvider } from "../core/workflow/index.ts";
 
 /**
  * `workflow run <script>`: execute a workflow script — bounded, schema-gated,
- * conditionally-routed stages fanning out to headless harness-CLI subagents.
+ * conditionally-routed stages fanning out to headless adapter-CLI subagents.
  * The script (deterministic code), not a model, decides routing between
  * stages, and the run terminates when the script returns.
  *
@@ -29,7 +29,7 @@ interface WorkflowRunOpts {
   maxAgents?: string;
   concurrency?: string;
   cwd?: string;
-  harness?: string;
+  adapter?: string;
   resumeFrom?: string;
   subscriptionOnly?: boolean;
   allowApiBilling?: boolean;
@@ -75,33 +75,42 @@ interface WorkflowReclaimOpts extends WorkflowConfirmedMutationOpts {
 }
 
 export function registerWorkflowCommand(program: Command, emit: EmitContext): void {
-  const registry = createBuiltinHarnessRegistry();
-  const harnesses = registry.ids();
+  const registry = createBuiltinAdapterRegistry();
+  const adapters = registry.ids();
   const workflow = program
-    .command("workflow")
-    .description("Run bounded, schema-gated multi-subagent workflow scripts.");
+    .command("run")
+    .description(
+      "Execute one bounded, schema-gated multi-subagent script. Subagents spawn as headless " +
+        "adapter-CLI subprocesses, born coordination-registered.",
+    )
+    // An option has to bind to whichever command name precedes it, so that a
+    // subcommand's own --policy / --json reach the subcommand and not `run`.
+    .enablePositionalOptions();
 
+  // Executing a script is `run`'s default, so `harn run ./wf.js` works with no
+  // second verb. It has to be a real (hidden) subcommand rather than an action
+  // on `run` itself: `run` and several of its subcommands declare the same
+  // option names, and a parent-level declaration swallows the child's copy.
   workflow
-    .command("run <script>")
+    .command("script <script>", { isDefault: true, hidden: true })
     .description(
-      "Execute a workflow script (plain JS: `export default async ({agent, parallel, stage, log, evidence, authorize}) => …`). " +
-        "Subagents spawn as headless harness-CLI subprocesses, coordination-registered.",
+      "Workflow script (plain JS: `export default async ({agent, parallel, stage, log, evidence, authorize}) => …`)",
     )
     .option("--max-agents <n>", "Total-agent ceiling for the run (default 50)")
     .option("--concurrency <n>", "Concurrent-subagent cap (default 4)")
     .option("--cwd <dir>", "Working directory children spawn in (default: coord root)")
     .option(
-      "--harness <name>",
-      `Default harness for agent() calls: ${harnesses.join(" | ")} (default claude-code); scripts can override per agent via opts.harness`,
+      "--adapter <name>",
+      `Default adapter for agent() calls: ${adapters.join(" | ")} (default claude-code); scripts can override per agent via opts.adapter`,
     )
     .option(
       "--resume-from <run-id>",
-      "Reuse completed agent results from a prior run's journal; only changed/failed calls re-run",
+      "Reuse completed agent results from a prior run's transcript; only changed/failed calls re-run",
     )
     .option(
       "--subscription-only",
       "Guarantee subscription billing: scrub API-key vars from child envs; fail loud when a " +
-        "harness has no stored login (repo default via config.jsonc workflow.subscriptionOnly)",
+        "adapter has no stored login (repo default via config.jsonc workflow.subscriptionOnly)",
     )
     .option(
       "--allow-api-billing",
@@ -131,10 +140,10 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
         });
         process.exit(1);
       }
-      if (opts.harness && !registry.get(opts.harness)) {
+      if (opts.adapter && !registry.get(opts.adapter)) {
         emit.error({
-          code: "bad_harness",
-          message: `unknown harness "${opts.harness}" (expected: ${harnesses.join(" | ")})`,
+          code: "bad_adapter",
+          message: `unknown adapter "${opts.adapter}" (expected: ${adapters.join(" | ")})`,
         });
         process.exit(1);
       }
@@ -179,14 +188,14 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
         const report = await runWorkflow(script, {
           coordRoot,
           spawners: registry.spawners(),
-          defaultHarness: opts.harness,
+          defaultAdapter: opts.adapter,
           resumeFrom: opts.resumeFrom,
           subscriptionOnly,
           allowApiBilling: opts.allowApiBilling,
           maxAgents: opts.maxAgents ? Number.parseInt(opts.maxAgents, 10) : undefined,
           concurrency: opts.concurrency ? Number.parseInt(opts.concurrency, 10) : undefined,
           cwd: opts.cwd,
-          ...harnessProofInputs(
+          ...adapterProofInputs(
             registry.list().map((adapter) => adapter.profile),
             { versionProbe: probeBinaryVersion },
           ),
@@ -195,7 +204,7 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
           approvalAddressee: opts.approvalTo,
           isolation: opts.isolation,
           workspace,
-          // CLI harness subprocesses inherit the host network. A policy that
+          // CLI adapter subprocesses inherit the host network. A policy that
           // forbids network must therefore deny dispatch unless a future host
           // adapter creates and declares a network-disabled boundary.
           networkAccess: "enabled",
@@ -207,14 +216,14 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
         }
         const cachedPart = report.agentsCached > 0 ? ` (+${report.agentsCached} cached)` : "";
         const billingPart = report.billing.length
-          ? `billing: ${report.billing.map((b) => `${b.harness}=${b.mode}`).join(", ")}\n`
+          ? `billing: ${report.billing.map((b) => `${b.adapter}=${b.mode}`).join(", ")}\n`
           : "";
         emit.text(
           `run ${report.runId} (${report.name}) finished: ${report.agentsSpawned} agent(s)${cachedPart}, ` +
             `$${report.costUsd.toFixed(4)}, ${Math.round(report.durationMs / 1000)}s\n${billingPart}` +
             `acceptance: ${report.acceptance.satisfied} satisfied, ${report.acceptance.unsatisfied} unsatisfied, ` +
             `${report.acceptance.unknown} unknown\n` +
-            `journal: ${report.journalPath}\n` +
+            `transcript: ${report.transcriptPath}\n` +
             `proof: ${report.proofPath}\n` +
             `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`,
         );
@@ -226,12 +235,12 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
               status: "parked",
               runId: err.runId,
               approvalId: err.approvalId,
-              journalPath: err.journalPath,
+              transcriptPath: err.transcriptPath,
             });
           } else {
             emit.text(
               `run ${err.runId} parked\napproval: ${err.approvalId}\n` +
-                `journal: ${err.journalPath}\n` +
+                `transcript: ${err.transcriptPath}\n` +
                 `resume after resolution: ${resolveBinName()} workflow resume ${err.runId}\n`,
             );
           }
@@ -282,7 +291,7 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
                 writableRoots: [binding.writable_root.configured],
               }
             : undefined,
-          ...harnessProofInputs(
+          ...adapterProofInputs(
             registry.list().map((adapter) => adapter.profile),
             { versionProbe: probeBinaryVersion },
           ),
@@ -298,7 +307,7 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
             `$${report.costUsd.toFixed(4)}, ${Math.round(report.durationMs / 1000)}s\n` +
             `acceptance: ${report.acceptance.satisfied} satisfied, ${report.acceptance.unsatisfied} unsatisfied, ` +
             `${report.acceptance.unknown} unknown\n` +
-            `journal: ${report.journalPath}\nproof: ${report.proofPath}\n` +
+            `transcript: ${report.transcriptPath}\nproof: ${report.proofPath}\n` +
             `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`,
         );
       } catch (err) {
@@ -309,12 +318,12 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
               status: "parked",
               runId: err.runId,
               approvalId: err.approvalId,
-              journalPath: err.journalPath,
+              transcriptPath: err.transcriptPath,
             });
           } else {
             emit.text(
               `run ${err.runId} parked again\napproval: ${err.approvalId}\n` +
-                `journal: ${err.journalPath}\n`,
+                `transcript: ${err.transcriptPath}\n`,
             );
           }
           return;
@@ -668,9 +677,9 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
       }
     });
 
-  const approvals = workflow
-    .command("approvals")
-    .description("Inspect and resolve durable workflow policy approvals.");
+  const approvals = program
+    .command("approval")
+    .description("Inspect and resolve durable run-policy approvals.");
 
   approvals
     .command("list")

package/src/core/{harnesses → adapters}/attest-projection.ts

@@ -21,7 +21,7 @@ import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { SpawnRequest, SpawnResult } from "../workflow/types.ts";
-import type { HarnessAdapter } from "./types.ts";
+import type { Adapter } from "./types.ts";
 
 /** Distinct names so a control artifact can never be mistaken for a treatment
  * one, even if a child writes both or the directory is reused. */
@@ -61,7 +61,7 @@ export interface ProjectionProbeOptions {
  * failing the whole attestation sweep.
  */
 export async function probeFilesystemProjection(
-  adapter: HarnessAdapter,
+  adapter: Adapter,
   opts: ProjectionProbeOptions,
 ): Promise<ProjectionProbeResult> {
   if (!adapter.profile.sandboxProjection) {

package/src/core/{harnesses → adapters}/attest.ts

@@ -1,14 +1,14 @@
 /**
  * The opt-in live probe that produces an attestation (ADR 0038).
  *
- * One bounded turn per harness, through the same `spawn` the workflow engine
+ * One bounded turn per adapter, through the same `spawn` the workflow engine
  * uses, so what gets attested is the path production takes rather than a
  * parallel test rig.
  */
 
 import type { SpawnResult } from "../workflow/types.ts";
 import { probeFilesystemProjection } from "./attest-projection.ts";
-import type { AttestableDimension, HarnessAttestation } from "./attestation.ts";
+import type { AdapterAttestation, AttestableDimension } from "./attestation.ts";
 import {
   ATTESTATION_SCHEMA_VERSION,
   profileDigest,
@@ -16,8 +16,8 @@ import {
   writeAttestation,
 } from "./attestation.ts";
 import { probeBinaryVersion } from "./bench.ts";
-import type { HarnessRegistry } from "./registry.ts";
-import type { CapabilitySupport, HarnessId } from "./types.ts";
+import type { AdapterRegistry } from "./registry.ts";
+import type { AdapterId, CapabilitySupport } from "./types.ts";
 
 /** Fixed and content-free, so nothing user-supplied can reach the record and
  * the turn stays as cheap as a turn can be. */
@@ -46,8 +46,8 @@ function boundedReason(reason: string | undefined): string {
 
 export type AttestationOutcome = "recorded" | "skipped" | "unreachable" | "failed";
 
-export interface HarnessAttestationResult {
-  harness: HarnessId;
+export interface AdapterAttestationResult {
+  adapter: AdapterId;
   outcome: AttestationOutcome;
   binaryVersion?: string;
   observations?: Partial<Record<AttestableDimension, CapabilitySupport>>;
@@ -55,18 +55,18 @@ export interface HarnessAttestationResult {
   note: string;
 }
 
-export interface HarnessAttestationReport {
+export interface AdapterAttestationReport {
   generatedAt: string;
-  harnesses: HarnessId[];
-  results: HarnessAttestationResult[];
+  adapters: AdapterId[];
+  results: AdapterAttestationResult[];
   recorded: number;
-  /** True when at least one selected harness could not be attested, so a
+  /** True when at least one selected adapter could not be attested, so a
    * caller can tell a partial sweep from a complete one. */
   incomplete: boolean;
 }
 
-export interface RunHarnessAttestationOptions {
-  harnesses?: readonly string[];
+export interface RunAdapterAttestationOptions {
+  adapters?: readonly string[];
   timeoutMs?: number;
   cwd?: string;
   coordRoot?: string;
@@ -78,12 +78,12 @@ export interface RunHarnessAttestationOptions {
   /** Test seam and alternate host probe. A null version means unavailable. */
   versionProbe?: (binary: string) => string | null;
   /** Test seam. Defaults to the adapter's production spawner. */
-  spawn?: (harness: HarnessId, prompt: string, timeoutMs: number) => Promise<SpawnResult>;
+  spawn?: (adapter: AdapterId, prompt: string, timeoutMs: number) => Promise<SpawnResult>;
   /** Test seam. Defaults to writing under the coord root. */
-  persist?: (record: HarnessAttestation) => void;
+  persist?: (record: AdapterAttestation) => void;
   /**
    * Also probe `filesystemPolicyProjection` (ADR 0041). Off by default because
-   * it costs two extra turns per capable harness, against one for everything
+   * it costs two extra turns per capable adapter, against one for everything
    * else: the observation needs a control run to be readable at all.
    */
   projection?: boolean;
@@ -92,24 +92,24 @@ export interface RunHarnessAttestationOptions {
   now?: () => Date;
 }
 
-export async function runHarnessAttestation(
-  registry: HarnessRegistry,
-  opts: RunHarnessAttestationOptions = {},
-): Promise<HarnessAttestationReport> {
-  const ids = opts.harnesses?.length ? [...opts.harnesses] : registry.ids();
+export async function runAdapterAttestation(
+  registry: AdapterRegistry,
+  opts: RunAdapterAttestationOptions = {},
+): Promise<AdapterAttestationReport> {
+  const ids = opts.adapters?.length ? [...opts.adapters] : registry.ids();
   const timeoutMs = opts.timeoutMs ?? DEFAULT_ATTESTATION_TIMEOUT_MS;
   const cwd = opts.cwd ?? process.cwd();
   const subscriptionOnly = opts.subscriptionOnly === true;
   const versionProbe = opts.versionProbe ?? probeBinaryVersion;
   const now = opts.now ?? (() => new Date());
-  const results: HarnessAttestationResult[] = [];
+  const results: AdapterAttestationResult[] = [];
 
   for (const id of ids) {
     const adapter = registry.require(id);
     const binaryVersion = versionProbe(adapter.profile.binary);
     if (!binaryVersion) {
       results.push({
-        harness: id,
+        adapter: id,
         outcome: "skipped",
         note: `${adapter.profile.binary} not found on PATH`,
       });
@@ -129,7 +129,7 @@ export async function runHarnessAttestation(
           });
     } catch (error) {
       results.push({
-        harness: id,
+        adapter: id,
         outcome: "failed",
         binaryVersion,
         note: `probe threw: ${boundedReason((error as Error).message)}`,
@@ -141,7 +141,7 @@ export async function runHarnessAttestation(
     // failed turn records nothing at all rather than a page of `unsupported`.
     if (!result.ok) {
       results.push({
-        harness: id,
+        adapter: id,
         outcome: "unreachable",
         binaryVersion,
         durationMs: result.durationMs,
@@ -172,7 +172,7 @@ export async function runHarnessAttestation(
 
     const record = sealAttestation({
       schema_version: ATTESTATION_SCHEMA_VERSION,
-      harness: id,
+      adapter: id,
       binary_version: binaryVersion,
       profile_digest: profileDigest(adapter.profile),
       subscription_only: subscriptionOnly,
@@ -184,7 +184,7 @@ export async function runHarnessAttestation(
     else writeAttestation(record, { coordRoot: opts.coordRoot });
 
     results.push({
-      harness: id,
+      adapter: id,
       outcome: "recorded",
       binaryVersion,
       observations,
@@ -195,7 +195,7 @@ export async function runHarnessAttestation(
 
   return {
     generatedAt: now().toISOString(),
-    harnesses: ids,
+    adapters: ids,
     results,
     recorded: results.filter((row) => row.outcome === "recorded").length,
     incomplete: results.some((row) => row.outcome !== "recorded"),

package/src/core/{harnesses → adapters}/attestation.ts

@@ -23,7 +23,7 @@ import {
 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";
+import type { AdapterId, AdapterProfile, CapabilitySupport } from "./types.ts";
 
 export const ATTESTATION_SCHEMA_VERSION = 2;
 
@@ -40,9 +40,9 @@ export const ATTESTABLE_DIMENSIONS = [
 
 export type AttestableDimension = (typeof ATTESTABLE_DIMENSIONS)[number];
 
-export interface HarnessAttestation {
+export interface AdapterAttestation {
   schema_version: number;
-  harness: HarnessId;
+  adapter: AdapterId;
   /** 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;
@@ -69,12 +69,12 @@ export interface AttestationStoreOptions {
 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");
+  return resolve(root, ".harnery", "adapters", "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 {
+export function profileDigest(profile: AdapterProfile): string {
   return stableDigest({
     id: profile.id,
     binary: profile.binary,
@@ -82,31 +82,31 @@ export function profileDigest(profile: HarnessProfile): string {
   });
 }
 
-function digestOf(record: Omit<HarnessAttestation, "record_digest">): string {
+function digestOf(record: Omit<AdapterAttestation, "record_digest">): string {
   return stableDigest(record);
 }
 
 export function sealAttestation(
-  record: Omit<HarnessAttestation, "record_digest">,
-): HarnessAttestation {
+  record: Omit<AdapterAttestation, "record_digest">,
+): AdapterAttestation {
   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}`);
+function attestationPath(adapter: AdapterId, opts: AttestationStoreOptions): string {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(adapter)) {
+    throw new Error(`unsafe adapter id for an attestation path: ${adapter}`);
   }
-  return resolve(attestationsDir(opts), `${harness}.json`);
+  return resolve(attestationsDir(opts), `${adapter}.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,
+  record: AdapterAttestation,
   opts: AttestationStoreOptions = {},
 ): string {
-  const path = attestationPath(record.harness, opts);
+  const path = attestationPath(record.adapter, opts);
   mkdirSync(attestationsDir(opts), { recursive: true, mode: 0o700 });
   const temporary = `${path}.tmp-${process.pid}`;
   try {
@@ -130,12 +130,12 @@ export function writeAttestation(
  * 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,
+  adapter: AdapterId,
   opts: AttestationStoreOptions = {},
-): HarnessAttestation | null {
+): AdapterAttestation | null {
   let raw: string;
   try {
-    raw = readFileSync(attestationPath(harness, opts), "utf8");
+    raw = readFileSync(attestationPath(adapter, opts), "utf8");
   } catch {
     return null;
   }
@@ -145,17 +145,17 @@ export function readAttestation(
   } catch {
     return null;
   }
-  return validateAttestation(parsed, harness);
+  return validateAttestation(parsed, adapter);
 }
 
 export function validateAttestation(
   value: unknown,
-  harness?: HarnessId,
-): HarnessAttestation | null {
+  adapter?: AdapterId,
+): AdapterAttestation | null {
   if (!value || typeof value !== "object") return null;
-  const record = value as HarnessAttestation;
+  const record = value as AdapterAttestation;
   if (record.schema_version !== ATTESTATION_SCHEMA_VERSION) return null;
-  if (typeof record.harness !== "string" || (harness && record.harness !== harness)) return null;
+  if (typeof record.adapter !== "string" || (adapter && record.adapter !== adapter)) return null;
   if (typeof record.binary_version !== "string" || typeof record.profile_digest !== "string") {
     return null;
   }
@@ -171,39 +171,39 @@ export function validateAttestation(
 /** An attestation speaks only for the vendor version and declaration it was
  * recorded against. */
 export function isAttestationCurrent(
-  record: HarnessAttestation | null,
+  record: AdapterAttestation | null,
   binaryVersion: string | null,
-  profile: HarnessProfile,
+  profile: AdapterProfile,
   subscriptionOnly?: boolean,
-): record is HarnessAttestation {
+): record is AdapterAttestation {
   if (!record || !binaryVersion) return false;
   if (record.binary_version !== binaryVersion) return false;
   if (subscriptionOnly !== undefined && record.subscription_only !== subscriptionOnly) return false;
   return record.profile_digest === profileDigest(profile);
 }
 
-export function listAttestations(opts: AttestationStoreOptions = {}): HarnessAttestation[] {
+export function listAttestations(opts: AttestationStoreOptions = {}): AdapterAttestation[] {
   let names: string[];
   try {
     names = readdirSync(attestationsDir(opts));
   } catch {
     return [];
   }
-  const records: HarnessAttestation[] = [];
+  const records: AdapterAttestation[] = [];
   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));
+  return records.sort((a, b) => a.adapter.localeCompare(b.adapter));
 }
 
-/** Both harness-derived proof inputs, read once, for a workflow run
+/** Both adapter-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
+ * lookups of its own. A adapter with no current attestation simply has no
  * citation; that absence is not a proof unknown. */
-export function harnessProofInputs(
-  profiles: readonly HarnessProfile[],
+export function adapterProofInputs(
+  profiles: readonly AdapterProfile[],
   opts: AttestationStoreOptions & {
     versionProbe: (binary: string) => string | null;
     /** Billing policy this run will use, so a record made under the other mode
@@ -211,24 +211,24 @@ export function harnessProofInputs(
     subscriptionOnly?: boolean;
   },
 ): {
-  harnessEvidence: Record<string, { toolEvidence: HarnessProfile["capabilities"]["toolEvidence"] }>;
-  harnessAttestations: Record<
+  adapterEvidence: Record<string, { toolEvidence: AdapterProfile["capabilities"]["toolEvidence"] }>;
+  adapterAttestations: Record<
     string,
     { binary_version: string; observed_at: string; record_digest: string }
   >;
 } {
-  const harnessEvidence: Record<
+  const adapterEvidence: Record<
     string,
-    { toolEvidence: HarnessProfile["capabilities"]["toolEvidence"] }
+    { toolEvidence: AdapterProfile["capabilities"]["toolEvidence"] }
   > = {};
-  const harnessAttestations: Record<
+  const adapterAttestations: 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;
+    adapterEvidence[profile.id] = { toolEvidence: profile.capabilities.toolEvidence };
+    let record: AdapterAttestation | null = null;
     try {
       record = readAttestation(profile.id, opts);
     } catch {
@@ -245,11 +245,11 @@ export function harnessProofInputs(
     ) {
       continue;
     }
-    harnessAttestations[profile.id] = {
+    adapterAttestations[profile.id] = {
       binary_version: record.binary_version,
       observed_at: record.observed_at,
       record_digest: record.record_digest,
     };
   }
-  return { harnessEvidence, harnessAttestations };
+  return { adapterEvidence, adapterAttestations };
 }