@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/chunk-HLKC4UYB.js

@@ -1,3514 +0,0 @@
-import {
-  contentAddress,
-  materializeTreeView,
-  pendingWaits,
-  replaySpawnTree
-} from "./chunk-ISPWRSEC.js";
-import {
-  addTokenUsage,
-  zeroTokenUsage
-} from "./chunk-3MDZX7YU.js";
-import {
-  RuntimeRunStateError,
-  ValidationError
-} from "./chunk-YEJR7IXO.js";
-
-// src/mcp/codex-diagnostics.ts
-import { constants } from "fs";
-import { open } from "fs/promises";
-import { stripVTControlCharacters } from "util";
-var CodexExecutionDiagnosticError = class extends Error {
-  constructor(reason, diagnostic, cause) {
-    super(
-      `runLocalHarness: reproducible Codex execution failed: ${reason}; diagnostic=${JSON.stringify(diagnostic)}`,
-      { cause }
-    );
-    this.reason = reason;
-    this.diagnostic = diagnostic;
-    this.name = "CodexExecutionDiagnosticError";
-  }
-  reason;
-  diagnostic;
-  code = "CODEX_EXECUTION_DIAGNOSTIC";
-};
-var CODEX_FAILURE_STREAM_MAX_CHARS = 4096;
-var CODEX_AUTH_MAX_BYTES = 1024 * 1024;
-var CODEX_REDACTED = "<REDACTED_CREDENTIAL>";
-var codexSensitiveEnvironmentName = /(TOKEN|KEY|SECRET|PASSWORD|CREDENTIAL|AUTH|COOKIE)/i;
-function createCodexExecutionDiagnosticError(opts) {
-  const redact = (value) => redactCodexDiagnostic(value, opts.codexHome, opts.redactionValues);
-  const boundedStdout = boundCodexDiagnostic(redact(opts.stdout));
-  const boundedStderr = boundCodexDiagnostic(redact(opts.stderr));
-  const diagnostic = {
-    exitCode: opts.exitCode,
-    killedBySignal: opts.killedBySignal,
-    timedOut: opts.timedOut,
-    ...opts.aborted !== void 0 ? { aborted: opts.aborted } : {},
-    durationMs: opts.durationMs,
-    stdout: boundedStdout.value,
-    stderr: boundedStderr.value,
-    stdoutTruncated: boundedStdout.truncated,
-    stderrTruncated: boundedStderr.truncated
-  };
-  const safeReason = boundCodexDiagnostic(redact(opts.reason), 1024).value;
-  return new CodexExecutionDiagnosticError(
-    safeReason,
-    diagnostic,
-    redactCodexErrorCause(opts.cause, safeReason, redact)
-  );
-}
-function redactCodexHome(value, codexHome) {
-  return codexHome ? value.replaceAll(codexHome, "<ISOLATED_CODEX_HOME>") : value;
-}
-function collectCodexDiagnosticRedactionValues(env, authText) {
-  const values = Object.entries(env).filter(
-    ([name, value]) => codexSensitiveEnvironmentName.test(name) && typeof value === "string"
-  ).map(([, value]) => value);
-  try {
-    collectStringLeaves(JSON.parse(authText), values);
-  } catch {
-  }
-  const encoded = values.filter((value) => value.length >= 8).flatMap((value) => [
-    Buffer.from(value, "utf8").toString("base64"),
-    Buffer.from(value, "utf8").toString("base64url"),
-    encodeURIComponent(value),
-    JSON.stringify(value).slice(1, -1)
-  ]);
-  return [.../* @__PURE__ */ new Set([...values, ...encoded])];
-}
-async function readCodexAuthRedactionText(path) {
-  const handle = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
-  try {
-    const stats = await handle.stat();
-    if (!stats.isFile() || !Number.isSafeInteger(stats.size) || stats.size > CODEX_AUTH_MAX_BYTES) {
-      throw new Error("Codex auth.json must be a regular file no larger than 1 MiB");
-    }
-    const buffer = Buffer.alloc(stats.size);
-    let offset = 0;
-    while (offset < buffer.length) {
-      const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
-      if (bytesRead === 0) break;
-      offset += bytesRead;
-    }
-    return buffer.subarray(0, offset).toString("utf8");
-  } finally {
-    await handle.close();
-  }
-}
-function boundCodexDiagnostic(value, maxChars = CODEX_FAILURE_STREAM_MAX_CHARS) {
-  if (value.length <= maxChars) return { value, truncated: false };
-  const marker = "\n<... OUTPUT TRUNCATED ...>\n";
-  const contentChars = maxChars - marker.length;
-  const headChars = Math.floor(contentChars / 2);
-  const tailChars = contentChars - headChars;
-  return {
-    value: `${value.slice(0, headChars)}${marker}${value.slice(-tailChars)}`,
-    truncated: true
-  };
-}
-function redactCodexDiagnostic(value, codexHome, protectedValues) {
-  let redacted = redactCodexHome(stripVTControlCharacters(value), codexHome);
-  const exactValues = [...new Set(protectedValues.filter((item) => item.length >= 6))].sort(
-    (a, b) => b.length - a.length
-  );
-  for (const secret of exactValues) redacted = redacted.replaceAll(secret, CODEX_REDACTED);
-  redacted = redacted.replace(/(\bBearer\s+)[A-Za-z0-9._~+/=-]{6,}/gi, `$1${CODEX_REDACTED}`).replace(/\b(?:sk|rk|pk)-[A-Za-z0-9._-]{8,}\b/g, CODEX_REDACTED).replace(/\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\b/g, CODEX_REDACTED).replace(
-    /((?:["']?(?:api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|client[-_]?secret|private[-_]?key|session[-_]?(?:id|token)|secret|password|passwd|authorization|credential|cookie)["']?)\s*[:=]\s*)(["'])[^"'\r\n]*\2/gi,
-    `$1$2${CODEX_REDACTED}$2`
-  ).replace(
-    /((?:["']?(?:api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|client[-_]?secret|private[-_]?key|session[-_]?(?:id|token)|secret|password|passwd|authorization|credential|cookie)["']?)\s*[:=]\s*)([^\s,;}]+)/gi,
-    `$1${CODEX_REDACTED}`
-  );
-  for (const secret of exactValues) redacted = redacted.replaceAll(secret, CODEX_REDACTED);
-  return redacted;
-}
-function redactCodexErrorCause(cause, safeReason, redact) {
-  if (!(cause instanceof Error)) return void 0;
-  const safeCause = new Error(safeReason);
-  safeCause.name = cause.name;
-  if (cause.stack) safeCause.stack = boundCodexDiagnostic(redact(cause.stack)).value;
-  return safeCause;
-}
-function collectStringLeaves(value, output) {
-  if (typeof value === "string") {
-    output.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) collectStringLeaves(item, output);
-    return;
-  }
-  if (value !== null && typeof value === "object") {
-    for (const item of Object.values(value)) collectStringLeaves(item, output);
-  }
-}
-
-// src/mcp/local-harness.ts
-import { spawn } from "child_process";
-import { createHash, randomUUID } from "crypto";
-import { constants as constants2, createReadStream } from "fs";
-import {
-  access,
-  chmod,
-  copyFile,
-  mkdir,
-  mkdtemp,
-  open as open2,
-  readFile,
-  realpath,
-  rm,
-  symlink,
-  writeFile
-} from "fs/promises";
-import { homedir, tmpdir } from "os";
-import { basename, delimiter, dirname, isAbsolute, join, resolve, sep } from "path";
-var codexReasoningEffort = {
-  none: "none",
-  minimal: "minimal",
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "xhigh",
-  ultracode: "xhigh"
-};
-function codexReasoningArgs(reasoningEffort) {
-  const mapped = codexReasoningEffort[reasoningEffort];
-  if (mapped === void 0) {
-    throw new Error(
-      `harnessInvocation: unsupported Codex reasoning effort ${String(reasoningEffort)}`
-    );
-  }
-  return ["-c", `model_reasoning_effort="${mapped}"`];
-}
-var HARNESS_INVOCATIONS = {
-  claude: {
-    command: "claude",
-    // `-p` IS headless/print mode; the old `--headless` flag was removed from the CLI.
-    // Permission bypass is an explicit per-run opt-in below, never the public default.
-    buildArgs: (taskPrompt) => ["-p", taskPrompt],
-    modelArgs: (model) => ["-m", model]
-  },
-  codex: {
-    command: "codex",
-    buildArgs: (taskPrompt) => ["exec", taskPrompt],
-    modelArgs: (model) => ["-m", model],
-    reasoningArgs: codexReasoningArgs
-  },
-  opencode: {
-    command: "opencode",
-    buildArgs: (taskPrompt) => ["run", taskPrompt],
-    modelArgs: (model) => ["-m", model]
-  }
-};
-var CODEX_REPRODUCIBLE_ARGS = [
-  "--ephemeral",
-  "--ignore-rules",
-  "--json",
-  "-c",
-  'approval_policy="never"',
-  "-c",
-  'web_search="disabled"',
-  "-c",
-  "project_doc_max_bytes=0",
-  "-c",
-  "skills.include_instructions=false",
-  "-c",
-  "include_apps_instructions=false",
-  "--disable",
-  "tool_suggest",
-  "-c",
-  'features.multi_agent_v2.root_agent_usage_hint_text=""',
-  "-c",
-  'features.multi_agent_v2.subagent_usage_hint_text=""',
-  "-c",
-  'features.multi_agent_v2.multi_agent_mode_hint_text=""',
-  "--strict-config"
-];
-function buildHarnessArgs(harness, taskPrompt, options = {}) {
-  const args = HARNESS_INVOCATIONS[harness].buildArgs(taskPrompt);
-  if (harness === "claude" && options.dangerouslySkipPermissions) {
-    args.push("--dangerously-skip-permissions");
-  }
-  if (options.codexReproducible) {
-    if (harness !== "codex") {
-      throw new Error("harnessInvocation: codexReproducible requires the Codex harness");
-    }
-    args.push(...CODEX_REPRODUCIBLE_ARGS);
-  }
-  return args;
-}
-function harnessInvocation(harness, profile, taskPrompt, options = {}) {
-  const invocation = HARNESS_INVOCATIONS[harness];
-  if (!invocation) {
-    throw new Error(`harnessInvocation: unknown harness ${String(harness)}`);
-  }
-  if (options.codexReproducible) {
-    const model2 = profile.model?.default;
-    if (typeof model2 !== "string" || model2.trim().length === 0) {
-      throw new Error("harnessInvocation: codexReproducible requires profile.model.default");
-    }
-    if (profile.model?.reasoningEffort === void 0) {
-      throw new Error("harnessInvocation: codexReproducible requires profile.model.reasoningEffort");
-    }
-  }
-  const systemPrompt = profile.prompt?.systemPrompt;
-  const instructions = profile.prompt?.instructions;
-  if (instructions !== void 0 && (!Array.isArray(instructions) || instructions.some((instruction) => typeof instruction !== "string"))) {
-    throw new Error("harnessInvocation: profile.prompt.instructions must be an array of strings");
-  }
-  const promptSections = [
-    ...typeof systemPrompt === "string" && systemPrompt.trim().length > 0 ? [systemPrompt] : [],
-    ...instructions?.filter((instruction) => instruction.trim().length > 0) ?? [],
-    taskPrompt
-  ];
-  const composedPrompt = promptSections.join("\n\n");
-  const args = buildHarnessArgs(harness, composedPrompt, options);
-  const model = profile.model?.default;
-  if (typeof model === "string" && model.length > 0) {
-    args.push(...invocation.modelArgs(model));
-  }
-  const reasoningEffort = profile.model?.reasoningEffort;
-  if (reasoningEffort !== void 0 && invocation.reasoningArgs) {
-    args.push(...invocation.reasoningArgs(reasoningEffort));
-  }
-  return { command: invocation.command, args, prompt: composedPrompt };
-}
-var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
-var DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
-var processKillGraceMs = 250;
-var processGroupExitConfirmMs = 1e3;
-var processGroupExitPollMs = 10;
-var RollingByteCapture = class {
-  constructor(maxBytes) {
-    this.maxBytes = maxBytes;
-  }
-  maxBytes;
-  chunks = [];
-  bytes = 0;
-  append(chunk) {
-    if (this.maxBytes === 0) return;
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-    this.chunks.push(buffer);
-    this.bytes += buffer.length;
-    let excess = this.bytes - this.maxBytes;
-    while (excess > 0 && this.chunks.length > 0) {
-      const first = this.chunks[0];
-      if (first.length <= excess) {
-        this.chunks.shift();
-        this.bytes -= first.length;
-        excess -= first.length;
-      } else {
-        this.chunks[0] = first.subarray(excess);
-        this.bytes -= excess;
-        excess = 0;
-      }
-    }
-  }
-  text() {
-    return Buffer.concat(this.chunks, this.bytes).toString("utf8");
-  }
-};
-async function runLocalHarness(options) {
-  const { harness, cwd, taskPrompt } = options;
-  if (options.codexReproducible && harness !== "codex") {
-    throw new Error("runLocalHarness: codexReproducible requires the Codex harness");
-  }
-  if (options.codexReproducible && process.platform !== "linux") {
-    throw new Error("runLocalHarness: codexReproducible currently requires Linux");
-  }
-  if (options.codexReadDeniedPaths !== void 0 && !options.codexReproducible) {
-    throw new Error("runLocalHarness: codexReadDeniedPaths requires codexReproducible");
-  }
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
-  if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0) {
-    throw new Error("runLocalHarness: maxOutputBytes must be a non-negative safe integer");
-  }
-  const spawnImpl = options.spawn ?? spawn;
-  const invocation = HARNESS_INVOCATIONS[harness];
-  if (!invocation) {
-    throw new Error(`runLocalHarness: unknown harness ${String(harness)}`);
-  }
-  const startedAt = Date.now();
-  const requestedCommand = options.invocation?.command ?? invocation.command;
-  const args = options.invocation ? [...options.invocation.args] : buildHarnessArgs(harness, taskPrompt, options);
-  if (options.codexReproducible) assertCodexReproducibleInvocation(requestedCommand, args);
-  options.signal?.throwIfAborted();
-  const baseEnv = { ...options.env ?? process.env, PWD: cwd };
-  const isolated = options.codexReproducible ? await isolateCodexHome({
-    baseEnv,
-    cwd,
-    command: requestedCommand,
-    readDeniedPaths: options.codexReadDeniedPaths ?? [],
-    resolveExecutable: options.resolveCodexExecutable ?? resolveCodexNativeExecutable
-  }) : {
-    env: baseEnv,
-    command: requestedCommand,
-    cleanup: async () => void 0,
-    controlledConfigSha256: "",
-    executableSha256: "",
-    readDeniedPathsSha256: "",
-    readDeniedPathCount: 0,
-    readDeniedPaths: [],
-    diagnosticRedactionValues: [],
-    ambientAuth: "",
-    isolatedAuth: "",
-    writeProbe: "",
-    stagedWriteProbe: "",
-    deniedProbePaths: []
-  };
-  const env = isolated.env;
-  const command = isolated.command;
-  if (options.codexReproducible) assertCodexReproducibleInvocation(command, args);
-  try {
-    const evidence = options.codexReproducible ? await collectCodexExecutionEvidence({
-      command,
-      args,
-      cwd,
-      env,
-      spawn: spawnImpl,
-      controlledConfigSha256: isolated.controlledConfigSha256,
-      executableSha256: isolated.executableSha256,
-      readDeniedPathsSha256: isolated.readDeniedPathsSha256,
-      readDeniedPathCount: isolated.readDeniedPathCount,
-      readDeniedPaths: isolated.readDeniedPaths,
-      ambientAuth: isolated.ambientAuth,
-      isolatedAuth: isolated.isolatedAuth,
-      writeProbe: isolated.writeProbe,
-      stagedWriteProbe: isolated.stagedWriteProbe,
-      deniedProbePaths: isolated.deniedProbePaths,
-      ...options.signal ? { signal: options.signal } : {}
-    }) : void 0;
-    return await new Promise((resolve2, reject) => {
-      let child;
-      try {
-        options.signal?.throwIfAborted();
-        child = spawnImpl(command, args, {
-          cwd,
-          env,
-          stdio: "pipe",
-          detached: process.platform !== "win32"
-        });
-      } catch (err) {
-        reject(err instanceof Error ? err : new Error(String(err)));
-        return;
-      }
-      child.stdin?.end();
-      const stdoutCapture = new RollingByteCapture(maxOutputBytes);
-      const stderrCapture = new RollingByteCapture(maxOutputBytes);
-      let timedOut = false;
-      let aborted = false;
-      let settled = false;
-      let leaderClosed = false;
-      let timer = null;
-      let termination = null;
-      const clearLifecycle = () => {
-        if (timer) clearTimeout(timer);
-        options.signal?.removeEventListener("abort", onAbort);
-      };
-      const rejectOnce = (err) => {
-        if (settled) return;
-        settled = true;
-        clearLifecycle();
-        reject(err instanceof Error ? err : new Error(String(err)));
-      };
-      const terminate = () => {
-        if (!termination) {
-          termination = terminateProcessTreeAndConfirm(child, () => leaderClosed);
-          void termination.catch(rejectOnce);
-        }
-        return termination;
-      };
-      timer = timeoutMs > 0 ? setTimeout(() => {
-        timedOut = true;
-        void terminate();
-      }, timeoutMs) : null;
-      if (timer && typeof timer.unref === "function") {
-        ;
-        timer.unref();
-      }
-      const onAbort = () => {
-        aborted = true;
-        void terminate();
-      };
-      if (options.signal) {
-        if (options.signal.aborted) onAbort();
-        else options.signal.addEventListener("abort", onAbort, { once: true });
-      }
-      child.stdout?.on("data", (chunk) => {
-        stdoutCapture.append(chunk);
-      });
-      child.stderr?.on("data", (chunk) => {
-        stderrCapture.append(chunk);
-      });
-      const finalize = (result) => {
-        if (settled) return;
-        settled = true;
-        clearLifecycle();
-        resolve2(result);
-      };
-      child.on("error", (err) => {
-        leaderClosed = true;
-        if (timer) clearTimeout(timer);
-        void (async () => {
-          try {
-            if (termination) await termination;
-            rejectOnce(err);
-          } catch (terminationError) {
-            rejectOnce(terminationError);
-          }
-        })();
-      });
-      child.on("close", (code, signal) => {
-        leaderClosed = true;
-        if (timer) clearTimeout(timer);
-        void (async () => {
-          const stdout = stdoutCapture.text();
-          const stderr = stderrCapture.text();
-          try {
-            if (!termination && process.platform !== "win32" && typeof child.pid === "number" && processGroupExists(child.pid)) {
-              await terminate();
-            }
-            if (termination) await termination;
-            const durationMs = Date.now() - startedAt;
-            const usage = options.codexReproducible ? parseCodexTokenUsage(stdout) : void 0;
-            finalize({
-              exitCode: code,
-              stdout,
-              stderr: redactCodexHome(stderr, env.CODEX_HOME),
-              killedBySignal: signal,
-              durationMs,
-              timedOut,
-              aborted,
-              ...usage ? { usage } : {},
-              ...evidence ? { evidence } : {}
-            });
-          } catch (err) {
-            if (settled) return;
-            settled = true;
-            clearLifecycle();
-            const durationMs = Date.now() - startedAt;
-            const reason = err instanceof Error ? err.message : String(err);
-            reject(
-              options.codexReproducible ? createCodexExecutionDiagnosticError({
-                reason,
-                exitCode: code,
-                killedBySignal: signal,
-                timedOut,
-                aborted,
-                durationMs,
-                stdout,
-                stderr,
-                codexHome: env.CODEX_HOME,
-                redactionValues: isolated.diagnosticRedactionValues,
-                cause: err
-              }) : err instanceof Error ? err : new Error(reason)
-            );
-          }
-        })();
-      });
-    });
-  } finally {
-    await isolated.cleanup();
-  }
-}
-var CODEX_EXECUTION_POLICY = {
-  sessionPersistence: "ephemeral",
-  userConfig: false,
-  rules: false,
-  projectInstructions: false,
-  skillInstructions: false,
-  appInstructions: false,
-  toolSuggestions: false,
-  multiAgentInstructions: false,
-  sandbox: "workspace-write",
-  permissionProfile: "agent_runtime_reproducible",
-  approvalPolicy: "never",
-  shellNetwork: false,
-  webSearch: false,
-  serviceTier: "default",
-  shellEnvironment: "core-filtered",
-  loginShell: false,
-  credentialsReadable: false,
-  hostHomeReadable: false,
-  procEnvironment: "private-sanitized",
-  sensitiveEnvironmentNamesVisible: false,
-  parentRepoRead: false,
-  gitMetadata: false,
-  temporaryDirectory: "workspace-private",
-  stagedExecutable: "static-elf-read-only",
-  callerReadDeniedPaths: "enforced",
-  containerSockets: false
-};
-var FORBIDDEN_CODEX_PROMPT_MARKERS = [
-  "<skills_instructions>",
-  "# AGENTS.md instructions",
-  "<apps_instructions>",
-  "<recommended_plugins>",
-  "<multi_agent_mode>",
-  "You are `/root`, the primary agent"
-];
-async function collectCodexExecutionEvidence(opts) {
-  assertCodexReproducibleInvocation(opts.command, opts.args);
-  const prompt = opts.args[1];
-  if (opts.args[0] !== "exec" || typeof prompt !== "string" || prompt.length === 0) {
-    throw new Error("runLocalHarness: reproducible Codex invocation must be codex exec <prompt>");
-  }
-  const cliVersion = (await runCodexProbe(opts, ["--version"])).stdout.trim();
-  if (!/^codex-cli \d+\.\d+\.\d+(?:[-+].+)?$/.test(cliVersion)) {
-    throw new Error(
-      `runLocalHarness: unexpected Codex CLI version output ${JSON.stringify(cliVersion)}`
-    );
-  }
-  const hiddenEnvironmentChecks = [
-    "CODEX_HOME",
-    "CODEX_ACCESS_TOKEN",
-    "CODEX_API_KEY",
-    "OPENAI_API_KEY"
-  ].map((name) => `test -z "\${${name}:-}"`).join(" && ");
-  const sandboxProof = [
-    hiddenEnvironmentChecks,
-    "test -r .",
-    "! test -r .git",
-    'touch "$1"',
-    'rm "$1"',
-    'staged_dir=$(dirname "$2")',
-    'test -x "$staged_dir/codex"',
-    '! chmod 700 "$staged_dir" 2>/dev/null',
-    '! rm "$staged_dir/codex" 2>/dev/null',
-    '! touch "$2" 2>/dev/null',
-    "shift 2",
-    'for path in "$@"; do ! test -r "$path" || exit 1; done',
-    'touch "$TMPDIR/.agent-runtime-tmp-proof"',
-    'rm "$TMPDIR/.agent-runtime-tmp-proof"'
-  ].join(" && ");
-  await runCodexProbe(opts, [
-    "sandbox",
-    "-P",
-    CODEX_PERMISSION_PROFILE,
-    "-C",
-    opts.cwd,
-    "sh",
-    "-c",
-    sandboxProof,
-    "sh",
-    opts.writeProbe,
-    opts.stagedWriteProbe,
-    ...opts.deniedProbePaths
-  ]);
-  await runCodexProbe(opts, [
-    "sandbox",
-    "-P",
-    CODEX_PERMISSION_PROFILE,
-    "-C",
-    opts.cwd,
-    "python3",
-    "-c",
-    `import os,re
-pattern=re.compile(br'(TOKEN|KEY|SECRET|PASSWORD|CREDENTIAL|AUTH|COOKIE|CODEX_HOME)', re.I)
-paths=('/proc/1/environ', '/proc/self/environ', f'/proc/{os.getppid()}/environ')
-for path in dict.fromkeys(paths):
- data=open(path,'rb').read().split(b'\\0')
- names=(item.split(b'=',1)[0] for item in data if b'=' in item)
- assert not any(pattern.search(name) for name in names), path`
-  ]);
-  await runCodexProbe(opts, [
-    "sandbox",
-    "-P",
-    CODEX_PERMISSION_PROFILE,
-    "-C",
-    opts.cwd,
-    "python3",
-    "-c",
-    "import socket,sys\nfor path in sys.argv[1:]:\n s=socket.socket(socket.AF_UNIX)\n try: s.connect(path)\n except OSError: continue\n raise SystemExit(1)",
-    "/var/run/docker.sock",
-    "/run/docker.sock",
-    "/var/run/containerd/containerd.sock",
-    "/run/containerd/containerd.sock"
-  ]);
-  const debugArgs = codexPromptDebugArgs(opts.args, prompt);
-  const renderedPrompt = (await runCodexProbe(opts, debugArgs)).stdout;
-  let parsedPrompt;
-  try {
-    parsedPrompt = JSON.parse(renderedPrompt);
-  } catch {
-    throw new Error("runLocalHarness: codex debug prompt-input returned invalid JSON");
-  }
-  const promptEvidenceText = normalizeCodexDebugPromptNewlines(prompt);
-  if (!Array.isArray(parsedPrompt) || !jsonTextContains(parsedPrompt, promptEvidenceText)) {
-    throw new Error("runLocalHarness: Codex prompt evidence did not contain the exact task prompt");
-  }
-  const promptContextWithoutTask = JSON.stringify(redactJsonText(parsedPrompt, promptEvidenceText));
-  for (const marker of FORBIDDEN_CODEX_PROMPT_MARKERS) {
-    if (promptContextWithoutTask.includes(marker)) {
-      throw new Error(`runLocalHarness: Codex prompt evidence contains forbidden marker ${marker}`);
-    }
-  }
-  for (const marker of ["<permissions instructions>", "<environment_context>"]) {
-    if (!renderedPrompt.includes(marker)) {
-      throw new Error(`runLocalHarness: Codex prompt evidence is missing required marker ${marker}`);
-    }
-  }
-  const nonPromptArgs = [
-    "codex",
-    ...opts.args.map((arg, index) => index === 1 ? "<PROMPT>" : arg)
-  ];
-  return {
-    cliVersion,
-    executableSha256: opts.executableSha256,
-    requestedPromptSha256: sha256(prompt),
-    effectivePromptSha256: sha256(renderedPrompt),
-    nonPromptArgsSha256: sha256(JSON.stringify(nonPromptArgs)),
-    controlledConfigSha256: opts.controlledConfigSha256,
-    readDeniedPathsSha256: opts.readDeniedPathsSha256,
-    readDeniedPathCount: opts.readDeniedPathCount,
-    readDeniedPaths: [...opts.readDeniedPaths],
-    policy: { ...CODEX_EXECUTION_POLICY }
-  };
-}
-function assertCodexReproducibleInvocation(command, args) {
-  const executable = basename(command);
-  if (executable !== "codex" && executable !== "codex.exe") {
-    throw new Error("runLocalHarness: reproducible Codex invocation must use the Codex executable");
-  }
-  const prompt = args[1];
-  const expectedPrefix = ["exec", prompt, ...CODEX_REPRODUCIBLE_ARGS];
-  const hasExactPrefix = expectedPrefix.every((arg, index) => args[index] === arg);
-  const tail = args.slice(expectedPrefix.length);
-  const validModel = tail[0] === "-m" && typeof tail[1] === "string" && tail[1].length > 0 && !tail[1].startsWith("-");
-  const validReasoning = tail[2] === "-c" && typeof tail[3] === "string" && /^model_reasoning_effort="(?:none|minimal|low|medium|high|xhigh)"$/.test(tail[3]);
-  if (!hasExactPrefix || tail.length !== 4 || !validModel || !validReasoning) {
-    throw new Error(
-      "runLocalHarness: reproducible Codex invocation does not match the required isolated argv"
-    );
-  }
-}
-function codexPromptDebugArgs(execArgs, prompt) {
-  const debugArgs = ["debug", "prompt-input"];
-  for (let index = 2; index < execArgs.length; index += 1) {
-    const arg = execArgs[index];
-    const value = execArgs[index + 1];
-    if (arg === "-c" && value !== void 0) {
-      debugArgs.push("-c", value);
-      index += 1;
-    } else if (arg === "--disable" && value !== void 0) {
-      debugArgs.push("--disable", value);
-      index += 1;
-    } else if (arg === "-m" && value !== void 0) {
-      debugArgs.push("-c", `model=${JSON.stringify(value)}`);
-      index += 1;
-    } else if (arg === "-s" && value !== void 0) {
-      debugArgs.push("-c", `sandbox_mode=${JSON.stringify(value)}`);
-      index += 1;
-    }
-  }
-  debugArgs.push(prompt);
-  return debugArgs;
-}
-function runCodexProbe(opts, args) {
-  return new Promise((resolve2, reject) => {
-    let child;
-    try {
-      child = opts.spawn(opts.command, args, {
-        cwd: opts.cwd,
-        env: opts.env,
-        stdio: "pipe",
-        detached: process.platform !== "win32"
-      });
-    } catch (err) {
-      reject(err instanceof Error ? err : new Error(String(err)));
-      return;
-    }
-    child.stdin?.end();
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    let leaderClosed = false;
-    let termination = null;
-    let terminationReason = null;
-    const clearLifecycle = () => {
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-    };
-    const rejectOnce = (err) => {
-      if (settled) return;
-      settled = true;
-      clearLifecycle();
-      reject(err instanceof Error ? err : new Error(String(err)));
-    };
-    const terminate = (reason) => {
-      if (reason) terminationReason ??= reason;
-      if (!termination) {
-        termination = terminateProcessTreeAndConfirm(child, () => leaderClosed);
-        void termination.catch(rejectOnce);
-      }
-      return termination;
-    };
-    const timer = setTimeout(() => {
-      void terminate("timed out");
-    }, 1e4);
-    timer.unref?.();
-    const onAbort = () => {
-      void terminate("aborted");
-    };
-    if (opts.signal) {
-      if (opts.signal.aborted) onAbort();
-      else opts.signal.addEventListener("abort", onAbort, { once: true });
-    }
-    child.stdout?.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (err) => {
-      leaderClosed = true;
-      clearTimeout(timer);
-      void (async () => {
-        try {
-          if (termination) await termination;
-          rejectOnce(err);
-        } catch (terminationError) {
-          rejectOnce(terminationError);
-        }
-      })();
-    });
-    child.on("close", (code, signal) => {
-      leaderClosed = true;
-      clearTimeout(timer);
-      void (async () => {
-        try {
-          if (!termination && process.platform !== "win32" && typeof child.pid === "number" && processGroupExists(child.pid)) {
-            await terminate();
-          }
-          if (termination) await termination;
-          if (settled) return;
-          settled = true;
-          clearLifecycle();
-          if (code !== 0 || terminationReason) {
-            const safeStderr = redactCodexHome(stderr, opts.env.CODEX_HOME);
-            reject(
-              new Error(
-                `runLocalHarness: Codex evidence probe ${terminationReason ?? "failed"} (exit ${String(code)}, signal ${String(signal)}): ${safeStderr.trim()}`
-              )
-            );
-            return;
-          }
-          resolve2({ stdout, stderr });
-        } catch (err) {
-          rejectOnce(err);
-        }
-      })();
-    });
-  });
-}
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function normalizeCodexDebugPromptNewlines(value) {
-  return value.replaceAll("\r\n", "\n");
-}
-function jsonTextContains(value, needle) {
-  if (typeof value === "string") return value.includes(needle);
-  if (Array.isArray(value)) return value.some((item) => jsonTextContains(item, needle));
-  if (isRecord(value)) return Object.values(value).some((item) => jsonTextContains(item, needle));
-  return false;
-}
-function redactJsonText(value, text) {
-  if (typeof value === "string") return value.replaceAll(text, "");
-  if (Array.isArray(value)) return value.map((item) => redactJsonText(item, text));
-  if (isRecord(value)) {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, item]) => [key, redactJsonText(item, text)])
-    );
-  }
-  return value;
-}
-var CODEX_AUTH_ENV = ["CODEX_ACCESS_TOKEN", "CODEX_API_KEY", "OPENAI_API_KEY"];
-var CODEX_PERMISSION_PROFILE = "agent_runtime_reproducible";
-async function isolateCodexHome(opts) {
-  const isolatedHome = await mkdtemp(join(tmpdir(), "agent-runtime-codex-"));
-  await chmod(isolatedHome, 448);
-  let workspaceTemp = "";
-  let stagedExecutableDir = "";
-  let ownsStagedExecutableDir = false;
-  let writeProbe = "";
-  const cleanup = async () => {
-    if (ownsStagedExecutableDir) {
-      await chmod(stagedExecutableDir, 448).catch(() => void 0);
-    }
-    await Promise.all([
-      ...writeProbe ? [rm(writeProbe, { force: true })] : [],
-      ...workspaceTemp ? [rm(workspaceTemp, { recursive: true, force: true })] : [],
-      ...ownsStagedExecutableDir ? [rm(stagedExecutableDir, { recursive: true, force: true })] : [],
-      rm(isolatedHome, { recursive: true, force: true })
-    ]);
-  };
-  try {
-    const readDeniedPaths = await normalizeReadDeniedPaths(opts.readDeniedPaths);
-    const candidateRoot = await realpath(opts.cwd);
-    writeProbe = join(candidateRoot, `.agent-runtime-write-proof-${randomUUID()}`);
-    const stagedPath = join(candidateRoot, ".agent-runtime-bin");
-    if (readDeniedPaths.some(
-      (path) => isSameOrDescendant(candidateRoot, path) || isSameOrDescendant(stagedPath, path) || isSameOrDescendant(path, stagedPath)
-    )) {
-      throw new Error(
-        "runLocalHarness: codexReadDeniedPaths cannot contain the candidate root or staged executable"
-      );
-    }
-    const nativeExecutable = await opts.resolveExecutable(opts.command, opts.baseEnv);
-    if (!await isStaticElfExecutable(nativeExecutable)) {
-      throw new Error(
-        "runLocalHarness: reproducible Codex mode requires a statically linked Linux Codex ELF"
-      );
-    }
-    const sourceExecutableSha256 = await sha256File(nativeExecutable);
-    stagedExecutableDir = stagedPath;
-    try {
-      await mkdir(stagedExecutableDir, { mode: 448 });
-      ownsStagedExecutableDir = true;
-    } catch (err) {
-      throw new Error(
-        `runLocalHarness: candidate-private .agent-runtime-bin must not already exist: ${String(err.code ?? err)}`
-      );
-    }
-    const stagedExecutable = join(stagedExecutableDir, "codex");
-    await copyFile(nativeExecutable, stagedExecutable, constants2.COPYFILE_FICLONE);
-    await chmod(stagedExecutable, 320);
-    const executableSha256 = await sha256File(stagedExecutable);
-    if (executableSha256 !== sourceExecutableSha256 || !await isStaticElfExecutable(stagedExecutable)) {
-      throw new Error("runLocalHarness: staged Codex executable digest mismatch");
-    }
-    await chmod(stagedExecutableDir, 320);
-    workspaceTemp = await mkdtemp(join(candidateRoot, ".agent-runtime-tmp-"));
-    await chmod(workspaceTemp, 448);
-    const ambientHome = resolve(opts.baseEnv.CODEX_HOME?.trim() || join(homedir(), ".codex"));
-    const ambientAuth = join(ambientHome, "auth.json");
-    const isolatedAuth = join(isolatedHome, "auth.json");
-    let authText = "";
-    try {
-      await access(ambientAuth, constants2.R_OK);
-      authText = await readCodexAuthRedactionText(ambientAuth);
-      await symlink(ambientAuth, isolatedAuth);
-    } catch (err) {
-      throw new Error(
-        `runLocalHarness: reproducible Codex mode requires readable auth.json: ${String(err.code ?? err)}`
-      );
-    }
-    const deniedHostRoots = [homedir(), opts.baseEnv.HOME?.trim(), ambientHome].filter((path) => Boolean(path)).map((path) => resolve(path)).filter((path, index, paths) => paths.indexOf(path) === index);
-    const controlledConfig = codexControlledConfig({
-      ambientTmp: opts.baseEnv.TMPDIR?.trim() || tmpdir(),
-      deniedHostRoots,
-      workspaceTemp,
-      stagedExecutableDir,
-      readDeniedPaths
-    });
-    await writeFile(join(isolatedHome, "config.toml"), controlledConfig, { mode: 384 });
-    const env = { ...opts.baseEnv };
-    for (const name of Object.keys(env)) {
-      if (codexSensitiveEnvironmentName.test(name) || CODEX_AUTH_ENV.some((authName) => authName === name)) {
-        delete env[name];
-      }
-    }
-    env.CODEX_HOME = isolatedHome;
-    const home = homedir();
-    const deniedProbePaths = [
-      ...deniedHostRoots,
-      ambientAuth,
-      isolatedAuth,
-      join(home, ".claude", ".credentials.json"),
-      join(home, ".claude.json"),
-      join(home, ".local", "share", "opencode", "auth.json"),
-      join(home, ".agents"),
-      join(home, "Documents"),
-      join(home, "Downloads"),
-      join(home, ".npm"),
-      join(home, "code"),
-      ...readDeniedPaths
-    ].filter((path, index, paths) => paths.indexOf(path) === index);
-    return {
-      env,
-      command: stagedExecutable,
-      cleanup,
-      controlledConfigSha256: sha256(controlledConfig),
-      executableSha256,
-      readDeniedPaths,
-      readDeniedPathsSha256: sha256(JSON.stringify(readDeniedPaths)),
-      readDeniedPathCount: readDeniedPaths.length,
-      diagnosticRedactionValues: collectCodexDiagnosticRedactionValues(opts.baseEnv, authText),
-      ambientAuth,
-      isolatedAuth,
-      writeProbe,
-      stagedWriteProbe: join(stagedExecutableDir, "write-proof"),
-      deniedProbePaths
-    };
-  } catch (err) {
-    await cleanup();
-    throw err;
-  }
-}
-function codexControlledConfig(opts) {
-  const rules = /* @__PURE__ */ new Map();
-  const broadDeniedPaths = minimalPathRoots([
-    ...opts.deniedHostRoots.map((path) => resolve(path)),
-    tmpdir(),
-    opts.ambientTmp,
-    "/proc",
-    "/run/docker",
-    "/run/containerd"
-  ]);
-  for (const path of broadDeniedPaths) {
-    rules.set(path, "deny");
-  }
-  const workspaceRoot = dirname(opts.workspaceTemp);
-  for (const path of opts.readDeniedPaths) {
-    const alreadyDenied = broadDeniedPaths.some((root) => isSameOrDescendant(path, root));
-    if (!alreadyDenied || isSameOrDescendant(path, workspaceRoot)) rules.set(path, "deny");
-  }
-  if (!rules.has(opts.workspaceTemp)) rules.set(opts.workspaceTemp, "write");
-  if (!rules.has(opts.stagedExecutableDir)) rules.set(opts.stagedExecutableDir, "read");
-  const filesystemRules = [...rules].sort(([a], [b]) => a.localeCompare(b)).map(([path, access2]) => `${JSON.stringify(path)} = ${JSON.stringify(access2)}`).join("\n");
-  return `default_permissions = "${CODEX_PERMISSION_PROFILE}"
-approval_policy = "never"
-allow_login_shell = false
-service_tier = "default"
-
-[shell_environment_policy]
-inherit = "core"
-ignore_default_excludes = false
-exclude = ["^CODEX_HOME$", "(?i).*TOKEN.*", "(?i).*KEY.*", "(?i).*SECRET.*", "(?i).*PASSWORD.*", "(?i).*CREDENTIAL.*", "(?i).*AUTH.*", "(?i).*COOKIE.*"]
-set = { TMPDIR = ${JSON.stringify(opts.workspaceTemp)} }
-
-[permissions.${CODEX_PERMISSION_PROFILE}.filesystem]
-":minimal" = "read"
-${filesystemRules}
-":slash_tmp" = "deny"
-
-[permissions.${CODEX_PERMISSION_PROFILE}.filesystem.":workspace_roots"]
-"." = "write"
-".git" = "deny"
-
-[permissions.${CODEX_PERMISSION_PROFILE}.network]
-enabled = false
-
-[permissions.${CODEX_PERMISSION_PROFILE}.network.unix_sockets]
-"/var/run/docker.sock" = "deny"
-"/run/docker.sock" = "deny"
-"/var/run/containerd/containerd.sock" = "deny"
-"/run/containerd/containerd.sock" = "deny"
-`;
-}
-function isSameOrDescendant(path, root) {
-  const normalizedPath = resolve(path);
-  const normalizedRoot = resolve(root);
-  return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}${sep}`);
-}
-function minimalPathRoots(paths) {
-  const ordered = [...new Set(paths.map((path) => resolve(path)))].sort(
-    (a, b) => a.length - b.length || a.localeCompare(b)
-  );
-  return ordered.filter(
-    (path, index) => !ordered.slice(0, index).some((root) => isSameOrDescendant(path, root))
-  );
-}
-async function normalizeReadDeniedPaths(paths) {
-  if (!Array.isArray(paths)) {
-    throw new Error("runLocalHarness: codexReadDeniedPaths must be an array of absolute paths");
-  }
-  const normalized = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    if (typeof path !== "string" || path.length === 0 || path.includes("\0") || !isAbsolute(path)) {
-      throw new Error("runLocalHarness: codexReadDeniedPaths must contain absolute paths");
-    }
-    const absolute = resolve(path);
-    normalized.add(absolute);
-    try {
-      normalized.add(await realpath(absolute));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  return [...normalized].sort();
-}
-async function resolveCodexNativeExecutable(command, env) {
-  const candidates = command.includes(sep) || isAbsolute(command) ? [resolve(command)] : (env.PATH ?? "").split(delimiter).filter(Boolean).map((entry) => join(entry, command));
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    let resolved;
-    try {
-      await access(candidate, constants2.X_OK);
-      resolved = await realpath(candidate);
-    } catch {
-      continue;
-    }
-    if (seen.has(resolved)) continue;
-    seen.add(resolved);
-    if (await isStaticElfExecutable(resolved)) return resolved;
-    const packageRoot = await findCodexPackageRoot(resolved);
-    if (!packageRoot) continue;
-    const bundled = await findBundledCodexExecutable(packageRoot);
-    if (bundled) return bundled;
-  }
-  throw new Error(
-    "runLocalHarness: could not resolve the native Codex executable from the requested command"
-  );
-}
-async function findCodexPackageRoot(file) {
-  let cursor = dirname(file);
-  while (true) {
-    try {
-      const parsed = JSON.parse(await readFile(join(cursor, "package.json"), "utf8"));
-      if (parsed.name === "@openai/codex") return cursor;
-    } catch {
-    }
-    const parent = dirname(cursor);
-    if (parent === cursor) return void 0;
-    cursor = parent;
-  }
-}
-async function findBundledCodexExecutable(packageRoot) {
-  const target = linuxCodexTarget();
-  const candidates = [
-    join(
-      packageRoot,
-      "node_modules",
-      "@openai",
-      target.packageName,
-      "vendor",
-      target.triple,
-      "bin",
-      "codex"
-    ),
-    join(packageRoot, "vendor", target.triple, "bin", "codex")
-  ];
-  for (const executable of candidates) {
-    if (await isStaticElfExecutable(executable)) return executable;
-  }
-  return void 0;
-}
-function linuxCodexTarget() {
-  if (process.platform !== "linux") {
-    throw new Error("runLocalHarness: reproducible Codex mode requires Linux");
-  }
-  if (process.arch === "x64") {
-    return { packageName: "codex-linux-x64", triple: "x86_64-unknown-linux-musl" };
-  }
-  if (process.arch === "arm64") {
-    return { packageName: "codex-linux-arm64", triple: "aarch64-unknown-linux-musl" };
-  }
-  throw new Error(`runLocalHarness: unsupported Linux architecture ${process.arch}`);
-}
-async function isStaticElfExecutable(path) {
-  let handle;
-  try {
-    await access(path, constants2.X_OK);
-    handle = await open2(path, "r");
-    const header = Buffer.alloc(64);
-    const { bytesRead } = await handle.read(header, 0, header.length, 0);
-    if (bytesRead !== header.length || !header.subarray(0, 4).equals(Buffer.from([127, 69, 76, 70])) || header[4] !== 2 || header[5] !== 1) {
-      return false;
-    }
-    const programHeaderOffset = Number(header.readBigUInt64LE(32));
-    const programHeaderSize = header.readUInt16LE(54);
-    const programHeaderCount = header.readUInt16LE(56);
-    const expectedMachine = process.arch === "x64" ? 62 : process.arch === "arm64" ? 183 : -1;
-    if (![2, 3].includes(header.readUInt16LE(16)) || header.readUInt16LE(18) !== expectedMachine || !Number.isSafeInteger(programHeaderOffset) || programHeaderOffset < 64 || programHeaderSize < 56 || programHeaderSize > 1024 || programHeaderCount === 0 || programHeaderCount > 1024) {
-      return false;
-    }
-    const tableSize = programHeaderSize * programHeaderCount;
-    const table = Buffer.alloc(tableSize);
-    const tableRead = await handle.read(table, 0, tableSize, programHeaderOffset);
-    if (tableRead.bytesRead !== tableSize) return false;
-    for (let index = 0; index < programHeaderCount; index += 1) {
-      const type = table.readUInt32LE(index * programHeaderSize);
-      if (type === 3) return false;
-    }
-    return true;
-  } catch {
-    return false;
-  } finally {
-    await handle?.close();
-  }
-}
-function sha256File(path) {
-  return new Promise((resolveDigest, reject) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(path);
-    stream.on("error", reject);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolveDigest(hash.digest("hex")));
-  });
-}
-function signalProcessTree(child, signal) {
-  if (process.platform !== "win32" && typeof child.pid === "number") {
-    try {
-      process.kill(-child.pid, signal);
-      return;
-    } catch (err) {
-      if (err.code === "ESRCH") return;
-    }
-  }
-  try {
-    child.kill(signal);
-  } catch {
-  }
-}
-async function terminateProcessTreeAndConfirm(child, leaderClosed, context = "runLocalHarness") {
-  signalProcessTree(child, "SIGTERM");
-  if (process.platform === "win32" || typeof child.pid !== "number") {
-    const graceDeadline2 = Date.now() + processKillGraceMs;
-    while (!leaderClosed() && Date.now() < graceDeadline2) {
-      await delayUntilNextProcessCheck(graceDeadline2);
-    }
-    if (!leaderClosed()) signalProcessTree(child, "SIGKILL");
-    return;
-  }
-  const processGroupId = child.pid;
-  const graceDeadline = Date.now() + processKillGraceMs;
-  if (await waitForProcessGroupExit(processGroupId, graceDeadline)) return;
-  signalProcessTree(child, "SIGKILL");
-  const killDeadline = Date.now() + processGroupExitConfirmMs;
-  if (await waitForProcessGroupExit(processGroupId, killDeadline)) return;
-  throw new Error(`${context}: process group ${processGroupId} survived SIGKILL`);
-}
-async function waitForProcessGroupExit(processGroupId, deadline) {
-  while (processGroupExists(processGroupId)) {
-    if (Date.now() >= deadline) return false;
-    await delayUntilNextProcessCheck(deadline);
-  }
-  return true;
-}
-async function delayUntilNextProcessCheck(deadline) {
-  const delayMs = Math.min(processGroupExitPollMs, Math.max(0, deadline - Date.now()));
-  if (delayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, delayMs));
-}
-function processGroupExists(processGroupId) {
-  try {
-    process.kill(-processGroupId, 0);
-    return true;
-  } catch (err) {
-    if (err.code === "ESRCH") return false;
-    return true;
-  }
-}
-function parseCodexTokenUsage(stdout) {
-  const completed = [];
-  for (const [index, line] of stdout.split(/\r?\n/).entries()) {
-    if (line.trim().length === 0) continue;
-    let event2;
-    try {
-      event2 = JSON.parse(line);
-    } catch {
-      throw new Error(`runLocalHarness: Codex JSONL line ${index + 1} is not valid JSON`);
-    }
-    if (isRecord(event2) && event2.type === "turn.completed") completed.push(event2);
-  }
-  if (completed.length !== 1) {
-    throw new Error(
-      `runLocalHarness: expected exactly one Codex turn.completed usage event, received ${completed.length}`
-    );
-  }
-  const event = completed[0];
-  if (!isRecord(event) || !isRecord(event.usage)) {
-    throw new Error("runLocalHarness: Codex turn.completed event is missing usage");
-  }
-  const usage = event.usage;
-  const inputTokens = naturalNumber(usage.input_tokens, "input_tokens");
-  const cachedInputTokens = naturalNumber(usage.cached_input_tokens, "cached_input_tokens");
-  const outputTokens = naturalNumber(usage.output_tokens, "output_tokens");
-  const reasoningOutputTokens = naturalNumber(
-    usage.reasoning_output_tokens,
-    "reasoning_output_tokens"
-  );
-  if (cachedInputTokens > inputTokens) {
-    throw new Error("runLocalHarness: Codex cached_input_tokens exceeds input_tokens");
-  }
-  if (reasoningOutputTokens > outputTokens) {
-    throw new Error("runLocalHarness: Codex reasoning_output_tokens exceeds output_tokens");
-  }
-  return { inputTokens, cachedInputTokens, outputTokens, reasoningOutputTokens };
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function naturalNumber(value, field) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`runLocalHarness: Codex usage.${field} must be a non-negative safe integer`);
-  }
-  return value;
-}
-
-// src/mcp/worktree.ts
-import { spawn as spawn2 } from "child_process";
-import { isAbsolute as isAbsolute2, win32 } from "path";
-async function runGitAsync(args, cwd, runner) {
-  if (runner) return runner(args, { cwd });
-  return new Promise((resolve2, reject) => {
-    const proc = spawn2("git", args, { cwd, stdio: "pipe" });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (c) => {
-      stdout += String(c);
-    });
-    proc.stderr?.on("data", (c) => {
-      stderr += String(c);
-    });
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? -1 }));
-  });
-}
-function ensureGitOk(step, result) {
-  if (result.exitCode !== 0) {
-    throw gitFailure(step, result);
-  }
-}
-function gitFailure(step, result) {
-  return new Error(
-    `worktree: git ${step} failed (exit ${result.exitCode}): ${result.stderr.slice(0, 400)}`
-  );
-}
-async function createWorktree(options) {
-  const variants = options.variantsDir ?? ".agent-worktrees";
-  const baseRef = options.baseRef ?? "HEAD";
-  const branch = `delegate/${options.runId}`;
-  const path = `${options.repoRoot.replace(/\/+$/, "")}/${variants}/${options.runId}`;
-  const headSha = await runGitAsync(["rev-parse", baseRef], options.repoRoot, options.runGit);
-  ensureGitOk(`rev-parse ${baseRef}`, headSha);
-  const add = await runGitAsync(
-    ["worktree", "add", "-b", branch, path, baseRef],
-    options.repoRoot,
-    options.runGit
-  );
-  ensureGitOk(`worktree add ${path}`, add);
-  return { path, baseSha: headSha.stdout.trim(), branch };
-}
-async function captureWorktreeDiff(options) {
-  const baseRef = options.baseRef ?? options.worktree.baseSha;
-  const pathspecs = worktreeDiffPathspecs(options.excludePaths ?? []);
-  const staged = await runGitAsync(
-    ["add", "-A", ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk("add -A", staged);
-  const patch = await runGitAsync(
-    ["diff", "--cached", baseRef, ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk(`diff --cached ${baseRef}`, patch);
-  const shortstat = await runGitAsync(
-    [
-      "diff",
-      "--cached",
-      "--shortstat",
-      baseRef,
-      ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []
-    ],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk(`diff --cached --shortstat ${baseRef}`, shortstat);
-  const stats = parseShortstat(shortstat.stdout);
-  return { patch: patch.stdout, stats };
-}
-function worktreeDiffPathspecs(paths) {
-  const normalized = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    if (typeof path !== "string" || path.length === 0 || path.includes("\\") || hasControlCharacter(path) || isAbsolute2(path) || win32.isAbsolute(path)) {
-      throw new Error(
-        `worktree: excluded path must be a canonical repository-relative path: ${path}`
-      );
-    }
-    const segments = path.split("/");
-    if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-      throw new Error(
-        `worktree: excluded path must be a canonical repository-relative path: ${path}`
-      );
-    }
-    normalized.add(path);
-  }
-  return [...normalized].sort((left, right) => left.localeCompare(right)).map((path) => `:(top,exclude,literal)${path}`);
-}
-function hasControlCharacter(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code < 32 || code === 127) return true;
-  }
-  return false;
-}
-function parseShortstat(text) {
-  const out = { filesChanged: 0, insertions: 0, deletions: 0 };
-  const filesMatch = text.match(/(\d+)\s+files?\s+changed/);
-  if (filesMatch?.[1]) out.filesChanged = Number(filesMatch[1]);
-  const insertMatch = text.match(/(\d+)\s+insertions?/);
-  if (insertMatch?.[1]) out.insertions = Number(insertMatch[1]);
-  const deleteMatch = text.match(/(\d+)\s+deletions?/);
-  if (deleteMatch?.[1]) out.deletions = Number(deleteMatch[1]);
-  return out;
-}
-async function removeWorktree(options) {
-  const force = options.force ?? true;
-  const args = ["worktree", "remove"];
-  if (force) args.push("--force");
-  args.push(options.worktree.path);
-  const removal = await runGitAsync(args, options.repoRoot, options.runGit);
-  const removalError = removal.exitCode !== 0 && !/not a working tree/iu.test(removal.stderr) ? gitFailure(`worktree remove ${options.worktree.path}`, removal) : void 0;
-  const branchRemoval = await runGitAsync(
-    ["branch", "-D", options.worktree.branch],
-    options.repoRoot,
-    options.runGit
-  );
-  const branchError = branchRemoval.exitCode !== 0 && !/branch .+ not found/iu.test(branchRemoval.stderr) ? gitFailure(`branch -D ${options.worktree.branch}`, branchRemoval) : void 0;
-  if (removalError && branchError) {
-    throw new AggregateError(
-      [removalError, branchError],
-      "worktree: failed to remove worktree and branch"
-    );
-  }
-  if (removalError) throw removalError;
-  if (branchError) throw branchError;
-}
-
-// src/runtime/router-client.ts
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
-
-// src/runtime/tool-loop.ts
-function estimateConversationTokens(messages) {
-  let chars = 0;
-  for (const m of messages) {
-    const content = m.content;
-    chars += typeof content === "string" ? content.length : safeJsonLength(content);
-    const calls = m.tool_calls;
-    if (calls) for (const c of calls) chars += c.function?.arguments?.length ?? 0;
-  }
-  return Math.ceil(chars / 4);
-}
-function safeJsonLength(value) {
-  if (value === void 0 || value === null) return 0;
-  try {
-    return JSON.stringify(value)?.length ?? 0;
-  } catch {
-    return String(value).length;
-  }
-}
-async function maybeCompact(messages, c, turn) {
-  const head = c.preserveHead !== void 0 && c.preserveHead > 0 ? c.preserveHead : 2;
-  if (messages.length <= head + 1) return false;
-  const estimate = c.estimateTokens ?? estimateConversationTokens;
-  const before = estimate(messages);
-  if (before <= c.thresholdTokens) return false;
-  const digest = await c.distill([...messages]);
-  messages.splice(head, messages.length - head, {
-    role: "user",
-    content: `[earlier work compacted to save context \u2014 progress so far]
-${digest}`
-  });
-  c.onCompact?.({ turn, beforeTokens: before, afterTokens: estimate(messages) });
-  return true;
-}
-async function runBrainLoop(opts) {
-  const maxTurns = opts.maxTurns ?? 4;
-  const messages = [...opts.initialMessages];
-  let toolCalls = 0;
-  let lastText = "";
-  const usage = { input: 0, output: 0 };
-  const toolTrace = [];
-  for (let turn = 1; turn <= maxTurns; turn += 1) {
-    if (opts.hooks?.stopBefore?.(turn)) break;
-    await opts.hooks?.beforeTurn?.(turn, messages);
-    if (opts.compaction) await maybeCompact(messages, opts.compaction, turn);
-    const r = await opts.chat(messages, opts.tools);
-    if (r.usage) {
-      usage.input += r.usage.input;
-      usage.output += r.usage.output;
-      opts.hooks?.onUsage?.(r.usage);
-    }
-    if (r.content) lastText = r.content;
-    if (r.toolCalls.length === 0) {
-      if (r.content) messages.push({ role: "assistant", content: r.content });
-      return { final: lastText, turns: turn, toolCalls, toolTrace, usage, messages };
-    }
-    messages.push({
-      role: "assistant",
-      content: r.content ?? "",
-      tool_calls: r.toolCalls.map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.name, arguments: tc.arguments }
-      }))
-    });
-    for (const tc of r.toolCalls) {
-      toolCalls += 1;
-      let args = {};
-      try {
-        args = JSON.parse(tc.arguments);
-      } catch {
-        messages.push({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: `error: arguments were not valid JSON: ${tc.arguments.slice(0, 200)}`
-        });
-        continue;
-      }
-      const out = await opts.execute(tc.name, args);
-      messages.push({ role: "tool", tool_call_id: tc.id, content: out });
-      toolTrace.push({ name: tc.name, args: tc.arguments, result: out });
-    }
-  }
-  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
-}
-
-// src/runtime/router-client.ts
-async function routerChatWithUsage(cfg, messages, opts) {
-  const url = `${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`;
-  const headers = { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` };
-  let temperature = opts?.temperature ?? 0.2;
-  const body = () => ({
-    model: cfg.model,
-    messages,
-    temperature,
-    max_tokens: opts?.maxTokens ?? 8192,
-    ...opts?.reasoningEffort ? { reasoning_effort: opts.reasoningEffort } : {}
-  });
-  if (cfg.complete) return parseChatResult(await cfg.complete(body()), cfg.model);
-  let lastErr = "";
-  for (let attempt = 0; attempt < 5; attempt += 1) {
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body()),
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
-    if (res.ok) return parseChatResult(await res.json(), cfg.model);
-    const status = res.status;
-    const text = (await res.text()).slice(0, 200);
-    lastErr = `router ${status}: ${text}`;
-    if (status === 400 && /temperature/i.test(text) && temperature !== 1) {
-      temperature = 1;
-      continue;
-    }
-    if (![408, 425, 429, 500, 502, 503, 504, 520, 522, 524].includes(status))
-      throw new Error(lastErr);
-    if (attempt < 4) await new Promise((r) => setTimeout(r, 800 * 2 ** attempt));
-  }
-  throw new Error(`${lastErr} (exhausted retries)`);
-}
-function parseChatResult(json, model) {
-  const data = json;
-  const u = data.usage;
-  const usage = u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number" ? { input: u.prompt_tokens, output: u.completion_tokens } : void 0;
-  const costUsd = usage && isModelPriced(model) ? estimateCost(usage.input, usage.output, model) : void 0;
-  const msg = data.choices?.[0]?.message;
-  const { content, reasoning } = splitReasoning(
-    msg?.content ?? "",
-    msg?.reasoning ?? msg?.reasoning_content
-  );
-  return {
-    content,
-    ...reasoning ? { reasoning } : {},
-    ...usage ? { usage } : {},
-    ...costUsd !== void 0 ? { costUsd } : {}
-  };
-}
-function splitReasoning(rawContent, fieldReasoning) {
-  const open3 = rawContent.indexOf("<think>");
-  if (open3 !== -1) {
-    const close = rawContent.indexOf("</think>", open3);
-    const inline = close !== -1 ? rawContent.slice(open3 + 7, close) : rawContent.slice(open3 + 7);
-    const rest = close !== -1 ? rawContent.slice(0, open3) + rawContent.slice(close + 8) : rawContent.slice(0, open3);
-    const reasoning = [fieldReasoning, inline.trim()].filter(Boolean).join("\n");
-    return { content: rest.trim(), ...reasoning ? { reasoning } : {} };
-  }
-  return { content: rawContent, ...fieldReasoning ? { reasoning: fieldReasoning } : {} };
-}
-async function routerChatWithTools(cfg, messages, tools, opts) {
-  const body = {
-    model: cfg.model,
-    messages,
-    tools,
-    tool_choice: opts?.toolChoice ?? "auto",
-    temperature: opts?.temperature ?? 0.3,
-    ...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {}
-  };
-  const raw = cfg.complete ? await cfg.complete(body) : await (async () => {
-    const res = await fetch(`${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
-      method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` },
-      body: JSON.stringify(body),
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
-    if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`);
-    return res.json();
-  })();
-  const data = raw;
-  const msg = data.choices?.[0]?.message;
-  const toolCalls = (msg?.tool_calls ?? []).map((tc, i) => ({
-    id: tc.id ?? `call_${i}`,
-    name: tc.function?.name ?? "",
-    arguments: tc.function?.arguments ?? "{}"
-  }));
-  const u = data.usage;
-  const usage = u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number" ? { input: u.prompt_tokens, output: u.completion_tokens } : void 0;
-  const costUsd = usage && isModelPriced(cfg.model) ? estimateCost(usage.input, usage.output, cfg.model) : void 0;
-  return {
-    content: msg?.content ?? null,
-    toolCalls,
-    ...usage ? { usage } : {},
-    ...costUsd !== void 0 ? { costUsd } : {}
-  };
-}
-async function routerToolLoop(cfg, system, user, tools, execute, opts) {
-  const initialMessages = opts?.initialMessages ?? [
-    { role: "system", content: system },
-    { role: "user", content: user }
-  ];
-  return runBrainLoop({
-    chat: (messages, toolSpecs) => routerChatWithTools(cfg, messages, toolSpecs, {
-      ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {},
-      ...opts?.maxTokens ? { maxTokens: opts.maxTokens } : {},
-      ...opts?.signal ? { signal: opts.signal } : {}
-    }),
-    tools,
-    execute,
-    initialMessages,
-    maxTurns: opts?.maxTurns ?? 4
-  });
-}
-function routerBrain(cfg, opts = {}) {
-  const temperature = opts.temperature ?? 0.4;
-  return (messages, tools) => routerChatWithTools(cfg, messages, tools, { temperature, toolChoice: "auto" });
-}
-
-// src/runtime-hooks.ts
-function defineRuntimeHooks(hooks) {
-  return hooks;
-}
-function composeRuntimeHooks(...entries) {
-  const hooks = entries.filter((entry) => !!entry);
-  return {
-    onEvent: hooks.some((hook) => hook.onEvent) ? (event, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onEvent?.(event, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0,
-    onDecisionPoint: hooks.some((hook) => hook.onDecisionPoint) ? (point, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onDecisionPoint?.(point, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0,
-    onHookError: hooks.some((hook) => hook.onHookError) ? (error, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onHookError?.(error, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0
-  };
-}
-function notifyRuntimeHookEvent(hooks, event, context = {}) {
-  const onEvent = hooks?.onEvent;
-  if (!onEvent) return;
-  try {
-    const result = onEvent(event, context);
-    if (isThenable(result)) {
-      void result.catch((error) => {
-        notifyRuntimeHookError(hooks, toError(error), {
-          hook: "onEvent",
-          eventId: event.id,
-          target: event.target,
-          phase: event.phase
-        });
-      });
-    }
-  } catch (error) {
-    notifyRuntimeHookError(hooks, toError(error), {
-      hook: "onEvent",
-      eventId: event.id,
-      target: event.target,
-      phase: event.phase
-    });
-  }
-}
-function notifyRuntimeDecisionPoint(hooks, point, context = {}) {
-  const onDecisionPoint = hooks?.onDecisionPoint;
-  if (!onDecisionPoint) return;
-  try {
-    const result = onDecisionPoint(point, context);
-    if (isThenable(result)) {
-      void result.catch((error) => {
-        notifyRuntimeHookError(hooks, toError(error), {
-          hook: "onDecisionPoint",
-          decisionId: point.id,
-          decisionKind: point.kind
-        });
-      });
-    }
-  } catch (error) {
-    notifyRuntimeHookError(hooks, toError(error), {
-      hook: "onDecisionPoint",
-      decisionId: point.id,
-      decisionKind: point.kind
-    });
-  }
-}
-function notifyRuntimeHookError(hooks, error, context) {
-  try {
-    const result = hooks?.onHookError?.(error, context);
-    if (isThenable(result)) void result.catch(() => void 0);
-  } catch {
-  }
-}
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-
-// src/runtime/supervise/progress.ts
-var DEFAULT_STALL_AFTER_MS = 18e4;
-function createActivityLog(limit = 12) {
-  const notes = [];
-  const cap = Math.max(1, Math.floor(limit));
-  return {
-    push(note) {
-      notes.push(note);
-      if (notes.length > cap) notes.splice(0, notes.length - cap);
-    },
-    read: () => [...notes],
-    last: () => notes[notes.length - 1],
-    size: () => notes.length
-  };
-}
-function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_AFTER_MS) {
-  const live = scope.status !== "done" && scope.status !== "failed" && scope.status !== "cancelled";
-  const executorActivityAt = executor?.recentActivity?.length ? executor.recentActivity[executor.recentActivity.length - 1].at : 0;
-  const lastActivityAt = Math.max(scope.lastActivityAt, executorActivityAt);
-  const idleMs = Math.max(0, now - lastActivityAt);
-  const note = executor?.note;
-  return {
-    id: scope.id,
-    status: scope.status,
-    live,
-    steerable: scope.steerable,
-    startedAt: scope.startedAt,
-    lastActivityAt,
-    idleMs,
-    // Only a LIVE worker can stall; a settled one is simply finished.
-    stalled: live && idleMs > stallAfterMs,
-    stallAfterMs,
-    turns: executor?.turns ?? scope.turns,
-    tokens: scope.tokens,
-    usd: scope.usd,
-    pendingMessages: executor?.pendingMessages ?? 0,
-    recentActivity: executor?.recentActivity ?? [],
-    ...note ? { note } : {}
-  };
-}
-
-// src/runtime/supervise/wait.ts
-function timerAt(ms, now) {
-  return { kind: "timer", untilMs: now + ms };
-}
-function pollFor(probe, opts, now) {
-  return {
-    kind: "poll",
-    probe,
-    intervalMs: opts.intervalMs,
-    ...opts.timeoutMs !== void 0 ? { timeoutAtMs: now + opts.timeoutMs } : {},
-    ...opts.args ? { args: opts.args } : {}
-  };
-}
-function createWaitProbes(entries) {
-  const map = new Map(Object.entries(entries));
-  return { resolve: (name) => map.get(name) };
-}
-function isWaitOutcome(value) {
-  return typeof value === "object" && value !== null && value.waitOutcome === true;
-}
-function waitUntil(spec) {
-  return spec.kind === "timer" ? spec.untilMs : spec.timeoutAtMs;
-}
-function validateWaitSpec(spec) {
-  if (spec.kind === "timer") {
-    return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
-  }
-  if (typeof spec.probe !== "string" || spec.probe.length === 0) {
-    return "poll.probe must be a non-empty probe name";
-  }
-  if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) {
-    return "poll.intervalMs must be > 0";
-  }
-  if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) {
-    return "poll.timeoutAtMs must be a finite epoch-ms instant";
-  }
-  return null;
-}
-function assertWaitWithinDeadline(spec, deadlineMs) {
-  if (deadlineMs <= 0) return true;
-  const until = waitUntil(spec);
-  if (until === void 0) return false;
-  return until <= deadlineMs;
-}
-async function runWait(args) {
-  const { spec, label, armedAt, resumed, signal, now } = args;
-  const sleep = args.sleep ?? defaultSleep;
-  if (signal.aborted) return { kind: "cancelled", reason: "aborted before arming" };
-  if (spec.kind === "timer") {
-    const remaining = spec.untilMs - now();
-    if (remaining > 0) await sleep(remaining, signal);
-    if (signal.aborted) return { kind: "cancelled", reason: "wait aborted" };
-    return {
-      kind: "woke",
-      outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
-    };
-  }
-  const probe = args.probes?.resolve(spec.probe);
-  if (!probe) {
-    throw new ValidationError(
-      `wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`
-    );
-  }
-  let polls = 0;
-  let probeErrors = 0;
-  for (; ; ) {
-    if (signal.aborted) return { kind: "cancelled", reason: "wait aborted" };
-    polls += 1;
-    let fired = false;
-    try {
-      fired = await probe(spec.args, signal);
-    } catch {
-      probeErrors += 1;
-    }
-    if (fired) {
-      return {
-        kind: "woke",
-        outcome: outcome(
-          "poll",
-          "fired",
-          label,
-          spec.timeoutAtMs,
-          armedAt,
-          now(),
-          polls,
-          probeErrors,
-          resumed
-        )
-      };
-    }
-    if (spec.timeoutAtMs !== void 0 && now() >= spec.timeoutAtMs) {
-      return {
-        kind: "woke",
-        outcome: outcome(
-          "poll",
-          "timeout",
-          label,
-          spec.timeoutAtMs,
-          armedAt,
-          now(),
-          polls,
-          probeErrors,
-          resumed
-        )
-      };
-    }
-    const nextCheck = spec.timeoutAtMs === void 0 ? spec.intervalMs : Math.min(spec.intervalMs, Math.max(0, spec.timeoutAtMs - now()));
-    await sleep(nextCheck, signal);
-  }
-}
-function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeErrors, resumed) {
-  return {
-    waitOutcome: true,
-    kind,
-    settled,
-    label,
-    ...untilMs !== void 0 ? { untilMs } : {},
-    armedAt,
-    wokenAt,
-    polls,
-    probeErrors,
-    resumed
-  };
-}
-function defaultSleep(ms, signal) {
-  if (ms <= 0 || signal.aborted) return Promise.resolve();
-  return new Promise((resolve2) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve2();
-    }, ms);
-    function onAbort() {
-      clearTimeout(timer);
-      resolve2();
-    }
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-// src/runtime/supervise/scope.ts
-var nestedScopeSeamKey = "nested-scope";
-function makeNestedScopeSeam(args, childNodeId) {
-  return {
-    depth: args.depth,
-    ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
-    journalRoot: args.root,
-    mount(nestedRoot, signal) {
-      return createScope({
-        parentId: childNodeId,
-        root: nestedRoot,
-        pool: args.pool,
-        journal: args.journal,
-        blobs: args.blobs,
-        executors: args.executors,
-        // Re-seed the parent's NON-recursion seams (sandbox/router for leaf grandchildren);
-        // the nested scope adds its OWN nested-scope seam per child in `spawn`.
-        seams: args.seams,
-        depth: args.depth + 1,
-        ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
-        signal,
-        ...args.now ? { now: args.now } : {},
-        ...args.hooks ? { hooks: args.hooks } : {}
-      });
-    }
-  };
-}
-function createScope(args) {
-  const children = /* @__PURE__ */ new Map();
-  let spawnOrdinal = args.resumeFrom ? args.resumeFrom.maxSpawnOrdinal + 1 : 0;
-  let cursorSeq = args.resumeFrom ? args.resumeFrom.maxCursorSeq + 1 : 0;
-  let waitOrdinal = args.resumeFrom ? args.resumeFrom.maxWaitOrdinal + 1 : 0;
-  let meterSeq = 0;
-  const now = args.now ?? Date.now;
-  const unclaimedWaits = new Map(
-    (args.resumeFrom?.waits ?? []).map((w) => [w.label, w])
-  );
-  function spawn4(agent, task, opts) {
-    if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) {
-      return { ok: false, reason: "depth-exceeded" };
-    }
-    const spec = agent.executorSpec;
-    if (!isAgentSpec(spec)) {
-      throw new ValidationError(
-        `scope.spawn: agent "${agent.name}" exposes no \`executorSpec\` (AgentSpec) to resolve a Executor`
-      );
-    }
-    const resolved = args.executors.resolve(spec);
-    if (!resolved.succeeded) throw new ValidationError(`scope.spawn: ${resolved.error}`);
-    const reservation = args.pool.reserve(opts.budget);
-    if (!reservation.ok) return { ok: false, reason: reservation.reason };
-    try {
-      const ordinal = spawnOrdinal++;
-      const id = `${args.parentId}:s${ordinal}`;
-      const childAbort = new AbortController();
-      const cascadeAbort = () => childAbort.abort();
-      if (args.signal.aborted) childAbort.abort();
-      else args.signal.addEventListener("abort", cascadeAbort, { once: true });
-      const ctx = {
-        signal: childAbort.signal,
-        seams: { ...args.seams, [nestedScopeSeamKey]: makeNestedScopeSeam(args, id) }
-      };
-      const executor = resolved.value(spec, ctx);
-      const handle = {
-        id,
-        label: opts.label,
-        get status() {
-          return children.get(id)?.status ?? "cancelled";
-        },
-        abort(reason) {
-          childAbort.abort(reason);
-        }
-      };
-      const live = {
-        id,
-        status: "acquiring",
-        runtime: executor.runtime,
-        budget: opts.budget,
-        label: opts.label,
-        spent: zeroSpend(),
-        settled: void 0,
-        delivered: false,
-        executorDone: false,
-        startedAt: now(),
-        lastActivityAt: now(),
-        ...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {},
-        ...executor.progress ? { readProgress: executor.progress.bind(executor) } : {},
-        ...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {}
-      };
-      children.set(id, live);
-      void args.journal.appendEvent(args.root, {
-        kind: "spawned",
-        id,
-        parent: args.parentId,
-        label: opts.label,
-        budget: opts.budget,
-        runtime: executor.runtime,
-        seq: ordinal,
-        at: new Date(now()).toISOString()
-      });
-      notifyRuntimeHookEvent(
-        args.hooks,
-        {
-          id: `${id}:spawn`,
-          runId: args.root,
-          target: "agent.spawn",
-          phase: "after",
-          timestamp: now(),
-          stepIndex: ordinal,
-          parentId: args.parentId,
-          payload: {
-            childId: id,
-            label: opts.label,
-            runtime: executor.runtime,
-            budget: opts.budget,
-            depth: args.depth
-          }
-        },
-        { signal: args.signal }
-      );
-      const settled = runChild(
-        live,
-        executor,
-        childAbort,
-        task,
-        opts,
-        args.pool,
-        reservation.ticket,
-        args.blobs,
-        now
-      ).then((s) => {
-        live.resolved = s;
-        return s;
-      }).finally(() => {
-        args.signal.removeEventListener("abort", cascadeAbort);
-      });
-      live.settled = settled;
-      return { ok: true, handle };
-    } catch (err) {
-      args.pool.reconcile(reservation.ticket, zeroSpend());
-      throw err;
-    }
-  }
-  async function next() {
-    const undelivered = () => [...children.values()].filter((c) => !c.delivered);
-    if (undelivered().length === 0) return null;
-    for (; ; ) {
-      const pending = undelivered();
-      if (pending.length === 0) return null;
-      const ready = pending.find((c) => c.resolved !== void 0);
-      const chosen = ready ?? await raceFirstSettled(pending);
-      if (chosen.delivered) continue;
-      chosen.delivered = true;
-      const seq = cursorSeq++;
-      const settlement = chosen.resolved;
-      if (!settlement) {
-        throw new ValidationError(
-          `scope.next: child '${chosen.id}' won the settle race without a resolved value`
-        );
-      }
-      return finalizeSettlement(chosen, settlement, seq, args, now);
-    }
-  }
-  async function nextResolved() {
-    for (; ; ) {
-      const candidates = [...children.values()].filter((c) => !c.delivered);
-      const pick = candidates.find((c) => c.resolved !== void 0) ?? candidates.find((c) => c.executorDone);
-      if (!pick) return null;
-      const settlement = await pick.settled;
-      if (pick.delivered) continue;
-      pick.delivered = true;
-      const seq = cursorSeq++;
-      return finalizeSettlement(pick, settlement, seq, args, now);
-    }
-  }
-  function send(nodeId, msg) {
-    const child = children.get(nodeId);
-    if (!child || child.delivered || !child.deliver) return false;
-    child.deliver(msg);
-    child.lastActivityAt = now();
-    return true;
-  }
-  function wait(spec, opts) {
-    if (validateWaitSpec(spec) !== null) return { ok: false, reason: "invalid-spec" };
-    if (spec.kind === "poll" && args.probes?.resolve(spec.probe) === void 0) {
-      return { ok: false, reason: "unknown-probe" };
-    }
-    const adopted = unclaimedWaits.get(opts.label);
-    if (adopted) unclaimedWaits.delete(opts.label);
-    const effectiveSpec = adopted?.spec ?? spec;
-    const armedAt = adopted?.armedAt ?? now();
-    if (!assertWaitWithinDeadline(effectiveSpec, args.pool.readout().deadlineMs)) {
-      return { ok: false, reason: "deadline-exceeded" };
-    }
-    const id = adopted ? adopted.id : `${args.parentId}:w${waitOrdinal}`;
-    const ordinal = adopted ? adopted.ordinal : waitOrdinal;
-    if (!adopted) waitOrdinal += 1;
-    const waitAbort = new AbortController();
-    const cascadeAbort = () => waitAbort.abort();
-    if (args.signal.aborted) waitAbort.abort();
-    else args.signal.addEventListener("abort", cascadeAbort, { once: true });
-    const handle = {
-      id,
-      label: opts.label,
-      get status() {
-        return children.get(id)?.status ?? "cancelled";
-      },
-      abort(reason) {
-        waitAbort.abort(reason);
-      }
-    };
-    const live = {
-      id,
-      status: "waiting",
-      runtime: "wait",
-      // A wait's recorded budget is zero on every channel — nothing was reserved, so nothing may
-      // be reconciled, and a journal reader sums it as the zero it truly is.
-      budget: { maxIterations: 0, maxTokens: 0 },
-      label: opts.label,
-      spent: zeroSpend(),
-      settled: void 0,
-      delivered: false,
-      executorDone: false,
-      startedAt: armedAt,
-      lastActivityAt: now(),
-      wait: { spec: effectiveSpec, armedAt, label: opts.label }
-    };
-    children.set(id, live);
-    if (!adopted) {
-      void args.journal.appendEvent(args.root, {
-        kind: "waiting",
-        id,
-        parent: args.parentId,
-        label: opts.label,
-        spec: effectiveSpec,
-        armedAt,
-        seq: ordinal,
-        at: new Date(now()).toISOString()
-      });
-    }
-    notifyRuntimeHookEvent(
-      args.hooks,
-      {
-        id: `${id}:waiting`,
-        runId: args.root,
-        target: "agent.spawn",
-        phase: "after",
-        timestamp: now(),
-        stepIndex: ordinal,
-        parentId: args.parentId,
-        payload: {
-          childId: id,
-          label: opts.label,
-          runtime: "wait",
-          wait: effectiveSpec,
-          armedAt,
-          resumed: adopted !== void 0
-        }
-      },
-      { signal: args.signal }
-    );
-    const settled = runWait({
-      spec: effectiveSpec,
-      label: opts.label,
-      armedAt,
-      resumed: adopted !== void 0,
-      signal: waitAbort.signal,
-      ...args.probes ? { probes: args.probes } : {},
-      now,
-      ...args.waitSleep ? { sleep: args.waitSleep } : {}
-    }).then(async (resolution) => {
-      live.executorDone = true;
-      live.lastActivityAt = now();
-      if (resolution.kind === "cancelled") {
-        return { kind: "down", reason: resolution.reason, infra: false, restartCount: 0 };
-      }
-      const outRef = contentAddress(resolution.outcome);
-      await args.blobs.put(outRef, resolution.outcome);
-      return { kind: "done", out: resolution.outcome, outRef, spent: zeroSpend() };
-    }).catch((err) => {
-      live.executorDone = true;
-      return { kind: "down", reason: errMessage(err), infra: true, restartCount: 0 };
-    }).then((s) => {
-      live.resolved = s;
-      return s;
-    }).finally(() => {
-      args.signal.removeEventListener("abort", cascadeAbort);
-    });
-    live.settled = settled;
-    return { ok: true, handle };
-  }
-  function progress(nodeId, opts = {}) {
-    const child = children.get(nodeId);
-    if (!child) return void 0;
-    let fromExecutor;
-    try {
-      fromExecutor = child.readProgress?.();
-    } catch {
-      fromExecutor = void 0;
-    }
-    return readWorkerProgress(
-      {
-        id: child.id,
-        status: child.status,
-        steerable: child.deliver !== void 0 && !child.delivered,
-        startedAt: child.startedAt,
-        lastActivityAt: child.lastActivityAt,
-        turns: child.spent.iterations,
-        tokens: child.spent.tokens,
-        usd: child.spent.usd
-      },
-      fromExecutor,
-      opts.now ?? now(),
-      opts.stallAfterMs ?? DEFAULT_STALL_AFTER_MS
-    );
-  }
-  function traceSource(nodeId) {
-    const child = children.get(nodeId);
-    if (!child) return void 0;
-    try {
-      return child.readTraceSource?.();
-    } catch {
-      return void 0;
-    }
-  }
-  async function meter(spend, detail) {
-    const seq = meterSeq++;
-    args.pool.observe(spend);
-    await args.journal.appendEvent(args.root, {
-      kind: "metered",
-      id: args.parentId,
-      spend,
-      seq,
-      at: new Date(now()).toISOString()
-    });
-    notifyRuntimeHookEvent(
-      args.hooks,
-      {
-        id: `${args.parentId}:meter:${seq}`,
-        runId: args.root,
-        target: "agent.turn",
-        phase: "after",
-        timestamp: now(),
-        parentId: args.parentId,
-        payload: { spend, ...detail ?? {} }
-      },
-      { signal: args.signal }
-    );
-  }
-  const resume = args.resumeFrom ? {
-    settled: args.resumeFrom.settled,
-    view: args.resumeFrom.view,
-    waits: args.resumeFrom.waits
-  } : void 0;
-  return {
-    spawn: spawn4,
-    next,
-    nextResolved,
-    send,
-    wait,
-    progress,
-    traceSource,
-    signal: args.signal,
-    meter,
-    ...resume ? { resume } : {},
-    get view() {
-      return makeTreeView(args.parentId, children);
-    },
-    get budget() {
-      return args.pool.readout();
-    }
-  };
-}
-async function raceFirstSettled(pending) {
-  return Promise.race(pending.map((c) => c.settled.then(() => c)));
-}
-async function finalizeSettlement(child, settlement, seq, args, now) {
-  const handle = frozenHandle(child);
-  if (child.wait) return finalizeWait(child, settlement, seq, args, now, handle);
-  if (settlement.kind === "down") {
-    child.status = "failed";
-    await args.journal.appendEvent(args.root, {
-      kind: "settled",
-      id: child.id,
-      status: "down",
-      spent: child.spent,
-      infra: settlement.infra,
-      seq,
-      at: new Date(now()).toISOString()
-    });
-    if (settlement.metered) {
-      await args.journal.appendEvent(args.root, {
-        kind: "metered",
-        id: child.id,
-        spend: settlement.metered,
-        seq,
-        at: new Date(now()).toISOString()
-      });
-    }
-    notifyRuntimeHookEvent(
-      args.hooks,
-      {
-        id: `${child.id}:settled`,
-        runId: args.root,
-        target: "agent.child",
-        phase: "after",
-        timestamp: now(),
-        stepIndex: seq,
-        parentId: args.parentId,
-        payload: {
-          childId: child.id,
-          status: "down",
-          reason: settlement.reason,
-          infra: settlement.infra,
-          spent: child.spent
-        }
-      },
-      { signal: args.signal }
-    );
-    return {
-      kind: "down",
-      handle,
-      reason: settlement.reason,
-      infra: settlement.infra,
-      restartCount: settlement.restartCount,
-      seq
-    };
-  }
-  child.status = "done";
-  child.outRef = settlement.outRef;
-  child.spent = settlement.spent;
-  await args.journal.appendEvent(args.root, {
-    kind: "settled",
-    id: child.id,
-    status: "done",
-    outRef: settlement.outRef,
-    ...settlement.verdict ? { verdict: settlement.verdict } : {},
-    spent: settlement.spent,
-    seq,
-    at: new Date(now()).toISOString()
-  });
-  if (settlement.metered) {
-    await args.journal.appendEvent(args.root, {
-      kind: "metered",
-      id: child.id,
-      spend: settlement.metered,
-      seq,
-      at: new Date(now()).toISOString()
-    });
-  }
-  notifyRuntimeHookEvent(
-    args.hooks,
-    {
-      id: `${child.id}:settled`,
-      runId: args.root,
-      target: "agent.child",
-      phase: "after",
-      timestamp: now(),
-      stepIndex: seq,
-      parentId: args.parentId,
-      payload: {
-        childId: child.id,
-        status: "done",
-        outRef: settlement.outRef,
-        score: settlement.verdict?.score,
-        valid: settlement.verdict?.valid,
-        spent: settlement.spent
-      }
-    },
-    { signal: args.signal }
-  );
-  return {
-    kind: "done",
-    handle,
-    out: settlement.out,
-    outRef: settlement.outRef,
-    ...settlement.verdict ? { verdict: settlement.verdict } : {},
-    spent: settlement.spent,
-    seq
-  };
-}
-async function finalizeWait(child, settlement, seq, args, now, handle) {
-  const at = new Date(now()).toISOString();
-  if (settlement.kind === "down") {
-    child.status = "cancelled";
-    await args.journal.appendEvent(args.root, {
-      kind: "woken",
-      id: child.id,
-      by: "cancelled",
-      seq,
-      at
-    });
-    return {
-      kind: "down",
-      handle,
-      reason: settlement.reason,
-      infra: settlement.infra,
-      restartCount: settlement.restartCount,
-      seq
-    };
-  }
-  child.status = "done";
-  child.outRef = settlement.outRef;
-  const out = settlement.out;
-  await args.journal.appendEvent(args.root, {
-    kind: "woken",
-    id: child.id,
-    by: out.settled,
-    outRef: settlement.outRef,
-    seq,
-    at
-  });
-  notifyRuntimeHookEvent(
-    args.hooks,
-    {
-      id: `${child.id}:woken`,
-      runId: args.root,
-      target: "agent.child",
-      phase: "after",
-      timestamp: now(),
-      stepIndex: seq,
-      parentId: args.parentId,
-      payload: { childId: child.id, status: "done", wait: out }
-    },
-    { signal: args.signal }
-  );
-  return {
-    kind: "done",
-    handle,
-    out: settlement.out,
-    outRef: settlement.outRef,
-    spent: settlement.spent,
-    seq
-  };
-}
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now) {
-  let reconciled = false;
-  const reconcileOnce = (spend) => {
-    if (reconciled) return;
-    reconciled = true;
-    pool.reconcile(ticket, clampSpend(spend, opts.budget));
-  };
-  try {
-    live.status = "running";
-    const ran = executor.execute(task, childAbort.signal);
-    let artifact;
-    if (isAsyncIterable(ran)) {
-      const spend = await foldStream(ran, (running) => {
-        live.spent = running;
-        live.lastActivityAt = now();
-      });
-      live.spent = spend;
-      artifact = executor.resultArtifact();
-      reconcileOnce(spend);
-    } else {
-      const terminal = await ran;
-      live.spent = terminal.spent;
-      artifact = terminal;
-      reconcileOnce(terminal.spent);
-    }
-    live.executorDone = true;
-    const ownMetered = executor.metered?.();
-    if (childAbort.signal.aborted) {
-      await teardownSafe(executor, opts.shutdown ?? "brutalKill");
-      return downRecord("aborted before settle", true, ownMetered);
-    }
-    const outRef = contentAddress(artifact.out);
-    await blobs.put(outRef, artifact.out);
-    await teardownSafe(executor, opts.shutdown ?? "infinity");
-    return {
-      kind: "done",
-      out: artifact.out,
-      outRef,
-      ...artifact.verdict ? { verdict: artifact.verdict } : {},
-      spent: live.spent,
-      ...ownMetered ? { metered: ownMetered } : {}
-    };
-  } catch (err) {
-    live.executorDone = true;
-    reconcileOnce(live.spent);
-    await teardownSafe(executor, "brutalKill");
-    const aborted = childAbort.signal.aborted || isAbortError(err);
-    return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
-  }
-}
-function settledToIteration(settled) {
-  if (settled.kind === "down") {
-    throw new ValidationError(
-      `settledToIteration: cannot adapt a 'down' settlement (node '${settled.handle.id}', seq ${settled.seq}) to an Iteration`
-    );
-  }
-  return {
-    index: settled.seq,
-    task: void 0,
-    agentRunName: settled.handle.label,
-    output: settled.out,
-    ...settled.verdict ? { verdict: settled.verdict } : {},
-    events: [],
-    startedAt: 0,
-    endedAt: settled.spent.ms,
-    costUsd: settled.spent.usd,
-    tokenUsage: { input: settled.spent.tokens.input, output: settled.spent.tokens.output }
-  };
-}
-function makeTreeView(root, children) {
-  const nodes = [...children.values()].map((c) => ({
-    id: c.id,
-    parent: root,
-    label: c.label,
-    status: c.status,
-    runtime: c.runtime,
-    budget: c.budget,
-    spent: c.spent,
-    ...c.outRef ? { outRef: c.outRef } : {}
-  }));
-  return {
-    root,
-    nodes,
-    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length,
-    waiting: nodes.filter((n) => n.status === "waiting").length
-  };
-}
-function frozenHandle(child) {
-  return {
-    id: child.id,
-    label: child.label,
-    status: child.status,
-    abort() {
-    }
-  };
-}
-async function foldStream(stream, onProgress) {
-  const tokens = { input: 0, output: 0 };
-  let usd = 0;
-  let iterations = 0;
-  for await (const ev of stream) {
-    if (ev.kind === "tokens") {
-      tokens.input += ev.input;
-      tokens.output += ev.output;
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-    onProgress?.({ iterations, tokens: { ...tokens }, usd, ms: 0 });
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-function clampSpend(spend, budget) {
-  const totalTokens2 = spend.tokens.input + spend.tokens.output;
-  const tokensOk = totalTokens2 <= budget.maxTokens;
-  const itersOk = spend.iterations <= budget.maxIterations;
-  const usdOk = budget.maxUsd === void 0 || spend.usd <= budget.maxUsd;
-  if (tokensOk && itersOk && usdOk) return spend;
-  const ratio = !tokensOk && totalTokens2 > 0 ? budget.maxTokens / totalTokens2 : 1;
-  return {
-    iterations: Math.min(spend.iterations, budget.maxIterations),
-    tokens: ratio < 1 ? {
-      input: Math.floor(spend.tokens.input * ratio),
-      output: Math.floor(spend.tokens.output * ratio)
-    } : spend.tokens,
-    usd: budget.maxUsd === void 0 ? spend.usd : Math.min(spend.usd, budget.maxUsd),
-    ...spend.usdKnown === false ? { usdKnown: false } : {},
-    ms: spend.ms
-  };
-}
-async function teardownSafe(executor, grace) {
-  try {
-    await executor.teardown(grace);
-  } catch {
-  }
-}
-function downRecord(reason, infra, metered) {
-  return { kind: "down", reason, infra, restartCount: 0, ...metered ? { metered } : {} };
-}
-function zeroSpend() {
-  return { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-}
-function isAsyncIterable(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
-}
-function isAgentSpec(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  return "profile" in v && "harness" in v;
-}
-function isAbortError(err) {
-  return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
-}
-function isInfraError(err) {
-  return err instanceof ValidationError;
-}
-function errMessage(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
-// src/runtime/supervise/budget.ts
-function spendFromUsageEvents(events) {
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let iterations = 0;
-  for (const ev of events) {
-    if (ev.kind === "tokens") {
-      addTokenUsage(tokens, { input: ev.input, output: ev.output });
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-async function foldUsage(events) {
-  if (Array.isArray(events)) return spendFromUsageEvents(events);
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let iterations = 0;
-  for await (const ev of events) {
-    if (ev.kind === "tokens") {
-      addTokenUsage(tokens, { input: ev.input, output: ev.output });
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-function totalTokens(usage) {
-  return usage.input + usage.output;
-}
-function createBudgetPool(root, now = Date.now) {
-  let freeTokens = root.maxTokens;
-  let reservedTokens = 0;
-  let committedTokens = 0;
-  const usdCapped = root.maxUsd !== void 0;
-  let freeUsd = root.maxUsd ?? 0;
-  let reservedUsd = 0;
-  let committedUsd = 0;
-  let freeIterations = root.maxIterations;
-  let reservedIterations = 0;
-  let committedIterations = 0;
-  const absoluteDeadlineMs = root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0;
-  let nextTicketId = 0;
-  const open3 = /* @__PURE__ */ new Set();
-  function reserve(b) {
-    const wantTokens = b.maxTokens;
-    const wantUsd = b.maxUsd ?? 0;
-    const wantIterations = b.maxIterations;
-    if (wantTokens > freeTokens) return { ok: false, reason: "budget-exhausted" };
-    if (wantIterations > freeIterations) return { ok: false, reason: "budget-exhausted" };
-    if (wantUsd > 0 && (!usdCapped || wantUsd > freeUsd)) {
-      return { ok: false, reason: "budget-exhausted" };
-    }
-    freeTokens -= wantTokens;
-    reservedTokens += wantTokens;
-    freeIterations -= wantIterations;
-    reservedIterations += wantIterations;
-    if (wantUsd > 0) {
-      freeUsd -= wantUsd;
-      reservedUsd += wantUsd;
-    }
-    const id = nextTicketId++;
-    open3.add(id);
-    return {
-      ok: true,
-      ticket: { id, reserved: { tokens: wantTokens, usd: wantUsd, iterations: wantIterations } }
-    };
-  }
-  function reconcile(ticket, spent) {
-    if (!open3.has(ticket.id)) {
-      throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`);
-    }
-    open3.delete(ticket.id);
-    const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved;
-    if (usdCapped && spent.usdKnown === false) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} reported unknown dollar cost under a dollar-capped budget`
-      );
-    }
-    const spentTokens = totalTokens(spent.tokens);
-    if (spentTokens > rTokens) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`
-      );
-    }
-    if (spent.iterations > rIterations) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`
-      );
-    }
-    if (usdCapped && spent.usd > rUsd) {
-      throw new Error(`budget pool: ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`);
-    }
-    reservedTokens -= rTokens;
-    committedTokens += spentTokens;
-    freeTokens += rTokens - spentTokens;
-    reservedIterations -= rIterations;
-    committedIterations += spent.iterations;
-    freeIterations += rIterations - spent.iterations;
-    if (usdCapped && rUsd > 0) {
-      reservedUsd -= rUsd;
-      committedUsd += spent.usd;
-      freeUsd += rUsd - spent.usd;
-    } else {
-      committedUsd += spent.usd;
-    }
-  }
-  function observe(spend) {
-    if (usdCapped && spend.usdKnown === false) {
-      throw new Error(
-        "budget pool: cannot observe unknown dollar cost under a dollar-capped budget"
-      );
-    }
-    const tokens = totalTokens(spend.tokens);
-    freeTokens -= tokens;
-    committedTokens += tokens;
-    freeIterations -= spend.iterations;
-    committedIterations += spend.iterations;
-    committedUsd += spend.usd;
-    if (usdCapped) freeUsd -= spend.usd;
-  }
-  function readout() {
-    return {
-      tokensLeft: freeTokens,
-      usdLeft: usdCapped ? freeUsd : 0,
-      usdCapped,
-      deadlineMs: absoluteDeadlineMs,
-      reservedTokens
-    };
-  }
-  function assertNoOpenTickets() {
-    if (open3.size > 0) {
-      throw new Error(
-        `budget pool: ${open3.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open3].join(", ")}) \u2014 conserved-pool invariant violated`
-      );
-    }
-  }
-  return {
-    reserve,
-    reconcile,
-    spendFrom: foldUsage,
-    readout,
-    observe,
-    assertNoOpenTickets
-  };
-}
-
-// src/runtime/supervise/supervisor.ts
-function maxSeqOf(events, pred) {
-  let max = -1;
-  for (const ev of events) if (pred(ev) && ev.seq > max) max = ev.seq;
-  return max;
-}
-var defaultMaxDepth = 4;
-function createSupervisor() {
-  let attached;
-  async function run(root, task, opts) {
-    const now = opts.now ?? Date.now;
-    const pool = createBudgetPool(opts.budget, now);
-    const prior = opts.resume === true ? await opts.journal.loadTree(opts.runId) : void 0;
-    const resuming = prior !== void 0 && prior.length > 0;
-    let resumeFrom;
-    if (resuming) {
-      const settled = await replaySpawnTree(opts.journal, opts.blobs, opts.runId);
-      const view = materializeTreeView(prior);
-      resumeFrom = {
-        settled,
-        view,
-        maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
-        maxCursorSeq: maxSeqOf(
-          prior,
-          (ev) => ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken"
-        ),
-        maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
-        // Waits armed but never woken: the run died mid-wait. They ride onto `Scope.resume.waits`,
-        // and re-arming the same label adopts the ORIGINAL absolute deadline rather than
-        // restarting the countdown from this process's clock.
-        waits: pendingWaits(prior)
-      };
-    } else {
-      await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
-      await opts.journal.appendEvent(opts.runId, {
-        kind: "spawned",
-        id: opts.runId,
-        label: "root",
-        budget: opts.budget,
-        runtime: "inline",
-        seq: 0,
-        at: new Date(now()).toISOString()
-      });
-    }
-    const controller = new AbortController();
-    const cascadeAbort = (reason) => {
-      if (controller.signal.aborted) return;
-      controller.abort(reason);
-    };
-    const onCallerAbort = () => cascadeAbort("caller signal aborted");
-    if (opts.signal) {
-      if (opts.signal.aborted) cascadeAbort("caller signal aborted");
-      else opts.signal.addEventListener("abort", onCallerAbort, { once: true });
-    }
-    const breaker = createIntensityBreaker(opts, () => cascadeAbort("intensity breaker tripped"));
-    const journal = wrapJournalForBreaker(opts.journal, breaker);
-    const scope = createScope({
-      parentId: opts.runId,
-      root: opts.runId,
-      pool,
-      journal,
-      blobs: opts.blobs,
-      executors: opts.executors,
-      seams: {},
-      depth: 0,
-      maxDepth: opts.maxDepth ?? defaultMaxDepth,
-      signal: controller.signal,
-      now,
-      hooks: opts.hooks,
-      ...opts.probes ? { probes: opts.probes } : {},
-      ...resumeFrom ? { resumeFrom } : {}
-    });
-    const openScope = scope;
-    if (attached) {
-      attached.bind({ scope: openScope, cascadeAbort, signal: pushRootSignal(cascadeAbort) });
-    }
-    let actOutcome;
-    try {
-      const out = await root.act(task, scope);
-      actOutcome = { ok: true, out };
-    } catch (error) {
-      actOutcome = { ok: false, error };
-    } finally {
-      await drainLiveChildren(openScope, controller);
-      if (opts.signal) opts.signal.removeEventListener("abort", onCallerAbort);
-      if (attached) attached.unbind();
-    }
-    const tree = scope.view;
-    if (actOutcome.ok) {
-      pool.assertNoOpenTickets();
-      const out = actOutcome.out;
-      if (out !== void 0) {
-        const outRef = contentAddress(out);
-        await opts.blobs.put(outRef, out);
-        const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
-        return {
-          kind: "winner",
-          out,
-          outRef,
-          tree,
-          spentTotal: addSpend(childWork, driverInference),
-          ...isNonEmptySpend(driverInference) ? { spentBreakdown: { driverInference, childWork } } : {}
-        };
-      }
-      return noWinner();
-    }
-    return noWinner();
-    async function noWinner() {
-      const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
-      return {
-        kind: "no-winner",
-        reason: classifyNoWinner(controller, pool, opts, breaker),
-        tree,
-        downCount: breaker.downCount(),
-        spentTotal: addSpend(childWork, driverInference)
-      };
-    }
-  }
-  function attach(h) {
-    const control = rootControls.get(h);
-    if (!control) {
-      throw new RuntimeRunStateError(
-        "supervisor.attach: handle was not minted by createRootHandle (no control channel)"
-      );
-    }
-    attached = control;
-  }
-  return { run, attach };
-}
-var rootControls = /* @__PURE__ */ new WeakMap();
-function pushRootSignal(cascadeAbort) {
-  return (msg) => {
-    if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
-  };
-}
-function createIntensityBreaker(opts, trip) {
-  const max = opts.maxRestarts;
-  const within = opts.withinMs;
-  const armed = max !== void 0 && within !== void 0;
-  const recent = [];
-  let total = 0;
-  let isTripped = false;
-  return {
-    recordDown(at) {
-      total += 1;
-      if (!armed || isTripped) return;
-      recent.push(at);
-      const cutoff = at - within;
-      while (recent.length > 0 && recent[0] < cutoff) recent.shift();
-      if (recent.length > max) {
-        isTripped = true;
-        trip();
-      }
-    },
-    tripped() {
-      return isTripped;
-    },
-    downCount() {
-      return total;
-    }
-  };
-}
-function wrapJournalForBreaker(journal, breaker) {
-  return {
-    loadTree: (root) => journal.loadTree(root),
-    beginTree: (root, at) => journal.beginTree(root, at),
-    appendEvent: (root, ev) => {
-      if (ev.kind === "settled" && ev.status === "down") breaker.recordDown(Date.parse(ev.at));
-      return journal.appendEvent(root, ev);
-    }
-  };
-}
-async function drainLiveChildren(scope, controller) {
-  const view = scope.view;
-  const hasLive = view.inFlight > 0 || view.waiting > 0;
-  if (!hasLive) return;
-  if (!controller.signal.aborted) controller.abort();
-  await Promise.allSettled([drainCursor(scope)]);
-}
-async function drainCursor(scope) {
-  for (; ; ) {
-    const settled = await scope.next();
-    if (settled === null) return;
-  }
-}
-function classifyNoWinner(controller, pool, opts, breaker) {
-  if (breaker.tripped()) return "all-children-down";
-  if (controller.signal.aborted) return "aborted";
-  if (poolExhausted(pool, opts)) return "budget-exhausted";
-  return "all-children-down";
-}
-function poolExhausted(pool, opts) {
-  const r = pool.readout();
-  if (r.tokensLeft <= 0) return true;
-  if (opts.budget.maxUsd !== void 0 && r.usdLeft <= 0) return true;
-  if (opts.budget.deadlineMs !== void 0 && r.deadlineMs > 0 && (opts.now ?? Date.now)() >= r.deadlineMs) {
-    return true;
-  }
-  return false;
-}
-async function spentFromJournal(journal, root) {
-  const events = await journal.loadTree(root);
-  if (events === void 0) {
-    throw new RuntimeRunStateError(
-      `supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`
-    );
-  }
-  const childWork = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-  const driverInference = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-  for (const ev of events) {
-    if (ev.kind === "settled") accumulate(childWork, ev.spent);
-    else if (ev.kind === "metered") accumulate(driverInference, ev.spend);
-  }
-  return { childWork, driverInference };
-}
-function accumulate(a, b) {
-  a.iterations += b.iterations;
-  a.tokens.input += b.tokens.input;
-  a.tokens.output += b.tokens.output;
-  a.usd += b.usd;
-  if (b.usdKnown === false) a.usdKnown = false;
-  a.ms += b.ms;
-}
-function addSpend(a, b) {
-  return {
-    iterations: a.iterations + b.iterations,
-    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
-    usd: a.usd + b.usd,
-    ...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-    ms: a.ms + b.ms
-  };
-}
-function isNonEmptySpend(s) {
-  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
-}
-
-// src/mcp/worktree-harness.ts
-import { spawn as spawn3 } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import {
-  applyWorkspacePlan,
-  materializeProfile
-} from "@tangle-network/agent-profile-materialize";
-var defaultCheckOutputCap = 16e3;
-async function runWorktreeHarness(opts) {
-  opts.signal?.throwIfAborted();
-  const runHarness = opts.runHarness ?? runLocalHarness;
-  const runCommand = opts.runCommand ?? defaultRunCommand;
-  const checkTimeoutMs = opts.checkTimeoutMs ?? opts.harnessTimeoutMs ?? 5 * 60 * 1e3;
-  const cap = opts.checkOutputCap ?? defaultCheckOutputCap;
-  const worktree = await createWorktree({
-    repoRoot: opts.repoRoot,
-    runId: opts.runId,
-    ...opts.baseRef ? { baseRef: opts.baseRef } : {},
-    ...opts.runGit ? { runGit: opts.runGit } : {}
-  });
-  const cleanup = () => removeWorktree({
-    worktree,
-    repoRoot: opts.repoRoot,
-    ...opts.runGit ? { runGit: opts.runGit } : {}
-  });
-  try {
-    assertSupportedWorktreeProfile(opts.profile, opts.harness);
-    assertSafeProfileResourcePaths(opts.profile);
-    const resourceInstructions = resolveResourceInstructions(opts.profile);
-    const workspaceProfile = materializationOnlyProfile(opts.profile);
-    const plan = materializeProfile(workspaceProfile, opts.harness);
-    if (plan.unsupported.length > 0) {
-      throw new Error(
-        `runWorktreeHarness: profile cannot be materialized for ${opts.harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`
-      );
-    }
-    assertSafeMaterializedPaths(plan);
-    const applied = applyWorkspacePlan(plan, worktree.path, { existingFiles: "reject" });
-    if (applied.unsupported.length > 0) {
-      throw new Error("runWorktreeHarness: applied profile unexpectedly retained unsupported rows");
-    }
-    const invocationProfile = profileWithResourceInstructions(opts.profile, resourceInstructions);
-    const { command, args } = harnessInvocation(opts.harness, invocationProfile, opts.taskPrompt, {
-      // This helper created the candidate worktree above; autonomous Claude
-      // edits are permitted only inside that isolated checkout.
-      dangerouslySkipPermissions: opts.harness === "claude",
-      ...opts.codexReproducible ? { codexReproducible: true } : {}
-    });
-    const harnessResult = await runHarness({
-      harness: opts.harness,
-      cwd: worktree.path,
-      taskPrompt: opts.taskPrompt,
-      invocation: { command, args: [...args, ...applied.flags] },
-      env: { ...process.env, ...applied.env },
-      ...opts.codexReproducible ? { codexReproducible: true } : {},
-      ...opts.codexReadDeniedPaths ? { codexReadDeniedPaths: opts.codexReadDeniedPaths } : {},
-      ...opts.harnessTimeoutMs !== void 0 ? { timeoutMs: opts.harnessTimeoutMs } : {},
-      ...opts.signal ? { signal: opts.signal } : {}
-    });
-    if (harnessResult.aborted || opts.signal?.aborted) {
-      throw new Error("runWorktreeHarness: harness was cancelled by the caller", {
-        cause: opts.signal?.reason
-      });
-    }
-    opts.signal?.throwIfAborted();
-    const diff = await captureWorktreeDiff({
-      worktree,
-      excludePaths: applied.written,
-      ...opts.runGit ? { runGit: opts.runGit } : {}
-    });
-    opts.signal?.throwIfAborted();
-    const checks = await runWorktreeChecks({
-      worktreePath: worktree.path,
-      ...opts.testCmd !== void 0 ? { testCmd: opts.testCmd } : {},
-      ...opts.typecheckCmd !== void 0 ? { typecheckCmd: opts.typecheckCmd } : {},
-      timeoutMs: checkTimeoutMs,
-      cap,
-      runCommand,
-      ...opts.signal ? { signal: opts.signal } : {}
-    });
-    opts.signal?.throwIfAborted();
-    const result = {
-      branch: worktree.branch,
-      patch: diff.patch,
-      stats: diff.stats,
-      profileMaterialization: profileMaterializationReceipt(applied, resourceInstructions),
-      harness: {
-        name: opts.harness,
-        exitCode: harnessResult.exitCode,
-        timedOut: harnessResult.timedOut,
-        killedBySignal: harnessResult.killedBySignal,
-        durationMs: harnessResult.durationMs,
-        stdout: harnessResult.stdout,
-        stderr: harnessResult.stderr,
-        ...harnessResult.usage ? { usage: harnessResult.usage } : {},
-        ...harnessResult.evidence ? {
-          cliVersion: harnessResult.evidence.cliVersion,
-          executableSha256: harnessResult.evidence.executableSha256,
-          requestedPromptSha256: harnessResult.evidence.requestedPromptSha256,
-          effectivePromptSha256: harnessResult.evidence.effectivePromptSha256,
-          nonPromptArgsSha256: harnessResult.evidence.nonPromptArgsSha256,
-          controlledConfigSha256: harnessResult.evidence.controlledConfigSha256,
-          readDeniedPaths: [...harnessResult.evidence.readDeniedPaths],
-          readDeniedPathsSha256: harnessResult.evidence.readDeniedPathsSha256,
-          readDeniedPathCount: harnessResult.evidence.readDeniedPathCount,
-          executionPolicy: harnessResult.evidence.policy
-        } : {}
-      },
-      ...checks ? { checks } : {}
-    };
-    return { worktree, result, cleanup };
-  } catch (err) {
-    try {
-      await cleanup();
-    } catch (cleanupError) {
-      throw new AggregateError(
-        [err, cleanupError],
-        "runWorktreeHarness: run failed and worktree cleanup also failed"
-      );
-    }
-    throw err;
-  }
-}
-function resolveResourceInstructions(profile) {
-  const instructions = profile.resources?.instructions;
-  if (instructions === void 0) return void 0;
-  if (typeof instructions === "string")
-    return instructions.trim().length > 0 ? instructions : void 0;
-  if (instructions.kind === "inline" && typeof instructions.content === "string") {
-    return instructions.content.trim().length > 0 ? instructions.content : void 0;
-  }
-  throw new Error(
-    "runWorktreeHarness: resources.instructions must be a string or inline resource; remote refs require pre-resolution"
-  );
-}
-function profileWithResourceInstructions(profile, resourceInstructions) {
-  let resources;
-  if (profile.resources) {
-    const { instructions: _instructions, ...structuralResources } = profile.resources;
-    resources = structuralResources;
-  }
-  return {
-    ...profile,
-    ...resources ? { resources } : {},
-    ...resourceInstructions === void 0 ? {} : {
-      prompt: {
-        ...profile.prompt,
-        instructions: [...profile.prompt?.instructions ?? [], resourceInstructions]
-      }
-    }
-  };
-}
-function materializationOnlyProfile(profile) {
-  const {
-    prompt: _prompt,
-    model: _model,
-    resources: profileResources,
-    ...structuralProfile
-  } = profile;
-  let resources;
-  if (profileResources) {
-    const { instructions: _instructions, ...fileBackedResources } = profileResources;
-    resources = fileBackedResources;
-  }
-  return {
-    ...structuralProfile,
-    ...resources ? { resources } : {}
-  };
-}
-function assertSupportedWorktreeProfile(profile, harness) {
-  const unsupportedAxes = [
-    hasEntries(profile.tools) ? "tools" : null,
-    hasEntries(profile.permissions) ? "permissions" : null,
-    profile.connections && profile.connections.length > 0 ? "connections" : null,
-    hasEntries(profile.confidential) ? "confidential" : null,
-    hasEntries(profile.modes) ? "modes" : null,
-    hasEntries(profile.extensions) ? "extensions" : null
-  ].filter((axis) => axis !== null);
-  if (profile.model?.reasoningEffort !== void 0 && harness !== "codex") {
-    unsupportedAxes.push("model.reasoningEffort");
-  }
-  for (const [name, server] of Object.entries(profile.mcp ?? {})) {
-    const path = `mcp[${JSON.stringify(name)}]`;
-    if (server.enabled === false && harness !== "opencode") {
-      unsupportedAxes.push(`${path}.enabled`);
-    }
-    if (hasEntries(server.headers) && harness === "codex") {
-      unsupportedAxes.push(`${path}.headers`);
-    }
-    if (server.cwd !== void 0 && harness === "opencode") {
-      unsupportedAxes.push(`${path}.cwd`);
-    }
-  }
-  if (harness === "claude") {
-    for (const [event, commands] of Object.entries(profile.hooks ?? {})) {
-      for (const [index, command] of commands.entries()) {
-        const path = `hooks[${JSON.stringify(event)}][${index}]`;
-        if (hasEntries(command.env)) unsupportedAxes.push(`${path}.env`);
-        if (command.blocking !== void 0) unsupportedAxes.push(`${path}.blocking`);
-      }
-    }
-  }
-  for (const [name, subagent] of Object.entries(profile.subagents ?? {})) {
-    const path = `subagents[${JSON.stringify(name)}]`;
-    if (hasEntries(subagent.permissions)) unsupportedAxes.push(`${path}.permissions`);
-    if (subagent.maxSteps !== void 0) unsupportedAxes.push(`${path}.maxSteps`);
-    if (hasEntries(subagent.tools) && harness !== "claude") {
-      unsupportedAxes.push(`${path}.tools`);
-    }
-  }
-  if (unsupportedAxes.length > 0) {
-    throw new Error(
-      `runWorktreeHarness: profile requests unsupported worktree behavior: ${unsupportedAxes.join(", ")}`
-    );
-  }
-}
-function hasEntries(value) {
-  return value !== void 0 && Object.keys(value).length > 0;
-}
-function assertSafeMaterializedPaths(plan) {
-  for (const file of plan.files) {
-    if (file.relPath.split("/").some(isGitMetadataSegment)) {
-      throw new Error(
-        `runWorktreeHarness: profile file cannot target reserved Git metadata: ${file.relPath}`
-      );
-    }
-  }
-}
-function assertSafeProfileResourcePaths(profile) {
-  for (const file of profile.resources?.files ?? []) {
-    if (file.path.split("/").some(isGitMetadataSegment)) {
-      throw new Error(
-        `runWorktreeHarness: profile file cannot target reserved Git metadata: ${file.path}`
-      );
-    }
-  }
-}
-function isGitMetadataSegment(segment) {
-  const windowsCanonical = segment.replace(/[ .]+$/u, "").toLowerCase();
-  return windowsCanonical === ".git" || windowsCanonical.startsWith(".git:");
-}
-function profileMaterializationReceipt(applied, resourceInstructions) {
-  const instructionBytes = resourceInstructions === void 0 ? null : Buffer.from(resourceInstructions, "utf8");
-  return {
-    workspacePlanDigest: applied.workspacePlanDigest,
-    writtenPaths: [...applied.written],
-    unsupported: [...applied.unsupported],
-    environmentNames: Object.keys(applied.env).sort(),
-    flags: [...applied.flags],
-    resourceInstructions: instructionBytes ? {
-      delivery: "invocation-prompt",
-      sha256: `sha256:${createHash2("sha256").update(instructionBytes).digest("hex")}`,
-      byteLength: instructionBytes.byteLength
-    } : { delivery: "none", sha256: null, byteLength: 0 }
-  };
-}
-async function runWorktreeChecks(opts) {
-  opts.signal?.throwIfAborted();
-  if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
-  const runCommand = opts.runCommand ?? defaultRunCommand;
-  const run = async (command) => {
-    opts.signal?.throwIfAborted();
-    const res = await runCommand({
-      command,
-      cwd: opts.worktreePath,
-      timeoutMs: opts.timeoutMs,
-      ...opts.signal ? { signal: opts.signal } : {}
-    });
-    opts.signal?.throwIfAborted();
-    return {
-      command,
-      passed: res.exitCode === 0,
-      exitCode: res.exitCode,
-      output: res.output.length > opts.cap ? res.output.slice(-opts.cap) : res.output
-    };
-  };
-  const checks = {};
-  if (opts.testCmd !== void 0) checks.tests = await run(opts.testCmd);
-  opts.signal?.throwIfAborted();
-  if (opts.typecheckCmd !== void 0) checks.typecheck = await run(opts.typecheckCmd);
-  opts.signal?.throwIfAborted();
-  return checks;
-}
-async function runSettledCommand(opts) {
-  opts.signal?.throwIfAborted();
-  return new Promise((resolve2, reject) => {
-    const child = spawn3(opts.command, opts.args ?? [], {
-      cwd: opts.cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: process.platform !== "win32"
-    });
-    const stdout = [];
-    const stderr = [];
-    let settled = false;
-    let leaderClosed = false;
-    let timedOut = false;
-    let termination = null;
-    const terminate = () => {
-      termination ??= terminateProcessTreeAndConfirm(child, () => leaderClosed, "defaultRunCommand");
-      return termination;
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      void terminate().catch(fail);
-    }, opts.timeoutMs);
-    const onAbort = () => void terminate().catch(fail);
-    if (opts.signal) {
-      if (opts.signal.aborted) onAbort();
-      else opts.signal.addEventListener("abort", onAbort, { once: true });
-    }
-    child.stdout?.on("data", (d) => stdout.push(String(d)));
-    child.stderr?.on("data", (d) => stderr.push(String(d)));
-    const finish = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-      fn();
-    };
-    function fail(err) {
-      finish(() => reject(err instanceof Error ? err : new Error(String(err))));
-    }
-    child.on("error", (err) => {
-      leaderClosed = true;
-      void (termination ?? Promise.resolve()).then(() => fail(err), fail);
-    });
-    child.on("close", (code, killedBySignal) => {
-      leaderClosed = true;
-      void (async () => {
-        try {
-          await (termination ?? terminate());
-          opts.signal?.throwIfAborted();
-          finish(
-            () => resolve2({
-              exitCode: code,
-              stdout: stdout.join(""),
-              stderr: stderr.join(""),
-              killedBySignal,
-              timedOut
-            })
-          );
-        } catch (err) {
-          fail(err);
-        }
-      })();
-    });
-  });
-}
-async function defaultRunCommand(opts) {
-  const result = await runSettledCommand({
-    command: "/bin/sh",
-    args: ["-c", opts.command],
-    cwd: opts.cwd,
-    timeoutMs: opts.timeoutMs,
-    ...opts.signal ? { signal: opts.signal } : {}
-  });
-  return { exitCode: result.exitCode, output: result.stdout + result.stderr };
-}
-
-// src/runtime/supervise/driver-executor.ts
-var driverRuntime = "driver";
-var driverRole = "driver";
-function isDriverSpec(spec) {
-  const role = spec.profile.metadata?.role;
-  if (role !== driverRole) return false;
-  const driver = spec.driver;
-  if (!isAgent(driver)) {
-    throw new ValidationError(
-      "driverExecutor: a driver-role spec must carry a `driver` Agent to run inside its nested scope"
-    );
-  }
-  return true;
-}
-var driverExecutorFactory = (spec, ctx) => {
-  if (!isDriverSpec(spec)) {
-    throw new ValidationError(
-      'driverExecutorFactory: spec is not a driver child (no role:"driver" marker)'
-    );
-  }
-  const driver = spec.driver;
-  const journal = spec.journal;
-  const seam = readNestedScopeSeam(ctx);
-  let artifact;
-  let meteredSpend;
-  return {
-    runtime: driverRuntime,
-    async execute(task, signal) {
-      const nestedRoot = nestedTreeKey(seam, journal);
-      await journal.beginTree(nestedRoot, (/* @__PURE__ */ new Date(0)).toISOString());
-      const nestedScope = seam.mount(nestedRoot, signal);
-      try {
-        const out = await driver.act(task, nestedScope);
-        const events = await loadTreeEvents(journal, nestedRoot);
-        const settled = events.filter(isSettled);
-        meteredSpend = nonZeroOrUndef(sumMetered(events));
-        const verdict = deriveDeliveryVerdict(settled);
-        artifact = {
-          outRef: `${driverRuntime}:${nestedRoot}`,
-          out,
-          spent: sumSpend(settled),
-          ...verdict ? { verdict } : {}
-        };
-        return artifact;
-      } catch (err) {
-        meteredSpend = await safeSumMetered(journal, nestedRoot);
-        throw err;
-      }
-    },
-    metered() {
-      return meteredSpend;
-    },
-    teardown() {
-      return Promise.resolve({ destroyed: true });
-    },
-    resultArtifact() {
-      if (!artifact) {
-        throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
-      }
-      return artifact;
-    }
-  };
-};
-function withDriverExecutor(base) {
-  return {
-    register: base.register.bind(base),
-    resolve(spec) {
-      const role = spec.profile.metadata?.role;
-      if (role === driverRole && !spec.executor) {
-        return { succeeded: true, value: driverExecutorFactory };
-      }
-      return base.resolve(spec);
-    }
-  };
-}
-function nestedTreeKey(seam, journal) {
-  return `${seam.journalRoot}/d${nextNestOrdinal(journal)}`;
-}
-var nestCounters = /* @__PURE__ */ new WeakMap();
-function nextNestOrdinal(journal) {
-  let c = nestCounters.get(journal);
-  if (!c) {
-    c = { n: 0 };
-    nestCounters.set(journal, c);
-  }
-  return c.n++;
-}
-async function loadTreeEvents(journal, nestedRoot) {
-  const events = await journal.loadTree(nestedRoot);
-  if (events === void 0) {
-    throw new ValidationError(
-      `driverExecutor: nested tree '${nestedRoot}' missing from the journal after run (corrupted log)`
-    );
-  }
-  return events;
-}
-function isSettled(ev) {
-  return ev.kind === "settled";
-}
-function sumSpend(settled) {
-  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-  for (const ev of settled) {
-    total.iterations += ev.spent.iterations;
-    total.tokens.input += ev.spent.tokens.input;
-    total.tokens.output += ev.spent.tokens.output;
-    total.usd += ev.spent.usd;
-    if (ev.spent.usdKnown === false) total.usdKnown = false;
-    total.ms += ev.spent.ms;
-  }
-  return total;
-}
-function sumMetered(events) {
-  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-  for (const ev of events) {
-    if (ev.kind !== "metered") continue;
-    total.iterations += ev.spend.iterations;
-    total.tokens.input += ev.spend.tokens.input;
-    total.tokens.output += ev.spend.tokens.output;
-    total.usd += ev.spend.usd;
-    if (ev.spend.usdKnown === false) total.usdKnown = false;
-    total.ms += ev.spend.ms;
-  }
-  return total;
-}
-function isNonZeroSpend(s) {
-  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
-}
-function nonZeroOrUndef(s) {
-  return isNonZeroSpend(s) ? s : void 0;
-}
-async function safeSumMetered(journal, nestedRoot) {
-  try {
-    return nonZeroOrUndef(sumMetered(await loadTreeEvents(journal, nestedRoot)));
-  } catch {
-    return void 0;
-  }
-}
-function deriveDeliveryVerdict(settled) {
-  let sawChild = false;
-  let anyValid = false;
-  let bestValidScore;
-  let bestDoneScore;
-  for (const ev of settled) {
-    sawChild = true;
-    if (ev.status !== "done") continue;
-    const score = ev.verdict?.score;
-    if (score !== void 0 && (bestDoneScore === void 0 || score > bestDoneScore)) {
-      bestDoneScore = score;
-    }
-    if (ev.verdict?.valid === true) {
-      anyValid = true;
-      if (score !== void 0 && (bestValidScore === void 0 || score > bestValidScore)) {
-        bestValidScore = score;
-      }
-    }
-  }
-  if (!sawChild) return void 0;
-  return {
-    valid: anyValid,
-    score: anyValid ? bestValidScore ?? 1 : bestDoneScore ?? 0
-  };
-}
-function readNestedScopeSeam(ctx) {
-  const seam = ctx.seams[nestedScopeSeamKey];
-  if (!seam || typeof seam.mount !== "function") {
-    throw new ValidationError(
-      `driverExecutor: missing required seam "${nestedScopeSeamKey}" \u2014 a driver child must be spawned through a Scope that seeds it (the keystone scope does)`
-    );
-  }
-  return seam;
-}
-function isAgent(value) {
-  return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
-}
-
-export {
-  CodexExecutionDiagnosticError,
-  harnessInvocation,
-  runLocalHarness,
-  parseCodexTokenUsage,
-  createWorktree,
-  captureWorktreeDiff,
-  removeWorktree,
-  runWorktreeHarness,
-  runWorktreeChecks,
-  runSettledCommand,
-  runBrainLoop,
-  routerChatWithUsage,
-  routerChatWithTools,
-  routerToolLoop,
-  routerBrain,
-  defineRuntimeHooks,
-  composeRuntimeHooks,
-  notifyRuntimeHookEvent,
-  notifyRuntimeDecisionPoint,
-  DEFAULT_STALL_AFTER_MS,
-  createActivityLog,
-  readWorkerProgress,
-  timerAt,
-  pollFor,
-  createWaitProbes,
-  isWaitOutcome,
-  waitUntil,
-  validateWaitSpec,
-  createScope,
-  settledToIteration,
-  withDriverExecutor,
-  spendFromUsageEvents,
-  createBudgetPool,
-  createSupervisor
-};
-//# sourceMappingURL=chunk-HLKC4UYB.js.map