harnery 0.29.0 → 0.31.0

package/dist/core/workflow/sandbox-projection.js

@@ -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.
  */
 export class SandboxProjectionError extends Error {
-    harness;
+    adapter;
     reason;
-    constructor(harness, reason, message) {
+    constructor(adapter, reason, message) {
         super(message);
         this.name = "SandboxProjectionError";
-        this.harness = harness;
+        this.adapter = adapter;
         this.reason = reason;
     }
 }
@@ -27,23 +27,23 @@ export class SandboxProjectionError extends Error {
  * Resolve a requested policy against what the adapter declares it can carry.
  * Throws rather than degrading; see the module note.
  */
-export function resolveSandboxProjection(harness, declaration, policy) {
+export function resolveSandboxProjection(adapter, declaration, policy) {
     if (!declaration) {
-        throw new SandboxProjectionError(harness, "no_projection", `${harness} cannot project a filesystem policy into its sandbox; remove the policy or use a harness that can`);
+        throw new SandboxProjectionError(adapter, "no_projection", `${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, "mode_unrepresentable", `${harness} does not distinguish the "${policy.mode}" filesystem mode, so it cannot be enforced`);
+        throw new SandboxProjectionError(adapter, "mode_unrepresentable", `${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, "writable_roots_unrepresentable", `${harness} does not accept an explicit writable-root set, so ${writableRoots.length} declared path(s) could not be enforced`);
+        throw new SandboxProjectionError(adapter, "writable_roots_unrepresentable", `${adapter} does not accept an explicit writable-root set, so ${writableRoots.length} declared path(s) could not be enforced`);
     }
     for (const root of writableRoots) {
         // Relative paths cannot be validated against the provider's roots and are
         // resolved differently by every vendor, so they are refused outright.
         if (typeof root !== "string" || !root.startsWith("/")) {
-            throw new SandboxProjectionError(harness, "writable_roots_unrepresentable", `writable root ${JSON.stringify(root)} must be an absolute path`);
+            throw new SandboxProjectionError(adapter, "writable_roots_unrepresentable", `writable root ${JSON.stringify(root)} must be an absolute path`);
         }
     }
     return { nativeMode, writableRoots };
@@ -62,10 +62,10 @@ function isWithin(root, candidate) {
  * the provider never sanctioned would let a projection quietly widen the blast
  * radius of a run that the workspace lifecycle believes it has contained.
  */
-export function assertProjectionWithinWorkspace(harness, allowedRootRealpath, writableRoots) {
+export function assertProjectionWithinWorkspace(adapter, allowedRootRealpath, writableRoots) {
     for (const root of writableRoots) {
         if (!isWithin(allowedRootRealpath, root)) {
-            throw new SandboxProjectionError(harness, "writable_root_escapes_workspace", `writable root ${JSON.stringify(root)} is outside the workspace root ${JSON.stringify(allowedRootRealpath)} the provider validated`);
+            throw new SandboxProjectionError(adapter, "writable_root_escapes_workspace", `writable root ${JSON.stringify(root)} is outside the workspace root ${JSON.stringify(allowedRootRealpath)} the provider validated`);
         }
     }
 }

package/dist/core/workflow/spawn-claude.d.ts

@@ -17,9 +17,9 @@
  *    gets HARNERY_WORKFLOW_CHILD=1 and the stop-hook rule exempts it
  *    (stop-hook.ts), keeping heartbeats + events on.
  */
-import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.js";
+import type { AdapterInvocation, AdapterRawResult } from "../adapters/types.js";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.js";
-export declare function buildClaudeInvocation(req: SpawnRequest): HarnessInvocation;
-export declare function normalizeClaudeResult(raw: HarnessRawResult): SpawnResult;
+export declare function buildClaudeInvocation(req: SpawnRequest): AdapterInvocation;
+export declare function normalizeClaudeResult(raw: AdapterRawResult): SpawnResult;
 export declare const claudeCodeSpawner: Spawner;
 //# sourceMappingURL=spawn-claude.d.ts.map

package/dist/core/workflow/spawn-claude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn-claude.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-claude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAKjF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAYrE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,iBAAiB,CAsB1E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAwDxE;AAED,eAAO,MAAM,iBAAiB,EAAE,OAc/B,CAAC"}
+{"version":3,"file":"spawn-claude.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-claude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKhF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAYrE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,iBAAiB,CAsB1E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CA2ExE;AAED,eAAO,MAAM,iBAAiB,EAAE,OAiB/B,CAAC"}

package/dist/core/workflow/spawn-claude.js

@@ -18,16 +18,16 @@
  *    (stop-hook.ts), keeping heartbeats + events on.
  */
 import { exec } from "../../lib/exec.js";
-import { builtinHarnessProfile, validateHarnessEffort } from "../harnesses/profiles.js";
+import { builtinAdapterProfile, validateAdapterEffort } from "../adapters/profiles.js";
+import { notFoundError } from "./adapters.js";
 import { buildChildEnv } from "./child-env.js";
-import { notFoundError } from "./harnesses.js";
 import { resolveSandboxProjection } from "./sandbox-projection.js";
-import { vendorFailureText } from "./spawn-failure.js";
+import { isUpstreamFailureText, vendorFailureText } from "./spawn-failure.js";
 export function buildClaudeInvocation(req) {
-    validateHarnessEffort("claude-code", req.effort);
+    validateAdapterEffort("claude-code", req.effort);
     if (req.filesystemPolicy) {
         // Declared unrepresentable: refuse rather than drop it silently (ADR 0039).
-        resolveSandboxProjection("claude-code", builtinHarnessProfile("claude-code")?.sandboxProjection, req.filesystemPolicy);
+        resolveSandboxProjection("claude-code", builtinAdapterProfile("claude-code")?.sandboxProjection, req.filesystemPolicy);
     }
     const argv = [
         "claude",
@@ -53,7 +53,20 @@ export function normalizeClaudeResult(raw) {
             error: `claude timed out after ${raw.durationMs}ms and was killed`,
         };
     }
+    // Structural environment signal: the binary was never there (spawned directly,
+    // so a missing binary surfaces as ENOENT). Uncharged and not retried.
+    if (raw.spawnErrno === "ENOENT") {
+        return {
+            ok: false,
+            text: "",
+            durationMs: raw.durationMs,
+            error: notFoundError("claude-code"),
+            class: "environment",
+        };
+    }
     if (raw.exitCode === 127) {
+        // A bare 127 with no errno is a shell/vendor 127, indistinguishable from a
+        // legitimate one — charged as work rather than classed environment.
         return {
             ok: false,
             text: "",
@@ -62,11 +75,13 @@ export function normalizeClaudeResult(raw) {
         };
     }
     if (raw.exitCode !== 0) {
+        const failureText = vendorFailureText(raw);
         return {
             ok: false,
             text: "",
             durationMs: raw.durationMs,
-            error: `claude exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
+            error: `claude exited ${raw.exitCode}: ${failureText}`,
+            ...(isUpstreamFailureText(failureText) ? { class: "upstream" } : {}),
         };
     }
     let envelope;
@@ -82,13 +97,15 @@ export function normalizeClaudeResult(raw) {
         };
     }
     if (envelope.is_error) {
+        const envelopeError = `${envelope.subtype ?? ""} ${(envelope.errors ?? []).join("; ")} ${String(envelope.result ?? "")}`;
         return {
             ok: false,
             text: String(envelope.result ?? ""),
             sessionId: envelope.session_id,
             costUsd: envelope.total_cost_usd,
             durationMs: raw.durationMs,
-            error: `harness error (${envelope.subtype ?? "unknown"}): ${(envelope.errors ?? []).join("; ") || "see envelope"}`,
+            error: `adapter error (${envelope.subtype ?? "unknown"}): ${(envelope.errors ?? []).join("; ") || "see envelope"}`,
+            ...(isUpstreamFailureText(envelopeError) ? { class: "upstream" } : {}),
         };
     }
     return {
@@ -110,7 +127,10 @@ export const claudeCodeSpawner = async (req) => {
     }
     const r = await exec(invocation.argv, {
         cwd: req.cwd,
-        env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+        env: buildChildEnv(req.runId, {
+            subscriptionOnly: req.subscriptionOnly,
+            agentId: req.agentId,
+        }),
         timeout: req.timeoutMs,
     });
     return normalizeClaudeResult({ ...r, durationMs: Date.now() - t0 });

package/dist/core/workflow/spawn-codex.d.ts

@@ -3,7 +3,7 @@
  * subprocess.
  *
  * Contract notes (LIVE-VERIFIED 2026-07-16 against codex-cli 0.144.5: flags
- * present, schema-gated triage + text stages round-trip via `--harness codex`):
+ * present, schema-gated triage + text stages round-trip via `--adapter codex`):
  * - `codex exec "<prompt>"` is the non-interactive mode.
  * - The final assistant message is captured via `--output-last-message <file>`
  *   (a temp file), which is far more drift-tolerant than parsing the
@@ -14,9 +14,9 @@
  * - No max-turns equivalent → `maxTurns` is accepted and ignored (documented
  *   in the CLI docs page).
  */
-import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.js";
+import type { AdapterInvocation, AdapterRawResult } from "../adapters/types.js";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.js";
-export declare function buildCodexInvocation(req: SpawnRequest, resultFile?: string): HarnessInvocation;
-export declare function normalizeCodexResult(raw: HarnessRawResult): SpawnResult;
+export declare function buildCodexInvocation(req: SpawnRequest, resultFile?: string): AdapterInvocation;
+export declare function normalizeCodexResult(raw: AdapterRawResult): SpawnResult;
 export declare const codexSpawner: Spawner;
 //# sourceMappingURL=spawn-codex.d.ts.map

package/dist/core/workflow/spawn-codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn-codex.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-codex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAKjF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,iBAAiB,CA8B9F;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAyBvE;AAED,eAAO,MAAM,YAAY,EAAE,OA2B1B,CAAC"}
+{"version":3,"file":"spawn-codex.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-codex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKhF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,iBAAiB,CA8B9F;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAwCvE;AAED,eAAO,MAAM,YAAY,EAAE,OA8B1B,CAAC"}

package/dist/core/workflow/spawn-codex.js

@@ -3,7 +3,7 @@
  * subprocess.
  *
  * Contract notes (LIVE-VERIFIED 2026-07-16 against codex-cli 0.144.5: flags
- * present, schema-gated triage + text stages round-trip via `--harness codex`):
+ * present, schema-gated triage + text stages round-trip via `--adapter codex`):
  * - `codex exec "<prompt>"` is the non-interactive mode.
  * - The final assistant message is captured via `--output-last-message <file>`
  *   (a temp file), which is far more drift-tolerant than parsing the
@@ -19,18 +19,18 @@ import { existsSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { exec } from "../../lib/exec.js";
-import { builtinHarnessProfile, validateHarnessEffort } from "../harnesses/profiles.js";
+import { builtinAdapterProfile, validateAdapterEffort } from "../adapters/profiles.js";
+import { notFoundError } from "./adapters.js";
 import { buildChildEnv } from "./child-env.js";
-import { notFoundError } from "./harnesses.js";
 import { resolveSandboxProjection } from "./sandbox-projection.js";
-import { vendorFailureText } from "./spawn-failure.js";
+import { isUpstreamFailureText, vendorFailureText } from "./spawn-failure.js";
 export function buildCodexInvocation(req, resultFile) {
-    validateHarnessEffort("codex", req.effort);
+    validateAdapterEffort("codex", req.effort);
     if (!resultFile)
         throw new Error("codex adapter requires a final-message result file");
     // Default stays workspace-write so an unprojected request is unchanged.
     const projection = req.filesystemPolicy
-        ? resolveSandboxProjection("codex", builtinHarnessProfile("codex")?.sandboxProjection, req.filesystemPolicy)
+        ? resolveSandboxProjection("codex", builtinAdapterProfile("codex")?.sandboxProjection, req.filesystemPolicy)
         : undefined;
     const argv = [
         "codex",
@@ -60,15 +60,30 @@ export function normalizeCodexResult(raw) {
             error: `codex timed out after ${raw.durationMs}ms and was killed`,
         };
     }
+    // Structural environment signal: the binary was never there (spawned directly,
+    // so a missing binary surfaces as ENOENT). Uncharged and not retried.
+    if (raw.spawnErrno === "ENOENT") {
+        return {
+            ok: false,
+            text: "",
+            durationMs: raw.durationMs,
+            error: notFoundError("codex"),
+            class: "environment",
+        };
+    }
     if (raw.exitCode === 127) {
+        // A bare 127 with no errno is a shell/vendor 127, indistinguishable from a
+        // legitimate one — charged as work rather than classed environment.
         return { ok: false, text: "", durationMs: raw.durationMs, error: notFoundError("codex") };
     }
     if (raw.exitCode !== 0) {
+        const failureText = vendorFailureText(raw);
         return {
             ok: false,
             text: "",
             durationMs: raw.durationMs,
-            error: `codex exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
+            error: `codex exited ${raw.exitCode}: ${failureText}`,
+            ...(isUpstreamFailureText(failureText) ? { class: "upstream" } : {}),
         };
     }
     return {
@@ -90,7 +105,10 @@ export const codexSpawner = async (req) => {
         }
         const r = await exec(invocation.argv, {
             cwd: req.cwd,
-            env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+            env: buildChildEnv(req.runId, {
+                subscriptionOnly: req.subscriptionOnly,
+                agentId: req.agentId,
+            }),
             timeout: req.timeoutMs,
         });
         return normalizeCodexResult({

package/dist/core/workflow/spawn-cursor.d.ts

@@ -4,7 +4,7 @@
  *
  * Contract notes (LIVE-VERIFIED 2026-07-17 against cursor-agent
  * 2026.07.16-899851b: schema-gated triage + text stages round-trip via
- * `--harness cursor`, session_id parses from the envelope):
+ * `--adapter cursor`, session_id parses from the envelope):
  * - `cursor-agent -p "<prompt>" --output-format json` prints a single result
  *   envelope modeled on Claude Code's (`{type: "result", is_error, result,
  *   session_id, …}`).
@@ -18,7 +18,7 @@
  * - No per-run cost surface → undefined. No max-turns equivalent → `maxTurns`
  *   accepted and ignored (documented in the CLI docs page).
  */
-import type { HarnessInvocation, HarnessRawResult } from "../harnesses/types.js";
+import type { AdapterInvocation, AdapterRawResult } from "../adapters/types.js";
 import type { Spawner, SpawnRequest, SpawnResult } from "./types.js";
 /** Exported for unit tests (no live binary to test against). */
 export declare function parseCursorOutput(stdout: string): {
@@ -26,7 +26,7 @@ export declare function parseCursorOutput(stdout: string): {
     sessionId?: string;
     isError: boolean;
 };
-export declare function buildCursorInvocation(req: SpawnRequest): HarnessInvocation;
-export declare function normalizeCursorResult(raw: HarnessRawResult): SpawnResult;
+export declare function buildCursorInvocation(req: SpawnRequest): AdapterInvocation;
+export declare function normalizeCursorResult(raw: AdapterRawResult): SpawnResult;
 export declare const cursorSpawner: Spawner;
 //# sourceMappingURL=spawn-cursor.d.ts.map

package/dist/core/workflow/spawn-cursor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn-cursor.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAKjF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AASrE,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB,CAWA;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,iBAAiB,CAkB1E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAqCxE;AAED,eAAO,MAAM,aAAa,EAAE,OAe3B,CAAC"}
+{"version":3,"file":"spawn-cursor.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKhF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AASrE,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB,CAWA;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,iBAAiB,CAkB1E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAqDxE;AAED,eAAO,MAAM,aAAa,EAAE,OAkB3B,CAAC"}

package/dist/core/workflow/spawn-cursor.js

@@ -4,7 +4,7 @@
  *
  * Contract notes (LIVE-VERIFIED 2026-07-17 against cursor-agent
  * 2026.07.16-899851b: schema-gated triage + text stages round-trip via
- * `--harness cursor`, session_id parses from the envelope):
+ * `--adapter cursor`, session_id parses from the envelope):
  * - `cursor-agent -p "<prompt>" --output-format json` prints a single result
  *   envelope modeled on Claude Code's (`{type: "result", is_error, result,
  *   session_id, …}`).
@@ -19,11 +19,11 @@
  *   accepted and ignored (documented in the CLI docs page).
  */
 import { exec } from "../../lib/exec.js";
-import { builtinHarnessProfile, validateHarnessEffort } from "../harnesses/profiles.js";
+import { builtinAdapterProfile, validateAdapterEffort } from "../adapters/profiles.js";
+import { notFoundError } from "./adapters.js";
 import { buildChildEnv } from "./child-env.js";
-import { notFoundError } from "./harnesses.js";
 import { resolveSandboxProjection } from "./sandbox-projection.js";
-import { vendorFailureText } from "./spawn-failure.js";
+import { isUpstreamFailureText, vendorFailureText } from "./spawn-failure.js";
 /** Exported for unit tests (no live binary to test against). */
 export function parseCursorOutput(stdout) {
     try {
@@ -39,10 +39,10 @@ export function parseCursorOutput(stdout) {
     }
 }
 export function buildCursorInvocation(req) {
-    validateHarnessEffort("cursor", req.effort);
+    validateAdapterEffort("cursor", req.effort);
     if (req.filesystemPolicy) {
         // Declared unrepresentable: refuse rather than drop it silently (ADR 0039).
-        resolveSandboxProjection("cursor", builtinHarnessProfile("cursor")?.sandboxProjection, req.filesystemPolicy);
+        resolveSandboxProjection("cursor", builtinAdapterProfile("cursor")?.sandboxProjection, req.filesystemPolicy);
     }
     // --trust: headless cursor-agent refuses untrusted workspaces (exit 1,
     // "Workspace Trust Required"). --force: a print-mode child has no interactive
@@ -63,15 +63,30 @@ export function normalizeCursorResult(raw) {
             error: `cursor timed out after ${raw.durationMs}ms and was killed`,
         };
     }
+    // Structural environment signal: the binary was never there (spawned directly,
+    // so a missing binary surfaces as ENOENT). Uncharged and not retried.
+    if (raw.spawnErrno === "ENOENT") {
+        return {
+            ok: false,
+            text: "",
+            durationMs: raw.durationMs,
+            error: notFoundError("cursor"),
+            class: "environment",
+        };
+    }
     if (raw.exitCode === 127) {
+        // A bare 127 with no errno is a shell/vendor 127, indistinguishable from a
+        // legitimate one — charged as work rather than classed environment.
         return { ok: false, text: "", durationMs: raw.durationMs, error: notFoundError("cursor") };
     }
     if (raw.exitCode !== 0) {
+        const failureText = vendorFailureText(raw);
         return {
             ok: false,
             text: "",
             durationMs: raw.durationMs,
-            error: `cursor-agent exited ${raw.exitCode}: ${vendorFailureText(raw)}`,
+            error: `cursor-agent exited ${raw.exitCode}: ${failureText}`,
+            ...(isUpstreamFailureText(failureText) ? { class: "upstream" } : {}),
         };
     }
     const parsed = parseCursorOutput(raw.stdout);
@@ -82,6 +97,7 @@ export function normalizeCursorResult(raw) {
             sessionId: parsed.sessionId,
             durationMs: raw.durationMs,
             error: `cursor-agent reported is_error: ${parsed.text.slice(0, 300)}`,
+            ...(isUpstreamFailureText(parsed.text) ? { class: "upstream" } : {}),
         };
     }
     return {
@@ -102,7 +118,10 @@ export const cursorSpawner = async (req) => {
     }
     const r = await exec(invocation.argv, {
         cwd: req.cwd,
-        env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+        env: buildChildEnv(req.runId, {
+            subscriptionOnly: req.subscriptionOnly,
+            agentId: req.agentId,
+        }),
         timeout: req.timeoutMs,
     });
     return normalizeCursorResult({ ...r, durationMs: Date.now() - t0 });

package/dist/core/workflow/spawn-failure.d.ts

@@ -1,5 +1,5 @@
 /**
- * Shared failure-text extraction for the harness spawn adapters.
+ * Shared failure-text extraction for the adapter spawn adapters.
  *
  * A vendor CLI prints its banner, resolved config, and startup warnings first,
  * and the reason it actually failed last. Every adapter used to keep the FIRST
@@ -15,4 +15,18 @@ export declare function vendorFailureText(raw: {
     stdout?: string;
     stderr?: string;
 }, maxChars?: number): string;
+/**
+ * Whether failure text names an UPSTREAM refusal — the vendor was reached and
+ * refused (a 5xx/429 status or circuit-open wording), as opposed to a work
+ * failure (the model ran and produced a wrong or incomplete result).
+ *
+ * There is no structural upstream signal the way ENOENT structurally marks a
+ * missing binary, so this is the one text match in the classifier. It is kept
+ * SHORT and documented on purpose: a per-vendor regex zoo would rot, and a
+ * false positive here wrongly withholds a charge, so both the phrase list and
+ * the numeric match stay tight — the number must sit in HTTP-status context, not
+ * merely fall in the 429/5xx range. Anything it does not match falls through to
+ * a charged work failure.
+ */
+export declare function isUpstreamFailureText(text: string): boolean;
 //# sourceMappingURL=spawn-failure.d.ts.map

package/dist/core/workflow/spawn-failure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn-failure.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,mEAAmE;AACnE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EACzC,QAAQ,SAAoB,GAC3B,MAAM,CAQR"}
+{"version":3,"file":"spawn-failure.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,mEAAmE;AACnE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EACzC,QAAQ,SAAoB,GAC3B,MAAM,CAQR;AAyBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D"}

package/dist/core/workflow/spawn-failure.js

@@ -1,5 +1,5 @@
 /**
- * Shared failure-text extraction for the harness spawn adapters.
+ * Shared failure-text extraction for the adapter spawn adapters.
  *
  * A vendor CLI prints its banner, resolved config, and startup warnings first,
  * and the reason it actually failed last. Every adapter used to keep the FIRST
@@ -22,3 +22,37 @@ export function vendorFailureText(raw, maxChars = DEFAULT_MAX_CHARS) {
     const combined = parts.join("\n");
     return combined.length > maxChars ? `…${combined.slice(-maxChars)}` : combined;
 }
+// A 429 or 5xx status, but only where it sits in HTTP-status CONTEXT — not any
+// digits that merely happen to fall in that range. A bare-number match treats a
+// line number ("at line 500"), an item count ("got 429 items"), or a duration
+// ("after 502 seconds") as an upstream refusal, which wrongly withholds a charge
+// for a failure that was entirely our code. Three recognized shapes:
+//   1. after an "HTTP" label:  "HTTP 429", "HTTP/1.1 503 Service Unavailable"
+//   2. after a "status" label: "status 500", "status: 429", "status code 502"
+//   3. a bare status line:     "503 Service Unavailable" (code at line start,
+//      then a reason phrase) — the classic "<code> <Reason-Phrase>" shape.
+// The trailing `(?![0-9])` and the label/line-start anchors also keep a status
+// embedded in a longer number ("4295"/"5031") out. All 5xx are server-side; 429
+// is the only 4xx that means "reached and refused, retry later".
+const STATUS = "(?:429|5[0-9]{2})";
+const UPSTREAM_STATUS = new RegExp(`(?:\\bHTTP\\b[/0-9. ]*|\\bstatus(?:\\s*code)?\\b[\\s:=]*)${STATUS}(?![0-9])` +
+    `|(?:^|\\n)\\s*${STATUS}\\s+[A-Za-z]`, "i");
+// Explicit vendor wording for the same conditions when a numeric status is
+// absent. Deliberately short — see isUpstreamFailureText.
+const UPSTREAM_PHRASES = /circuit[ _-]?open|service unavailable|too many requests|rate[ _-]?limit|overloaded|bad gateway|gateway time-?out|internal server error/i;
+/**
+ * Whether failure text names an UPSTREAM refusal — the vendor was reached and
+ * refused (a 5xx/429 status or circuit-open wording), as opposed to a work
+ * failure (the model ran and produced a wrong or incomplete result).
+ *
+ * There is no structural upstream signal the way ENOENT structurally marks a
+ * missing binary, so this is the one text match in the classifier. It is kept
+ * SHORT and documented on purpose: a per-vendor regex zoo would rot, and a
+ * false positive here wrongly withholds a charge, so both the phrase list and
+ * the numeric match stay tight — the number must sit in HTTP-status context, not
+ * merely fall in the 429/5xx range. Anything it does not match falls through to
+ * a charged work failure.
+ */
+export function isUpstreamFailureText(text) {
+    return UPSTREAM_STATUS.test(text) || UPSTREAM_PHRASES.test(text);
+}

package/dist/core/workflow/specialists.js

@@ -21,7 +21,7 @@ export function normalizeWorkflowSpecialists(input) {
         }
         normalized[id] = {
             instructions: bounded(profile.instructions, `workflow specialist ${id} instructions`, MAX_INSTRUCTIONS),
-            harness: optional(profile.harness, `workflow specialist ${id} harness`),
+            adapter: optional(profile.adapter, `workflow specialist ${id} adapter`),
             model: optional(profile.model, `workflow specialist ${id} model`),
             effort: optional(profile.effort, `workflow specialist ${id} effort`),
             maxAttempts: positiveOptional(profile.maxAttempts, `workflow specialist ${id} maxAttempts`, 10),
@@ -44,7 +44,7 @@ export function resolveSpecialistAssignment(profiles, prompt, opts) {
         prompt: `${profile.instructions}\n\nAssignment:\n${prompt}`,
         opts: {
             specialist: opts.specialist,
-            harness: opts.harness ?? profile.harness,
+            adapter: opts.adapter ?? profile.adapter,
             model: opts.model ?? profile.model,
             effort: opts.effort ?? profile.effort,
             maxAttempts: opts.maxAttempts ?? profile.maxAttempts,

package/dist/core/workflow/{journal.d.ts → transcript.d.ts}

@@ -1,14 +1,14 @@
-export declare const WORKFLOW_JOURNAL_EVENT_BYTES: number;
+export declare const WORKFLOW_TRANSCRIPT_EVENT_BYTES: number;
 /** Key under which a shrunk record names the fields it had to drop. */
-export declare const WORKFLOW_JOURNAL_OMITTED = "omitted_fields";
-export interface WorkflowJournalOmission {
+export declare const WORKFLOW_TRANSCRIPT_OMITTED = "omitted_fields";
+export interface WorkflowTranscriptOmission {
     field: string;
     bytes: number;
     sha256: string;
 }
-export declare function workflowJournalPath(coordRoot: string, runId: string): string;
+export declare function workflowTranscriptPath(coordRoot: string, runId: string): string;
 /**
- * Append one journal record, always.
+ * Append one transcript record, always.
  *
  * A record that would exceed what a reader accepts has its largest fields
  * replaced by a digest and a byte count until it fits, and it names what it
@@ -20,11 +20,11 @@ export declare function workflowJournalPath(coordRoot: string, runId: string): s
  * this limit by construction. Losing detail from a record is recoverable.
  * Losing the run that was writing it is not.
  */
-export declare function appendWorkflowJournalEvent(coordRoot: string, runId: string, event: string, data: Record<string, unknown>): void;
+export declare function appendWorkflowTranscriptEvent(coordRoot: string, runId: string, event: string, data: Record<string, unknown>): void;
 /**
  * Shrink a record to the reader's limit by dropping its largest fields first.
  * The envelope is never dropped, so a record keeps its run id, timestamp, and
  * event name however much detail it loses. Exported for tests.
  */
-export declare function fitWorkflowJournalRecord(envelope: Record<string, unknown>, data: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=journal.d.ts.map
+export declare function fitWorkflowTranscriptRecord(envelope: Record<string, unknown>, data: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/core/workflow/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/transcript.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,+BAA+B,QAAY,CAAC;AAEzD,uEAAuE;AACvE,eAAO,MAAM,2BAA2B,mBAAmB,CAAC;AAI5D,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,IAAI,CAiBN;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBzB"}

package/dist/core/workflow/{journal.js → transcript.js}

@@ -2,18 +2,18 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, writeFileSync }
 import { dirname, join, resolve } from "node:path";
 import { fsyncParentDirectory, stableDigest } from "./durable-record.js";
 // Limit for the JSON record body. The trailing newline delimiter is outside the
-// record and is not counted by readers after splitting journal lines.
-export const WORKFLOW_JOURNAL_EVENT_BYTES = 16 * 1024;
+// record and is not counted by readers after splitting transcript lines.
+export const WORKFLOW_TRANSCRIPT_EVENT_BYTES = 16 * 1024;
 /** Key under which a shrunk record names the fields it had to drop. */
-export const WORKFLOW_JOURNAL_OMITTED = "omitted_fields";
+export const WORKFLOW_TRANSCRIPT_OMITTED = "omitted_fields";
 const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
-export function workflowJournalPath(coordRoot, runId) {
+export function workflowTranscriptPath(coordRoot, runId) {
     if (!RUN_ID.test(runId))
         throw new Error(`invalid workflow run id ${JSON.stringify(runId)}`);
-    return join(resolve(coordRoot), ".harnery", "workflows", runId, "journal.jsonl");
+    return join(resolve(coordRoot), ".harnery", "workflows", runId, "transcript.jsonl");
 }
 /**
- * Append one journal record, always.
+ * Append one transcript record, always.
  *
  * A record that would exceed what a reader accepts has its largest fields
  * replaced by a digest and a byte count until it fits, and it names what it
@@ -25,9 +25,9 @@ export function workflowJournalPath(coordRoot, runId) {
  * this limit by construction. Losing detail from a record is recoverable.
  * Losing the run that was writing it is not.
  */
-export function appendWorkflowJournalEvent(coordRoot, runId, event, data) {
-    const path = workflowJournalPath(coordRoot, runId);
-    const record = fitWorkflowJournalRecord({ schema_version: 1, run_id: runId, ts: new Date().toISOString(), event }, data);
+export function appendWorkflowTranscriptEvent(coordRoot, runId, event, data) {
+    const path = workflowTranscriptPath(coordRoot, runId);
+    const record = fitWorkflowTranscriptRecord({ schema_version: 1, run_id: runId, ts: new Date().toISOString(), event }, data);
     const line = `${JSON.stringify(record)}\n`;
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const existed = existsSync(path);
@@ -47,9 +47,9 @@ export function appendWorkflowJournalEvent(coordRoot, runId, event, data) {
  * The envelope is never dropped, so a record keeps its run id, timestamp, and
  * event name however much detail it loses. Exported for tests.
  */
-export function fitWorkflowJournalRecord(envelope, data) {
+export function fitWorkflowTranscriptRecord(envelope, data) {
     const candidate = { ...envelope, ...data };
-    if (Buffer.byteLength(JSON.stringify(candidate)) <= WORKFLOW_JOURNAL_EVENT_BYTES) {
+    if (Buffer.byteLength(JSON.stringify(candidate)) <= WORKFLOW_TRANSCRIPT_EVENT_BYTES) {
         return candidate;
     }
     const kept = { ...data };
@@ -60,11 +60,11 @@ export function fitWorkflowJournalRecord(envelope, data) {
     for (const { field, bytes } of bySize) {
         omitted.push({ field, bytes, sha256: stableDigest(data[field]) });
         delete kept[field];
-        const next = { ...envelope, ...kept, [WORKFLOW_JOURNAL_OMITTED]: omitted };
-        if (Buffer.byteLength(JSON.stringify(next)) <= WORKFLOW_JOURNAL_EVENT_BYTES)
+        const next = { ...envelope, ...kept, [WORKFLOW_TRANSCRIPT_OMITTED]: omitted };
+        if (Buffer.byteLength(JSON.stringify(next)) <= WORKFLOW_TRANSCRIPT_EVENT_BYTES)
             return next;
     }
     // Every field dropped and still over: the omission list is itself the excess.
     // Keep the envelope and a count so the record stays parseable and honest.
-    return { ...envelope, [WORKFLOW_JOURNAL_OMITTED]: omitted.length };
+    return { ...envelope, [WORKFLOW_TRANSCRIPT_OMITTED]: omitted.length };
 }