harnery 0.29.0 → 0.31.0

package/src/core/workflow/evidence-preflight.ts

@@ -0,0 +1,165 @@
+import { EVIDENCE_KINDS } from "./types.ts";
+
+/**
+ * Reject an unusable evidence kind before the first agent is spawned.
+ *
+ * `evidence()` is by construction near the end of a workflow, so an invalid
+ * kind throws after every agent has finished. Measured: a fifty-minute run with
+ * three completed agents died at its final line on `kind: "design"`, reported
+ * `work_failed`, and burned an attempt. The work survived only because it had
+ * already been written to the tree; nothing in the proof could recover it.
+ *
+ * A workflow's evidence kinds are usually written literally, and a literal is
+ * checkable by reading the file. Where a kind is computed the scan says nothing
+ * and the existing runtime validation still applies — a partial check that
+ * costs one file read is worth more than a complete one nobody can implement.
+ */
+
+export interface EvidencePreflightProblem {
+  kind: string;
+  line: number;
+}
+
+/** Every literal `evidence({ kind: … })` in this source whose kind is not in the
+ * vocabulary. Computed kinds are invisible here, by design. */
+export function findInvalidEvidenceKinds(source: string): EvidencePreflightProblem[] {
+  const { masked, literals } = maskSource(source);
+  const problems: EvidencePreflightProblem[] = [];
+  const valid = new Set<string>(EVIDENCE_KINDS);
+
+  for (const call of evidenceCallRanges(masked)) {
+    // `kind` as an object key, then the value's first character. A quote there
+    // means a literal we can read; anything else is computed, so skip it.
+    const property = /\bkind\s*:\s*/g;
+    property.lastIndex = 0;
+    const slice = masked.slice(call.start, call.end);
+    let match = property.exec(slice);
+    while (match !== null) {
+      const valueAt = call.start + match.index + match[0].length;
+      const literal = literals.get(valueAt);
+      if (literal !== undefined && !valid.has(literal)) {
+        problems.push({ kind: literal, line: lineOf(source, valueAt) });
+      }
+      match = property.exec(slice);
+    }
+  }
+  return problems;
+}
+
+/** The thrown message, or undefined when the script is clean or unreadable. */
+export function evidencePreflightError(source: string, scriptPath: string): string | undefined {
+  const problems = findInvalidEvidenceKinds(source);
+  if (problems.length === 0) return undefined;
+  const listed = problems
+    .map((problem) => `line ${problem.line}: ${JSON.stringify(problem.kind)}`)
+    .join(", ");
+  return (
+    `${scriptPath}: evidence kind must be one of: ${EVIDENCE_KINDS.join(", ")} ` +
+    `(${listed}). Rejected before running, because an invalid kind would otherwise ` +
+    `throw at the end of the workflow and discard the work every agent had already done.`
+  );
+}
+
+interface MaskedSource {
+  /** The source with comment bodies and string interiors blanked to spaces, so
+   * structural scanning cannot be fooled by a brace or paren inside either.
+   * Same length as the input, so every index still maps back. */
+  masked: string;
+  /** String-literal value, keyed by the index of its opening quote. Template
+   * literals are absent: one may interpolate, so its value is not static. */
+  literals: Map<number, string>;
+}
+
+function maskSource(source: string): MaskedSource {
+  const out = source.split("");
+  const literals = new Map<number, string>();
+  let index = 0;
+  const blank = (from: number, to: number): void => {
+    for (let i = from; i < to && i < out.length; i++) {
+      if (out[i] !== "\n") out[i] = " ";
+    }
+  };
+
+  while (index < source.length) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (char === "/" && next === "/") {
+      const end = source.indexOf("\n", index);
+      blank(index, end === -1 ? source.length : end);
+      index = end === -1 ? source.length : end;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const end = source.indexOf("*/", index + 2);
+      const stop = end === -1 ? source.length : end + 2;
+      blank(index, stop);
+      index = stop;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const start = index;
+      let cursor = index + 1;
+      let value = "";
+      while (cursor < source.length) {
+        const inner = source[cursor];
+        if (inner === "\\") {
+          value += source[cursor + 1] ?? "";
+          cursor += 2;
+          continue;
+        }
+        if (inner === char) break;
+        // An unterminated single- or double-quoted string cannot span lines, so
+        // stop rather than swallowing the rest of the file on a syntax error.
+        if (inner === "\n" && char !== "`") break;
+        value += inner;
+        cursor++;
+      }
+      const closed = source[cursor] === char;
+      blank(start + 1, cursor);
+      if (closed && char !== "`") literals.set(start, value);
+      index = closed ? cursor + 1 : cursor;
+      continue;
+    }
+    index++;
+  }
+  return { masked: out.join(""), literals };
+}
+
+/** The argument list of every `evidence(` call, as index ranges into the masked
+ * source. A dotted receiver (`ctx.evidence(`) counts; a longer identifier that
+ * merely ends in "evidence" does not. */
+function evidenceCallRanges(masked: string): { start: number; end: number }[] {
+  const ranges: { start: number; end: number }[] = [];
+  const call = /evidence\s*\(/g;
+  let match = call.exec(masked);
+  while (match !== null) {
+    const before = match.index > 0 ? masked[match.index - 1]! : "";
+    if (!/[A-Za-z0-9_$]/.test(before)) {
+      const open = match.index + match[0].length - 1;
+      const close = matchingParen(masked, open);
+      if (close > open) ranges.push({ start: open + 1, end: close });
+    }
+    match = call.exec(masked);
+  }
+  return ranges;
+}
+
+function matchingParen(masked: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < masked.length; i++) {
+    if (masked[i] === "(") depth++;
+    else if (masked[i] === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function lineOf(source: string, index: number): number {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source[i] === "\n") line++;
+  }
+  return line;
+}

package/src/core/workflow/index.ts

@@ -25,6 +25,7 @@ export { runWorkflow, WorkflowParkedError, WorkflowRunError } from "./engine.ts"
 export {
   buildWorkflowProof,
   createEvidenceRecord,
+  deriveRunFailureClass,
   digestResult,
   normalizeWorkflowMeta,
   readWorkflowProof,
@@ -43,22 +44,24 @@ export {
   workflowScriptDigest,
   writeWorkflowRunManifest,
 } from "./run-state.ts";
+export { isUpstreamFailureText, vendorFailureText } from "./spawn-failure.ts";
 export type {
   AcceptanceCriterion,
   AcceptanceResult,
   AcceptanceStatus,
   AcceptanceSummary,
+  AdapterEvidenceCapability,
+  AdapterEvidenceCoverage,
+  AdapterName,
   AgentOpts,
   EngineOpts,
   EvidenceKind,
   EvidenceSource,
   EvidenceStatus,
-  HarnessEvidenceCapability,
-  HarnessEvidenceCoverage,
-  HarnessName,
   ResultDigest,
   RunReport,
   Spawner,
+  SpawnFailureClass,
   SpawnRequest,
   SpawnResult,
   StageSchema,

package/src/core/workflow/proof.ts

@@ -16,10 +16,12 @@ import type {
   AcceptanceCriterion,
   AcceptanceResult,
   AcceptanceSummary,
-  HarnessAttestationCitation,
-  HarnessEvidenceCapability,
-  HarnessEvidenceCoverage,
+  AdapterAttestationCitation,
+  AdapterEvidenceCapability,
+  AdapterEvidenceCoverage,
   ResultDigest,
+  RunFailureClass,
+  SpawnFailureClass,
   WorkflowAgentProof,
   WorkflowAttemptContext,
   WorkflowEvidenceInput,
@@ -33,7 +35,7 @@ import type {
   WorkflowSandboxProjectionEvidence,
   WorkflowWorkContext,
 } from "./types.ts";
-import { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.ts";
+import { EVIDENCE_KINDS, WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.ts";
 import { isCanonicalWorkflowWorkContext } from "./work-context.ts";
 import type {
   WorkspaceAttestation,
@@ -77,23 +79,26 @@ export interface BuildWorkflowProofInput {
   startedAt: string;
   endedAt: string;
   durationMs: number;
-  journalPath: string;
+  transcriptPath: string;
   before: RepoSnapshot;
   after: RepoSnapshot;
   agents: WorkflowAgentProof[];
   evidence: WorkflowEvidenceRecord[];
-  harnessEvidence?: Readonly<Record<string, HarnessEvidenceCapability | undefined>>;
+  adapterEvidence?: Readonly<Record<string, AdapterEvidenceCapability | undefined>>;
   /** Filesystem policy actually projected into children (ADR 0039). */
   sandboxProjection?: WorkflowSandboxProjectionEvidence;
-  /** Live attestations backing each harness's claims (ADR 0038). Injected by
+  /** Live attestations backing each adapter's claims (ADR 0038). Injected by
    * the caller so proof stays free of filesystem lookups. */
-  harnessAttestations?: Readonly<Record<string, HarnessAttestationCitation | undefined>>;
+  adapterAttestations?: Readonly<Record<string, AdapterAttestationCitation | undefined>>;
   policy?: {
     config: Readonly<NormalizedPolicy>;
     decisions: readonly PolicyDecision[];
     isolation: PolicyIsolation;
     networkAccess: PolicyNetworkAccess;
   };
+  /** Set when the script called ctx.blocked(): the run stopped because a human
+   * must rule. Forces run class "decision" regardless of the agents' classes. */
+  blocked?: { reason: string; decisionId?: string };
   workspaceBinding?: WorkspaceBinding;
   workspaceAttestation?: WorkspaceAttestation;
   workspaceFallback?: WorkspaceUnsupportedExecutionEvidence;
@@ -166,11 +171,7 @@ export function createEvidenceRecord(input: {
     id: `e${input.sequence}`,
     source: "workflow",
     recorded_at: input.recordedAt ?? new Date().toISOString(),
-    kind: enumValue(
-      value.kind,
-      ["test", "command", "artifact", "change", "review", "observation"],
-      "evidence kind",
-    ),
+    kind: enumValue(value.kind, EVIDENCE_KINDS, "evidence kind"),
     status: enumValue(value.status, ["passed", "failed", "observed", "unknown"], "evidence status"),
     label: boundedRequired(value.label, "evidence label", MAX_LABEL_CHARS),
     summary: boundedOptional(value.summary, "evidence summary", MAX_SUMMARY_CHARS),
@@ -218,6 +219,36 @@ export function digestResult(value: unknown, kind?: "text" | "json"): ResultDige
   };
 }
 
+/**
+ * The run-level failure class (ADR 0046), derived from the agents rather than a
+ * single terminal throw so it survives a script's `parallel()` swallowing the
+ * rejection — a swallowed agent's proof is still recorded with its class.
+ *
+ * Rules, in order, all in service of "default to charging":
+ * 1. A succeeded run is never classed (there is nothing uncharged about it).
+ * 2. If ANY agent produced a result (succeeded or replayed from cache) the
+ *    attempt was informative about the work — charge it. This also keeps a
+ *    resumed run whose earlier segment did real work from being written off by
+ *    a later environment failure.
+ * 3. Otherwise, among the failed agents, environment wins over upstream: a
+ *    missing binary means nothing ran at all, and it is the operator-chosen
+ *    hard stop.
+ * 4. Anything else is undefined ⇒ a charged work failure, exactly as today.
+ */
+export function deriveRunFailureClass(
+  status: "succeeded" | "failed",
+  agents: readonly Pick<WorkflowAgentProof, "status" | "class">[],
+): SpawnFailureClass | undefined {
+  if (status !== "failed") return undefined;
+  if (agents.some((agent) => agent.status === "succeeded" || agent.status === "cached")) {
+    return undefined;
+  }
+  const failed = agents.filter((agent) => agent.status === "failed");
+  if (failed.some((agent) => agent.class === "environment")) return "environment";
+  if (failed.some((agent) => agent.class === "upstream")) return "upstream";
+  return undefined;
+}
+
 export function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProof {
   const acceptance = rollupAcceptance(input.meta.acceptance, input.evidence);
   const repository = buildRepoEvidence(input.before, input.after);
@@ -229,9 +260,16 @@ 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, input.harnessAttestations);
-  const unknowns = buildUnknowns(agents, harnesses, repository);
-  const journal = readFileSync(input.journalPath);
+  const adapters = buildAdapterCoverage(agents, input.adapterEvidence, input.adapterAttestations);
+  const unknowns = buildUnknowns(agents, adapters, repository);
+  // A declared stop-on-human beats a derived spawn class. If the script said a
+  // human must rule, that is the true reason the run ended, even when some agent
+  // also happened to hit a flaky vendor on the way there.
+  const runClass: RunFailureClass | undefined =
+    input.status === "failed" && input.blocked
+      ? "decision"
+      : deriveRunFailureClass(input.status, agents);
+  const transcript = readFileSync(input.transcriptPath);
   return {
     schema_version: WORKFLOW_PROOF_SCHEMA_VERSION,
     run: {
@@ -247,6 +285,10 @@ export function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProo
       objective: input.meta.objective,
       error: clippedOptional(input.error, MAX_SUMMARY_CHARS),
       result: input.result === undefined ? undefined : digestResult(input.result),
+      ...(runClass ? { class: runClass } : {}),
+      ...(runClass === "decision" && input.blocked?.decisionId
+        ? { decision_id: clipped(input.blocked.decisionId, MAX_REF_CHARS) }
+        : {}),
     },
     acceptance,
     agents,
@@ -258,13 +300,13 @@ export function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProo
         : input.workspaceFallback,
     repository,
     ...(input.sandboxProjection ? { sandbox_projection: input.sandboxProjection } : {}),
-    harnesses,
+    adapters,
     unknowns,
     integrity: {
-      journal: {
-        path: "journal.jsonl",
-        sha256: createHash("sha256").update(journal).digest("hex"),
-        bytes: journal.byteLength,
+      transcript: {
+        path: "transcript.jsonl",
+        sha256: createHash("sha256").update(transcript).digest("hex"),
+        bytes: transcript.byteLength,
       },
     },
   };
@@ -326,6 +368,10 @@ export function readWorkflowProof(coordRoot: string, runId: string): WorkflowPro
   if (
     proof.schema_version !== WORKFLOW_PROOF_SCHEMA_VERSION ||
     proof.run?.id !== runId ||
+    (proof.run.class !== undefined &&
+      proof.run.class !== "environment" &&
+      proof.run.class !== "upstream" &&
+      proof.run.class !== "decision") ||
     (proof.run.work_context !== undefined &&
       (!proof.run.work_item_id ||
         proof.run.work_context.id !== proof.run.work_item_id ||
@@ -418,7 +464,7 @@ export function renderWorkflowProof(proof: WorkflowProof): string {
     lines.push(`unknowns: ${proof.unknowns.length}`);
     for (const unknown of proof.unknowns) lines.push(`  - ${unknown.message}`);
   }
-  lines.push(`journal sha256: ${proof.integrity.journal.sha256}`);
+  lines.push(`transcript sha256: ${proof.integrity.transcript.sha256}`);
   return `${lines.join("\n")}\n`;
 }
 
@@ -460,47 +506,47 @@ function normalizeRepoSnapshot(snapshot: RepoSnapshot): WorkflowRepoSnapshot {
   };
 }
 
-function buildHarnessCoverage(
+function buildAdapterCoverage(
   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);
+  claims: Readonly<Record<string, AdapterEvidenceCapability | undefined>> | undefined,
+  attestations: Readonly<Record<string, AdapterAttestationCitation | undefined>> | undefined,
+): AdapterEvidenceCoverage[] {
+  return [...new Set(agents.map((agent) => agent.adapter))].map((adapter) => {
+    const adapterAgents = agents.filter((agent) => agent.adapter === adapter);
     return {
-      harness,
-      tool_evidence: claims?.[harness]?.toolEvidence ?? {
+      adapter,
+      tool_evidence: claims?.[adapter]?.toolEvidence ?? {
         support: "unknown",
-        note: "No harness capability claim was supplied to this workflow run.",
+        note: "No adapter capability claim was supplied to this workflow run.",
       },
       observed: {
-        final_results: harnessAgents.filter((agent) => agent.result).length,
-        session_ids: harnessAgents.filter((agent) => agent.session_id).length,
-        costs: harnessAgents.filter((agent) => agent.cost_usd !== undefined).length,
+        final_results: adapterAgents.filter((agent) => agent.result).length,
+        session_ids: adapterAgents.filter((agent) => agent.session_id).length,
+        costs: adapterAgents.filter((agent) => agent.cost_usd !== undefined).length,
       },
-      ...(attestations?.[harness] ? { attestation: attestations[harness] } : {}),
+      ...(attestations?.[adapter] ? { attestation: attestations[adapter] } : {}),
     };
   });
 }
 
 function buildUnknowns(
   agents: WorkflowAgentProof[],
-  harnesses: HarnessEvidenceCoverage[],
+  adapters: AdapterEvidenceCoverage[],
   repository: WorkflowRepoEvidence,
 ): WorkflowProofUnknown[] {
   const unknowns: WorkflowProofUnknown[] = [];
-  for (const harness of harnesses) {
-    if (harness.tool_evidence.support === "unknown") {
+  for (const adapter of adapters) {
+    if (adapter.tool_evidence.support === "unknown") {
       unknowns.push({
-        code: "harness_capability_unregistered",
-        harness: harness.harness,
-        message: `${harness.harness}: tool-evidence capability was not registered for this run.`,
+        code: "adapter_capability_unregistered",
+        adapter: adapter.adapter,
+        message: `${adapter.adapter}: tool-evidence capability was not registered for this run.`,
       });
-    } else if (harness.tool_evidence.support !== "supported") {
+    } else if (adapter.tool_evidence.support !== "supported") {
       unknowns.push({
         code: "tool_evidence_unavailable",
-        harness: harness.harness,
-        message: `${harness.harness}: adapter-native tool evidence is ${harness.tool_evidence.support}.`,
+        adapter: adapter.adapter,
+        message: `${adapter.adapter}: adapter-native tool evidence is ${adapter.tool_evidence.support}.`,
       });
     }
   }
@@ -508,17 +554,17 @@ function buildUnknowns(
     if (agent.cost_usd === undefined) {
       unknowns.push({
         code: "agent_cost_unreported",
-        harness: agent.harness,
+        adapter: agent.adapter,
         agent_id: agent.id,
-        message: `${agent.id}: ${agent.harness} did not report per-run cost.`,
+        message: `${agent.id}: ${agent.adapter} did not report per-run cost.`,
       });
     }
     if (!agent.session_id) {
       unknowns.push({
         code: "agent_session_unreported",
-        harness: agent.harness,
+        adapter: agent.adapter,
         agent_id: agent.id,
-        message: `${agent.id}: ${agent.harness} did not report a child session id.`,
+        message: `${agent.id}: ${agent.adapter} did not report a child session id.`,
       });
     }
   }

package/src/core/workflow/run-state.ts

@@ -58,7 +58,7 @@ export interface WorkflowRunManifest {
   repository_before: RepoSnapshot;
   execution: {
     cwd: string;
-    default_harness: string;
+    default_adapter: string;
     max_agents: number;
     concurrency: number;
     subscription_only: boolean;
@@ -149,11 +149,11 @@ export function assertWorkflowRunResumable(
   runId: string,
 ): { manifest: WorkflowRunManifest; approvalId: string } {
   const manifest = readWorkflowRunManifest(coordRoot, runId);
-  const journalPath = join(coordRoot, ".harnery", "workflows", runId, "journal.jsonl");
-  if (!existsSync(journalPath)) throw new Error(`workflow run ${runId} has no journal`);
+  const transcriptPath = join(coordRoot, ".harnery", "workflows", runId, "transcript.jsonl");
+  if (!existsSync(transcriptPath)) throw new Error(`workflow run ${runId} has no transcript`);
   let approvalId: string | undefined;
   let terminal = false;
-  for (const line of readFileSync(journalPath, "utf8").split("\n")) {
+  for (const line of readFileSync(transcriptPath, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       const event = JSON.parse(line) as { event?: string; approval_id?: string };
@@ -162,7 +162,7 @@ export function assertWorkflowRunResumable(
       }
       if (event.event === "run.end") terminal = true;
     } catch {
-      throw new Error(`workflow run ${runId} has a malformed journal line`);
+      throw new Error(`workflow run ${runId} has a malformed transcript line`);
     }
   }
   if (terminal) throw new Error(`workflow run ${runId} is already terminal`);
@@ -270,8 +270,8 @@ function validExecution(value: WorkflowRunManifest["execution"]): boolean {
   if (!value || typeof value !== "object") return false;
   return (
     isAbsolute(value.cwd) &&
-    typeof value.default_harness === "string" &&
-    value.default_harness.length > 0 &&
+    typeof value.default_adapter === "string" &&
+    value.default_adapter.length > 0 &&
     positiveSafeInteger(value.max_agents) &&
     positiveSafeInteger(value.concurrency) &&
     typeof value.subscription_only === "boolean" &&

package/src/core/workflow/sandbox-projection.ts

@@ -1,5 +1,5 @@
 /**
- * Project the host's filesystem policy into a harness's own vendor sandbox
+ * Project the host's filesystem policy into a adapter's own vendor sandbox
  * (ADR 0039).
  *
  * Harnery decides where a workflow child may write. Until this existed it never
@@ -14,12 +14,12 @@
  * not, which is worse than refusing and worse than never offering the feature.
  */
 
-import type { HarnessSandboxProjection } from "../harnesses/types.ts";
+import type { AdapterSandboxProjection } from "../adapters/types.ts";
 import type { GitAdministrativeGrant, SpawnFilesystemPolicy } from "./types.ts";
 import type { WorkspaceBinding } from "./workspaces/types.ts";
 
 export class SandboxProjectionError extends Error {
-  readonly harness: string;
+  readonly adapter: string;
   readonly reason:
     | "mode_unrepresentable"
     | "writable_roots_unrepresentable"
@@ -27,10 +27,10 @@ export class SandboxProjectionError extends Error {
     | "writable_root_escapes_workspace"
     | "git_grant_unavailable";
 
-  constructor(harness: string, reason: SandboxProjectionError["reason"], message: string) {
+  constructor(adapter: string, reason: SandboxProjectionError["reason"], message: string) {
     super(message);
     this.name = "SandboxProjectionError";
-    this.harness = harness;
+    this.adapter = adapter;
     this.reason = reason;
   }
 }
@@ -46,31 +46,31 @@ export interface ResolvedSandboxProjection {
  * Throws rather than degrading; see the module note.
  */
 export function resolveSandboxProjection(
-  harness: string,
-  declaration: HarnessSandboxProjection | undefined,
+  adapter: string,
+  declaration: AdapterSandboxProjection | undefined,
   policy: SpawnFilesystemPolicy,
 ): ResolvedSandboxProjection {
   if (!declaration) {
     throw new SandboxProjectionError(
-      harness,
+      adapter,
       "no_projection",
-      `${harness} cannot project a filesystem policy into its sandbox; remove the policy or use a harness that can`,
+      `${adapter} cannot project a filesystem policy into its sandbox; remove the policy or use a adapter that can`,
     );
   }
   const nativeMode = declaration.modes[policy.mode];
   if (!nativeMode) {
     throw new SandboxProjectionError(
-      harness,
+      adapter,
       "mode_unrepresentable",
-      `${harness} does not distinguish the "${policy.mode}" filesystem mode, so it cannot be enforced`,
+      `${adapter} does not distinguish the "${policy.mode}" filesystem mode, so it cannot be enforced`,
     );
   }
   const writableRoots = policy.writableRoots ?? [];
   if (writableRoots.length > 0 && !declaration.writableRoots) {
     throw new SandboxProjectionError(
-      harness,
+      adapter,
       "writable_roots_unrepresentable",
-      `${harness} does not accept an explicit writable-root set, so ${writableRoots.length} declared path(s) could not be enforced`,
+      `${adapter} does not accept an explicit writable-root set, so ${writableRoots.length} declared path(s) could not be enforced`,
     );
   }
   for (const root of writableRoots) {
@@ -78,7 +78,7 @@ export function resolveSandboxProjection(
     // resolved differently by every vendor, so they are refused outright.
     if (typeof root !== "string" || !root.startsWith("/")) {
       throw new SandboxProjectionError(
-        harness,
+        adapter,
         "writable_roots_unrepresentable",
         `writable root ${JSON.stringify(root)} must be an absolute path`,
       );
@@ -103,14 +103,14 @@ function isWithin(root: string, candidate: string): boolean {
  * radius of a run that the workspace lifecycle believes it has contained.
  */
 export function assertProjectionWithinWorkspace(
-  harness: string,
+  adapter: string,
   allowedRootRealpath: string,
   writableRoots: readonly string[],
 ): void {
   for (const root of writableRoots) {
     if (!isWithin(allowedRootRealpath, root)) {
       throw new SandboxProjectionError(
-        harness,
+        adapter,
         "writable_root_escapes_workspace",
         `writable root ${JSON.stringify(root)} is outside the workspace root ${JSON.stringify(allowedRootRealpath)} the provider validated`,
       );