harnery 0.30.0 → 0.31.0

package/dist/commands/workflow.js

@@ -1,27 +1,34 @@
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { adapterProofInputs, createBuiltinAdapterRegistry, probeBinaryVersion, } from "../core/adapters/index.js";
 import { resolveBinName, workflowSubscriptionOnly } from "../core/config.js";
-import { createBuiltinHarnessRegistry, harnessProofInputs, probeBinaryVersion, } from "../core/harnesses/index.js";
 import { findCoordRoot } from "../core/hooks/resolve/coord-root.js";
 import { loadPolicyFile } from "../core/policy/index.js";
 import { WorkflowParkedError } from "../core/workflow/engine.js";
 export function registerWorkflowCommand(program, emit) {
-    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>")
-        .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.")
+        .command("script <script>", { isDefault: true, hidden: true })
+        .description("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`)
-        .option("--resume-from <run-id>", "Reuse completed agent results from a prior run's journal; only changed/failed calls re-run")
+        .option("--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 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", "Permit an exported API key to override a stored subscription login (per-token billing); " +
         "without this the engine refuses that silent-override state")
         .option("--policy <file>", "Host policy JSON/JSONC applied before dispatch and external mutation")
@@ -38,10 +45,10 @@ export function registerWorkflowCommand(program, emit) {
             });
             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);
         }
@@ -81,20 +88,20 @@ export function registerWorkflowCommand(program, emit) {
             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(registry.list().map((adapter) => adapter.profile), { versionProbe: probeBinaryVersion }),
+                ...adapterProofInputs(registry.list().map((adapter) => adapter.profile), { versionProbe: probeBinaryVersion }),
                 policy: opts.policy ? loadPolicyFile(opts.policy) : undefined,
                 approvalMode: "park",
                 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",
@@ -106,13 +113,13 @@ export function registerWorkflowCommand(program, emit) {
             }
             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`);
         }
@@ -124,12 +131,12 @@ export function registerWorkflowCommand(program, emit) {
                         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`);
                 }
                 return;
@@ -174,7 +181,7 @@ export function registerWorkflowCommand(program, emit) {
                         writableRoots: [binding.writable_root.configured],
                     }
                     : undefined,
-                ...harnessProofInputs(registry.list().map((adapter) => adapter.profile), { versionProbe: probeBinaryVersion }),
+                ...adapterProofInputs(registry.list().map((adapter) => adapter.profile), { versionProbe: probeBinaryVersion }),
             });
             if (opts.json) {
                 emit.config({ format: "json" });
@@ -186,7 +193,7 @@ export function registerWorkflowCommand(program, emit) {
                 `$${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) {
@@ -197,12 +204,12 @@ export function registerWorkflowCommand(program, emit) {
                         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;
             }
@@ -523,9 +530,9 @@ export function registerWorkflowCommand(program, emit) {
             process.exit(1);
         }
     });
-    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")
         .description("List durable workflow approvals.")

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

@@ -17,7 +17,7 @@
  * rule the main attestation applies to a failed turn.
  */
 import type { SpawnRequest, SpawnResult } from "../workflow/types.js";
-import type { HarnessAdapter } from "./types.js";
+import type { Adapter } from "./types.js";
 export declare function projectionPrompt(sentinel: string): string;
 export type ProjectionObservation = "supported" | "unsupported" | "inconclusive";
 export interface ProjectionProbeResult {
@@ -40,5 +40,5 @@ export interface ProjectionProbeOptions {
  * probe that cannot reach a verdict degrades into "nothing recorded" instead of
  * failing the whole attestation sweep.
  */
-export declare function probeFilesystemProjection(adapter: HarnessAdapter, opts: ProjectionProbeOptions): Promise<ProjectionProbeResult>;
+export declare function probeFilesystemProjection(adapter: Adapter, opts: ProjectionProbeOptions): Promise<ProjectionProbeResult>;
 //# sourceMappingURL=attest-projection.d.ts.map

package/dist/core/adapters/attest-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attest-projection.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/attest-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAW1C,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,CAAC;AAEjF,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,qBAAqB,CAAC;IACnC,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,+DAA+D;IAC/D,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACxD,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,qBAAqB,CAAC,CAoDhC"}

package/dist/core/{harnesses → adapters}/attest.d.ts

@@ -1,39 +1,39 @@
 /**
  * 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.js";
 import { probeFilesystemProjection } from "./attest-projection.js";
-import type { AttestableDimension, HarnessAttestation } from "./attestation.js";
-import type { HarnessRegistry } from "./registry.js";
-import type { CapabilitySupport, HarnessId } from "./types.js";
+import type { AdapterAttestation, AttestableDimension } from "./attestation.js";
+import type { AdapterRegistry } from "./registry.js";
+import type { AdapterId, CapabilitySupport } from "./types.js";
 /** Fixed and content-free, so nothing user-supplied can reach the record and
  * the turn stays as cheap as a turn can be. */
 export declare const ATTESTATION_PROMPT = "Reply with the single word: ok";
 export declare const DEFAULT_ATTESTATION_TIMEOUT_MS = 120000;
 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>>;
     durationMs?: number;
     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;
@@ -45,12 +45,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;
@@ -58,5 +58,5 @@ export interface RunHarnessAttestationOptions {
     probeProjection?: typeof probeFilesystemProjection;
     now?: () => Date;
 }
-export declare function runHarnessAttestation(registry: HarnessRegistry, opts?: RunHarnessAttestationOptions): Promise<HarnessAttestationReport>;
+export declare function runAdapterAttestation(registry: AdapterRegistry, opts?: RunAdapterAttestationOptions): Promise<AdapterAttestationReport>;
 //# sourceMappingURL=attest.d.ts.map

package/dist/core/adapters/attest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attest.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/attest.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAQhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/D;+CAC+C;AAC/C,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AAEnE,eAAO,MAAM,8BAA8B,SAAU,CAAC;AAqBtD,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEnF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,SAAS,CAAC;IACnB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,OAAO,EAAE,wBAAwB,EAAE,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB;8DAC0D;IAC1D,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;mDAG+C;IAC/C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,4EAA4E;IAC5E,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACjD,+DAA+D;IAC/D,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACxF,2DAA2D;IAC3D,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC/C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,eAAe,CAAC,EAAE,OAAO,yBAAyB,CAAC;IACnD,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,IAAI,GAAE,4BAAiC,GACtC,OAAO,CAAC,wBAAwB,CAAC,CAyGnC"}

package/dist/core/{harnesses → adapters}/attest.js

@@ -1,7 +1,7 @@
 /**
  * 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.
  */
@@ -31,8 +31,8 @@ function boundedReason(reason) {
         ? `…${collapsed.slice(-MAX_NOTE_REASON_CHARS)}`
         : collapsed;
 }
-export async function runHarnessAttestation(registry, opts = {}) {
-    const ids = opts.harnesses?.length ? [...opts.harnesses] : registry.ids();
+export async function runAdapterAttestation(registry, opts = {}) {
+    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;
@@ -44,7 +44,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
         const binaryVersion = versionProbe(adapter.profile.binary);
         if (!binaryVersion) {
             results.push({
-                harness: id,
+                adapter: id,
                 outcome: "skipped",
                 note: `${adapter.profile.binary} not found on PATH`,
             });
@@ -64,7 +64,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
         }
         catch (error) {
             results.push({
-                harness: id,
+                adapter: id,
                 outcome: "failed",
                 binaryVersion,
                 note: `probe threw: ${boundedReason(error.message)}`,
@@ -75,7 +75,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
         // 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,
@@ -103,7 +103,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
         }
         const record = sealAttestation({
             schema_version: ATTESTATION_SCHEMA_VERSION,
-            harness: id,
+            adapter: id,
             binary_version: binaryVersion,
             profile_digest: profileDigest(adapter.profile),
             subscription_only: subscriptionOnly,
@@ -115,7 +115,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
         else
             writeAttestation(record, { coordRoot: opts.coordRoot });
         results.push({
-            harness: id,
+            adapter: id,
             outcome: "recorded",
             binaryVersion,
             observations,
@@ -125,7 +125,7 @@ export async function runHarnessAttestation(registry, opts = {}) {
     }
     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/dist/core/{harnesses → adapters}/attestation.d.ts

@@ -11,16 +11,16 @@
  * no host paths. It lives under the host's coordination directory and is never
  * published.
  */
-import type { CapabilitySupport, HarnessId, HarnessProfile } from "./types.js";
+import type { AdapterId, AdapterProfile, CapabilitySupport } from "./types.js";
 export declare const ATTESTATION_SCHEMA_VERSION = 2;
 /** 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 declare const ATTESTABLE_DIMENSIONS: readonly ["invocation", "finalResult", "sessionId", "cost", "filesystemPolicyProjection"];
 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;
@@ -45,35 +45,35 @@ export interface AttestationStoreOptions {
 export declare function attestationsDir(opts?: AttestationStoreOptions): string;
 /** Stable identity of a declaration, so editing a claim invalidates the
  * attestation that was recorded against the old one. */
-export declare function profileDigest(profile: HarnessProfile): string;
-export declare function sealAttestation(record: Omit<HarnessAttestation, "record_digest">): HarnessAttestation;
+export declare function profileDigest(profile: AdapterProfile): string;
+export declare function sealAttestation(record: Omit<AdapterAttestation, "record_digest">): AdapterAttestation;
 /** 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 declare function writeAttestation(record: HarnessAttestation, opts?: AttestationStoreOptions): string;
+export declare function writeAttestation(record: AdapterAttestation, opts?: AttestationStoreOptions): string;
 /** 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 declare function readAttestation(harness: HarnessId, opts?: AttestationStoreOptions): HarnessAttestation | null;
-export declare function validateAttestation(value: unknown, harness?: HarnessId): HarnessAttestation | null;
+export declare function readAttestation(adapter: AdapterId, opts?: AttestationStoreOptions): AdapterAttestation | null;
+export declare function validateAttestation(value: unknown, adapter?: AdapterId): AdapterAttestation | null;
 /** An attestation speaks only for the vendor version and declaration it was
  * recorded against. */
-export declare function isAttestationCurrent(record: HarnessAttestation | null, binaryVersion: string | null, profile: HarnessProfile, subscriptionOnly?: boolean): record is HarnessAttestation;
-export declare function listAttestations(opts?: AttestationStoreOptions): HarnessAttestation[];
-/** Both harness-derived proof inputs, read once, for a workflow run
+export declare function isAttestationCurrent(record: AdapterAttestation | null, binaryVersion: string | null, profile: AdapterProfile, subscriptionOnly?: boolean): record is AdapterAttestation;
+export declare function listAttestations(opts?: AttestationStoreOptions): AdapterAttestation[];
+/** 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 declare function harnessProofInputs(profiles: readonly HarnessProfile[], opts: AttestationStoreOptions & {
+export declare 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
      * is not cited as if it applied. */
     subscriptionOnly?: boolean;
 }): {
-    harnessEvidence: Record<string, {
-        toolEvidence: HarnessProfile["capabilities"]["toolEvidence"];
+    adapterEvidence: Record<string, {
+        toolEvidence: AdapterProfile["capabilities"]["toolEvidence"];
     }>;
-    harnessAttestations: Record<string, {
+    adapterAttestations: Record<string, {
         binary_version: string;
         observed_at: string;
         record_digest: string;

package/dist/core/adapters/attestation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/attestation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;uBAEuB;AACvB,eAAO,MAAM,qBAAqB,2FAMxB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,CAAC;IACnB;kFAC8E;IAC9E,cAAc,EAAE,MAAM,CAAC;IACvB;kDAC8C;IAC9C,cAAc,EAAE,MAAM,CAAC;IACvB;;8DAE0D;IAC1D,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB;6DACyD;IACzD,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACtE,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,eAAe,CAAC,IAAI,GAAE,uBAA4B,GAAG,MAAM,CAI1E;AAED;wDACwD;AACxD,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAM7D;AAMD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,eAAe,CAAC,GAChD,kBAAkB,CAEpB;AASD;;aAEa;AACb,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,GAAE,uBAA4B,GACjC,MAAM,CAmBR;AAED;;kEAEkE;AAClE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,EAClB,IAAI,GAAE,uBAA4B,GACjC,kBAAkB,GAAG,IAAI,CAc3B;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,SAAS,GAClB,kBAAkB,GAAG,IAAI,CAe3B;AAED;uBACuB;AACvB,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,GAAG,IAAI,EACjC,aAAa,EAAE,MAAM,GAAG,IAAI,EAC5B,OAAO,EAAE,cAAc,EACvB,gBAAgB,CAAC,EAAE,OAAO,GACzB,MAAM,IAAI,kBAAkB,CAK9B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,uBAA4B,GAAG,kBAAkB,EAAE,CAczF;AAED;;;oDAGoD;AACpD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,IAAI,EAAE,uBAAuB,GAAG;IAC9B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAChD;wCACoC;IACpC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GACA;IACD,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,YAAY,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC,cAAc,CAAC,CAAA;KAAE,CAAC,CAAC;IAClG,mBAAmB,EAAE,MAAM,CACzB,MAAM,EACN;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CACvE,CAAC;CACH,CAoCA"}

package/dist/core/{harnesses → adapters}/attestation.js

@@ -30,7 +30,7 @@ export function attestationsDir(opts = {}) {
     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. */
@@ -47,17 +47,17 @@ function digestOf(record) {
 export function sealAttestation(record) {
     return { ...record, record_digest: digestOf(record) };
 }
-function attestationPath(harness, opts) {
-    if (!/^[a-z0-9][a-z0-9._-]*$/i.test(harness)) {
-        throw new Error(`unsafe harness id for an attestation path: ${harness}`);
+function attestationPath(adapter, opts) {
+    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, opts = {}) {
-    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 {
@@ -81,10 +81,10 @@ export function writeAttestation(record, opts = {}) {
 /** 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, opts = {}) {
+export function readAttestation(adapter, opts = {}) {
     let raw;
     try {
-        raw = readFileSync(attestationPath(harness, opts), "utf8");
+        raw = readFileSync(attestationPath(adapter, opts), "utf8");
     }
     catch {
         return null;
@@ -96,15 +96,15 @@ export function readAttestation(harness, opts = {}) {
     catch {
         return null;
     }
-    return validateAttestation(parsed, harness);
+    return validateAttestation(parsed, adapter);
 }
-export function validateAttestation(value, harness) {
+export function validateAttestation(value, adapter) {
     if (!value || typeof value !== "object")
         return null;
     const record = value;
     if (record.schema_version !== ATTESTATION_SCHEMA_VERSION)
         return null;
-    if (typeof record.harness !== "string" || (harness && record.harness !== harness))
+    if (typeof record.adapter !== "string" || (adapter && record.adapter !== adapter))
         return null;
     if (typeof record.binary_version !== "string" || typeof record.profile_digest !== "string") {
         return null;
@@ -145,17 +145,17 @@ export function listAttestations(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, opts) {
-    const harnessEvidence = {};
-    const harnessAttestations = {};
+export function adapterProofInputs(profiles, opts) {
+    const adapterEvidence = {};
+    const adapterAttestations = {};
     for (const profile of profiles) {
-        harnessEvidence[profile.id] = { toolEvidence: profile.capabilities.toolEvidence };
+        adapterEvidence[profile.id] = { toolEvidence: profile.capabilities.toolEvidence };
         let record = null;
         try {
             record = readAttestation(profile.id, opts);
@@ -167,11 +167,11 @@ export function harnessProofInputs(profiles, opts) {
         if (!isAttestationCurrent(record, opts.versionProbe(profile.binary), profile, opts.subscriptionOnly)) {
             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 };
 }

package/dist/core/{harnesses → adapters}/bench.d.ts

@@ -1,8 +1,8 @@
-import type { HarnessAttestation } from "./attestation.js";
-import type { HarnessRegistry } from "./registry.js";
-import type { CapabilitySupport, HarnessCapabilityDimension, HarnessId } from "./types.js";
+import type { AdapterAttestation } from "./attestation.js";
+import type { AdapterRegistry } from "./registry.js";
+import type { AdapterCapabilityDimension, AdapterId, CapabilitySupport } from "./types.js";
 export type BenchVerdict = "supported" | "partial" | "unsupported" | "not_applicable" | "unknown" | "skipped" | "drift";
-export type BenchDimension = "registration" | "binary" | "contract" | HarnessCapabilityDimension;
+export type BenchDimension = "registration" | "binary" | "contract" | AdapterCapabilityDimension;
 /** How a result was established (ADR 0037). Orthogonal to the verdict: this
  * answers "how do we know", not "what is true".
  *
@@ -12,7 +12,7 @@ export type BenchDimension = "registration" | "binary" | "contract" | HarnessCap
  * - `declared`: not checked. The value is the declaration, repeated. */
 export type BenchBasis = "adapter" | "attested" | "declared";
 export interface BenchResult {
-    harness: HarnessId;
+    adapter: AdapterId;
     dimension: BenchDimension;
     declared: CapabilitySupport | "not_applicable";
     observed: BenchVerdict;
@@ -20,10 +20,10 @@ export interface BenchResult {
     basis: BenchBasis;
     note?: string;
 }
-export interface HarnessBenchReport {
+export interface AdapterBenchReport {
     generatedAt: string;
     mode: "offline";
-    harnesses: HarnessId[];
+    adapters: AdapterId[];
     results: BenchResult[];
     summary: Record<BenchVerdict, number>;
     /** Result counts per basis, so a caller can tell a clean report from an
@@ -32,21 +32,21 @@ export interface HarnessBenchReport {
     drift: boolean;
     skipped: boolean;
 }
-export interface HarnessBenchOptions {
-    harnesses?: readonly string[];
-    dimensions?: readonly HarnessCapabilityDimension[];
+export interface AdapterBenchOptions {
+    adapters?: readonly string[];
+    dimensions?: readonly AdapterCapabilityDimension[];
     /** 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;
+    attestationReader?: (adapter: AdapterId) => AdapterAttestation | null;
     /** Only cite attestations recorded under this billing mode. Omitted means
      * any mode is acceptable for reporting purposes. */
     subscriptionOnly?: boolean;
 }
-export declare function runHarnessBench(registry: HarnessRegistry, opts?: HarnessBenchOptions): HarnessBenchReport;
+export declare function runAdapterBench(registry: AdapterRegistry, opts?: AdapterBenchOptions): AdapterBenchReport;
 /** 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. */

package/dist/core/adapters/bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bench.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/bench.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAuB,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAW,0BAA0B,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpG,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,SAAS,GACT,aAAa,GACb,gBAAgB,GAChB,SAAS,GACT,SAAS,GACT,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,QAAQ,GAAG,UAAU,GAAG,0BAA0B,CAAC;AAEjG;;;;;;wEAMwE;AACxE,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAE7D,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;IAC/C,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IACtC;sDACkD;IAClD,YAAY,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IACnD,4EAA4E;IAC5E,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACjD;qDACiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,kBAAkB,GAAG,IAAI,CAAC;IACtE;wDACoD;IACpD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAkDD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,eAAe,EACzB,IAAI,GAAE,mBAAwB,GAC7B,kBAAkB,CAwEpB;AAuLD;;kDAEkD;AAClD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIhE"}