harnery 0.30.0 → 0.31.0

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

@@ -1,16 +1,11 @@
 import { spawnSync } from "node:child_process";
-import { HARNESS_SPECS } from "../hooks/harness/events.ts";
+import { ADAPTER_SPECS } from "../hooks/adapter/events.ts";
 import type { SpawnRequest, SpawnResult } from "../workflow/types.ts";
-import type { AttestableDimension, HarnessAttestation } from "./attestation.ts";
+import type { AdapterAttestation, AttestableDimension } from "./attestation.ts";
 import { isAttestationCurrent, readAttestation } from "./attestation.ts";
-import type { HarnessRegistry } from "./registry.ts";
-import type {
-  CapabilitySupport,
-  HarnessAdapter,
-  HarnessCapabilityDimension,
-  HarnessId,
-} from "./types.ts";
-import { HARNESS_CAPABILITY_DIMENSIONS } from "./types.ts";
+import type { AdapterRegistry } from "./registry.ts";
+import type { Adapter, AdapterCapabilityDimension, AdapterId, CapabilitySupport } from "./types.ts";
+import { ADAPTER_CAPABILITY_DIMENSIONS } from "./types.ts";
 
 export type BenchVerdict =
   | "supported"
@@ -21,7 +16,7 @@ export type BenchVerdict =
   | "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".
@@ -33,7 +28,7 @@ export type BenchDimension = "registration" | "binary" | "contract" | HarnessCap
 export type BenchBasis = "adapter" | "attested" | "declared";
 
 export interface BenchResult {
-  harness: HarnessId;
+  adapter: AdapterId;
   dimension: BenchDimension;
   declared: CapabilitySupport | "not_applicable";
   observed: BenchVerdict;
@@ -42,10 +37,10 @@ export interface BenchResult {
   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
@@ -55,16 +50,16 @@ export interface HarnessBenchReport {
   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;
@@ -90,12 +85,12 @@ const EMPTY_BASIS_SUMMARY: Record<BenchBasis, number> = {
  * 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,
+  id: AdapterId,
   version: string | null,
-  adapter: HarnessAdapter,
-  opts: HarnessBenchOptions,
-): HarnessAttestation | null {
-  let record: HarnessAttestation | null = null;
+  adapter: Adapter,
+  opts: AdapterBenchOptions,
+): AdapterAttestation | null {
+  let record: AdapterAttestation | null = null;
   try {
     record = opts.attestationReader
       ? opts.attestationReader(id)
@@ -118,21 +113,21 @@ function versionToken(value: string | null | undefined): string | null {
   return match ? match[0].toLowerCase() : null;
 }
 
-export function runHarnessBench(
-  registry: HarnessRegistry,
-  opts: HarnessBenchOptions = {},
-): HarnessBenchReport {
-  const ids = opts.harnesses?.length ? [...opts.harnesses] : registry.ids();
+export function runAdapterBench(
+  registry: AdapterRegistry,
+  opts: AdapterBenchOptions = {},
+): AdapterBenchReport {
+  const ids = opts.adapters?.length ? [...opts.adapters] : registry.ids();
   const dimensions = opts.dimensions?.length
     ? [...new Set(opts.dimensions)]
-    : [...HARNESS_CAPABILITY_DIMENSIONS];
+    : [...ADAPTER_CAPABILITY_DIMENSIONS];
   const versionProbe = opts.versionProbe ?? probeBinaryVersion;
   const results: BenchResult[] = [];
 
   for (const id of ids) {
     const adapter = registry.require(id);
     results.push({
-      harness: id,
+      adapter: id,
       dimension: "registration",
       declared: "supported",
       observed: "supported",
@@ -143,7 +138,7 @@ export function runHarnessBench(
 
     const version = versionProbe(adapter.profile.binary);
     results.push({
-      harness: id,
+      adapter: id,
       dimension: "binary",
       declared: "supported",
       observed: version ? "supported" : "skipped",
@@ -166,7 +161,7 @@ export function runHarnessBench(
         ? { observed: live, basis: "attested" }
         : observations[dimension];
       results.push({
-        harness: id,
+        adapter: id,
         dimension,
         declared: claim.support,
         observed,
@@ -186,7 +181,7 @@ export function runHarnessBench(
   return {
     generatedAt: new Date().toISOString(),
     mode: "offline",
-    harnesses: ids,
+    adapters: ids,
     results,
     summary,
     basisSummary,
@@ -203,13 +198,9 @@ export function runHarnessBench(
  * 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 {
+function contractResult(id: AdapterId, adapter: Adapter, version: string | null): BenchResult {
   const recorded = adapter.profile.verified;
-  const base = { harness: id, dimension: "contract" as const, declared: "supported" as const };
+  const base = { adapter: id, dimension: "contract" as const, declared: "supported" as const };
 
   if (!version) {
     return {
@@ -265,8 +256,8 @@ function fromAdapter(observed: BenchVerdict): DimensionObservation {
 const NOT_CHECKED: DimensionObservation = { observed: "unknown", basis: "declared" };
 
 function observeAdapter(
-  adapter: HarnessAdapter,
-): Record<HarnessCapabilityDimension, DimensionObservation> {
+  adapter: Adapter,
+): Record<AdapterCapabilityDimension, DimensionObservation> {
   const profile = adapter.profile;
   const effort = profile.effortValues[0];
   const request: SpawnRequest = {
@@ -312,8 +303,8 @@ function observeAdapter(
   const sessionObserved = normalized?.sessionId !== undefined ? "supported" : "unsupported";
   const costObserved = normalized?.costUsd !== undefined ? "supported" : "unsupported";
   const hookSpec =
-    adapter.profile.id in HARNESS_SPECS
-      ? HARNESS_SPECS[adapter.profile.id as keyof typeof HARNESS_SPECS]
+    adapter.profile.id in ADAPTER_SPECS
+      ? ADAPTER_SPECS[adapter.profile.id as keyof typeof ADAPTER_SPECS]
       : undefined;
   const hookSubcommands = new Set(hookSpec?.events.map((event) => event.subcommand) ?? []);
 

package/src/core/adapters/index.ts

@@ -0,0 +1,56 @@
+export type { Spawner, SpawnRequest, SpawnResult } from "../workflow/types.ts";
+export type {
+  AdapterAttestationReport,
+  AdapterAttestationResult,
+  AttestationOutcome,
+  RunAdapterAttestationOptions,
+} from "./attest.ts";
+export { ATTESTATION_PROMPT, runAdapterAttestation } from "./attest.ts";
+export type {
+  AdapterAttestation,
+  AttestableDimension,
+  AttestationStoreOptions,
+} from "./attestation.ts";
+export {
+  ATTESTABLE_DIMENSIONS,
+  ATTESTATION_SCHEMA_VERSION,
+  adapterProofInputs,
+  attestationsDir,
+  isAttestationCurrent,
+  listAttestations,
+  profileDigest,
+  readAttestation,
+  validateAttestation,
+  writeAttestation,
+} from "./attestation.ts";
+export type {
+  AdapterBenchOptions,
+  AdapterBenchReport,
+  BenchBasis,
+  BenchDimension,
+  BenchResult,
+  BenchVerdict,
+} from "./bench.ts";
+export { probeBinaryVersion, runAdapterBench } from "./bench.ts";
+export type { BuiltinAdapterId } from "./profiles.ts";
+export {
+  BUILTIN_ADAPTER_IDS,
+  BUILTIN_ADAPTER_PROFILES,
+  builtinAdapterProfile,
+  isBuiltinAdapter,
+  validateAdapterEffort,
+} from "./profiles.ts";
+export { AdapterRegistry, createBuiltinAdapterRegistry } from "./registry.ts";
+export type {
+  Adapter,
+  AdapterBenchFixture,
+  AdapterCapabilities,
+  AdapterCapabilityDimension,
+  AdapterId,
+  AdapterInvocation,
+  AdapterProfile,
+  AdapterRawResult,
+  CapabilityClaim,
+  CapabilitySupport,
+} from "./types.ts";
+export { ADAPTER_CAPABILITY_DIMENSIONS } from "./types.ts";

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

@@ -1,11 +1,11 @@
-import type { CapabilityClaim, HarnessCapabilities, HarnessProfile } from "./types.ts";
+import type { AdapterCapabilities, AdapterProfile, CapabilityClaim } from "./types.ts";
 
 const supported = (note?: string): CapabilityClaim => ({ support: "supported", note });
 const unsupported = (note?: string): CapabilityClaim => ({ support: "unsupported", note });
 const partial = (note: string): CapabilityClaim => ({ support: "partial", note });
 const unknown = (note: string): CapabilityClaim => ({ support: "unknown", note });
 
-function capabilities(overrides: Partial<HarnessCapabilities>): HarnessCapabilities {
+function capabilities(overrides: Partial<AdapterCapabilities>): AdapterCapabilities {
   return {
     invocation: supported("Headless CLI subprocess."),
     modelSelection: supported("Explicit model flag is mapped by the adapter."),
@@ -25,14 +25,14 @@ function capabilities(overrides: Partial<HarnessCapabilities>): HarnessCapabilit
     contextTelemetry: unknown("The workflow adapter does not expose live context usage."),
     preCompactionSignal: unknown("No compaction lifecycle probe has certified this adapter."),
     postCompactionSignal: unknown("No compaction lifecycle probe has certified this adapter."),
-    compaction: unsupported("Harnery does not initiate native harness compaction."),
+    compaction: unsupported("Harnery does not initiate native adapter compaction."),
     ...overrides,
   };
 }
 
-/** The one built-in profile catalog. Adding a fourth harness starts here; CLI
+/** The one built-in profile catalog. Adding a fourth adapter starts here; CLI
  * choices, doctor metadata, workflow dispatch, and the bench derive from it. */
-export const BUILTIN_HARNESS_PROFILES = {
+export const BUILTIN_ADAPTER_PROFILES = {
   "claude-code": {
     id: "claude-code",
     displayName: "Claude Code",
@@ -123,26 +123,26 @@ export const BUILTIN_HARNESS_PROFILES = {
       ),
     }),
   },
-} as const satisfies Record<string, HarnessProfile>;
+} as const satisfies Record<string, AdapterProfile>;
 
-export type BuiltinHarnessId = keyof typeof BUILTIN_HARNESS_PROFILES;
+export type BuiltinAdapterId = keyof typeof BUILTIN_ADAPTER_PROFILES;
 
-export const BUILTIN_HARNESS_IDS = Object.freeze(
-  Object.keys(BUILTIN_HARNESS_PROFILES) as BuiltinHarnessId[],
+export const BUILTIN_ADAPTER_IDS = Object.freeze(
+  Object.keys(BUILTIN_ADAPTER_PROFILES) as BuiltinAdapterId[],
 );
 
-export function isBuiltinHarness(id: string): id is BuiltinHarnessId {
-  return Object.hasOwn(BUILTIN_HARNESS_PROFILES, id);
+export function isBuiltinAdapter(id: string): id is BuiltinAdapterId {
+  return Object.hasOwn(BUILTIN_ADAPTER_PROFILES, id);
 }
 
-export function builtinHarnessProfile(id: string): HarnessProfile | undefined {
-  return isBuiltinHarness(id) ? BUILTIN_HARNESS_PROFILES[id] : undefined;
+export function builtinAdapterProfile(id: string): AdapterProfile | undefined {
+  return isBuiltinAdapter(id) ? BUILTIN_ADAPTER_PROFILES[id] : undefined;
 }
 
-export function validateHarnessEffort(id: string, effort: string | undefined): void {
+export function validateAdapterEffort(id: string, effort: string | undefined): void {
   if (!effort) return;
-  const profile = builtinHarnessProfile(id);
-  if (!profile) throw new Error(`unknown harness ${JSON.stringify(id)}`);
+  const profile = builtinAdapterProfile(id);
+  if (!profile) throw new Error(`unknown adapter ${JSON.stringify(id)}`);
   if (!profile.effortValues.includes(effort)) {
     const supportedValues = profile.effortValues.length ? profile.effortValues.join(", ") : "none";
     throw new Error(

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

@@ -14,15 +14,15 @@ import {
   normalizeCursorResult,
 } from "../workflow/spawn-cursor.ts";
 import {
-  BUILTIN_HARNESS_IDS,
-  BUILTIN_HARNESS_PROFILES,
-  type BuiltinHarnessId,
+  BUILTIN_ADAPTER_IDS,
+  BUILTIN_ADAPTER_PROFILES,
+  type BuiltinAdapterId,
 } from "./profiles.ts";
-import type { HarnessAdapter, HarnessId } from "./types.ts";
+import type { Adapter, AdapterId } from "./types.ts";
 
-const BUILTIN_ADAPTERS: Record<BuiltinHarnessId, HarnessAdapter> = {
+const BUILTIN_ADAPTERS: Record<BuiltinAdapterId, Adapter> = {
   "claude-code": {
-    profile: BUILTIN_HARNESS_PROFILES["claude-code"],
+    profile: BUILTIN_ADAPTER_PROFILES["claude-code"],
     spawn: claudeCodeSpawner,
     buildInvocation: buildClaudeInvocation,
     normalizeResult: normalizeClaudeResult,
@@ -47,7 +47,7 @@ const BUILTIN_ADAPTERS: Record<BuiltinHarnessId, HarnessAdapter> = {
     },
   },
   codex: {
-    profile: BUILTIN_HARNESS_PROFILES.codex,
+    profile: BUILTIN_ADAPTER_PROFILES.codex,
     spawn: codexSpawner,
     buildInvocation: buildCodexInvocation,
     normalizeResult: normalizeCodexResult,
@@ -63,7 +63,7 @@ const BUILTIN_ADAPTERS: Record<BuiltinHarnessId, HarnessAdapter> = {
     },
   },
   cursor: {
-    profile: BUILTIN_HARNESS_PROFILES.cursor,
+    profile: BUILTIN_ADAPTER_PROFILES.cursor,
     spawn: cursorSpawner,
     buildInvocation: buildCursorInvocation,
     normalizeResult: normalizeCursorResult,
@@ -89,52 +89,52 @@ const BUILTIN_ADAPTERS: Record<BuiltinHarnessId, HarnessAdapter> = {
 
 /** Mutable registry for embedders, initialized empty unless adapters are
  * provided. Duplicate ids fail loud instead of silently replacing behavior. */
-export class HarnessRegistry {
-  readonly #adapters = new Map<HarnessId, HarnessAdapter>();
+export class AdapterRegistry {
+  readonly #adapters = new Map<AdapterId, Adapter>();
 
-  constructor(adapters: Iterable<HarnessAdapter> = []) {
+  constructor(adapters: Iterable<Adapter> = []) {
     for (const adapter of adapters) this.register(adapter);
   }
 
-  register(adapter: HarnessAdapter): this {
+  register(adapter: Adapter): this {
     const id = adapter.profile.id.trim();
-    if (!id) throw new Error("harness adapter id cannot be empty");
+    if (!id) throw new Error("adapter adapter id cannot be empty");
     if (this.#adapters.has(id))
-      throw new Error(`harness adapter ${JSON.stringify(id)} is already registered`);
+      throw new Error(`adapter adapter ${JSON.stringify(id)} is already registered`);
     if (adapter.profile.binary.trim() === "") {
-      throw new Error(`harness adapter ${JSON.stringify(id)} has no binary`);
+      throw new Error(`adapter adapter ${JSON.stringify(id)} has no binary`);
     }
     this.#adapters.set(id, adapter);
     return this;
   }
 
-  get(id: HarnessId): HarnessAdapter | undefined {
+  get(id: AdapterId): Adapter | undefined {
     return this.#adapters.get(id);
   }
 
-  require(id: HarnessId): HarnessAdapter {
+  require(id: AdapterId): Adapter {
     const adapter = this.get(id);
     if (!adapter) {
       throw new Error(
-        `unknown harness ${JSON.stringify(id)} (registered: ${this.ids().join(", ") || "none"})`,
+        `unknown adapter ${JSON.stringify(id)} (registered: ${this.ids().join(", ") || "none"})`,
       );
     }
     return adapter;
   }
 
-  list(): HarnessAdapter[] {
+  list(): Adapter[] {
     return Array.from(this.#adapters.values());
   }
 
-  ids(): HarnessId[] {
+  ids(): AdapterId[] {
     return Array.from(this.#adapters.keys());
   }
 
-  spawners(): Record<HarnessId, HarnessAdapter["spawn"]> {
+  spawners(): Record<AdapterId, Adapter["spawn"]> {
     return Object.fromEntries(this.list().map((adapter) => [adapter.profile.id, adapter.spawn]));
   }
 }
 
-export function createBuiltinHarnessRegistry(): HarnessRegistry {
-  return new HarnessRegistry(BUILTIN_HARNESS_IDS.map((id) => BUILTIN_ADAPTERS[id]));
+export function createBuiltinAdapterRegistry(): AdapterRegistry {
+  return new AdapterRegistry(BUILTIN_ADAPTER_IDS.map((id) => BUILTIN_ADAPTERS[id]));
 }

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

@@ -1,12 +1,12 @@
 import type { Spawner, SpawnRequest, SpawnResult } from "../workflow/types.ts";
 
-/** Open harness identifier. Built-ins are registered at runtime rather than
+/** Open adapter identifier. Built-ins are registered at runtime rather than
  * repeated through closed unions in every consumer. */
-export type HarnessId = string;
+export type AdapterId = string;
 
 export type CapabilitySupport = "supported" | "partial" | "unsupported" | "unknown";
 
-export const HARNESS_CAPABILITY_DIMENSIONS = [
+export const ADAPTER_CAPABILITY_DIMENSIONS = [
   "invocation",
   "modelSelection",
   "effortSelection",
@@ -28,7 +28,7 @@ export const HARNESS_CAPABILITY_DIMENSIONS = [
   "compaction",
 ] as const;
 
-export type HarnessCapabilityDimension = (typeof HARNESS_CAPABILITY_DIMENSIONS)[number];
+export type AdapterCapabilityDimension = (typeof ADAPTER_CAPABILITY_DIMENSIONS)[number];
 
 export interface CapabilityClaim {
   support: CapabilitySupport;
@@ -37,21 +37,21 @@ export interface CapabilityClaim {
   note?: string;
 }
 
-export type HarnessCapabilities = Record<HarnessCapabilityDimension, CapabilityClaim>;
+export type AdapterCapabilities = Record<AdapterCapabilityDimension, CapabilityClaim>;
 
-/** What one harness can represent of a filesystem-policy projection
- * (ADR 0039). `null` means the harness does not distinguish that, which is a
- * fact about the harness rather than something to paper over: a projection the
+/** What one adapter can represent of a filesystem-policy projection
+ * (ADR 0039). `null` means the adapter does not distinguish that, which is a
+ * fact about the adapter rather than something to paper over: a projection the
  * adapter would silently drop must be refused instead. */
-export interface HarnessSandboxProjection {
+export interface AdapterSandboxProjection {
   /** Native representation per canonical mode, or null when unrepresentable. */
   modes: Record<"read-only" | "workspace-write", string | null>;
-  /** Whether the harness accepts an explicit writable-root set. */
+  /** Whether the adapter accepts an explicit writable-root set. */
   writableRoots: boolean;
 }
 
-export interface HarnessProfile {
-  id: HarnessId;
+export interface AdapterProfile {
+  id: AdapterId;
   displayName: string;
   binary: string;
   installHint: string;
@@ -61,23 +61,23 @@ export interface HarnessProfile {
   authModel: "own-auth";
   modelFamily: "claude" | "gpt" | "multi";
   effortValues: readonly string[];
-  capabilities: HarnessCapabilities;
+  capabilities: AdapterCapabilities;
   /** The last real vendor CLI contract used to validate this declaration. */
   verified?: { date: string; version: string };
   /** How this adapter projects host filesystem policy into the vendor's own
    * sandbox (ADR 0039). Absent means it cannot project any of it. */
-  sandboxProjection?: HarnessSandboxProjection;
+  sandboxProjection?: AdapterSandboxProjection;
 }
 
 /** Fully planned child invocation. `resultFile` is used by adapters such as
  * Codex that deliver the authoritative final answer out-of-band. */
-export interface HarnessInvocation {
+export interface AdapterInvocation {
   argv: string[];
   resultFile?: string;
 }
 
 /** Vendor subprocess material passed through an adapter's normalizer. */
-export interface HarnessRawResult {
+export interface AdapterRawResult {
   stdout: string;
   stderr: string;
   exitCode: number;
@@ -95,8 +95,8 @@ export interface HarnessRawResult {
   spawnErrno?: string;
 }
 
-export interface HarnessBenchFixture {
-  raw: HarnessRawResult;
+export interface AdapterBenchFixture {
+  raw: AdapterRawResult;
   expected: Pick<SpawnResult, "ok" | "text"> & {
     sessionId?: string;
     costUsd?: number;
@@ -106,10 +106,10 @@ export interface HarnessBenchFixture {
 /** One registered executable adapter. The same planner and normalizer power
  * production workflow runs and the offline conformance bench, preventing the
  * bench from testing a parallel mock implementation. */
-export interface HarnessAdapter {
-  profile: HarnessProfile;
+export interface Adapter {
+  profile: AdapterProfile;
   spawn: Spawner;
-  buildInvocation: (request: SpawnRequest, resultFile?: string) => HarnessInvocation;
-  normalizeResult: (raw: HarnessRawResult) => SpawnResult;
-  fixture: HarnessBenchFixture;
+  buildInvocation: (request: SpawnRequest, resultFile?: string) => AdapterInvocation;
+  normalizeResult: (raw: AdapterRawResult) => SpawnResult;
+  fixture: AdapterBenchFixture;
 }

package/src/core/agents/canonical-emit.ts

@@ -1,6 +1,6 @@
 /**
  * Emit canonical events by spawning `agent-coord emit-event`. Used by every
- * `agents …` / `scratch` / `presence` write that has a canonical state event.
+ * `agents …` / `journal` / `presence` write that has a canonical state event.
  *
  * Soft-fails: never throws into the caller. A failed emit logs to stderr
  * (visible to operators in their terminal) but never breaks the CLI flow.
@@ -18,7 +18,7 @@ export interface CanonicalEmitInput {
   type: string;
   owner: string;
   session: string;
-  harness: "claude-code" | "cursor" | "codex";
+  adapter: "claude-code" | "cursor" | "codex";
   data: Record<string, unknown>;
   turnId?: string;
   parentSessionId?: string;
@@ -68,8 +68,8 @@ export function emitCanonical(input: CanonicalEmitInput): void {
       input.owner,
       "--session",
       input.session,
-      "--harness",
-      input.harness,
+      "--adapter",
+      input.adapter,
       "--data-json",
       JSON.stringify(input.data),
     ];
@@ -96,9 +96,9 @@ export function emitCanonical(input: CanonicalEmitInput): void {
 
 /**
  * Normalize the heartbeat's `platform` field (which uses snake_case
- * `claude_code`) to the canonical kebab-case Harness type.
+ * `claude_code`) to the canonical kebab-case Adapter type.
  */
-export function normalizeHarness(platform: string | undefined): "claude-code" | "cursor" | "codex" {
+export function normalizeAdapter(platform: string | undefined): "claude-code" | "cursor" | "codex" {
   if (platform === "cursor") return "cursor";
   if (platform === "codex") return "codex";
   return "claude-code";

package/src/core/agents/cli-emit.ts

@@ -47,7 +47,7 @@ export function emitAndProject(
             parent_session_id: envelope.parent_session_id,
             turn_id: envelope.turn_id,
             parent_turn_id: envelope.parent_turn_id,
-            harness: envelope.harness,
+            adapter: envelope.adapter,
             source: envelope.source,
             data: envelope.data,
           },