@open330/oac 2026.2.5

package/dist/chunk-QPVNC7S4.js

@@ -0,0 +1,1833 @@
+import {
+  OacError,
+  executionError
+} from "./chunk-7C7SC4TZ.js";
+import {
+  isRecord
+} from "./chunk-6A37SKAJ.js";
+
+// src/execution/agents/claude-code.adapter.ts
+import { createInterface } from "readline";
+import { execa } from "execa";
+
+// src/execution/agents/shared.ts
+var AsyncEventQueue = class {
+  values = [];
+  resolvers = [];
+  done = false;
+  pendingError;
+  push(value) {
+    if (this.done) {
+      return;
+    }
+    const nextResolver = this.resolvers.shift();
+    if (nextResolver) {
+      nextResolver({ done: false, value });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    this.flush();
+  }
+  fail(error) {
+    this.pendingError = error;
+    this.done = true;
+    this.flush();
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.values.length > 0) {
+          const value = this.values.shift();
+          if (value === void 0) {
+            return { done: true, value: void 0 };
+          }
+          return { done: false, value };
+        }
+        if (this.pendingError !== void 0) {
+          throw this.pendingError;
+        }
+        if (this.done) {
+          return { done: true, value: void 0 };
+        }
+        return new Promise((resolve2) => {
+          this.resolvers.push(resolve2);
+        });
+      }
+    };
+  }
+  flush() {
+    for (const resolve2 of this.resolvers.splice(0)) {
+      resolve2({ done: true, value: void 0 });
+    }
+  }
+};
+function readNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+
+// src/execution/agents/claude-code.adapter.ts
+function parseJsonPayload(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const candidates = [trimmed];
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const fragment = trimmed.slice(start, end + 1);
+    if (fragment !== trimmed) {
+      candidates.push(fragment);
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function patchTokenState(state, patch) {
+  if (patch.inputTokens === void 0 && patch.outputTokens === void 0 && patch.cumulativeTokens === void 0) {
+    return void 0;
+  }
+  state.inputTokens = patch.inputTokens ?? state.inputTokens;
+  state.outputTokens = patch.outputTokens ?? state.outputTokens;
+  const computedTotal = state.inputTokens + state.outputTokens;
+  state.cumulativeTokens = Math.max(
+    state.cumulativeTokens,
+    patch.cumulativeTokens ?? computedTotal
+  );
+  return {
+    type: "tokens",
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    cumulativeTokens: state.cumulativeTokens
+  };
+}
+function parseTokenPatchFromPayload(payload) {
+  const usage = isRecord(payload.usage) ? payload.usage : void 0;
+  return {
+    inputTokens: readNumber(
+      payload.inputTokens ?? payload.input_tokens ?? payload.promptTokens ?? payload.prompt_tokens ?? usage?.inputTokens ?? usage?.input_tokens ?? usage?.promptTokens ?? usage?.prompt_tokens
+    ),
+    outputTokens: readNumber(
+      payload.outputTokens ?? payload.output_tokens ?? payload.completionTokens ?? payload.completion_tokens ?? usage?.outputTokens ?? usage?.output_tokens ?? usage?.completionTokens ?? usage?.completion_tokens
+    ),
+    cumulativeTokens: readNumber(
+      payload.cumulativeTokens ?? payload.cumulative_tokens ?? payload.totalTokens ?? payload.total_tokens ?? usage?.cumulativeTokens ?? usage?.cumulative_tokens ?? usage?.totalTokens ?? usage?.total_tokens
+    )
+  };
+}
+function parseTokenPatchFromLine(line) {
+  const inputMatch = line.match(/(?:input|prompt)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const outputMatch = line.match(/(?:output|completion)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const totalMatch = line.match(/(?:total|cumulative|used)\s*tokens?\s*[:=]\s*(\d+)/i);
+  return {
+    inputTokens: inputMatch ? Number.parseInt(inputMatch[1], 10) : void 0,
+    outputTokens: outputMatch ? Number.parseInt(outputMatch[1], 10) : void 0,
+    cumulativeTokens: totalMatch ? Number.parseInt(totalMatch[1], 10) : void 0
+  };
+}
+function parseTokenEvent(line, state) {
+  const payload = parseJsonPayload(line);
+  const patch = payload ? parseTokenPatchFromPayload(payload) : parseTokenPatchFromLine(line);
+  return patchTokenState(state, patch);
+}
+function normalizeFileAction(value) {
+  if (value !== "create" && value !== "modify" && value !== "delete") {
+    return void 0;
+  }
+  return value;
+}
+function parseFileEditFromPayload(payload) {
+  if (payload.type === "file_edit") {
+    const action = normalizeFileAction(payload.action);
+    const path = readString(payload.path);
+    if (action && path) {
+      return {
+        type: "file_edit",
+        action,
+        path
+      };
+    }
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  const input = isRecord(payload.input) ? payload.input : void 0;
+  const inputPath = readString(input?.path ?? input?.file_path ?? input?.filePath);
+  if (!tool || !inputPath) {
+    return void 0;
+  }
+  if (tool === "create_file") {
+    return { type: "file_edit", action: "create", path: inputPath };
+  }
+  if (tool === "delete_file") {
+    return { type: "file_edit", action: "delete", path: inputPath };
+  }
+  if (tool === "write_file" || tool === "edit_file" || tool === "replace_file") {
+    return { type: "file_edit", action: "modify", path: inputPath };
+  }
+  return void 0;
+}
+function parseFileEditFromLine(line) {
+  const fileActionMatch = line.match(/\b(created|modified|deleted)\s+(?:file\s+)?([^\s"'`]+)/i);
+  if (!fileActionMatch) {
+    return void 0;
+  }
+  const actionMap = {
+    created: "create",
+    modified: "modify",
+    deleted: "delete"
+  };
+  const action = actionMap[fileActionMatch[1].toLowerCase()];
+  const path = fileActionMatch[2]?.trim();
+  if (!action || !path) {
+    return void 0;
+  }
+  return {
+    type: "file_edit",
+    action,
+    path
+  };
+}
+function parseFileEditEvent(line) {
+  const payload = parseJsonPayload(line);
+  return payload ? parseFileEditFromPayload(payload) : parseFileEditFromLine(line);
+}
+function parseToolUseEvent(line) {
+  const payload = parseJsonPayload(line);
+  if (!payload) {
+    return void 0;
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    type: "tool_use",
+    tool,
+    input: payload.input
+  };
+}
+function parseErrorEvent(line, stream) {
+  const payload = parseJsonPayload(line);
+  if (payload?.type === "error") {
+    const message = readString(payload.message) ?? "Unknown Claude CLI error";
+    const recoverable = payload.recoverable !== false;
+    return { type: "error", message, recoverable };
+  }
+  if (stream === "stderr" && /error|failed|exception/i.test(line)) {
+    return { type: "error", message: line.trim(), recoverable: true };
+  }
+  return void 0;
+}
+function estimateTokenCount(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalizeUnknownError(error, executionId) {
+  if (error instanceof OacError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError("AGENT_TIMEOUT", `Claude execution timed out for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError("AGENT_OOM", `Claude execution ran out of memory for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError(
+      "Claude execution failed due to network issues",
+      "NETWORK_ERROR",
+      "recoverable",
+      {
+        executionId,
+        message
+      },
+      error
+    );
+  }
+  return executionError("AGENT_EXECUTION_FAILED", `Claude execution failed for ${executionId}`, {
+    context: { executionId, message },
+    cause: error
+  });
+}
+function computeTotalTokens(state) {
+  return Math.max(state.cumulativeTokens, state.inputTokens + state.outputTokens);
+}
+function normalizeExitCode(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return 1;
+}
+function hasBooleanFlag(value, key) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value[key] === true;
+}
+function buildFailureMessage(stdout, stderr) {
+  const trimmedStderr = stderr.trim();
+  if (trimmedStderr.length > 0) {
+    return trimmedStderr;
+  }
+  const trimmedStdout = stdout.trim();
+  if (trimmedStdout.length > 0) {
+    return trimmedStdout;
+  }
+  return "Claude CLI process exited with a non-zero status.";
+}
+var ClaudeCodeAdapter = class {
+  id = "claude-code";
+  name = "Claude Code";
+  runningExecutions = /* @__PURE__ */ new Map();
+  async checkAvailability() {
+    try {
+      const result = await execa("claude", ["--version"], { reject: false });
+      const version = result.stdout.trim().split("\n")[0];
+      if (result.exitCode === 0) {
+        return {
+          available: true,
+          version: version.length > 0 ? version : void 0
+        };
+      }
+      return {
+        available: false,
+        error: result.stderr.trim() || `claude --version exited with code ${result.exitCode}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        available: false,
+        error: message
+      };
+    }
+  }
+  execute(params) {
+    const startedAt = Date.now();
+    const filesChanged = /* @__PURE__ */ new Set();
+    const tokenState = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cumulativeTokens: 0
+    };
+    const eventQueue = new AsyncEventQueue();
+    const processEnv = {
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(
+          (entry) => typeof entry[1] === "string" && // Strip Claude Code session markers to allow spawning a fresh Claude subprocess
+          entry[0] !== "CLAUDECODE" && entry[0] !== "CLAUDE_CODE_SESSION"
+        )
+      ),
+      ...params.env,
+      OAC_TOKEN_BUDGET: `${params.tokenBudget}`,
+      OAC_ALLOW_COMMITS: `${params.allowCommits}`
+    };
+    const subprocess = execa("claude", ["-p", params.prompt], {
+      cwd: params.workingDirectory,
+      env: processEnv,
+      extendEnv: false,
+      reject: false,
+      timeout: params.timeoutMs
+    });
+    this.runningExecutions.set(params.executionId, subprocess);
+    const consumeStream = async (stream, streamName) => {
+      if (!stream) {
+        return;
+      }
+      const lineReader = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      for await (const line of lineReader) {
+        eventQueue.push({
+          type: "output",
+          content: line,
+          stream: streamName
+        });
+        const tokenEvent = parseTokenEvent(line, tokenState);
+        if (tokenEvent?.type === "tokens") {
+          eventQueue.push(tokenEvent);
+        }
+        const fileEvent = parseFileEditEvent(line);
+        if (fileEvent) {
+          filesChanged.add(fileEvent.path);
+          eventQueue.push(fileEvent);
+        }
+        const toolEvent = parseToolUseEvent(line);
+        if (toolEvent) {
+          eventQueue.push(toolEvent);
+        }
+        const errorEvent = parseErrorEvent(line, streamName);
+        if (errorEvent) {
+          eventQueue.push(errorEvent);
+        }
+      }
+    };
+    const stdoutDone = consumeStream(subprocess.stdout ?? void 0, "stdout");
+    const stderrDone = consumeStream(subprocess.stderr ?? void 0, "stderr");
+    const resultPromise = (async () => {
+      try {
+        const settled = await subprocess;
+        await Promise.all([stdoutDone, stderrDone]);
+        const timedOut = hasBooleanFlag(settled, "timedOut");
+        if (timedOut) {
+          const timeoutError = executionError(
+            "AGENT_TIMEOUT",
+            `Claude execution timed out for ${params.executionId}`,
+            {
+              context: {
+                executionId: params.executionId,
+                timeoutMs: params.timeoutMs
+              }
+            }
+          );
+          eventQueue.push({
+            type: "error",
+            message: timeoutError.message,
+            recoverable: true
+          });
+          throw timeoutError;
+        }
+        const canceled = hasBooleanFlag(settled, "isCanceled");
+        if (canceled) {
+          return {
+            success: false,
+            exitCode: normalizeExitCode(settled.exitCode),
+            totalTokensUsed: computeTotalTokens(tokenState),
+            filesChanged: [...filesChanged],
+            duration: Date.now() - startedAt,
+            error: "Claude execution was cancelled."
+          };
+        }
+        const exitCode = normalizeExitCode(settled.exitCode);
+        const success = exitCode === 0;
+        return {
+          success,
+          exitCode,
+          totalTokensUsed: computeTotalTokens(tokenState),
+          filesChanged: [...filesChanged],
+          duration: Date.now() - startedAt,
+          error: success ? void 0 : buildFailureMessage(settled.stdout, settled.stderr)
+        };
+      } catch (error) {
+        const normalized = normalizeUnknownError(error, params.executionId);
+        eventQueue.push({
+          type: "error",
+          message: normalized.message,
+          recoverable: normalized.severity !== "fatal"
+        });
+        eventQueue.fail(normalized);
+        throw normalized;
+      } finally {
+        this.runningExecutions.delete(params.executionId);
+        eventQueue.close();
+      }
+    })();
+    return {
+      executionId: params.executionId,
+      providerId: this.id,
+      events: eventQueue,
+      result: resultPromise,
+      pid: subprocess.pid
+    };
+  }
+  async estimateTokens(params) {
+    const contextTokens = params.contextTokens ?? params.targetFiles.length * 80 + params.targetFiles.join("\n").length;
+    const promptTokens = estimateTokenCount(params.prompt);
+    const expectedOutputTokens = params.expectedOutputTokens ?? Math.max(128, Math.ceil(promptTokens * 0.6));
+    const totalEstimatedTokens = contextTokens + promptTokens + expectedOutputTokens;
+    return {
+      taskId: params.taskId,
+      providerId: this.id,
+      contextTokens,
+      promptTokens,
+      expectedOutputTokens,
+      totalEstimatedTokens,
+      confidence: 0.6,
+      feasible: true
+    };
+  }
+  async abort(executionId) {
+    const running = this.runningExecutions.get(executionId);
+    if (!running) {
+      return;
+    }
+    running.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      running.kill("SIGKILL");
+    }, 5e3);
+    forceKillTimer.unref();
+    try {
+      await running;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+};
+
+// src/execution/agents/codex.adapter.ts
+import { stat } from "fs/promises";
+import { createInterface as createInterface2 } from "readline";
+import { execa as execa2 } from "execa";
+function parseJsonPayload2(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isRecord(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseTokenPatchFromPayload2(payload) {
+  const usage = isRecord(payload.usage) ? payload.usage : void 0;
+  return {
+    inputTokens: readNumber(
+      payload.inputTokens ?? payload.input_tokens ?? payload.promptTokens ?? payload.prompt_tokens ?? usage?.inputTokens ?? usage?.input_tokens ?? usage?.promptTokens ?? usage?.prompt_tokens
+    ),
+    outputTokens: readNumber(
+      payload.outputTokens ?? payload.output_tokens ?? payload.completionTokens ?? payload.completion_tokens ?? usage?.outputTokens ?? usage?.output_tokens ?? usage?.completionTokens ?? usage?.completion_tokens
+    ),
+    cumulativeTokens: readNumber(
+      payload.cumulativeTokens ?? payload.cumulative_tokens ?? payload.totalTokens ?? payload.total_tokens ?? usage?.cumulativeTokens ?? usage?.cumulative_tokens ?? usage?.totalTokens ?? usage?.total_tokens
+    )
+  };
+}
+function patchTokenState2(state, patch) {
+  if (patch.inputTokens === void 0 && patch.outputTokens === void 0 && patch.cumulativeTokens === void 0) {
+    return void 0;
+  }
+  state.inputTokens = patch.inputTokens ?? state.inputTokens;
+  state.outputTokens = patch.outputTokens ?? state.outputTokens;
+  const computedTotal = state.inputTokens + state.outputTokens;
+  state.cumulativeTokens = Math.max(
+    state.cumulativeTokens,
+    patch.cumulativeTokens ?? computedTotal
+  );
+  return {
+    type: "tokens",
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    cumulativeTokens: state.cumulativeTokens
+  };
+}
+function parseTokenEvent2(line, payload, state) {
+  if (payload) {
+    return patchTokenState2(state, parseTokenPatchFromPayload2(payload));
+  }
+  const inputMatch = line.match(/(?:input|prompt)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const outputMatch = line.match(/(?:output|completion)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const totalMatch = line.match(/(?:total|cumulative|used)\s*tokens?\s*[:=]\s*(\d+)/i);
+  return patchTokenState2(state, {
+    inputTokens: inputMatch ? Number.parseInt(inputMatch[1], 10) : void 0,
+    outputTokens: outputMatch ? Number.parseInt(outputMatch[1], 10) : void 0,
+    cumulativeTokens: totalMatch ? Number.parseInt(totalMatch[1], 10) : void 0
+  });
+}
+function normalizeFileAction2(value) {
+  if (value !== "create" && value !== "modify" && value !== "delete") {
+    return void 0;
+  }
+  return value;
+}
+function parseFileEditFromPayload2(payload) {
+  if (payload.type === "file_edit") {
+    const action = normalizeFileAction2(payload.action);
+    const path = readString(payload.path);
+    if (action && path) {
+      return {
+        type: "file_edit",
+        action,
+        path
+      };
+    }
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  const input = isRecord(payload.input) ? payload.input : void 0;
+  const inputPath = readString(input?.path ?? input?.file_path ?? input?.filePath);
+  if (!tool || !inputPath) {
+    return void 0;
+  }
+  if (tool === "create_file") {
+    return { type: "file_edit", action: "create", path: inputPath };
+  }
+  if (tool === "delete_file") {
+    return { type: "file_edit", action: "delete", path: inputPath };
+  }
+  if (tool === "write_file" || tool === "edit_file" || tool === "replace_file") {
+    return { type: "file_edit", action: "modify", path: inputPath };
+  }
+  return void 0;
+}
+function parseToolUseFromPayload(payload) {
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    type: "tool_use",
+    tool,
+    input: payload.input
+  };
+}
+function parseErrorFromPayload(payload) {
+  if (payload.type !== "error") {
+    return void 0;
+  }
+  return {
+    type: "error",
+    message: readString(payload.message) ?? "Unknown Codex CLI error",
+    recoverable: payload.recoverable !== false
+  };
+}
+function estimateTokenCount2(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalizeUnknownError2(error, executionId) {
+  if (error instanceof OacError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError("AGENT_TIMEOUT", `Codex execution timed out for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError("AGENT_OOM", `Codex execution ran out of memory for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/rate.limit|429|too many requests|throttl/i.test(message)) {
+    return executionError("AGENT_RATE_LIMITED", `Codex execution rate-limited for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError(
+      "Codex execution failed due to network issues",
+      "NETWORK_ERROR",
+      "recoverable",
+      {
+        executionId,
+        message
+      },
+      error
+    );
+  }
+  return executionError("AGENT_EXECUTION_FAILED", `Codex execution failed for ${executionId}`, {
+    context: { executionId, message },
+    cause: error
+  });
+}
+function computeTotalTokens2(state) {
+  return Math.max(state.cumulativeTokens, state.inputTokens + state.outputTokens);
+}
+function normalizeExitCode2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return 1;
+}
+function hasBooleanFlag2(value, key) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value[key] === true;
+}
+function buildFailureMessage2(stdout, stderr) {
+  const trimmedStderr = stderr.trim();
+  if (trimmedStderr.length > 0) {
+    return trimmedStderr;
+  }
+  const trimmedStdout = stdout.trim();
+  if (trimmedStdout.length > 0) {
+    return trimmedStdout;
+  }
+  return "Codex CLI process exited with a non-zero status.";
+}
+function parseVersion(output) {
+  const match = output.match(/(\d+\.\d+\.\d+)/);
+  if (!match) {
+    return void 0;
+  }
+  return match[1];
+}
+async function estimateContextTokens(targetFiles) {
+  let totalBytes = 0;
+  for (const filePath of targetFiles) {
+    try {
+      const fileStat = await stat(filePath);
+      if (fileStat.isFile()) {
+        totalBytes += fileStat.size;
+      }
+    } catch {
+    }
+  }
+  return Math.ceil(totalBytes / 4);
+}
+var CodexAdapter = class {
+  id = "codex";
+  name = "Codex CLI";
+  runningExecutions = /* @__PURE__ */ new Map();
+  async checkAvailability() {
+    try {
+      const result = await execa2("codex", ["--version"], { reject: false });
+      if (result.exitCode === 0) {
+        const versionLine = result.stdout.trim().split("\n")[0] ?? "";
+        return {
+          available: true,
+          version: parseVersion(versionLine)
+        };
+      }
+      return {
+        available: false,
+        error: result.stderr.trim() || result.stdout.trim() || `codex --version exited with code ${result.exitCode}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        available: false,
+        error: message
+      };
+    }
+  }
+  execute(params) {
+    const startedAt = Date.now();
+    const filesChanged = /* @__PURE__ */ new Set();
+    const tokenState = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cumulativeTokens: 0
+    };
+    const eventQueue = new AsyncEventQueue();
+    const processEnv = {
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ),
+      ...params.env,
+      OAC_TOKEN_BUDGET: `${params.tokenBudget}`,
+      OAC_ALLOW_COMMITS: `${params.allowCommits}`
+    };
+    const subprocess = execa2(
+      "codex",
+      ["exec", "--full-auto", "-C", params.workingDirectory, params.prompt],
+      {
+        cwd: params.workingDirectory,
+        env: processEnv,
+        reject: false,
+        timeout: params.timeoutMs
+      }
+    );
+    this.runningExecutions.set(params.executionId, subprocess);
+    const processStdoutLine = (line) => {
+      const payload = parseJsonPayload2(line);
+      const tokenEvent = parseTokenEvent2(line, payload, tokenState);
+      if (tokenEvent?.type === "tokens") {
+        eventQueue.push(tokenEvent);
+      }
+      if (!payload) return;
+      const fileEvent = parseFileEditFromPayload2(payload);
+      if (fileEvent) {
+        filesChanged.add(fileEvent.path);
+        eventQueue.push(fileEvent);
+      }
+      const toolEvent = parseToolUseFromPayload(payload);
+      if (toolEvent) {
+        eventQueue.push(toolEvent);
+      }
+      const errorEvent = parseErrorFromPayload(payload);
+      if (errorEvent) {
+        eventQueue.push(errorEvent);
+      }
+    };
+    const consumeStream = async (stream, streamName) => {
+      if (!stream) {
+        return;
+      }
+      const lineReader = createInterface2({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      for await (const line of lineReader) {
+        eventQueue.push({ type: "output", content: line, stream: streamName });
+        if (streamName === "stdout") {
+          processStdoutLine(line);
+        } else if (/error|failed|exception/i.test(line)) {
+          eventQueue.push({ type: "error", message: line.trim(), recoverable: true });
+        }
+      }
+    };
+    const stdoutDone = consumeStream(subprocess.stdout ?? void 0, "stdout");
+    const stderrDone = consumeStream(subprocess.stderr ?? void 0, "stderr");
+    const resultPromise = (async () => {
+      try {
+        const settled = await subprocess;
+        await Promise.all([stdoutDone, stderrDone]);
+        const timedOut = hasBooleanFlag2(settled, "timedOut");
+        if (timedOut) {
+          const timeoutError = executionError(
+            "AGENT_TIMEOUT",
+            `Codex execution timed out for ${params.executionId}`,
+            {
+              context: {
+                executionId: params.executionId,
+                timeoutMs: params.timeoutMs
+              }
+            }
+          );
+          eventQueue.push({
+            type: "error",
+            message: timeoutError.message,
+            recoverable: true
+          });
+          throw timeoutError;
+        }
+        const canceled = hasBooleanFlag2(settled, "isCanceled");
+        if (canceled) {
+          return {
+            success: false,
+            exitCode: normalizeExitCode2(settled.exitCode),
+            totalTokensUsed: computeTotalTokens2(tokenState),
+            filesChanged: [...filesChanged],
+            duration: Date.now() - startedAt,
+            error: "Codex execution was cancelled."
+          };
+        }
+        const exitCode = normalizeExitCode2(settled.exitCode);
+        const success = exitCode === 0;
+        return {
+          success,
+          exitCode,
+          totalTokensUsed: computeTotalTokens2(tokenState),
+          filesChanged: [...filesChanged],
+          duration: Date.now() - startedAt,
+          error: success ? void 0 : buildFailureMessage2(settled.stdout, settled.stderr)
+        };
+      } catch (error) {
+        const normalized = normalizeUnknownError2(error, params.executionId);
+        eventQueue.push({
+          type: "error",
+          message: normalized.message,
+          recoverable: normalized.severity !== "fatal"
+        });
+        eventQueue.fail(normalized);
+        throw normalized;
+      } finally {
+        this.runningExecutions.delete(params.executionId);
+        eventQueue.close();
+      }
+    })();
+    return {
+      executionId: params.executionId,
+      providerId: this.id,
+      events: eventQueue,
+      result: resultPromise,
+      pid: subprocess.pid
+    };
+  }
+  async estimateTokens(params) {
+    const baseTokens = params.targetFiles.length * 2e3;
+    const promptTokens = estimateTokenCount2(params.prompt);
+    const contextTokens = await estimateContextTokens(params.targetFiles);
+    const expectedOutputTokens = baseTokens;
+    const totalEstimatedTokens = contextTokens + promptTokens + expectedOutputTokens;
+    return {
+      taskId: params.taskId,
+      providerId: this.id,
+      contextTokens,
+      promptTokens,
+      expectedOutputTokens,
+      totalEstimatedTokens,
+      confidence: 0.6,
+      feasible: totalEstimatedTokens < 2e5
+    };
+  }
+  async abort(executionId) {
+    const running = this.runningExecutions.get(executionId);
+    if (!running) {
+      return;
+    }
+    running.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      running.kill("SIGKILL");
+    }, 2e3);
+    forceKillTimer.unref();
+    try {
+      await running;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+};
+
+// src/execution/agents/opencode.adapter.ts
+import { stat as stat2 } from "fs/promises";
+import { createInterface as createInterface3 } from "readline";
+import { execa as execa3 } from "execa";
+function parseJsonPayload3(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isRecord(parsed)) return parsed;
+  } catch {
+  }
+  return void 0;
+}
+function parseTokenPatchFromPayload3(payload) {
+  const usage = isRecord(payload.usage) ? payload.usage : void 0;
+  return {
+    inputTokens: readNumber(
+      payload.inputTokens ?? payload.input_tokens ?? payload.promptTokens ?? payload.prompt_tokens ?? usage?.inputTokens ?? usage?.input_tokens ?? usage?.promptTokens ?? usage?.prompt_tokens
+    ),
+    outputTokens: readNumber(
+      payload.outputTokens ?? payload.output_tokens ?? payload.completionTokens ?? payload.completion_tokens ?? usage?.outputTokens ?? usage?.output_tokens ?? usage?.completionTokens ?? usage?.completion_tokens
+    ),
+    cumulativeTokens: readNumber(
+      payload.cumulativeTokens ?? payload.cumulative_tokens ?? payload.totalTokens ?? payload.total_tokens ?? usage?.cumulativeTokens ?? usage?.cumulative_tokens ?? usage?.totalTokens ?? usage?.total_tokens
+    )
+  };
+}
+function patchTokenState3(state, patch) {
+  if (patch.inputTokens === void 0 && patch.outputTokens === void 0 && patch.cumulativeTokens === void 0) {
+    return void 0;
+  }
+  state.inputTokens = patch.inputTokens ?? state.inputTokens;
+  state.outputTokens = patch.outputTokens ?? state.outputTokens;
+  const computedTotal = state.inputTokens + state.outputTokens;
+  state.cumulativeTokens = Math.max(
+    state.cumulativeTokens,
+    patch.cumulativeTokens ?? computedTotal
+  );
+  return {
+    type: "tokens",
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    cumulativeTokens: state.cumulativeTokens
+  };
+}
+function parseTokenEvent3(line, payload, state) {
+  if (payload) {
+    return patchTokenState3(state, parseTokenPatchFromPayload3(payload));
+  }
+  const inputMatch = line.match(/(?:input|prompt)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const outputMatch = line.match(/(?:output|completion)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const totalMatch = line.match(/(?:total|cumulative|used)\s*tokens?\s*[:=]\s*(\d+)/i);
+  return patchTokenState3(state, {
+    inputTokens: inputMatch ? Number.parseInt(inputMatch[1], 10) : void 0,
+    outputTokens: outputMatch ? Number.parseInt(outputMatch[1], 10) : void 0,
+    cumulativeTokens: totalMatch ? Number.parseInt(totalMatch[1], 10) : void 0
+  });
+}
+function normalizeFileAction3(value) {
+  if (value !== "create" && value !== "modify" && value !== "delete") return void 0;
+  return value;
+}
+function parseFileEditFromPayload3(payload) {
+  if (payload.type === "file_edit") {
+    const action = normalizeFileAction3(payload.action);
+    const path = readString(payload.path);
+    if (action && path) return { type: "file_edit", action, path };
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  const input = isRecord(payload.input) ? payload.input : void 0;
+  const inputPath = readString(input?.path ?? input?.file_path ?? input?.filePath);
+  if (!tool || !inputPath) return void 0;
+  if (tool === "create_file") return { type: "file_edit", action: "create", path: inputPath };
+  if (tool === "delete_file") return { type: "file_edit", action: "delete", path: inputPath };
+  if (tool === "write_file" || tool === "edit_file" || tool === "replace_file") {
+    return { type: "file_edit", action: "modify", path: inputPath };
+  }
+  return void 0;
+}
+function parseToolUseFromPayload2(payload) {
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  if (!tool) return void 0;
+  return { type: "tool_use", tool, input: payload.input };
+}
+function parseErrorFromPayload2(payload) {
+  if (payload.type !== "error") return void 0;
+  return {
+    type: "error",
+    message: readString(payload.message) ?? "Unknown OpenCode CLI error",
+    recoverable: payload.recoverable !== false
+  };
+}
+function estimateTokenCount3(text) {
+  if (text.length === 0) return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalizeUnknownError3(error, executionId) {
+  if (error instanceof OacError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError("AGENT_TIMEOUT", `OpenCode execution timed out for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError("AGENT_OOM", `OpenCode execution ran out of memory for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/rate.limit|429|too many requests|throttl/i.test(message)) {
+    return executionError("AGENT_RATE_LIMITED", `OpenCode execution rate-limited for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError(
+      "OpenCode execution failed due to network issues",
+      "NETWORK_ERROR",
+      "recoverable",
+      { executionId, message },
+      error
+    );
+  }
+  return executionError("AGENT_EXECUTION_FAILED", `OpenCode execution failed for ${executionId}`, {
+    context: { executionId, message },
+    cause: error
+  });
+}
+function computeTotalTokens3(state) {
+  return Math.max(state.cumulativeTokens, state.inputTokens + state.outputTokens);
+}
+function normalizeExitCode3(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return 1;
+}
+function hasBooleanFlag3(value, key) {
+  if (!isRecord(value)) return false;
+  return value[key] === true;
+}
+function buildFailureMessage3(stdout, stderr) {
+  const trimmedStderr = stderr.trim();
+  if (trimmedStderr.length > 0) return trimmedStderr;
+  const trimmedStdout = stdout.trim();
+  if (trimmedStdout.length > 0) return trimmedStdout;
+  return "OpenCode CLI process exited with a non-zero status.";
+}
+function parseVersion2(output) {
+  const match = output.match(/(\d+\.\d+\.\d+)/);
+  return match ? match[1] : void 0;
+}
+async function estimateContextTokens2(targetFiles) {
+  let totalBytes = 0;
+  for (const filePath of targetFiles) {
+    try {
+      const fileStat = await stat2(filePath);
+      if (fileStat.isFile()) totalBytes += fileStat.size;
+    } catch {
+    }
+  }
+  return Math.ceil(totalBytes / 4);
+}
+var OpenCodeAdapter = class {
+  id = "opencode";
+  name = "OpenCode";
+  runningExecutions = /* @__PURE__ */ new Map();
+  async checkAvailability() {
+    try {
+      const result = await execa3("opencode", ["--version"], { reject: false });
+      if (result.exitCode === 0) {
+        const versionLine = result.stdout.trim().split("\n")[0] ?? "";
+        return {
+          available: true,
+          version: parseVersion2(versionLine)
+        };
+      }
+      return {
+        available: false,
+        error: result.stderr.trim() || result.stdout.trim() || `opencode --version exited with code ${result.exitCode}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { available: false, error: message };
+    }
+  }
+  execute(params) {
+    const startedAt = Date.now();
+    const filesChanged = /* @__PURE__ */ new Set();
+    const tokenState = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cumulativeTokens: 0
+    };
+    const eventQueue = new AsyncEventQueue();
+    const processEnv = {
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ),
+      ...params.env,
+      OAC_TOKEN_BUDGET: `${params.tokenBudget}`,
+      OAC_ALLOW_COMMITS: `${params.allowCommits}`
+    };
+    const subprocess = execa3(
+      "opencode",
+      ["run", "--format", "json", params.prompt],
+      {
+        cwd: params.workingDirectory,
+        env: processEnv,
+        reject: false,
+        timeout: params.timeoutMs
+      }
+    );
+    this.runningExecutions.set(params.executionId, subprocess);
+    const processStdoutLine = (line) => {
+      const payload = parseJsonPayload3(line);
+      const tokenEvent = parseTokenEvent3(line, payload, tokenState);
+      if (tokenEvent?.type === "tokens") {
+        eventQueue.push(tokenEvent);
+      }
+      if (!payload) return;
+      const fileEvent = parseFileEditFromPayload3(payload);
+      if (fileEvent) {
+        filesChanged.add(fileEvent.path);
+        eventQueue.push(fileEvent);
+      }
+      const toolEvent = parseToolUseFromPayload2(payload);
+      if (toolEvent) {
+        eventQueue.push(toolEvent);
+      }
+      const errorEvent = parseErrorFromPayload2(payload);
+      if (errorEvent) {
+        eventQueue.push(errorEvent);
+      }
+    };
+    const consumeStream = async (stream, streamName) => {
+      if (!stream) return;
+      const lineReader = createInterface3({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      for await (const line of lineReader) {
+        eventQueue.push({ type: "output", content: line, stream: streamName });
+        if (streamName === "stdout") {
+          processStdoutLine(line);
+        } else if (/error|failed|exception/i.test(line)) {
+          eventQueue.push({ type: "error", message: line.trim(), recoverable: true });
+        }
+      }
+    };
+    const stdoutDone = consumeStream(subprocess.stdout ?? void 0, "stdout");
+    const stderrDone = consumeStream(subprocess.stderr ?? void 0, "stderr");
+    const resultPromise = (async () => {
+      try {
+        const settled = await subprocess;
+        await Promise.all([stdoutDone, stderrDone]);
+        const timedOut = hasBooleanFlag3(settled, "timedOut");
+        if (timedOut) {
+          const timeoutError = executionError(
+            "AGENT_TIMEOUT",
+            `OpenCode execution timed out for ${params.executionId}`,
+            { context: { executionId: params.executionId, timeoutMs: params.timeoutMs } }
+          );
+          eventQueue.push({ type: "error", message: timeoutError.message, recoverable: true });
+          throw timeoutError;
+        }
+        const canceled = hasBooleanFlag3(settled, "isCanceled");
+        if (canceled) {
+          return {
+            success: false,
+            exitCode: normalizeExitCode3(settled.exitCode),
+            totalTokensUsed: computeTotalTokens3(tokenState),
+            filesChanged: [...filesChanged],
+            duration: Date.now() - startedAt,
+            error: "OpenCode execution was cancelled."
+          };
+        }
+        const exitCode = normalizeExitCode3(settled.exitCode);
+        const success = exitCode === 0;
+        return {
+          success,
+          exitCode,
+          totalTokensUsed: computeTotalTokens3(tokenState),
+          filesChanged: [...filesChanged],
+          duration: Date.now() - startedAt,
+          error: success ? void 0 : buildFailureMessage3(settled.stdout, settled.stderr)
+        };
+      } catch (error) {
+        const normalized = normalizeUnknownError3(error, params.executionId);
+        eventQueue.push({
+          type: "error",
+          message: normalized.message,
+          recoverable: normalized.severity !== "fatal"
+        });
+        eventQueue.fail(normalized);
+        throw normalized;
+      } finally {
+        this.runningExecutions.delete(params.executionId);
+        eventQueue.close();
+      }
+    })();
+    return {
+      executionId: params.executionId,
+      providerId: this.id,
+      events: eventQueue,
+      result: resultPromise,
+      pid: subprocess.pid
+    };
+  }
+  async estimateTokens(params) {
+    const baseTokens = params.targetFiles.length * 2e3;
+    const promptTokens = estimateTokenCount3(params.prompt);
+    const contextTokens = await estimateContextTokens2(params.targetFiles);
+    const expectedOutputTokens = baseTokens;
+    const totalEstimatedTokens = contextTokens + promptTokens + expectedOutputTokens;
+    return {
+      taskId: params.taskId,
+      providerId: this.id,
+      contextTokens,
+      promptTokens,
+      expectedOutputTokens,
+      totalEstimatedTokens,
+      confidence: 0.5,
+      feasible: totalEstimatedTokens < 2e5
+    };
+  }
+  async abort(executionId) {
+    const running = this.runningExecutions.get(executionId);
+    if (!running) return;
+    running.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      running.kill("SIGKILL");
+    }, 3e3);
+    forceKillTimer.unref();
+    try {
+      await running;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+};
+
+// src/execution/agents/registry.ts
+var AdapterRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  /** Well-known aliases (e.g. legacy IDs) that map to canonical provider IDs. */
+  aliases = /* @__PURE__ */ new Map([
+    ["codex-cli", "codex"]
+  ]);
+  /** Register a new adapter factory. Replaces any previous factory for the same ID. */
+  register(id, factory) {
+    this.factories.set(id, factory);
+  }
+  /** Add an alias that maps to an existing canonical ID. */
+  alias(alias, canonicalId) {
+    this.aliases.set(alias, canonicalId);
+  }
+  /** Resolve an ID (including aliases) and return the factory, or `undefined`. */
+  get(rawId) {
+    const canonicalId = this.aliases.get(rawId) ?? rawId;
+    return this.factories.get(canonicalId);
+  }
+  /** Canonical ID after alias resolution. */
+  resolveId(rawId) {
+    return this.aliases.get(rawId) ?? rawId;
+  }
+  /** All registered canonical provider IDs. */
+  registeredIds() {
+    return [...this.factories.keys()];
+  }
+};
+var adapterRegistry = new AdapterRegistry();
+adapterRegistry.register("claude-code", () => new ClaudeCodeAdapter());
+adapterRegistry.register("codex", () => new CodexAdapter());
+adapterRegistry.register("opencode", () => new OpenCodeAdapter());
+
+// src/execution/sandbox.ts
+import { mkdir } from "fs/promises";
+import { join, resolve } from "path";
+import { simpleGit } from "simple-git";
+var worktreeLock = Promise.resolve();
+function withWorktreeLock(fn) {
+  const next = worktreeLock.catch(() => {
+  }).then(fn);
+  worktreeLock = next.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  return next;
+}
+function getWorktreePath(repoPath, branchName) {
+  return resolve(join(repoPath, "..", ".oac-worktrees", branchName));
+}
+var SAFE_BRANCH_RE = /^[a-zA-Z0-9/_.-]+$/;
+async function createSandbox(repoPath, branchName, baseBranch) {
+  if (!SAFE_BRANCH_RE.test(branchName)) {
+    throw executionError("AGENT_EXECUTION_FAILED", `Invalid branch name: ${branchName}`);
+  }
+  if (!SAFE_BRANCH_RE.test(baseBranch)) {
+    throw executionError("AGENT_EXECUTION_FAILED", `Invalid base branch name: ${baseBranch}`);
+  }
+  const worktreePath = getWorktreePath(repoPath, branchName);
+  const worktreeRoot = resolve(join(repoPath, "..", ".oac-worktrees"));
+  const git = simpleGit(repoPath);
+  await withWorktreeLock(async () => {
+    await mkdir(worktreeRoot, { recursive: true });
+    await git.raw(["worktree", "add", worktreePath, "-b", branchName, `origin/${baseBranch}`]);
+  });
+  let cleanedUp = false;
+  return {
+    path: worktreePath,
+    branchName,
+    cleanup: async () => {
+      if (cleanedUp) {
+        return;
+      }
+      cleanedUp = true;
+      await withWorktreeLock(async () => {
+        try {
+          await git.raw(["worktree", "remove", worktreePath, "--force"]);
+        } finally {
+          try {
+            await git.raw(["worktree", "prune"]);
+          } catch {
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/execution/worker.ts
+import { randomUUID } from "crypto";
+
+// src/execution/normalize-error.ts
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function normalizeExecutionError(error, context) {
+  if (error instanceof OacError) {
+    return error;
+  }
+  const message = toErrorMessage(error);
+  const { jobId, taskId, attempt, executionId } = context;
+  const ctx = { taskId };
+  if (jobId) ctx.jobId = jobId;
+  if (executionId) ctx.executionId = executionId;
+  if (attempt !== void 0) ctx.attempt = attempt;
+  ctx.message = message;
+  if (/timed out|timeout/i.test(message)) {
+    return executionError("AGENT_TIMEOUT", `Task ${taskId} timed out during execution.`, {
+      context: ctx,
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError("AGENT_OOM", `Task ${taskId} ran out of memory.`, {
+      context: ctx,
+      cause: error
+    });
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError(
+      `Task ${taskId} failed due to a network error.`,
+      "NETWORK_ERROR",
+      "recoverable",
+      ctx,
+      error
+    );
+  }
+  if (/index\.lock|cannot lock ref|Unable to create '.+?\.git\/index\.lock'/i.test(message)) {
+    return new OacError(
+      `Task ${taskId} failed due to a git lock conflict.`,
+      "GIT_LOCK_FAILED",
+      "recoverable",
+      ctx,
+      error
+    );
+  }
+  if (isRecord(error) && error.name === "AbortError") {
+    return executionError("AGENT_EXECUTION_FAILED", `Task ${taskId} was aborted.`, {
+      context: ctx,
+      cause: error
+    });
+  }
+  return executionError("AGENT_EXECUTION_FAILED", `Task ${taskId} failed during execution.`, {
+    context: ctx,
+    cause: error
+  });
+}
+
+// src/execution/worker.ts
+var DEFAULT_TOKEN_BUDGET = 5e4;
+var DEFAULT_TIMEOUT_MS = 3e5;
+function readPositiveNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function readMetadataNumber(task, key) {
+  return readPositiveNumber(task.metadata[key]);
+}
+function buildTaskPrompt(task) {
+  const fileList = task.targetFiles.length > 0 ? task.targetFiles.join("\n") : "(none provided)";
+  const lines = [
+    "You are implementing a scoped repository contribution task.",
+    `Task ID: ${task.id}`,
+    `Title: ${task.title}`,
+    `Source: ${task.source}`,
+    `Priority: ${task.priority}`,
+    `Complexity: ${task.complexity}`,
+    `Execution mode: ${task.executionMode}`
+  ];
+  if (task.linkedIssue) {
+    lines.push(
+      "",
+      `GitHub Issue #${task.linkedIssue.number}: ${task.linkedIssue.url}`,
+      task.linkedIssue.labels.length > 0 ? `Labels: ${task.linkedIssue.labels.join(", ")}` : "",
+      "Resolve this issue completely. Read the issue description carefully and implement the fix."
+    );
+  }
+  lines.push(
+    "",
+    "Description:",
+    task.description,
+    "",
+    "Target files:",
+    fileList,
+    "",
+    "Apply minimal, safe changes and ensure the repository remains buildable."
+  );
+  return lines.filter((l) => l !== void 0).join("\n");
+}
+function stageFromEvent(event) {
+  switch (event.type) {
+    case "output":
+      return event.stream;
+    case "tokens":
+      return "tokens";
+    case "file_edit":
+      return `file:${event.action}`;
+    case "tool_use":
+      return `tool:${event.tool}`;
+    case "error":
+      return event.recoverable ? "agent-warning" : "agent-error";
+    default:
+      return "running";
+  }
+}
+function mergeExecutionResult(result, observedTokens, observedFiles, startedAt) {
+  for (const changedFile of result.filesChanged) {
+    observedFiles.add(changedFile);
+  }
+  return {
+    success: result.success,
+    exitCode: result.exitCode,
+    totalTokensUsed: Math.max(result.totalTokensUsed, observedTokens),
+    filesChanged: [...observedFiles],
+    duration: result.duration > 0 ? result.duration : Date.now() - startedAt,
+    error: result.error
+  };
+}
+async function executeTask(agent, task, sandbox, eventBus, options = {}) {
+  const executionId = options.executionId ?? randomUUID();
+  const tokenBudget = options.tokenBudget ?? readMetadataNumber(task, "tokenBudget") ?? DEFAULT_TOKEN_BUDGET;
+  const timeoutMs = options.timeoutMs ?? readMetadataNumber(task, "timeoutMs") ?? DEFAULT_TIMEOUT_MS;
+  const allowCommits = options.allowCommits ?? true;
+  const startedAt = Date.now();
+  let observedTokens = 0;
+  const observedFiles = /* @__PURE__ */ new Set();
+  const execution = agent.execute({
+    executionId,
+    workingDirectory: sandbox.path,
+    prompt: buildTaskPrompt(task),
+    targetFiles: task.targetFiles,
+    tokenBudget,
+    allowCommits,
+    timeoutMs
+  });
+  const streamPromise = (async () => {
+    for await (const event of execution.events) {
+      if (event.type === "tokens") {
+        observedTokens = Math.max(observedTokens, event.cumulativeTokens);
+      }
+      if (event.type === "file_edit") {
+        observedFiles.add(event.path);
+      }
+      eventBus.emit("execution:progress", {
+        jobId: executionId,
+        tokensUsed: observedTokens,
+        stage: stageFromEvent(event)
+      });
+    }
+  })();
+  try {
+    const result = await execution.result;
+    await streamPromise;
+    return mergeExecutionResult(result, observedTokens, observedFiles, startedAt);
+  } catch (error) {
+    try {
+      await streamPromise;
+    } catch {
+    }
+    throw normalizeExecutionError(error, { taskId: task.id, executionId });
+  }
+}
+function buildEpicPrompt(epic) {
+  const lines = [
+    "You are implementing a coherent set of changes as a single epic.",
+    `Epic: ${epic.title}`,
+    `Scope: ${epic.scope} module`,
+    "",
+    "Description:",
+    epic.description,
+    "",
+    `Subtasks (${epic.subtasks.length}):`
+  ];
+  for (let i = 0; i < epic.subtasks.length; i++) {
+    const task = epic.subtasks[i];
+    const files = task.targetFiles.length > 0 ? ` [${task.targetFiles.join(", ")}]` : "";
+    lines.push(`  ${i + 1}. ${task.title}${files}`);
+    if (task.description) {
+      lines.push(`     ${task.description}`);
+    }
+  }
+  if (epic.contextFiles.length > 0) {
+    lines.push(
+      "",
+      "Context files to read for understanding:",
+      ...epic.contextFiles.map((f) => `  - ${f}`)
+    );
+  }
+  lines.push(
+    "",
+    "Instructions:",
+    "- Apply all changes in a single coherent commit.",
+    "- Ensure the repository remains buildable after changes.",
+    "- Address all subtasks listed above."
+  );
+  return lines.join("\n");
+}
+function epicAsTask(epic) {
+  const allTargetFiles = [...new Set(epic.subtasks.flatMap((t) => t.targetFiles))];
+  return {
+    id: epic.id,
+    source: epic.subtasks[0]?.source ?? "custom",
+    title: epic.title,
+    description: buildEpicPrompt(epic),
+    targetFiles: allTargetFiles,
+    priority: epic.priority,
+    complexity: epic.subtasks.length >= 7 ? "complex" : epic.subtasks.length >= 4 ? "moderate" : "simple",
+    executionMode: "new-pr",
+    metadata: { epicId: epic.id, subtaskCount: epic.subtasks.length },
+    discoveredAt: epic.createdAt,
+    parentEpicId: void 0
+  };
+}
+
+// src/execution/engine.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { setTimeout as delay } from "timers/promises";
+import PQueue from "p-queue";
+var DEFAULT_CONCURRENCY = 2;
+var DEFAULT_MAX_ATTEMPTS = 2;
+var DEFAULT_TIMEOUT_MS2 = 3e5;
+var DEFAULT_TOKEN_BUDGET2 = 5e4;
+function sanitizeBranchSegment(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
+  return sanitized || "task";
+}
+function isTransientError(error) {
+  return error.code === "AGENT_TIMEOUT" || error.code === "AGENT_OOM" || error.code === "AGENT_RATE_LIMITED" || error.code === "NETWORK_ERROR" || error.code === "GIT_LOCK_FAILED";
+}
+var ExecutionEngine = class {
+  constructor(agents, eventBus, config = {}) {
+    this.agents = agents;
+    this.eventBus = eventBus;
+    if (agents.length === 0) {
+      throw executionError(
+        "AGENT_NOT_AVAILABLE",
+        "ExecutionEngine requires at least one agent provider"
+      );
+    }
+    this.concurrency = Math.max(1, config.concurrency ?? DEFAULT_CONCURRENCY);
+    this.maxAttempts = Math.max(1, config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    this.repoPath = config.repoPath ?? process.cwd();
+    this.baseBranch = config.baseBranch ?? "main";
+    this.branchPrefix = config.branchPrefix ?? "oac";
+    this.taskTimeoutMs = Math.max(1, config.taskTimeoutMs ?? DEFAULT_TIMEOUT_MS2);
+    this.defaultTokenBudget = Math.max(1, config.defaultTokenBudget ?? DEFAULT_TOKEN_BUDGET2);
+    this.queue = new PQueue({
+      concurrency: this.concurrency,
+      autoStart: false
+    });
+  }
+  queue;
+  jobs = /* @__PURE__ */ new Map();
+  activeJobs = /* @__PURE__ */ new Map();
+  concurrency;
+  maxAttempts;
+  repoPath;
+  baseBranch;
+  branchPrefix;
+  taskTimeoutMs;
+  defaultTokenBudget;
+  aborted = false;
+  nextAgentIndex = 0;
+  enqueue(plan) {
+    const enqueuedJobs = [];
+    for (const { task, estimate } of plan.selectedTasks) {
+      const job = {
+        id: randomUUID2(),
+        task,
+        estimate,
+        status: "queued",
+        attempts: 0,
+        maxAttempts: this.maxAttempts,
+        createdAt: Date.now()
+      };
+      this.jobs.set(job.id, job);
+      enqueuedJobs.push(job);
+      this.schedule(job);
+    }
+    return enqueuedJobs;
+  }
+  async run() {
+    this.aborted = false;
+    this.queue.start();
+    await this.queue.onIdle();
+    return this.buildRunResult();
+  }
+  async abort() {
+    this.aborted = true;
+    this.queue.pause();
+    this.queue.clear();
+    const abortError = executionError("AGENT_EXECUTION_FAILED", "Execution aborted by user.");
+    for (const job of this.jobs.values()) {
+      if (job.status === "queued" || job.status === "retrying") {
+        job.status = "aborted";
+        job.completedAt = Date.now();
+        job.error = abortError;
+      }
+    }
+    await Promise.all(
+      [...this.activeJobs.values()].map(async ({ job, agent }) => {
+        job.status = "aborted";
+        job.completedAt = Date.now();
+        job.error = abortError;
+        this.eventBus.emit("execution:failed", {
+          jobId: job.id,
+          error: abortError
+        });
+        try {
+          await agent.abort(job.id);
+        } catch {
+        }
+      })
+    );
+  }
+  schedule(job, delayMs = 0) {
+    void this.queue.add(
+      async () => {
+        if (delayMs > 0) {
+          await delay(delayMs);
+        }
+        await this.runJob(job);
+      },
+      { priority: job.task.priority }
+    ).catch((error) => {
+      const normalized = this.normalizeError(error, job);
+      job.status = "failed";
+      job.completedAt = Date.now();
+      job.error = normalized;
+      this.eventBus.emit("execution:failed", {
+        jobId: job.id,
+        error: normalized
+      });
+    });
+  }
+  async runJob(job) {
+    if (this.aborted || job.status === "aborted") {
+      return;
+    }
+    job.attempts += 1;
+    job.status = "running";
+    job.startedAt ??= Date.now();
+    const agent = this.selectAgent();
+    job.workerId = agent.id;
+    this.activeJobs.set(job.id, { job, agent });
+    this.eventBus.emit("execution:started", {
+      jobId: job.id,
+      task: job.task,
+      agent: agent.id
+    });
+    let sandboxCleanup;
+    try {
+      const branchName = this.createBranchName(job);
+      const sandbox = await createSandbox(this.repoPath, branchName, this.baseBranch);
+      sandboxCleanup = sandbox.cleanup;
+      const result = await executeTask(agent, job.task, sandbox, this.eventBus, {
+        executionId: job.id,
+        tokenBudget: job.estimate.totalEstimatedTokens > 0 ? job.estimate.totalEstimatedTokens : this.defaultTokenBudget,
+        timeoutMs: this.taskTimeoutMs,
+        allowCommits: true
+      });
+      job.result = result;
+      job.completedAt = Date.now();
+      if (result.success) {
+        job.status = "completed";
+        this.eventBus.emit("execution:completed", {
+          jobId: job.id,
+          result
+        });
+        return;
+      }
+      const failure = executionError(
+        "AGENT_EXECUTION_FAILED",
+        result.error ?? `Task ${job.task.id} exited with code ${result.exitCode}.`,
+        {
+          context: {
+            taskId: job.task.id,
+            jobId: job.id,
+            exitCode: result.exitCode,
+            attempt: job.attempts
+          }
+        }
+      );
+      await this.handleFailure(job, failure);
+    } catch (error) {
+      const normalized = this.normalizeError(error, job);
+      await this.handleFailure(job, normalized);
+    } finally {
+      this.activeJobs.delete(job.id);
+      if (sandboxCleanup) {
+        try {
+          await sandboxCleanup();
+        } catch (cleanupError) {
+          const cleanupMessage = toErrorMessage(cleanupError);
+          job.error ??= executionError(
+            "AGENT_EXECUTION_FAILED",
+            `Sandbox cleanup failed for job ${job.id}`,
+            {
+              context: {
+                jobId: job.id,
+                cleanupError: cleanupMessage
+              },
+              cause: cleanupError
+            }
+          );
+        }
+      }
+    }
+  }
+  async handleFailure(job, error) {
+    job.error = error;
+    if (this.aborted || job.status === "aborted") {
+      job.status = "aborted";
+      job.completedAt = Date.now();
+      return;
+    }
+    if (job.attempts < job.maxAttempts && isTransientError(error)) {
+      job.status = "retrying";
+      const retryDelay = error.code === "AGENT_RATE_LIMITED" ? Math.min(6e4, 1e4 * 2 ** (job.attempts - 1)) : Math.min(5e3, job.attempts * 1e3);
+      this.schedule(job, retryDelay);
+      return;
+    }
+    job.status = "failed";
+    job.completedAt = Date.now();
+    this.eventBus.emit("execution:failed", {
+      jobId: job.id,
+      error
+    });
+  }
+  selectAgent() {
+    const agent = this.agents[this.nextAgentIndex % this.agents.length];
+    this.nextAgentIndex = (this.nextAgentIndex + 1) % this.agents.length;
+    return agent;
+  }
+  createBranchName(job) {
+    const dateSegment = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replaceAll("-", "");
+    const taskSegment = sanitizeBranchSegment(job.task.id);
+    return `${this.branchPrefix}/${dateSegment}/${taskSegment}-${job.id.slice(0, 8)}-a${job.attempts}`;
+  }
+  normalizeError(error, job) {
+    return normalizeExecutionError(error, {
+      jobId: job.id,
+      taskId: job.task.id,
+      attempt: job.attempts
+    });
+  }
+  buildRunResult() {
+    const jobs = [...this.jobs.values()];
+    return {
+      jobs,
+      completed: jobs.filter((job) => job.status === "completed"),
+      failed: jobs.filter((job) => job.status === "failed"),
+      aborted: jobs.filter((job) => job.status === "aborted")
+    };
+  }
+};
+
+export {
+  ClaudeCodeAdapter,
+  CodexAdapter,
+  OpenCodeAdapter,
+  adapterRegistry,
+  createSandbox,
+  executeTask,
+  buildEpicPrompt,
+  epicAsTask,
+  isTransientError,
+  ExecutionEngine
+};
+//# sourceMappingURL=chunk-QPVNC7S4.js.map