@titan-design/agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -24,8 +24,8 @@ var STRIPPED_PROXY_VARS = [
 var DEFAULT_MAX_RETRIES = "3";
 var AuthMisconfiguredError = class extends Error {
   hint;
-  constructor(message, hint) {
-    super(message);
+  constructor(message2, hint) {
+    super(message2);
     this.name = "AuthMisconfiguredError";
     this.hint = hint;
   }
@@ -214,10 +214,10 @@ var Session = class {
     const elapsed = () => (this.deps.now ?? Date.now)() - startedAt;
     try {
       this.stream = run({ prompt: this.config.prompt, options: this.buildOptions() });
-      for await (const message of this.stream) {
+      for await (const message2 of this.stream) {
         this.resetWatchdog();
-        this.config.onMessage?.(message);
-        this.absorb(message);
+        this.config.onMessage?.(message2);
+        this.absorb(message2);
         if (this.endReason || this.authError) break;
       }
     } catch (error) {
@@ -253,21 +253,21 @@ var Session = class {
     }
     return options;
   }
-  absorb(message) {
-    if ("session_id" in message && typeof message.session_id === "string") this.sessionId = message.session_id;
-    if (message.type === "system" && message.subtype === "init") {
+  absorb(message2) {
+    if ("session_id" in message2 && typeof message2.session_id === "string") this.sessionId = message2.session_id;
+    if (message2.type === "system" && message2.subtype === "init") {
       this.init = {
-        apiKeySource: message.apiKeySource,
-        model: message.model,
-        tools: message.tools ?? [],
-        permissionMode: message.permissionMode,
-        claudeCodeVersion: message.claude_code_version
+        apiKeySource: message2.apiKeySource,
+        model: message2.model,
+        tools: message2.tools ?? [],
+        permissionMode: message2.permissionMode,
+        claudeCodeVersion: message2.claude_code_version
       };
-      if (!this.config.allowApiKeyBilling) this.checkApiKeySource(message.apiKeySource);
+      if (!this.config.allowApiKeyBilling) this.checkApiKeySource(message2.apiKeySource);
       return;
     }
-    if (message.type === "rate_limit_event") this.rateLimitResetsAt = message.rate_limit_info.resetsAt;
-    if (message.type === "result") this.result = message;
+    if (message2.type === "rate_limit_event") this.rateLimitResetsAt = message2.rate_limit_info.resetsAt;
+    if (message2.type === "result") this.result = message2;
   }
   checkApiKeySource(observed) {
     try {
@@ -345,18 +345,1475 @@ function endFailure(reason) {
 function describeEnd(reason) {
   return reason.kind === "aborted" ? reason.reason : `no message for ${reason.timeoutMs}ms`;
 }
+
+// src/harness-contracts.ts
+var CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
+var CODEX_APPROVAL_POLICIES = ["untrusted", "on-failure", "on-request", "never"];
+var EXECUTION_CAPABILITIES = [
+  "fresh_run",
+  "resume",
+  "fork",
+  "structured_output",
+  "interactive_approvals",
+  "external_cancellation",
+  "semantic_interrupt",
+  "active_turn_steering",
+  "idle_turn_submission",
+  "persisted_transcript",
+  "process_reattachment",
+  "token_reporting"
+];
+
+// src/preflight.ts
+import { conversationRef } from "@titan-design/agent-protocol";
+function preflightHarnessRun(request, descriptor) {
+  if (request.harness !== descriptor.harness) {
+    return mismatch(`request harness ${request.harness} does not match adapter harness ${descriptor.harness}`);
+  }
+  if (request.target.kind === "resume" && request.target.conversation.harness !== request.harness) {
+    return mismatch(`resume conversation harness ${request.target.conversation.harness} does not match ${request.harness}`);
+  }
+  const identityFailure = invalidIdentity(request);
+  if (identityFailure) return identityFailure;
+  const invalid2 = invalidNumbers(request);
+  if (invalid2) return invalid2;
+  const nativeFailure = invalidNativeOptions(request);
+  if (nativeFailure) return nativeFailure;
+  if (request.signal?.aborted) return { kind: "aborted", reason: String(request.signal.reason ?? "aborted by caller") };
+  const capabilityFailure = checkCapabilities(request, descriptor);
+  if (capabilityFailure) return capabilityFailure;
+  return checkLimits(request, descriptor);
+}
+function invalidIdentity(request) {
+  if (request.target.kind === "fresh") {
+    return nonempty(request.target.namespace) ? void 0 : invalid("fresh target namespace must be a nonempty string");
+  }
+  try {
+    conversationRef(request.target.conversation);
+    return void 0;
+  } catch {
+    return invalid("resume conversation identity components must be nonempty strings");
+  }
+}
+var CLAUDE_ONLY = ["allowedTools", "disallowedTools", "permissionMode", "agents", "mcpServers", "hooks", "settingSources", "allowApiKeyBilling"];
+var CODEX_ONLY = ["reasoningEffort", "sandbox", "approvalPolicy"];
+var CLAUDE_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
+var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
+function invalidNativeOptions(request) {
+  if (request.native === void 0) return void 0;
+  if (!record(request.native)) return invalid("native options must be an object");
+  const native = request.native;
+  const forbidden = request.harness === "codex" ? CLAUDE_ONLY : CODEX_ONLY;
+  const field = forbidden.find((name) => name in native);
+  if (field) return invalid(`${field} is not a ${request.harness} native option`);
+  const options = native;
+  return request.harness === "codex" ? invalidCodexOptions(options) : invalidClaudeOptions(options);
+}
+function invalidCodexOptions(options) {
+  const invalidModel = optionalNonempty("model", options.model);
+  if (invalidModel) return invalidModel;
+  const invalidEffort = optionalNonempty("reasoningEffort", options.reasoningEffort);
+  if (invalidEffort) return invalidEffort;
+  const enums = [
+    ["sandbox", options.sandbox, CODEX_SANDBOXES],
+    ["approvalPolicy", options.approvalPolicy, CODEX_APPROVAL_POLICIES]
+  ];
+  for (const [name, value, allowed] of enums) {
+    if (value !== void 0 && !allowed.includes(value)) return invalid(`${name} is not a recognized Codex value`);
+  }
+  if (options.outputSchema === void 0) return void 0;
+  if (!record(options.outputSchema)) return invalid("Codex outputSchema must be an object");
+  if (!record(options.outputSchema.jsonSchema)) return invalid("Codex outputSchema.jsonSchema must be an object");
+  return typeof options.outputSchema.parse === "function" ? void 0 : invalid("Codex outputSchema.parse must be callable");
+}
+function invalidClaudeOptions(options) {
+  const invalidModel = optionalNonempty("model", options.model);
+  if (invalidModel) return invalidModel;
+  if (options.permissionMode !== void 0 && !CLAUDE_PERMISSION_MODES.includes(options.permissionMode)) {
+    return invalid("permissionMode is not a recognized Claude Code value");
+  }
+  for (const name of ["allowedTools", "disallowedTools"]) {
+    if (options[name] !== void 0 && !stringArray(options[name])) return invalid(`${name} must be an array of strings`);
+  }
+  if (options.settingSources !== void 0 && !enumArray(options.settingSources, CLAUDE_SETTING_SOURCES)) {
+    return invalid("settingSources must contain recognized Claude Code values");
+  }
+  if (options.allowApiKeyBilling !== void 0 && typeof options.allowApiKeyBilling !== "boolean") {
+    return invalid("allowApiKeyBilling must be boolean");
+  }
+  if (options.outputSchema !== void 0 && (!record(options.outputSchema) || typeof options.outputSchema.safeParse !== "function")) {
+    return invalid("Claude Code outputSchema must be a Zod schema");
+  }
+  return void 0;
+}
+async function dispatchHarnessRun(request, adapter) {
+  const failure = preflightHarnessRun(request, adapter.descriptor);
+  if (failure) return { ok: false, harness: request.harness, failure, usage: [] };
+  try {
+    return await adapter.run(request);
+  } catch (error) {
+    return {
+      ok: false,
+      harness: request.harness,
+      failure: { kind: "runtime_error", reason: messageOf2(error), native: error },
+      usage: []
+    };
+  }
+}
+function invalidNumbers(request) {
+  if (!positiveFinite(request.wallTimeMs)) return invalid("wallTimeMs must be a positive finite number");
+  for (const limit of request.limits ?? []) {
+    if (!positiveFinite(limit.value)) return invalid(`${limit.unit} limit must be a positive finite number`);
+    if (limit.unit !== "usd" && !Number.isInteger(limit.value)) {
+      return invalid(`${limit.unit} limit must be a positive integer`);
+    }
+  }
+  return void 0;
+}
+function checkCapabilities(request, descriptor) {
+  for (const capability of requiredCapabilities(request)) {
+    const assessment = descriptor.capabilities[capability] ?? {
+      status: "unverified",
+      reason: "adapter did not declare this capability"
+    };
+    const failure = rejectAssessment(assessment, { kind: "capability", capability });
+    if (failure) return failure;
+  }
+  return void 0;
+}
+function requiredCapabilities(request) {
+  const required = new Set(request.requires ?? []);
+  required.add(request.target.kind === "fresh" ? "fresh_run" : "resume");
+  if (request.native?.outputSchema !== void 0) required.add("structured_output");
+  if (request.signal) required.add("external_cancellation");
+  return [...required];
+}
+function checkLimits(request, descriptor) {
+  const wallTime = {
+    unit: "milliseconds",
+    value: request.wallTimeMs,
+    scope: "execution",
+    enforcement: "hard"
+  };
+  for (const limit of [wallTime, ...request.limits ?? []]) {
+    const declared = descriptor.limits.find((candidate) => sameLimit(candidate, limit));
+    const assessment = declared?.assessment ?? { status: "unverified", reason: "adapter did not declare this limit" };
+    const requirement = { kind: "limit", limit: { ...limit, assessment } };
+    const failure = rejectAssessment(assessment, requirement);
+    if (failure) return failure;
+  }
+  return void 0;
+}
+function sameLimit(capability, limit) {
+  return capability.unit === limit.unit && capability.scope === limit.scope && capability.enforcement === limit.enforcement;
+}
+function rejectAssessment(assessment, requirement) {
+  if (assessment.status === "supported") return void 0;
+  const name = requirement.kind === "capability" ? requirement.capability : describeLimit(requirement.limit);
+  return { kind: "unsupported_requirement", reason: `${name} is ${assessment.status}: ${assessment.reason}`, requirement, status: assessment.status };
+}
+function describeLimit(limit) {
+  return `${limit.enforcement} ${limit.scope} limit in ${limit.unit}`;
+}
+function positiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function nonempty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function optionalNonempty(name, value) {
+  return value === void 0 || nonempty(value) ? void 0 : invalid(`${name} must be a nonempty string`);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function enumArray(value, allowed) {
+  return stringArray(value) && value.every((item) => allowed.includes(item));
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function invalid(reason) {
+  return { kind: "invalid_request", reason };
+}
+function mismatch(reason) {
+  return { kind: "harness_mismatch", reason };
+}
+
+// src/codex-exec.ts
+import { randomUUID } from "crypto";
+import { isAbsolute } from "path";
+import { performance } from "perf_hooks";
+
+// src/codex-exec-session.ts
+import { conversationItemRef } from "@titan-design/agent-protocol";
+var DEFAULT_CODEX_KILL_GRACE_MS = 2e3;
+async function runCodexExecSession(request, processHandle, executionId, now, killGraceMs = DEFAULT_CODEX_KILL_GRACE_MS, processWallTimeMs = request.wallTimeMs, cleanup) {
+  return new CodexExecSession(request, processHandle, executionId, now, killGraceMs, processWallTimeMs, cleanup).run();
+}
+var CodexExecSession = class {
+  constructor(request, processHandle, executionId, now, killGraceMs, processWallTimeMs, cleanup) {
+    this.request = request;
+    this.processHandle = processHandle;
+    this.executionId = executionId;
+    this.now = now;
+    this.killGraceMs = killGraceMs;
+    this.processWallTimeMs = processWallTimeMs;
+    this.cleanup = cleanup;
+  }
+  request;
+  processHandle;
+  executionId;
+  now;
+  killGraceMs;
+  processWallTimeMs;
+  cleanup;
+  conversation;
+  finalText;
+  usageRaw;
+  nativeTurnId;
+  turnCompleted = false;
+  nativeTerminalObserved = false;
+  streamError;
+  stderr = "";
+  stopReason;
+  timer;
+  forceTimer;
+  onAbort = () => this.stop("abort");
+  async run() {
+    try {
+      this.request.signal?.addEventListener("abort", this.onAbort);
+      this.timer = setTimeout(() => this.stop("timeout"), this.processWallTimeMs);
+      this.timer.unref?.();
+      this.emit({ kind: "execution_started", execution: { executionId: this.executionId } });
+      const [, , exit] = await Promise.all([this.readStdout(), this.readStderr(), this.processHandle.completed]);
+      let result = this.settle(exit);
+      result = await this.finishCleanup(result);
+      return this.finish(result);
+    } catch (error) {
+      this.terminate();
+      await this.ignoreExitFailure();
+      let result = this.failure({ kind: "runtime_error", reason: messageOf3(error), native: error });
+      result = await this.finishCleanup(result);
+      return this.finish(result);
+    } finally {
+      this.dispose();
+    }
+  }
+  async readStdout() {
+    for await (const line of this.processHandle.stdout) {
+      if (!line.trim()) continue;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        this.streamError = { kind: "runtime_error", reason: "Codex emitted malformed JSONL", native: { line } };
+        this.terminate();
+        return;
+      }
+      this.absorb(event);
+    }
+  }
+  async readStderr() {
+    for await (const line of this.processHandle.stderr) this.stderr = `${this.stderr}${line}
+`.slice(-65536);
+  }
+  absorb(value) {
+    if (!record2(value) || typeof value.type !== "string") return;
+    if (value.type === "thread.started" && typeof value.thread_id === "string") this.identify(value.thread_id);
+    if (value.type === "turn.started") this.nativeTurnId = turnId(value) ?? this.nativeTurnId;
+    if (isAgentMessage(value)) {
+      this.finalText = value.item.text;
+      this.emit({ kind: "assistant_output", executionId: this.executionId, text: value.item.text });
+    }
+    if (value.type === "turn.completed") {
+      this.turnCompleted = true;
+      this.nativeTerminalObserved = true;
+      this.nativeTurnId = turnId(value) ?? this.nativeTurnId;
+      this.usageRaw = value.usage;
+    }
+    if (value.type === "turn.failed") this.nativeTerminalObserved = true;
+    if (value.type === "turn.failed" || value.type === "error") {
+      this.streamError = { kind: "runtime_error", reason: eventMessage(value), native: value };
+    }
+  }
+  identify(nativeId) {
+    if (!nativeId.trim()) return this.failStream("Codex emitted an empty native thread ID");
+    if (this.request.target.kind === "resume" && nativeId !== this.request.target.conversation.nativeId) {
+      return this.failStream("Codex resumed a different native conversation");
+    }
+    const namespace = this.request.target.kind === "fresh" ? this.request.target.namespace : this.request.target.conversation.namespace;
+    this.conversation = { harness: "codex", namespace, nativeId };
+    this.emit({ kind: "conversation_identified", executionId: this.executionId, conversation: this.conversation });
+  }
+  failStream(reason) {
+    this.streamError = { kind: "runtime_error", reason };
+    this.terminate();
+  }
+  settle(exit) {
+    if (this.stopReason && !this.nativeTerminalObserved) return this.failure(cancelledUnknown(this.stopReason, this.request, exit));
+    if (this.stopReason === "timeout") return this.failure(timeoutFailure(this.request.wallTimeMs));
+    if (this.stopReason === "abort") return this.failure(abortFailure(this.request.signal));
+    if (this.streamError) return this.failure(this.streamError);
+    if (exit.exitCode !== 0) return this.failure(exitFailure(exit, this.stderr));
+    return this.success();
+  }
+  success() {
+    if (!this.conversation) return this.failure({ kind: "runtime_error", reason: "Codex completed without a thread.started event" });
+    if (!this.turnCompleted) return this.failure({ kind: "runtime_error", reason: "Codex completed without a turn.completed event" });
+    if (this.finalText === void 0) return this.failure({ kind: "runtime_error", reason: "Codex completed without a final agent message" });
+    const output = parseOutput(this.request, this.finalText);
+    if ("failure" in output) return this.failure(output.failure);
+    return {
+      ok: true,
+      harness: "codex",
+      execution: { executionId: this.executionId, conversation: this.conversation },
+      conversation: this.conversation,
+      output: output.output,
+      usage: this.usage(),
+      transcript: { format: "codex-rollout-jsonl", namespace: this.conversation.namespace }
+    };
+  }
+  usage() {
+    if (!this.conversation || !record2(this.usageRaw)) return [];
+    const measurement = {
+      kind: "snapshot",
+      scope: "turn",
+      scopeId: this.turnScopeId(),
+      epoch: this.executionId,
+      sequence: 0,
+      model: this.request.native?.model ?? null,
+      tokens: tokenCounts(this.usageRaw),
+      cost: null,
+      source: "codex-exec.turn.completed.usage"
+    };
+    return [measurement];
+  }
+  turnScopeId() {
+    if (this.conversation && this.nativeTurnId) return conversationItemRef(this.conversation, "turn", this.nativeTurnId);
+    return `execution:${encodeURIComponent(this.executionId)}:turn`;
+  }
+  failure(failure) {
+    const execution = {
+      executionId: this.executionId,
+      ...this.conversation ? { conversation: this.conversation } : {}
+    };
+    const result = {
+      ok: false,
+      harness: "codex",
+      execution,
+      failure,
+      usage: this.usage()
+    };
+    if (this.conversation) result.conversation = this.conversation;
+    return result;
+  }
+  stop(reason) {
+    if (this.stopReason) return;
+    this.stopReason = reason;
+    this.terminate();
+  }
+  terminate() {
+    this.processHandle.terminate("SIGTERM");
+    if (this.forceTimer) return;
+    this.forceTimer = setTimeout(() => this.processHandle.terminate("SIGKILL"), this.killGraceMs);
+    this.forceTimer.unref?.();
+  }
+  async ignoreExitFailure() {
+    try {
+      await this.processHandle.completed;
+    } catch {
+    }
+  }
+  finish(result) {
+    for (const measurement of result.usage) {
+      this.emit({ kind: "usage", executionId: this.executionId, measurement });
+    }
+    if (this.streamError && result.ok) result = this.failure(this.streamError);
+    const cancelled = !result.ok && (result.failure.kind === "aborted" || result.failure.kind === "cancelled_unknown");
+    const outcome = result.ok ? "succeeded" : cancelled ? "cancelled" : "failed";
+    this.emit({ kind: "execution_finished", executionId: this.executionId, outcome });
+    return this.streamError && result.ok ? this.failure(this.streamError) : result;
+  }
+  emit(progress) {
+    if (!this.request.onProgress || this.streamError) return;
+    try {
+      this.request.onProgress({ ...progress, harness: "codex", atMs: this.now() });
+    } catch (error) {
+      this.streamError = { kind: "runtime_error", reason: `Codex progress callback failed: ${messageOf3(error)}`, native: error };
+      this.terminate();
+    }
+  }
+  async finishCleanup(result) {
+    if (!this.cleanup) return result;
+    try {
+      await this.cleanup();
+      return result;
+    } catch (error) {
+      return this.failure({ kind: "runtime_error", reason: messageOf3(error), native: error });
+    }
+  }
+  dispose() {
+    if (this.timer) clearTimeout(this.timer);
+    if (this.forceTimer) clearTimeout(this.forceTimer);
+    this.request.signal?.removeEventListener("abort", this.onAbort);
+  }
+};
+function parseOutput(request, text) {
+  const schema = request.native?.outputSchema;
+  if (!schema) return { output: { kind: "text", text } };
+  try {
+    return { output: { kind: "structured", value: schema.parse(JSON.parse(text)) } };
+  } catch (error) {
+    const reason = `structured output validation failed: ${messageOf3(error)}`;
+    return { failure: { kind: "output_invalid", reason, native: { text, error } } };
+  }
+}
+function tokenCounts(usage) {
+  const input = count(usage.input_tokens);
+  const output = count(usage.output_tokens);
+  return {
+    input,
+    output,
+    cachedInput: count(usage.cached_input_tokens),
+    cacheWriteInput: null,
+    reasoningOutput: count(usage.reasoning_output_tokens),
+    total: input === null || output === null ? null : input + output
+  };
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function isAgentMessage(event) {
+  return event.type === "item.completed" && record2(event.item) && event.item.type === "agent_message" && typeof event.item.text === "string";
+}
+function turnId(event) {
+  if (typeof event.turn_id === "string" && event.turn_id.trim()) return event.turn_id;
+  if (record2(event.turn) && typeof event.turn.id === "string" && event.turn.id.trim()) return event.turn.id;
+  return void 0;
+}
+function timeoutFailure(wallTimeMs) {
+  return { kind: "wall_time_exceeded", reason: "Codex execution exceeded its wall deadline", wallTimeMs };
+}
+function abortFailure(signal) {
+  return { kind: "aborted", reason: String(signal?.reason ?? "aborted by caller") };
+}
+function cancelledUnknown(cause, request, exit) {
+  const requested = cause === "timeout" ? { kind: "wall_time_exceeded", wallTimeMs: request.wallTimeMs } : { kind: "external_abort", reason: String(request.signal?.reason ?? "aborted by caller") };
+  return {
+    kind: "cancelled_unknown",
+    reason: `Codex process stopped after ${cause} without a native terminal turn event`,
+    native: { cause, requested, processExit: exit }
+  };
+}
+function exitFailure(exit, stderr) {
+  return {
+    kind: "runtime_error",
+    reason: stderr.trim() || `Codex exited with status ${String(exit.exitCode)}`,
+    native: exit
+  };
+}
+function eventMessage(event) {
+  if (typeof event.message === "string") return event.message;
+  if (record2(event.error) && typeof event.error.message === "string") return event.error.message;
+  return `Codex emitted ${String(event.type)}`;
+}
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageOf3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/codex-process.ts
+import { execFile, spawn } from "child_process";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createInterface } from "readline";
+async function inspectCodexVersion(executablePath, env, options) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      executablePath,
+      ["--version"],
+      {
+        env,
+        encoding: "utf8",
+        signal: options.signal,
+        timeout: Math.max(1, Math.ceil(options.timeoutMs)),
+        killSignal: "SIGKILL"
+      },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout);
+      }
+    );
+  });
+}
+function startCodexProcess(input) {
+  const child = spawn(input.executablePath, input.args, {
+    cwd: input.cwd,
+    env: input.env,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return {
+    stdout: lines(child.stdout),
+    stderr: lines(child.stderr),
+    completed: completionOf(child),
+    terminate: (signal) => terminateProcessGroup(child, signal)
+  };
+}
+async function createCodexSchemaFile(schema) {
+  const directory = await mkdtemp(join(tmpdir(), "titan-codex-schema-"));
+  const path = join(directory, "output-schema.json");
+  try {
+    await writeFile(path, JSON.stringify(schema), { encoding: "utf8", mode: 384 });
+    return { path, dispose: () => rm(directory, { recursive: true, force: true }) };
+  } catch (error) {
+    await rm(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function* lines(stream) {
+  const reader = createInterface({ input: stream });
+  for await (const line of reader) yield line;
+}
+function completionOf(child) {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
+  });
+}
+function terminateProcessGroup(child, signal) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+
+// src/codex-exec.ts
+var DEFAULT_CODEX_EXECUTABLE = "/Applications/ChatGPT.app/Contents/Resources/codex";
+var SUPPORTED_CODEX_EXEC_VERSION = "0.154.0-alpha.6.1";
+var STRIPPED_CODEX_AUTH_VARS = ["CODEX_API_KEY", "OPENAI_API_KEY", "OPENAI_ACCESS_TOKEN"];
+function createCodexExecAdapter(options, deps = {}) {
+  validateOptions(options);
+  const executablePath = options.executablePath ?? DEFAULT_CODEX_EXECUTABLE;
+  const env = prepareCodexEnv(options.env ?? process.env);
+  const descriptor = codexExecCapabilities();
+  return {
+    descriptor,
+    async run(request) {
+      const preflight = preflightHarnessRun(request, descriptor);
+      if (preflight) return failed(preflight);
+      const invalid2 = validateAdapterRequest(request);
+      if (invalid2) return failed(invalid2);
+      try {
+        return await runSupervised(request, { executablePath, env, killGraceMs: options.killGraceMs }, deps);
+      } catch (error) {
+        return failed({ kind: "runtime_error", reason: messageOf4(error), native: error });
+      }
+    }
+  };
+}
+function prepareCodexEnv(env) {
+  const prepared = {};
+  for (const [name, value] of Object.entries(env)) {
+    if (value !== void 0 && !STRIPPED_CODEX_AUTH_VARS.includes(name)) prepared[name] = value;
+  }
+  return prepared;
+}
+function codexExecCapabilities() {
+  const supported = (evidence) => ({ status: "supported", evidence });
+  const unsupported = (reason) => ({ status: "unsupported", reason });
+  const capabilities = Object.fromEntries(
+    EXECUTION_CAPABILITIES.map((capability) => [
+      capability,
+      unsupported("not implemented by the supervised exec adapter")
+    ])
+  );
+  capabilities.fresh_run = supported("codex exec starts a persisted thread");
+  capabilities.resume = supported("codex exec resume uses an explicit native thread ID");
+  capabilities.structured_output = supported("native output schema plus caller parser validation");
+  capabilities.external_cancellation = supported("owned local process group receives termination signals");
+  capabilities.persisted_transcript = supported("adapter never passes --ephemeral");
+  capabilities.token_reporting = supported("turn.completed usage is normalized with source provenance");
+  const limits = limitCapabilities(supported, unsupported);
+  return {
+    harness: "codex",
+    adapter: { name: "codex-exec-json", version: SUPPORTED_CODEX_EXEC_VERSION },
+    capabilities,
+    limits
+  };
+}
+function limitCapabilities(supported, unsupported) {
+  const limits = [
+    {
+      unit: "milliseconds",
+      scope: "execution",
+      enforcement: "hard",
+      assessment: supported("local process deadline")
+    }
+  ];
+  for (const unit of ["usd", "model_requests", "agent_iterations", "tokens"]) {
+    for (const scope of ["execution", "conversation"]) {
+      limits.push({
+        unit,
+        scope,
+        enforcement: "hard",
+        assessment: unsupported("codex exec has no verified hard cap in this unit")
+      });
+    }
+  }
+  return limits;
+}
+function validateOptions(options) {
+  if (options.auth !== "cached-cli") throw new TypeError("Codex exec adapter supports only cached-cli authentication");
+  if (options.executablePath !== void 0) {
+    if (options.executablePath.trim().length === 0) throw new TypeError("executablePath must be a nonempty string");
+    if (!isAbsolute(options.executablePath)) throw new TypeError("executablePath must be absolute");
+  }
+  if (options.killGraceMs !== void 0 && (!Number.isFinite(options.killGraceMs) || options.killGraceMs < 0)) {
+    throw new TypeError("killGraceMs must be a finite nonnegative number");
+  }
+}
+function validateAdapterRequest(request) {
+  if (!request.prompt.trim()) return { kind: "invalid_request", reason: "Codex exec requires a nonempty prompt" };
+  if (!isAbsolute(request.cwd)) return { kind: "invalid_request", reason: "Codex exec requires an absolute cwd" };
+  if (!request.native?.model) return { kind: "invalid_request", reason: "Codex exec requires an explicit model" };
+  if (request.native.approvalPolicy && request.native.approvalPolicy !== "never") {
+    return { kind: "invalid_request", reason: "Codex exec supports only the noninteractive never approval policy" };
+  }
+  return void 0;
+}
+async function checkVersion(inspect, expected) {
+  try {
+    const actual = parseVersion(await inspect());
+    if (actual === expected) return void 0;
+    return { kind: "runtime_error", reason: `unsupported Codex CLI version ${actual}; expected ${expected}` };
+  } catch (error) {
+    const reason = `could not verify Codex CLI version: ${messageOf4(error)}`;
+    return { kind: "runtime_error", reason, native: error };
+  }
+}
+function parseVersion(output) {
+  const match = /^codex-cli\s+(\S+)/m.exec(output.trim());
+  if (!match?.[1]) throw new Error(`unrecognized version output: ${output.trim()}`);
+  return match[1];
+}
+async function runSupervised(request, config, deps) {
+  const deadlineNow = deps.deadlineNow ?? performance.now.bind(performance);
+  const startedAt = deadlineNow();
+  const remaining = () => Math.max(0, request.wallTimeMs - (deadlineNow() - startedAt));
+  let schemaFile;
+  try {
+    const versionOutput = await setupStep(
+      (deps.inspectVersion ?? inspectCodexVersion)(config.executablePath, config.env, {
+        signal: request.signal,
+        timeoutMs: remaining()
+      }),
+      request.signal,
+      remaining()
+    );
+    const versionFailure = await checkVersion(async () => versionOutput, SUPPORTED_CODEX_EXEC_VERSION);
+    if (versionFailure) return failed(versionFailure);
+    if (request.native?.outputSchema) {
+      schemaFile = await setupStep(
+        (deps.createSchemaFile ?? createCodexSchemaFile)(request.native.outputSchema.jsonSchema),
+        request.signal,
+        remaining(),
+        (lateFile) => lateFile.dispose()
+      );
+    }
+    if (request.signal?.aborted) return failed(abortFailure2(request.signal));
+    const processWallTimeMs = remaining();
+    if (processWallTimeMs <= 0) return failed(timeoutFailure2(request.wallTimeMs));
+    const input = {
+      executablePath: config.executablePath,
+      args: buildCodexExecArgs(request, schemaFile?.path),
+      cwd: request.cwd,
+      env: config.env
+    };
+    const executionId = (deps.executionId ?? randomUUID)();
+    const processHandle = (deps.start ?? startCodexProcess)(input);
+    const cleanup = async () => {
+      const file = schemaFile;
+      schemaFile = void 0;
+      await file?.dispose();
+    };
+    return await runCodexExecSession(
+      request,
+      processHandle,
+      executionId,
+      deps.now ?? Date.now,
+      config.killGraceMs,
+      processWallTimeMs,
+      cleanup
+    );
+  } catch (error) {
+    if (request.signal?.aborted) return failed(abortFailure2(request.signal));
+    if (error instanceof SetupTimeoutError || isProcessTimeout(error)) {
+      return failed(timeoutFailure2(request.wallTimeMs));
+    }
+    return failed({ kind: "runtime_error", reason: messageOf4(error), native: error });
+  } finally {
+    await schemaFile?.dispose();
+  }
+}
+function buildCodexExecArgs(request, schemaPath) {
+  const native = request.native;
+  const args = ["exec"];
+  if (request.target.kind === "resume") args.push("resume");
+  args.push("--json", "--strict-config", "--ignore-user-config", "--model", native.model);
+  args.push("--config", `approval_policy=${JSON.stringify(native.approvalPolicy ?? "never")}`);
+  args.push("--config", `sandbox_mode=${JSON.stringify(native.sandbox ?? "read-only")}`);
+  if (native.reasoningEffort) {
+    args.push("--config", `model_reasoning_effort=${JSON.stringify(native.reasoningEffort)}`);
+  }
+  if (request.target.kind === "fresh") args.push("--cd", request.cwd);
+  if (schemaPath) args.push("--output-schema", schemaPath);
+  if (request.target.kind === "resume") args.push(request.target.conversation.nativeId);
+  args.push("--", request.prompt);
+  return args;
+}
+function failed(failure) {
+  return { ok: false, harness: "codex", failure, usage: [] };
+}
+function messageOf4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function timeoutFailure2(wallTimeMs) {
+  return { kind: "wall_time_exceeded", reason: "Codex execution exceeded its wall deadline", wallTimeMs };
+}
+function abortFailure2(signal) {
+  return { kind: "aborted", reason: String(signal.reason ?? "aborted by caller") };
+}
+var SetupTimeoutError = class extends Error {
+};
+function setupStep(work, signal, timeoutMs, disposeLateValue) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return false;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      callback();
+      return true;
+    };
+    const onAbort = () => finish(() => reject(signal?.reason ?? new Error("aborted by caller")));
+    const timer = setTimeout(
+      () => finish(() => reject(new SetupTimeoutError("Codex setup exceeded its wall deadline"))),
+      Math.max(0, timeoutMs)
+    );
+    timer.unref?.();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    work.then(
+      (value) => {
+        if (!finish(() => resolve(value)) && disposeLateValue) {
+          void Promise.resolve(disposeLateValue(value)).catch(() => void 0);
+        }
+      },
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+function isProcessTimeout(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const value = error;
+  return value.code === "ETIMEDOUT" || value.killed === true && value.signal === "SIGKILL";
+}
+
+// src/durable-dispatcher.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  isTerminalExecutionPhase as isTerminalExecutionPhase2
+} from "@titan-design/agent-protocol";
+
+// src/durable-result.ts
+function terminalFromHarnessResult(result) {
+  if (result.ok) {
+    return {
+      outcome: "succeeded",
+      result: {
+        harness: result.harness,
+        adapterExecution: result.execution,
+        conversation: result.conversation,
+        output: result.output,
+        usage: result.usage,
+        ...result.transcript ? { transcript: result.transcript } : {}
+      }
+    };
+  }
+  const reason = `${result.failure.kind}: ${result.failure.reason}`;
+  if (result.failure.kind === "aborted" || result.failure.kind === "cancelled_unknown" || result.failure.kind === "wall_time_exceeded") {
+    return { outcome: "cancellation_unknown", reason, evidence: cancellationEvidence(result.failure) };
+  }
+  return { outcome: "failed", reason, retryable: false };
+}
+function cancellationEvidence(failure) {
+  if (failure.kind === "wall_time_exceeded") return "wall deadline elapsed after durable dispatch without a native terminal acknowledgement";
+  return failure.kind === "cancelled_unknown" ? "adapter reported cancellation without a native terminal acknowledgement" : "adapter was aborted after durable dispatch without a native terminal acknowledgement";
+}
+
+// src/durable-dispatcher-support.ts
+function failureKind(kind) {
+  return kind === "ownership_lost" || kind === "revision_conflict" ? "ownership_lost" : "recovery_required";
+}
+function positive(name, value) {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeError(`${name} must be a positive finite number`);
+}
+function nonempty2(name, value) {
+  if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${name} must be a nonempty string`);
+}
+function recordFence(record3) {
+  if (!record3.owner) throw new Error("execution has no active owner");
+  return { supervisorId: record3.owner.supervisorId, generation: record3.owner.generation };
+}
+function ownsLiveFence(record3, fence, now) {
+  return record3.owner?.supervisorId === fence.supervisorId && record3.owner.generation === fence.generation && Date.parse(record3.owner.leaseUntil) > now;
+}
+function validateDispatchInput(input, adapterHarness) {
+  nonempty2("executionId", input.executionId);
+  nonempty2("requestKey", input.requestKey);
+  if (input.request.harness !== adapterHarness) throw new TypeError("request harness does not match adapter");
+}
+function startLiveExecution(options) {
+  let resolveProblem;
+  const problemPromise = new Promise((resolve) => {
+    resolveProblem = resolve;
+  });
+  const timer = options.schedule(options.onRenew, options.renewEveryMs);
+  if (typeof timer === "object") timer.unref?.();
+  const live = {
+    fence: options.fence,
+    controller: options.controller,
+    completion: Promise.resolve(void 0),
+    problemPromise,
+    resolveProblem,
+    timer,
+    ...options.externalSignal ? { externalSignal: options.externalSignal, onExternalAbort: options.onExternalAbort } : {}
+  };
+  options.externalSignal?.addEventListener("abort", options.onExternalAbort, { once: true });
+  return live;
+}
+async function raceLiveResult(result, live) {
+  return Promise.race([
+    result.then((value) => ({ kind: "result", result: value })),
+    live.problemPromise.then((problem) => ({ kind: "problem", problem }))
+  ]);
+}
+function readLedgerRecord(ledger, executionId) {
+  try {
+    return { ok: true, record: ledger.get(executionId) };
+  } catch (error) {
+    return { ok: false, evidence: `execution ledger read failed: ${message(error)}` };
+  }
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/durable-reconcile.ts
+import { isTerminalExecutionPhase } from "@titan-design/agent-protocol";
+function reconcileLive(ledger, executionId, live, now, fail) {
+  const read = readLedgerRecord(ledger, executionId);
+  const evidence = !read.ok ? `live ownership could not be verified: ${read.evidence}` : !read.record || !ownsLiveFence(read.record, live.fence, now) ? "live execution no longer has its captured owner lease" : void 0;
+  if (evidence) {
+    fail(evidence);
+    return { kind: "ownership_lost", evidence };
+  }
+  return { kind: "running", running: { runnerRef: executionId, completion: live.completion }, evidence: "same dispatcher owns the completion handle" };
+}
+function claimForRecovery(record3, options, apply) {
+  if (record3.owner && Date.parse(record3.owner.leaseUntil) > options.now) return { ok: false, evidence: "another live owner lease fences recovery" };
+  try {
+    const result = apply(record3, {
+      kind: "claim_owner",
+      owner: { supervisorId: options.supervisorId, generation: record3.ownerGeneration + 1, leaseUntil: options.leaseUntil }
+    });
+    return result.ok ? { ok: true, record: result.record } : { ok: false, evidence: result.reason };
+  } catch (error) {
+    return { ok: false, evidence: `ownership claim failed: ${message(error)}` };
+  }
+}
+function closePrepared(record3, apply) {
+  const terminal = {
+    outcome: "failed",
+    reason: "durable preparation exists but dispatch never began",
+    retryable: true
+  };
+  try {
+    const result = apply(record3, { kind: "finish", fence: recordFence(record3), terminal });
+    return result.ok ? { kind: "terminal", terminal, evidence: "prepared phase proves begin_dispatch was never committed" } : { kind: "ownership_lost", evidence: result.reason };
+  } catch (error) {
+    return { kind: "ownership_lost", evidence: `prepared execution could not be closed: ${message(error)}` };
+  }
+}
+function requireRecovery(record3, fence, evidence, apply) {
+  if (!record3) return { kind: "ownership_lost", evidence: "execution record is unavailable" };
+  if (!record3.owner || record3.owner.supervisorId !== fence.supervisorId || record3.owner.generation !== fence.generation) {
+    return { kind: "ownership_lost", record: record3, evidence: "execution ownership changed before recovery evidence could be stored" };
+  }
+  if (record3.phase === "recovery_required") return { kind: "recovery_required", record: record3, evidence };
+  if (isTerminalExecutionPhase(record3.phase)) return { kind: "terminal", record: record3, terminal: record3.terminal };
+  try {
+    const result = apply(record3, { kind: "require_recovery", fence, evidence });
+    return result.ok ? { kind: "recovery_required", record: result.record, evidence } : { kind: "ownership_lost", record: record3, evidence: result.reason };
+  } catch (error) {
+    return { kind: "ownership_lost", record: record3, evidence: `recovery evidence was not durable: ${message(error)}` };
+  }
+}
+
+// src/durable-dispatcher.ts
+function createDurableHarnessDispatcher(adapter, options, deps = {}) {
+  return new Dispatcher(adapter, options, deps);
+}
+var Dispatcher = class {
+  constructor(adapter, options, deps) {
+    this.adapter = adapter;
+    this.options = options;
+    nonempty2("supervisorId", options.supervisorId);
+    positive("leaseMs", options.leaseMs);
+    this.renewEveryMs = options.renewEveryMs ?? Math.max(1, Math.floor(options.leaseMs / 3));
+    positive("renewEveryMs", this.renewEveryMs);
+    if (this.renewEveryMs >= options.leaseMs) throw new TypeError("renewEveryMs must be less than leaseMs");
+    this.eventId = deps.eventId ?? randomUUID2;
+    this.now = deps.now ?? Date.now;
+    this.schedule = deps.setInterval ?? globalThis.setInterval;
+    this.unschedule = deps.clearInterval ?? globalThis.clearInterval;
+  }
+  adapter;
+  options;
+  live = /* @__PURE__ */ new Map();
+  eventId;
+  now;
+  schedule;
+  unschedule;
+  renewEveryMs;
+  async dispatch(input) {
+    validateDispatchInput(input, this.adapter.descriptor.harness);
+    const prepared = this.prepare(input);
+    if (input.request.signal?.aborted) return this.preCancelled(input, prepared);
+    this.apply(input.executionId, {
+      kind: "begin_dispatch",
+      fence: recordFence(prepared)
+    });
+    const controller = new AbortController();
+    const live = this.startLive(input.executionId, recordFence(prepared), controller, input.request.signal);
+    this.live.set(input.executionId, live);
+    const completion = this.runAdapter(input, live);
+    live.completion = completion;
+    completion.catch(() => void 0);
+    return { executionId: input.executionId, requestKey: input.requestKey, runnerRef: input.executionId, completion };
+  }
+  async reconcile(executionId) {
+    nonempty2("executionId", executionId);
+    const active = this.live.get(executionId);
+    if (active) return reconcileLive(this.options.ledger, executionId, active, this.now(), (evidence) => this.failLive(active, "ownership_lost", evidence));
+    const read = readLedgerRecord(this.options.ledger, executionId);
+    if (!read.ok) return { kind: "ownership_lost", evidence: read.evidence };
+    const current = read.record;
+    if (!current) return { kind: "unknown", evidence: "execution ledger has no durable receipt; native submission cannot be excluded" };
+    if (current.terminal) return { kind: "terminal", terminal: current.terminal, evidence: "terminal execution ledger receipt" };
+    const claimed = claimForRecovery(
+      current,
+      { now: this.now(), supervisorId: this.options.supervisorId, leaseUntil: this.leaseUntil() },
+      (record3, fields) => this.tryApply(record3, fields)
+    );
+    if (!claimed.ok) return { kind: "ownership_lost", evidence: claimed.evidence };
+    if (claimed.record.phase === "prepared") {
+      return closePrepared(claimed.record, (record3, fields) => this.tryApply(record3, fields));
+    }
+    if (claimed.record.phase !== "recovery_required") {
+      const recovered = requireRecovery(claimed.record, recordFence(claimed.record), "dispatcher restarted without a transport attachment handle", (record3, fields) => this.tryApply(record3, fields));
+      if (recovered.kind === "ownership_lost") return recovered;
+      if (recovered.kind === "terminal") return { kind: "terminal", terminal: recovered.terminal, evidence: "execution became terminal during reconciliation" };
+    }
+    return { kind: "unknown", evidence: "transport cannot prove liveness, terminal state, or safe absence after restart" };
+  }
+  cancel(executionId, reason) {
+    nonempty2("reason", reason);
+    const live = this.live.get(executionId);
+    if (!live) return { kind: "not_live", evidence: "this dispatcher has no owned live handle" };
+    let current;
+    try {
+      current = this.options.ledger.get(executionId);
+    } catch (error) {
+      this.failLive(live, "ownership_lost", `cancellation ownership could not be verified: ${message(error)}`);
+      return { kind: "ownership_lost", evidence: message(error) };
+    }
+    if (!current) return { kind: "ownership_lost", evidence: "execution record disappeared" };
+    if (current.phase === "cancel_requested" && current.cancellation?.reason === reason) {
+      if (!ownsLiveFence(current, live.fence, this.now())) {
+        this.failLive(live, "ownership_lost", "cancellation owner lease changed or expired");
+        return { kind: "ownership_lost", record: current, evidence: "cancellation owner lease changed or expired" };
+      }
+      live.controller.abort(new Error(reason));
+      return { kind: "requested", record: current };
+    }
+    let result;
+    try {
+      result = this.tryApply(current, { kind: "request_cancellation", fence: live.fence, reason });
+    } catch (error) {
+      this.failLive(live, "recovery_required", `cancellation intent was not durable: ${message(error)}`);
+      return { kind: "ownership_lost", record: current, evidence: message(error) };
+    }
+    if (!result.ok) {
+      this.failLive(live, failureKind(result.kind), `cancellation intent was rejected: ${result.reason}`);
+      return { kind: "ownership_lost", record: current, evidence: result.reason };
+    }
+    live.controller.abort(new Error(reason));
+    return { kind: "requested", record: result.record };
+  }
+  prepare(input) {
+    const conversation = input.request.target.kind === "resume" ? input.request.target.conversation : void 0;
+    const result = this.options.ledger.apply({
+      kind: "prepare",
+      executionId: input.executionId,
+      eventId: this.eventId(),
+      expectedRevision: 0,
+      occurredAt: this.iso(),
+      execution: { executionId: input.executionId, ...conversation ? { conversation } : {} },
+      ...input.agent ? { agent: input.agent } : {},
+      harness: input.request.harness,
+      requestKey: input.requestKey,
+      target: input.request.target,
+      owner: { supervisorId: this.options.supervisorId, generation: 1, leaseUntil: this.leaseUntil() }
+    });
+    if (!result.ok) throw new Error(`could not prepare execution: ${result.kind}: ${result.reason}`);
+    if (!result.applied) throw new Error("dispatch requires a new execution identity");
+    return result.record;
+  }
+  preCancelled(input, record3) {
+    const reason = String(input.request.signal?.reason ?? "aborted before dispatch");
+    const result = this.apply(input.executionId, {
+      kind: "finish",
+      fence: recordFence(record3),
+      terminal: { outcome: "cancelled", reason }
+    });
+    const terminal = result.terminal;
+    const completion = Promise.resolve({ kind: "terminal", record: result, terminal });
+    return { executionId: input.executionId, requestKey: input.requestKey, runnerRef: input.executionId, completion };
+  }
+  startLive(executionId, fence, controller, externalSignal) {
+    return startLiveExecution({
+      fence,
+      controller,
+      schedule: this.schedule,
+      renewEveryMs: this.renewEveryMs,
+      onRenew: () => this.renew(executionId),
+      onExternalAbort: () => {
+        this.cancel(executionId, String(externalSignal?.reason ?? "aborted by caller"));
+      },
+      ...externalSignal ? { externalSignal } : {}
+    });
+  }
+  async runAdapter(input, live) {
+    try {
+      const raced = await raceLiveResult(this.adapter.run({
+        ...input.request,
+        signal: live.controller.signal,
+        onProgress: (progress) => this.progress(input.executionId, live, progress, input.request.onProgress)
+      }), live);
+      if (raced.kind === "problem") {
+        return this.problemSettlement(input.executionId, live, raced.problem);
+      }
+      const result = raced.result;
+      if (!result.ok && result.failure.kind === "runtime_error") {
+        return this.problemSettlement(input.executionId, live, {
+          kind: "recovery_required",
+          evidence: `adapter runtime state is ambiguous: ${result.failure.reason}`
+        });
+      }
+      return this.persistResult(input.executionId, live, result);
+    } catch (error) {
+      return this.problemSettlement(input.executionId, live, {
+        kind: "recovery_required",
+        evidence: `adapter threw after durable dispatch: ${message(error)}`
+      });
+    } finally {
+      this.stopLive(input.executionId, live);
+    }
+  }
+  progress(executionId, live, progress, forward) {
+    if (progress.kind === "execution_started") {
+      if (live.adapterExecutionId && live.adapterExecutionId !== progress.execution.executionId) {
+        this.failLive(live, "recovery_required", "adapter execution identity changed during one dispatch");
+      } else {
+        live.adapterExecutionId = progress.execution.executionId;
+        const read = readLedgerRecord(this.options.ledger, executionId);
+        if (!read.ok || !read.record) this.failLive(live, "ownership_lost", read.ok ? "execution record disappeared" : read.evidence);
+        const current = read.ok ? read.record : void 0;
+        if (current && (current.phase === "dispatching" || current.phase === "recovery_required")) {
+          try {
+            const result = this.tryApply(current, {
+              kind: "observe_running",
+              fence: live.fence,
+              runnerRef: executionId,
+              adapterExecution: progress.execution,
+              evidence: "adapter emitted execution_started"
+            });
+            if (!result.ok) this.failLive(live, failureKind(result.kind), result.reason);
+          } catch (error) {
+            this.failLive(live, "recovery_required", `could not persist running observation: ${message(error)}`);
+          }
+        }
+      }
+    }
+    if (progress.kind === "conversation_identified") this.observeConversation(executionId, live, progress);
+    forward?.(progress);
+  }
+  observeConversation(executionId, live, progress) {
+    if (live.adapterExecutionId && live.adapterExecutionId !== progress.executionId) {
+      this.failLive(live, "recovery_required", "conversation referred to a different adapter execution");
+      return;
+    }
+    try {
+      const read = readLedgerRecord(this.options.ledger, executionId);
+      if (!read.ok) {
+        this.failLive(live, "ownership_lost", read.evidence);
+        return;
+      }
+      const current = read.record;
+      if (!current || isTerminalExecutionPhase2(current.phase)) {
+        this.failLive(live, "ownership_lost", "execution record is unavailable or terminal while identifying conversation");
+        return;
+      }
+      const result = this.tryApply(current, { kind: "identify_conversation", fence: live.fence, conversation: progress.conversation });
+      if (!result.ok) this.failLive(live, failureKind(result.kind), result.reason);
+    } catch (error) {
+      this.failLive(live, "recovery_required", `could not persist conversation identity: ${message(error)}`);
+    }
+  }
+  persistResult(executionId, live, result) {
+    const read = readLedgerRecord(this.options.ledger, executionId);
+    if (!read.ok) return { kind: "ownership_lost", evidence: read.evidence };
+    const current = read.record;
+    if (!current) return { kind: "ownership_lost", evidence: "execution record disappeared before terminal persistence" };
+    const terminal = terminalFromHarnessResult(result);
+    const applied = this.tryApply(current, {
+      kind: "finish",
+      fence: live.fence,
+      terminal,
+      ...result.execution ? { adapterExecution: result.execution } : {},
+      ...result.conversation ? { conversation: result.conversation } : {}
+    });
+    if (!applied.ok) return requireRecovery(current, live.fence, `terminal result was not durable: ${applied.reason}`, (record3, fields) => this.tryApply(record3, fields));
+    return {
+      kind: "terminal",
+      record: applied.record,
+      terminal
+    };
+  }
+  renew(executionId) {
+    const live = this.live.get(executionId);
+    if (!live) return;
+    try {
+      const current = this.options.ledger.get(executionId);
+      if (!current || isTerminalExecutionPhase2(current.phase)) {
+        this.failLive(live, "ownership_lost", "execution record is unavailable or terminal during lease renewal");
+        return;
+      }
+      const result = this.tryApply(current, { kind: "renew_owner", fence: live.fence, leaseUntil: this.leaseUntil() });
+      if (!result.ok) this.failLive(live, failureKind(result.kind), `lease renewal failed: ${result.reason}`);
+    } catch (error) {
+      this.failLive(live, "ownership_lost", `lease renewal threw: ${message(error)}`);
+    }
+  }
+  failLive(live, kind, evidence) {
+    if (!live.problem) {
+      live.problem = { kind, evidence };
+      live.resolveProblem(live.problem);
+    }
+    live.controller.abort(new Error(evidence));
+  }
+  problemSettlement(executionId, live, problem) {
+    const read = readLedgerRecord(this.options.ledger, executionId);
+    if (!read.ok) return { kind: "ownership_lost", evidence: `${problem.evidence}; ${read.evidence}` };
+    if (problem.kind === "ownership_lost") return { kind: "ownership_lost", record: read.record, evidence: problem.evidence };
+    return requireRecovery(read.record, live.fence, problem.evidence, (record3, fields) => this.tryApply(record3, fields));
+  }
+  tryApply(current, fields) {
+    return this.options.ledger.apply({
+      ...fields,
+      executionId: current.execution.executionId,
+      eventId: this.eventId(),
+      expectedRevision: current.revision,
+      occurredAt: this.iso()
+    });
+  }
+  apply(executionId, fields) {
+    const current = this.options.ledger.get(executionId);
+    if (!current) throw new Error(`execution ${executionId} is missing`);
+    const result = this.tryApply(current, fields);
+    if (!result.ok) throw new Error(`${result.kind}: ${result.reason}`);
+    return result.record;
+  }
+  stopLive(executionId, live) {
+    this.unschedule(live.timer);
+    live.externalSignal?.removeEventListener("abort", live.onExternalAbort);
+    if (this.live.get(executionId) === live) this.live.delete(executionId);
+  }
+  iso() {
+    return new Date(this.now()).toISOString();
+  }
+  leaseUntil() {
+    return new Date(this.now() + this.options.leaseMs).toISOString();
+  }
+};
+
+// src/claude-code-adapter.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/claude-code-result.ts
+function claudeFailure(failure) {
+  const reason = failure.reason;
+  switch (failure.kind) {
+    case "rate_limited":
+      return { kind: "rate_limited", reason, retryAtMs: failure.retryAt?.getTime() };
+    case "budget_exceeded":
+      return { kind: "limit_exceeded", reason, unit: "usd" };
+    case "max_turns":
+      return { kind: "runtime_error", reason: `native maxTurns reached: ${reason}` };
+    case "schema_invalid":
+      return { kind: "output_invalid", reason };
+    case "inactivity_timeout":
+      return { kind: "cancelled_unknown", reason };
+    case "refusal":
+      return { kind: "output_invalid", reason: `native refusal: ${reason}` };
+    case "auth_misconfigured":
+      return { kind: "auth_misconfigured", reason };
+    case "aborted":
+      return { kind: "aborted", reason };
+    case "runtime_error":
+      return { kind: "runtime_error", reason };
+  }
+}
+function claudeUsage(usage, executionId) {
+  if (!usage) return [];
+  const models = Object.entries(usage.modelUsage);
+  const sum = (field) => {
+    const values = models.map(([, model]) => model[field]);
+    if (values.length === 0) return null;
+    let total = 0;
+    for (const value of values) {
+      if (typeof value !== "number" || !Number.isFinite(value)) return null;
+      total += value;
+    }
+    return total;
+  };
+  const uncached = sum("inputTokens");
+  const cachedInput = sum("cacheReadInputTokens");
+  const cacheWriteInput = sum("cacheCreationInputTokens");
+  const input = uncached === null || cachedInput === null || cacheWriteInput === null ? null : uncached + cachedInput + cacheWriteInput;
+  return [{
+    kind: "snapshot",
+    scope: "turn",
+    scopeId: executionId,
+    epoch: executionId,
+    sequence: 0,
+    model: models.length === 1 ? models[0][0] : null,
+    source: "claude-sdk:query-result",
+    tokens: { input, output: sum("outputTokens"), cachedInput, cacheWriteInput, reasoningOutput: null, total: null },
+    cost: { usd: usage.totalCostUsd, kind: "estimate" }
+  }];
+}
+
+// src/claude-code-adapter.ts
+function createClaudeCodeAdapter(options) {
+  for (const field of ["maxTurns", "maxBudgetUsd", "inactivityTimeoutMs"]) {
+    const value = options[field];
+    if (value === void 0 && field === "inactivityTimeoutMs") continue;
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`${field} must be positive and finite`);
+  }
+  const descriptor = claudeCodeCapabilities();
+  return {
+    descriptor,
+    async run(request) {
+      const failure = preflightHarnessRun(request, descriptor);
+      if (failure) return { ok: false, harness: "claude-code", failure, usage: [] };
+      if (request.wallTimeMs > 2147483647) return { ok: false, harness: "claude-code", failure: { kind: "invalid_request", reason: "wallTimeMs exceeds the local timer range" }, usage: [] };
+      return new ClaudeInvocation(request, options).run();
+    }
+  };
+}
+function claudeCodeCapabilities() {
+  const capabilities = Object.fromEntries(EXECUTION_CAPABILITIES.map((capability) => [capability, {
+    status: "unsupported",
+    reason: "not exposed by this bounded Claude SDK adapter"
+  }]));
+  for (const capability of ["fresh_run", "resume", "structured_output", "external_cancellation", "token_reporting"]) {
+    capabilities[capability] = { status: "supported", evidence: "bounded wrapper around the existing runAgent SDK query" };
+  }
+  return {
+    harness: "claude-code",
+    adapter: { name: "claude-sdk-bounded", version: "1" },
+    capabilities,
+    limits: [{ unit: "milliseconds", scope: "execution", enforcement: "hard", assessment: {
+      status: "supported",
+      evidence: "local deadline aborts and closes the owned query; native cancellation remains unconfirmed"
+    } }]
+  };
+}
+var ClaudeInvocation = class {
+  constructor(request, options) {
+    this.request = request;
+    this.options = options;
+    this.conversation = request.target.kind === "resume" ? request.target.conversation : void 0;
+    this.execution = { executionId: randomUUID3(), ...this.conversation ? { conversation: this.conversation } : {} };
+  }
+  request;
+  options;
+  controller = new AbortController();
+  execution;
+  conversation;
+  stream;
+  active = true;
+  timer;
+  stop;
+  onAbort = () => this.stop({ kind: "aborted", reason: String(this.request.signal?.reason ?? "caller aborted") });
+  async run() {
+    try {
+      const stopped = new Promise((resolve) => {
+        this.stop = (failure) => {
+          if (!this.active) return;
+          this.active = false;
+          this.controller.abort(new Error(failure.reason));
+          this.close();
+          resolve(this.failed(failure));
+        };
+      });
+      this.timer = setTimeout(() => this.stop({ kind: "wall_time_exceeded", reason: "Claude query exceeded local wall deadline", wallTimeMs: this.request.wallTimeMs }), this.request.wallTimeMs);
+      this.timer.unref?.();
+      this.request.signal?.addEventListener("abort", this.onAbort, { once: true });
+      if (this.request.signal?.aborted) this.onAbort();
+      this.emit({ kind: "execution_started", execution: this.execution });
+      if (!this.active) return await stopped;
+      const result = await Promise.race([this.invoke(), stopped]);
+      this.active = false;
+      this.emit({
+        kind: "execution_finished",
+        executionId: this.execution.executionId,
+        outcome: result.ok ? "succeeded" : result.failure.kind === "aborted" || result.failure.kind === "wall_time_exceeded" || result.failure.kind === "cancelled_unknown" ? "cancelled" : "failed"
+      });
+      return result;
+    } catch (error) {
+      this.controller.abort(error);
+      return this.failed({ kind: "runtime_error", reason: error instanceof Error ? error.message : String(error) });
+    } finally {
+      this.active = false;
+      if (this.timer) clearTimeout(this.timer);
+      this.request.signal?.removeEventListener("abort", this.onAbort);
+      this.close();
+    }
+  }
+  async invoke() {
+    const result = await runAgent({
+      ...this.request.native,
+      prompt: this.request.prompt,
+      cwd: this.request.cwd,
+      maxTurns: this.options.maxTurns,
+      maxBudgetUsd: this.options.maxBudgetUsd,
+      inactivityTimeoutMs: this.options.inactivityTimeoutMs,
+      signal: this.controller.signal,
+      resumeSessionId: this.request.target.kind === "resume" ? this.request.target.conversation.nativeId : void 0,
+      onMessage: (message2) => this.observe(message2)
+    }, { ...this.options.deps, query: (args) => {
+      this.stream = (this.options.deps?.query ?? query2)(args);
+      return this.stream;
+    } });
+    if (!this.active) return this.failed({ kind: "cancelled_unknown", reason: "query completed after local supervision ended" });
+    if (result.sessionId) this.identify(result.sessionId);
+    const usage = claudeUsage(result.usage, this.execution.executionId);
+    if (!result.ok) return { ...this.failed(claudeFailure(result.failure)), usage };
+    if (!this.conversation) return this.failed({ kind: "runtime_error", reason: "Claude query returned no conversation identity" });
+    return {
+      ok: true,
+      harness: "claude-code",
+      execution: { ...this.execution, conversation: this.conversation },
+      conversation: this.conversation,
+      output: this.request.native?.outputSchema ? { kind: "structured", value: result.output } : { kind: "text", text: String(result.output) },
+      usage
+    };
+  }
+  observe(message2) {
+    if (!this.active) return;
+    if ("session_id" in message2 && typeof message2.session_id === "string") this.identify(message2.session_id);
+    if (message2.type === "assistant") {
+      for (const block of message2.message.content) {
+        if (block.type === "text") this.emit({ kind: "assistant_output", executionId: this.execution.executionId, text: block.text });
+      }
+    }
+  }
+  identify(nativeId) {
+    if (this.conversation) {
+      if (this.conversation.nativeId !== nativeId) throw new Error("Claude query changed conversation identity");
+      return;
+    }
+    this.conversation = { harness: "claude-code", namespace: this.request.target.kind === "fresh" ? this.request.target.namespace : this.request.target.conversation.namespace, nativeId };
+    this.emit({ kind: "conversation_identified", executionId: this.execution.executionId, conversation: this.conversation });
+  }
+  failed(failure) {
+    return {
+      ok: false,
+      harness: "claude-code",
+      execution: this.execution,
+      ...this.conversation ? { conversation: this.conversation } : {},
+      failure,
+      usage: []
+    };
+  }
+  emit(progress) {
+    this.request.onProgress?.({ ...progress, harness: "claude-code", atMs: (this.options.deps?.now ?? Date.now)() });
+  }
+  close() {
+    try {
+      this.stream?.close();
+    } catch {
+    }
+  }
+};
 export {
   ANTI_NESTING_VARS,
   AuthMisconfiguredError,
   CLAUDE_CODE_PASSTHROUGH_VARS,
+  CODEX_APPROVAL_POLICIES,
+  CODEX_SANDBOXES,
+  DEFAULT_CODEX_EXECUTABLE,
+  DEFAULT_CODEX_KILL_GRACE_MS,
   DEFAULT_INACTIVITY_MS,
   DEFAULT_MAX_RETRIES,
+  EXECUTION_CAPABILITIES,
   FORBIDDEN_API_KEY_SOURCES,
   STRIPPED_AUTH_VARS,
+  STRIPPED_CODEX_AUTH_VARS,
   STRIPPED_PROXY_VARS,
+  SUPPORTED_CODEX_EXEC_VERSION,
   assertApiKeySourceAllowed,
   assertAuthEnvOk,
+  buildCodexExecArgs,
   classifyResult,
+  claudeCodeCapabilities,
+  codexExecCapabilities,
+  createClaudeCodeAdapter,
+  createCodexExecAdapter,
+  createDurableHarnessDispatcher,
+  dispatchHarnessRun,
+  preflightHarnessRun,
+  prepareCodexEnv,
   prepareEnv,
   runAgent,
   sumModelCost,