issue-flow 0.12.0 → 0.14.0

package/dist/chunk-QJ5UZAH5.js

@@ -0,0 +1,2718 @@
+#!/usr/bin/env node
+import {
+  resolveIssuePaths
+} from "./chunk-QK7WUO7A.js";
+import {
+  formatDuration,
+  printWarning
+} from "./chunk-TYRNTSPJ.js";
+import {
+  getGlobalRoot
+} from "./chunk-HAKDLR6N.js";
+import {
+  RETRY_CONFIG_KEYS,
+  getProjectRoot,
+  run
+} from "./chunk-BEZ5BA5U.js";
+import {
+  DEFAULT_TELEMETRY_CONFIG
+} from "./chunk-67YIU2VB.js";
+import {
+  parseCodexUsage,
+  parseUsage
+} from "./chunk-J3SOTUVI.js";
+import {
+  AGENT_PHASES,
+  ANTIGRAVITY_CAPABILITIES,
+  CLAUDE_CAPABILITIES,
+  CODEX_CAPABILITIES,
+  CURSOR_CAPABILITIES,
+  agentConfigInputSchema,
+  globalConfigSchema,
+  isAgentPhase,
+  isAgentProviderId,
+  issuesConfigSchema,
+  parsePhasesInput,
+  policyConfigInputSchema,
+  policyConfigSchema,
+  prReviewConfigSchema,
+  resilienceConfigSchema,
+  routingConfigSchema,
+  telemetryConfigInputSchema,
+  verifyConfigSchema,
+  webConfigSchema
+} from "./chunk-LBGHI4S2.js";
+
+// src/config.ts
+import { existsSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { platform } from "os";
+import { dirname, join as join2 } from "path";
+
+// src/agents/availability.ts
+import { execa as execa6 } from "execa";
+
+// src/agents/registry.ts
+import { execa as execa5 } from "execa";
+
+// src/agents/antigravity.ts
+import { execa as execa2 } from "execa";
+
+// src/core/shutdown.ts
+var SHUTDOWN_GRACE_MS = 15e3;
+var GRACE_POLL_MS = 100;
+var EXIT_CODES = { SIGINT: 130, SIGTERM: 143 };
+var controller = null;
+var installed = false;
+var shuttingDown = false;
+var forced = false;
+var hooks = /* @__PURE__ */ new Set();
+var children = /* @__PURE__ */ new Set();
+function getShutdownSignal() {
+  controller ??= new AbortController();
+  return controller.signal;
+}
+function onShutdown(hook) {
+  hooks.add(hook);
+  return () => {
+    hooks.delete(hook);
+  };
+}
+function registerChild(child) {
+  children.add(child);
+  return () => {
+    children.delete(child);
+  };
+}
+function installShutdownHandlers(options = {}) {
+  if (installed) return;
+  installed = true;
+  const listen = options.onSignal ?? ((signal, handler) => {
+    process.on(signal, handler);
+  });
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    listen(signal, () => {
+      void beginShutdown(signal, options);
+    });
+  }
+}
+async function beginShutdown(reason, options = {}) {
+  const exit = options.exit ?? ((code) => process.exit(code));
+  const notify = options.notify ?? ((message) => process.stderr.write(`${message}
+`));
+  if (shuttingDown) {
+    forced = true;
+    killChildren("SIGKILL");
+    exit(EXIT_CODES[reason]);
+    return;
+  }
+  shuttingDown = true;
+  getShutdownSignal();
+  controller?.abort();
+  notify(
+    `
+Interrupted. Saving a checkpoint and stopping the agent (press ${reason === "SIGINT" ? "Ctrl+C" : "the signal"} again to quit now)\u2026`
+  );
+  await runHooks("checkpoint", reason, notify);
+  await terminateChildren(options.graceMs ?? SHUTDOWN_GRACE_MS);
+  await runHooks("close", reason, notify);
+  exit(EXIT_CODES[reason]);
+}
+async function runHooks(phase, reason, notify) {
+  for (const hook of [...hooks]) {
+    if (hook.phase !== phase) continue;
+    try {
+      await hook.run(reason);
+    } catch (err) {
+      notify(
+        `issue-flow: a shutdown step failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+function killChildren(signal) {
+  for (const child of [...children]) {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+async function terminateChildren(graceMs) {
+  if (children.size === 0) return;
+  const pending = [...children];
+  let alive = pending.length;
+  for (const child of pending) {
+    void child.done.then(
+      () => {
+        alive--;
+      },
+      () => {
+        alive--;
+      }
+    );
+  }
+  killChildren("SIGTERM");
+  const deadline = Date.now() + graceMs;
+  while (alive > 0 && !forced && Date.now() < deadline) {
+    await sleep(GRACE_POLL_MS);
+  }
+  if (alive > 0) killChildren("SIGKILL");
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
+// src/core/watchdog.ts
+var DEFAULT_INACTIVITY_TIMEOUT_MS = 6e5;
+var CHECK_DIVISOR = 10;
+var MIN_CHECK_MS = 250;
+var MAX_CHECK_MS = 5e3;
+function checkIntervalFor(timeoutMs) {
+  return Math.min(MAX_CHECK_MS, Math.max(MIN_CHECK_MS, Math.floor(timeoutMs / CHECK_DIVISOR)));
+}
+function createWatchdog(options = {}) {
+  const timeoutMs = options.inactivityTimeoutMs ?? DEFAULT_INACTIVITY_TIMEOUT_MS;
+  const clock = options.clock ?? Date.now;
+  const start = options.setInterval ?? ((handler, ms) => setInterval(handler, ms));
+  const clear = options.clearInterval ?? ((timer2) => clearInterval(timer2));
+  const state = { stalled: false, silentMs: 0 };
+  if (timeoutMs <= 0) {
+    return {
+      beat: () => {
+      },
+      stop: () => {
+      },
+      get stalled() {
+        return state.stalled;
+      },
+      get silentMs() {
+        return state.silentMs;
+      }
+    };
+  }
+  let lastBeat = clock();
+  let timer = null;
+  let killTimer = null;
+  const stop = () => {
+    if (timer !== null) {
+      clear(timer);
+      timer = null;
+    }
+    if (killTimer !== null) {
+      clearTimeout(killTimer);
+      killTimer = null;
+    }
+  };
+  const declareStalled = () => {
+    state.stalled = true;
+    state.silentMs = clock() - lastBeat;
+    stop();
+    options.onStall?.(state.silentMs);
+    const child = options.child;
+    if (child === void 0) return;
+    child.kill("SIGTERM");
+    killTimer = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, options.graceMs ?? SHUTDOWN_GRACE_MS);
+    killTimer.unref?.();
+    void child.done.then(
+      () => {
+        if (killTimer !== null) {
+          clearTimeout(killTimer);
+          killTimer = null;
+        }
+      },
+      () => {
+      }
+    );
+  };
+  timer = start(() => {
+    if (state.stalled) return;
+    if (clock() - lastBeat > timeoutMs) declareStalled();
+  }, checkIntervalFor(timeoutMs));
+  timer.unref?.();
+  return {
+    beat: () => {
+      lastBeat = clock();
+    },
+    stop,
+    get stalled() {
+      return state.stalled;
+    },
+    get silentMs() {
+      return state.silentMs;
+    }
+  };
+}
+function describeStall(silentMs, provider = "claude") {
+  return `${provider} produced no output for ${Math.round(silentMs / 1e3)}s and was stopped (stalled)`;
+}
+
+// src/agents/claude.ts
+import { execa } from "execa";
+
+// src/core/stream.ts
+import { createInterface } from "readline";
+async function readClaudeStream(stdout, options = {}) {
+  const outcome = { result: "", isError: false, usage: null, events: 0, raw: "" };
+  const collected = [];
+  const lines = createInterface({ input: stdout });
+  for await (const line of lines) {
+    options.onLine?.(line);
+    if (line.trim() === "") continue;
+    outcome.events++;
+    collected.push(line);
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof event !== "object" || event === null) continue;
+    const record = event;
+    options.onEvent?.(record);
+    if (record.type === "result") {
+      outcome.result = typeof record.result === "string" ? record.result : "";
+      outcome.isError = record.is_error === true;
+      outcome.usage = parseUsage(record) ?? outcome.usage;
+    }
+  }
+  outcome.raw = collected.join("\n");
+  return outcome;
+}
+
+// src/agents/argv.ts
+function pushRepeatedFlag(args, flag, values) {
+  if (!values || values.length === 0) return;
+  for (const value of values) {
+    args.push(flag, value);
+  }
+}
+function formatCodexConfigValue(value) {
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (/^[A-Za-z0-9_.-]+$/.test(value)) return value;
+  return JSON.stringify(value);
+}
+
+// src/agents/process.ts
+var TIMEOUT_ATTRIBUTION_RATIO = 0.9;
+function reachedTimeout(timeoutMs, elapsedMs) {
+  return timeoutMs > 0 && elapsedMs >= timeoutMs * TIMEOUT_ATTRIBUTION_RATIO;
+}
+function wasTimedOut(proc, timeoutMs, elapsedMs) {
+  if (proc.timedOut === true) return true;
+  if (!reachedTimeout(timeoutMs, elapsedMs)) return false;
+  return proc.signal === "SIGTERM" || proc.signal === "SIGKILL" || proc.exitCode === 143 || proc.exitCode === 137;
+}
+function describeAgentFailure(proc, diagnostics, timeoutMs, elapsedMs, command) {
+  if (wasTimedOut(proc, timeoutMs, elapsedMs)) {
+    return `Headless invocation timed out after ${formatDuration(Math.round(timeoutMs / 1e3))}. Raise the limit with --timeout <seconds> (0 = no limit).`;
+  }
+  return diagnostics.trim() || `${command} exited with code ${proc.exitCode ?? "unknown"}`;
+}
+
+// src/agents/claude.ts
+var READ_ONLY_DENIED_TOOLS = [
+  "Agent",
+  "Task",
+  "Monitor",
+  "NotebookEdit",
+  "Edit",
+  "Write"
+];
+function toolContext(name, input) {
+  switch (name) {
+    case "Read":
+    case "Write":
+    case "Edit":
+      return shortPath(typeof input.file_path === "string" ? input.file_path : void 0);
+    case "Glob":
+    case "Grep":
+      return typeof input.pattern === "string" ? input.pattern : "";
+    case "Bash": {
+      const cmd = typeof input.command === "string" ? input.command : "";
+      return cmd.length > 60 ? `${cmd.substring(0, 57)}...` : cmd;
+    }
+    default:
+      return "";
+  }
+}
+function shortPath(filePath) {
+  if (!filePath) return "";
+  const cwd = process.cwd();
+  if (filePath.startsWith(cwd)) return filePath.substring(cwd.length + 1);
+  const parts = filePath.split("/");
+  return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : filePath;
+}
+function emitClaudeEvent(event, onEvent) {
+  if (!onEvent) return;
+  if (event.type !== "assistant") return;
+  const message = event.message;
+  if (typeof message !== "object" || message === null) return;
+  const content = message.content;
+  if (!Array.isArray(content)) return;
+  for (const block of content) {
+    if (typeof block !== "object" || block === null) continue;
+    const item = block;
+    if (item.type === "text" && item.text) {
+      onEvent({ kind: "text", text: item.text });
+    }
+    if (item.type === "tool_use" && item.name) {
+      const detail = item.input ? toolContext(item.name, item.input) : "";
+      onEvent({ kind: "tool", name: item.name, ...detail ? { detail } : {} });
+    }
+  }
+}
+function buildClaudeArgv(invocation, settings) {
+  if (invocation.permission === "autonomous") {
+    const args2 = [
+      "--dangerously-skip-permissions",
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    if (settings.model) args2.push("--model", settings.model);
+    if (settings.claude.ignoreUserConfig === true) {
+      args2.push("--setting-sources", "project");
+      if (settings.claude.strictMcpConfig !== false) {
+        args2.push("--strict-mcp-config");
+      }
+    }
+    pushRepeatedFlag(args2, "--add-dir", invocation.addDirs);
+    return { args: args2, stdinMode: "prompt" };
+  }
+  const maxTurns = invocation.maxTurns ?? 10;
+  const args = [
+    "-p",
+    invocation.prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--max-turns",
+    String(maxTurns)
+  ];
+  pushRepeatedFlag(args, "--allowedTools", invocation.allowedTools);
+  pushRepeatedFlag(args, "--add-dir", invocation.addDirs);
+  if (invocation.permission === "read-only") {
+    args.push("--permission-mode", "plan");
+    const allowed = new Set(invocation.allowedTools ?? []);
+    const denied = READ_ONLY_DENIED_TOOLS.filter((tool) => !allowed.has(tool));
+    if (denied.length > 0) {
+      args.push("--disallowedTools", ...denied);
+    }
+  }
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.claude.ignoreUserConfig === true) {
+    args.push("--setting-sources", "project");
+    if (settings.claude.strictMcpConfig !== false) {
+      args.push("--strict-mcp-config");
+    }
+  }
+  return { args, stdinMode: "ignore" };
+}
+var ClaudeCodeRunner = class {
+  id = "claude";
+  capabilities = CLAUDE_CAPABILITIES;
+  versionCommand() {
+    return { command: "claude", args: ["--version"] };
+  }
+  async run(invocation, settings) {
+    const { args, stdinMode } = buildClaudeArgv(invocation, settings);
+    const execaOptions = {
+      reject: false,
+      timeout: invocation.timeout,
+      stripFinalNewline: false,
+      ...stdinMode === "prompt" ? { input: invocation.prompt } : { stdin: "ignore" },
+      ...invocation.workingDirectory ? { cwd: invocation.workingDirectory } : {}
+    };
+    const startTime = Date.now();
+    const agent = { provider: this.id, model: settings.model };
+    const base = {
+      agent,
+      harnessVersion: peekHarnessVersion(this.id)
+    };
+    let cleanup = null;
+    try {
+      const subprocess = execa("claude", args, execaOptions);
+      const unregister = registerChild({
+        kill: (signal) => subprocess.kill(signal),
+        done: subprocess.then(
+          () => void 0,
+          () => void 0
+        )
+      });
+      const watchdog = createWatchdog({
+        ...invocation.inactivityTimeoutMs === void 0 ? {} : { inactivityTimeoutMs: invocation.inactivityTimeoutMs },
+        child: {
+          kill: (signal) => subprocess.kill(signal),
+          done: subprocess.then(
+            () => void 0,
+            () => void 0
+          )
+        }
+      });
+      cleanup = () => {
+        watchdog.stop();
+        unregister();
+      };
+      let streamed = {
+        result: "",
+        isError: false,
+        usage: null,
+        events: 0,
+        raw: ""
+      };
+      if (subprocess.stdout) {
+        streamed = await readClaudeStream(subprocess.stdout, {
+          onLine: (line) => {
+            watchdog.beat();
+            invocation.onLine?.(line);
+          },
+          onEvent: (event) => emitClaudeEvent(event, invocation.onEvent)
+        });
+      }
+      const proc = await subprocess;
+      watchdog.stop();
+      unregister();
+      const stdout = streamed.raw === "" ? proc.stdout?.toString() ?? "" : streamed.raw;
+      const stderr = proc.stderr?.toString() ?? "";
+      const rawOutput = stdout + (stderr ? `
+${stderr}` : "");
+      const exitCode = proc.exitCode ?? 1;
+      const elapsedMs = Date.now() - startTime;
+      if (watchdog.stalled) {
+        return {
+          success: false,
+          result: "",
+          rawOutput: describeStall(watchdog.silentMs),
+          exitCode: exitCode === 0 ? 1 : exitCode,
+          usage: null,
+          error: describeStall(watchdog.silentMs),
+          ...base
+        };
+      }
+      if (exitCode !== 0) {
+        return {
+          success: false,
+          result: "",
+          rawOutput,
+          exitCode,
+          usage: null,
+          error: describeAgentFailure(
+            proc,
+            stderr || stdout,
+            invocation.timeout,
+            elapsedMs,
+            "claude"
+          ),
+          ...base
+        };
+      }
+      if (streamed.result !== "") {
+        return {
+          success: !streamed.isError,
+          result: streamed.result,
+          rawOutput,
+          exitCode,
+          usage: streamed.usage,
+          error: streamed.isError ? streamed.result : null,
+          ...base
+        };
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        const resultText = typeof parsed.result === "string" ? parsed.result : stdout;
+        const isError = parsed.is_error === true;
+        return {
+          success: !isError,
+          result: resultText,
+          rawOutput,
+          exitCode,
+          usage: parseUsage(parsed),
+          error: isError ? resultText : null,
+          ...base
+        };
+      } catch {
+        return {
+          success: true,
+          result: rawOutput,
+          rawOutput,
+          exitCode,
+          usage: null,
+          error: null,
+          ...base
+        };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const elapsedMs = Date.now() - startTime;
+      const timedOut = message.includes("timed out") || message.includes("ETIMEDOUT");
+      return {
+        success: false,
+        result: "",
+        rawOutput: message,
+        exitCode: 1,
+        usage: null,
+        error: timedOut ? describeAgentFailure(
+          { timedOut: reachedTimeout(invocation.timeout, elapsedMs) },
+          message,
+          invocation.timeout,
+          elapsedMs,
+          "claude"
+        ) : message,
+        ...base
+      };
+    } finally {
+      cleanup?.();
+    }
+  }
+};
+var harnessVersions = /* @__PURE__ */ new Map();
+function peekHarnessVersion(id) {
+  return harnessVersions.has(id) ? harnessVersions.get(id) ?? null : void 0;
+}
+function cacheHarnessVersion(id, version) {
+  harnessVersions.set(id, version);
+}
+
+// src/agents/antigravity.ts
+var ANTIGRAVITY_MIN_VERSION = "1.1.22";
+var DEFAULT_EXECUTE_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+var DEFAULT_MAX_PROMPT_BYTES = 1e5;
+var TOOL_NAMES = {
+  run_command: "Bash",
+  command_status: "Bash",
+  view_file: "Read",
+  read_resource: "Read",
+  write_to_file: "Edit",
+  replace_file_content: "Edit",
+  multi_replace_file_content: "Edit",
+  notebook_edit: "Edit",
+  grep_search: "Grep",
+  find_by_name: "Glob",
+  list_dir: "Glob",
+  read_url_content: "WebFetch",
+  open_browser_url: "WebFetch"
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function formatPrintTimeout(ms) {
+  const totalSeconds = Math.max(1, Math.round(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  let out = "";
+  if (hours > 0) out += `${hours}h`;
+  if (minutes > 0 || hours > 0) out += `${minutes}m`;
+  out += `${seconds}s`;
+  return out;
+}
+function parseDurationMs(value) {
+  if (value === void 0) return DEFAULT_EXECUTE_TIMEOUT_MS;
+  if (value === null) return null;
+  if (typeof value === "number") return value > 0 ? value : null;
+  const trimmed = value.trim();
+  if (trimmed === "" || trimmed === "0") return null;
+  const match = trimmed.match(/^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?$/);
+  if (!match || match[0] === "") return null;
+  const hours = Number(match[1] ?? 0);
+  const minutes = Number(match[2] ?? 0);
+  const seconds = Number(match[3] ?? 0);
+  const ms = ((hours * 60 + minutes) * 60 + seconds) * 1e3;
+  return ms > 0 ? ms : null;
+}
+function resolveAntigravityTimeoutMs(invocation, settings) {
+  if (invocation.timeout > 0) return invocation.timeout;
+  return parseDurationMs(settings.antigravity.executeTimeout);
+}
+function compareVersions(actual, minimum) {
+  const left = actual.replace(/^v/i, "").split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+  const right = minimum.replace(/^v/i, "").split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i++) {
+    const a = left[i] ?? 0;
+    const b = right[i] ?? 0;
+    if (a > b) return 1;
+    if (a < b) return -1;
+  }
+  return 0;
+}
+function normalizeAntigravityTool(name) {
+  if (name.startsWith("call_mcp_tool")) return name;
+  return TOOL_NAMES[name] ?? name;
+}
+function parseAntigravityUsage(usage, numTurns) {
+  if (!isRecord(usage)) return null;
+  if (numTurns === 0) return null;
+  const input = usage.input_tokens;
+  const output = usage.output_tokens;
+  const cacheRead = usage.cache_read_tokens;
+  const result = {};
+  if (typeof input === "number" && Number.isFinite(input)) result.inputTokens = input;
+  if (typeof output === "number" && Number.isFinite(output)) result.outputTokens = output;
+  if (typeof cacheRead === "number" && Number.isFinite(cacheRead)) {
+    result.cacheReadTokens = cacheRead;
+  }
+  if (typeof numTurns === "number" && Number.isFinite(numTurns)) result.numTurns = numTurns;
+  if (Object.keys(result).length === 0) return null;
+  return result;
+}
+function isPermissionDenial(message) {
+  return /permission check failed|user denied permission/i.test(message);
+}
+function mainParameter(parameters) {
+  for (const key of ["CommandLine", "TargetFile", "Path", "Query", "Url", "url"]) {
+    const value = parameters[key];
+    if (typeof value === "string" && value !== "") {
+      return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+    }
+  }
+  return "";
+}
+function consumeAntigravityEvent(event, onEvent, acc) {
+  if (event.event === "init") {
+    if (typeof event.conversation_id === "string") acc.sessionId = event.conversation_id;
+    return;
+  }
+  if (event.event === "step_update") {
+    const step = isRecord(event.step_update) ? event.step_update : {};
+    if (typeof step.text_delta === "string" && step.text_delta !== "") {
+      onEvent?.({ kind: "text", text: step.text_delta });
+    }
+    if (step.step_type === "tool") {
+      const rawName = typeof step.tool_name === "string" ? step.tool_name : "tool";
+      const info = isRecord(step.tool_info) ? step.tool_info : {};
+      const parameters = isRecord(info.parameters) ? info.parameters : {};
+      const detail = mainParameter(parameters);
+      const name = rawName === "call_mcp_tool" ? mcpToolName(parameters) : normalizeAntigravityTool(rawName);
+      if (step.state === "ACTIVE") {
+        onEvent?.({ kind: "tool", name, ...detail === "" ? {} : { detail } });
+      }
+      if (step.state === "ERROR") {
+        const err = isRecord(info.error) ? info.error : {};
+        const message = typeof err.message === "string" ? err.message : "TOOL_ERROR";
+        if (isPermissionDenial(message)) {
+          acc.permissionDenied = { tool: rawName, message };
+        } else {
+          acc.warnings.push(`TOOL_ERROR on ${rawName}: ${message}`);
+        }
+      }
+    }
+    return;
+  }
+  if (event.event === "result") {
+    acc.seenResult = true;
+    const result = isRecord(event.result) ? event.result : event;
+    if (typeof result.conversation_id === "string") acc.sessionId = result.conversation_id;
+    if (typeof result.response === "string") acc.result = result.response;
+    if (typeof result.error === "string" && result.error !== "") acc.error = result.error;
+    if (typeof result.status === "string") {
+      acc.status = result.status;
+    }
+    const numTurns = typeof result.num_turns === "number" ? result.num_turns : void 0;
+    acc.usage = parseAntigravityUsage(result.usage, numTurns);
+  }
+}
+function mcpToolName(parameters) {
+  const server = typeof parameters.server === "string" ? parameters.server : "";
+  const tool = typeof parameters.tool === "string" ? parameters.tool : "";
+  if (server && tool) return `${server}/${tool}`;
+  if (tool) return tool;
+  if (server) return server;
+  return "call_mcp_tool";
+}
+function parseAntigravityStream(raw, onEvent) {
+  const acc = {
+    result: "",
+    status: null,
+    sessionId: null,
+    model: null,
+    usage: null,
+    seenResult: false,
+    permissionDenied: null,
+    warnings: [],
+    error: null
+  };
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (!isRecord(event)) continue;
+      consumeAntigravityEvent(event, onEvent, acc);
+    } catch {
+    }
+  }
+  return acc;
+}
+function maxPromptBytesOf(settings) {
+  return settings.maxPromptBytes ?? DEFAULT_MAX_PROMPT_BYTES;
+}
+function buildAntigravityArgv(invocation, settings) {
+  const timeoutMs = resolveAntigravityTimeoutMs(invocation, settings);
+  if (timeoutMs === null) {
+    return {
+      error: "configuration: Antigravity has nativeTimeout and received timeout: 0 without a ceiling. Set agent.antigravity.executeTimeout (default 4h)."
+    };
+  }
+  const promptBytes = Buffer.byteLength(invocation.prompt, "utf8");
+  const limit = maxPromptBytesOf(settings.antigravity);
+  if (promptBytes > limit) {
+    return {
+      error: `configuration: prompt exceeds Antigravity argv limit (${promptBytes} bytes > ${limit} maxPromptBytes). The promptChannel is argv; shorten the prompt or raise agent.antigravity.maxPromptBytes.`
+    };
+  }
+  const workspace = invocation.workingDirectory ?? process.cwd();
+  const args = [
+    "-p",
+    invocation.prompt,
+    "--output-format",
+    "stream-json",
+    "--print-timeout",
+    formatPrintTimeout(timeoutMs),
+    "--add-dir",
+    workspace,
+    "--dangerously-skip-permissions",
+    "--disable-slash-commands",
+    "--mode",
+    invocation.permission === "read-only" ? "plan" : "accept-edits"
+  ];
+  for (const dir of invocation.addDirs ?? []) {
+    args.push("--add-dir", dir);
+  }
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.antigravity.effort) args.push("--effort", settings.antigravity.effort);
+  if (settings.antigravity.sandbox === true) args.push("--sandbox");
+  return { command: "agy", args };
+}
+function antigravityRunVerdict(input) {
+  if (input.parsed.permissionDenied) {
+    return {
+      success: false,
+      error: `configuration: permission check failed for ${input.parsed.permissionDenied.tool}. --dangerously-skip-permissions is required so Antigravity does not finish SUCCESS without writing. ${input.parsed.permissionDenied.message}`
+    };
+  }
+  if (input.parsed.status === "WAITING") {
+    return {
+      success: false,
+      error: "configuration: Antigravity ended waiting for human input (status: WAITING). Headless runs cannot continue from a prompt."
+    };
+  }
+  if (input.parsed.status === "CANCELED" || input.parsed.status === "INTERRUPTED") {
+    return { success: false, error: `Antigravity was ${input.parsed.status.toLowerCase()}.` };
+  }
+  if (!input.parsed.seenResult) {
+    return {
+      success: false,
+      error: "configuration: Antigravity finished without a result event in the stream."
+    };
+  }
+  if (input.parsed.status === "ERROR" || input.parsed.status !== "SUCCESS" || input.exitCode !== 0 || input.timedOut) {
+    return {
+      success: false,
+      error: input.parsed.error ?? `agy exited with code ${input.exitCode}`
+    };
+  }
+  return { success: true, error: null };
+}
+function configurationFailure(agent, message, rawOutput = message) {
+  return {
+    success: false,
+    result: "",
+    rawOutput,
+    exitCode: 1,
+    usage: null,
+    error: message,
+    agent,
+    harnessVersion: peekHarnessVersion("antigravity")
+  };
+}
+var AntigravityRunner = class {
+  id = "antigravity";
+  capabilities = ANTIGRAVITY_CAPABILITIES;
+  versionCommand() {
+    return { command: "agy", args: ["--version"] };
+  }
+  async run(invocation, settings) {
+    const agent = { provider: this.id, model: settings.model };
+    const built = buildAntigravityArgv(invocation, settings);
+    if ("error" in built) return configurationFailure(agent, built.error);
+    const minimum = settings.antigravity.minVersion ?? ANTIGRAVITY_MIN_VERSION;
+    const installed2 = peekHarnessVersion(this.id);
+    if (typeof installed2 === "string" && compareVersions(installed2, minimum) < 0) {
+      return configurationFailure(
+        agent,
+        `configuration: agy ${installed2} is below the minimum ${minimum}. Update Antigravity CLI.`
+      );
+    }
+    const { command, args } = built;
+    const startTime = Date.now();
+    const timeoutMs = resolveAntigravityTimeoutMs(invocation, settings) ?? invocation.timeout;
+    let cleanup = null;
+    try {
+      const subprocess = execa2(command, args, {
+        reject: false,
+        timeout: timeoutMs > 0 ? timeoutMs : void 0,
+        stripFinalNewline: false,
+        stdin: "ignore",
+        ...invocation.workingDirectory ? { cwd: invocation.workingDirectory } : {}
+      });
+      const unregister = registerChild({
+        kill: (signal) => subprocess.kill(signal),
+        done: subprocess.then(
+          () => void 0,
+          () => void 0
+        )
+      });
+      const watchdog = createWatchdog({
+        ...invocation.inactivityTimeoutMs === void 0 ? {} : { inactivityTimeoutMs: invocation.inactivityTimeoutMs },
+        child: {
+          kill: (signal) => subprocess.kill(signal),
+          done: subprocess.then(
+            () => void 0,
+            () => void 0
+          )
+        }
+      });
+      cleanup = () => {
+        watchdog.stop();
+        unregister();
+      };
+      const chunks = [];
+      if (subprocess.stdout) {
+        subprocess.stdout.on("data", (chunk) => {
+          watchdog.beat();
+          const text = chunk.toString();
+          chunks.push(text);
+          invocation.onLine?.(text);
+        });
+      }
+      if (subprocess.stderr) {
+        subprocess.stderr.on("data", () => {
+          watchdog.beat();
+        });
+      }
+      const proc = await subprocess;
+      watchdog.stop();
+      unregister();
+      const stdout = chunks.join("") || proc.stdout?.toString() || "";
+      const stderr = proc.stderr?.toString() ?? "";
+      const parsed = parseAntigravityStream(stdout, invocation.onEvent);
+      const warningBlock = parsed.warnings.length > 0 ? `
+${parsed.warnings.join("\n")}` : "";
+      const rawOutput = stdout + (stderr ? `
+${stderr}` : "") + warningBlock;
+      const exitCode = proc.exitCode ?? 1;
+      const elapsedMs = Date.now() - startTime;
+      const timedOut = wasTimedOut(proc, timeoutMs, elapsedMs);
+      const stalled = watchdog.stalled;
+      const authFailed = /not logged into antigravity|authentication required/i.test(
+        `${stderr}
+${stdout}`
+      );
+      if (stalled) {
+        return {
+          success: false,
+          result: "",
+          rawOutput: describeStall(watchdog.silentMs, "agy"),
+          exitCode: 1,
+          usage: parsed.usage,
+          error: describeStall(watchdog.silentMs, "agy"),
+          agent: { provider: this.id, model: parsed.model ?? settings.model },
+          sessionId: parsed.sessionId ?? void 0,
+          harnessVersion: peekHarnessVersion(this.id)
+        };
+      }
+      if (authFailed) {
+        return {
+          success: false,
+          result: parsed.result,
+          rawOutput,
+          exitCode: timedOut ? 1 : exitCode,
+          usage: parsed.usage,
+          error: stderr.trim() || "You are not logged into Antigravity.",
+          agent: { provider: this.id, model: parsed.model ?? settings.model },
+          sessionId: parsed.sessionId ?? void 0,
+          harnessVersion: peekHarnessVersion(this.id)
+        };
+      }
+      const verdict = antigravityRunVerdict({ exitCode, parsed, timedOut });
+      if (!verdict.success) {
+        return {
+          success: false,
+          result: parsed.result,
+          rawOutput,
+          exitCode: timedOut || exitCode === 0 && verdict.error?.startsWith("configuration:") === true ? 1 : exitCode,
+          usage: parsed.usage,
+          error: timedOut ? describeAgentFailure(proc, stderr || rawOutput, timeoutMs, elapsedMs, command) : verdict.error ?? parsed.error ?? (stderr.trim() || rawOutput),
+          agent: { provider: this.id, model: parsed.model ?? settings.model },
+          sessionId: parsed.sessionId ?? void 0,
+          harnessVersion: peekHarnessVersion(this.id)
+        };
+      }
+      return {
+        success: true,
+        result: parsed.result,
+        rawOutput,
+        exitCode,
+        usage: parsed.usage,
+        error: null,
+        agent: { provider: this.id, model: parsed.model ?? settings.model },
+        sessionId: parsed.sessionId ?? void 0,
+        harnessVersion: peekHarnessVersion(this.id)
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const missing = /ENOENT|not found|command not found/i.test(message);
+      return configurationFailure(
+        agent,
+        missing ? "configuration: agy is not installed. Install Antigravity CLI: https://antigravity.google/docs/cli/install/" : message
+      );
+    } finally {
+      cleanup?.();
+    }
+  }
+};
+
+// src/agents/codex.ts
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { execa as execa3 } from "execa";
+var BANNED_CODEX_FLAGS = [
+  "--dangerously-bypass-approvals-and-sandbox",
+  "--dangerously-bypass-hook-trust"
+];
+function sandboxFor(permission, configured) {
+  if (configured === "danger-full-access") return "danger-full-access";
+  if (permission === "read-only") return "read-only";
+  return "workspace-write";
+}
+function shortPath2(filePath) {
+  if (!filePath) return "";
+  const cwd = process.cwd();
+  if (filePath.startsWith(cwd)) return filePath.substring(cwd.length + 1);
+  const parts = filePath.split("/");
+  return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : filePath;
+}
+function truncateCommand(command) {
+  return command.length > 60 ? `${command.substring(0, 57)}...` : command;
+}
+function buildCodexArgv(invocation, settings, outputFile) {
+  const sandbox = sandboxFor(invocation.permission, settings.codex.sandbox);
+  if (sandbox === "danger-full-access") {
+    printWarning(
+      'agent.codex.sandbox is "danger-full-access": the Codex sandbox is off for this invocation.'
+    );
+  }
+  const args = [
+    "exec",
+    "--json",
+    "--output-last-message",
+    outputFile,
+    "--sandbox",
+    sandbox,
+    "--color",
+    "never"
+  ];
+  if (invocation.workingDirectory) args.push("--cd", invocation.workingDirectory);
+  pushRepeatedFlag(args, "--add-dir", invocation.addDirs);
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.codex.reasoningEffort) {
+    args.push("-c", `model_reasoning_effort=${settings.codex.reasoningEffort}`);
+  }
+  if (settings.codex.ignoreUserConfig === true) args.push("--ignore-user-config");
+  if (settings.codex.skipGitRepoCheck === true) args.push("--skip-git-repo-check");
+  for (const [key, value] of Object.entries(settings.codex.configOverrides ?? {})) {
+    args.push("-c", `${key}=${formatCodexConfigValue(value)}`);
+  }
+  args.push("-");
+  for (const banned of BANNED_CODEX_FLAGS) {
+    if (args.includes(banned)) {
+      throw new Error(`Internal error: banned Codex flag ${banned} reached argv.`);
+    }
+  }
+  return args;
+}
+function emptyCodexState() {
+  return {
+    result: "",
+    lastAgentMessage: "",
+    usage: null,
+    failed: false,
+    error: null,
+    completed: false
+  };
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function consumeCodexEvent(event, state, onEvent) {
+  const type = event.type;
+  if (type === "thread.started" && typeof event.thread_id === "string") {
+    state.sessionId = event.thread_id;
+    return;
+  }
+  if (type === "turn.completed") {
+    state.completed = true;
+    state.usage = parseCodexUsage(event.usage) ?? state.usage;
+    return;
+  }
+  if (type === "turn.failed") {
+    state.failed = true;
+    const err = asRecord(event.error);
+    state.error = typeof err?.message === "string" ? err.message : "turn.failed";
+    return;
+  }
+  if (type === "error") {
+    state.failed = true;
+    state.error = typeof event.message === "string" ? event.message : "error";
+    return;
+  }
+  const item = asRecord(event.item);
+  if (!item) return;
+  const itemType = item.type;
+  if (type === "item.completed" && itemType === "agent_message" && typeof item.text === "string") {
+    state.lastAgentMessage = item.text;
+    onEvent?.({ kind: "text", text: item.text });
+    return;
+  }
+  if (type === "item.completed" && itemType === "error" && typeof item.message === "string") {
+    onEvent?.({ kind: "text", text: item.message });
+    return;
+  }
+  if (type === "item.started" && itemType === "command_execution") {
+    const command = typeof item.command === "string" ? item.command : "";
+    onEvent?.({ kind: "tool", name: "Bash", detail: truncateCommand(command) });
+    return;
+  }
+  if (type === "item.started" && itemType === "file_change") {
+    const changes = Array.isArray(item.changes) ? item.changes : [];
+    const first = asRecord(changes[0]);
+    const path = typeof first?.path === "string" ? first.path : "";
+    onEvent?.({ kind: "tool", name: "Edit", detail: shortPath2(path) });
+    return;
+  }
+  if (type === "item.completed" && itemType === "web_search") {
+    const query = typeof item.query === "string" ? item.query : "";
+    onEvent?.({ kind: "tool", name: "WebSearch", ...query ? { detail: query } : {} });
+    return;
+  }
+  if (type === "item.completed" && itemType === "mcp_tool_call") {
+    const server = typeof item.server === "string" ? item.server : "";
+    const tool = typeof item.tool === "string" ? item.tool : "";
+    const name = [server, tool].filter(Boolean).join(".") || "mcp";
+    onEvent?.({ kind: "tool", name });
+  }
+}
+function parseCodexStream(lines, onEvent) {
+  const state = emptyCodexState();
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = asRecord(event);
+    if (!record) continue;
+    consumeCodexEvent(record, state, onEvent);
+  }
+  return state;
+}
+var CodexRunner = class {
+  id = "codex";
+  capabilities = CODEX_CAPABILITIES;
+  versionCommand() {
+    return { command: "codex", args: ["--version"] };
+  }
+  authCommand() {
+    return { command: "codex", args: ["login", "status"] };
+  }
+  async run(invocation, settings) {
+    const tmp = await mkdtemp(join(tmpdir(), "issue-flow-codex-"));
+    const outputFile = join(tmp, "last-message.txt");
+    const args = buildCodexArgv(invocation, settings, outputFile);
+    const agent = { provider: this.id, model: settings.model };
+    const base = { agent, harnessVersion: peekHarnessVersion(this.id) };
+    const startTime = Date.now();
+    let cleanup = null;
+    try {
+      const subprocess = execa3("codex", args, {
+        input: invocation.prompt,
+        reject: false,
+        timeout: invocation.timeout,
+        stripFinalNewline: false,
+        ...invocation.workingDirectory ? { cwd: invocation.workingDirectory } : {}
+      });
+      const unregister = registerChild({
+        kill: (signal) => subprocess.kill(signal),
+        done: subprocess.then(
+          () => void 0,
+          () => void 0
+        )
+      });
+      const watchdog = createWatchdog({
+        ...invocation.inactivityTimeoutMs === void 0 ? {} : { inactivityTimeoutMs: invocation.inactivityTimeoutMs },
+        child: {
+          kill: (signal) => subprocess.kill(signal),
+          done: subprocess.then(
+            () => void 0,
+            () => void 0
+          )
+        }
+      });
+      cleanup = () => {
+        watchdog.stop();
+        unregister();
+      };
+      const collected = [];
+      if (subprocess.stdout) {
+        const { createInterface: createInterface2 } = await import("readline");
+        const lines = createInterface2({ input: subprocess.stdout });
+        for await (const line of lines) {
+          watchdog.beat();
+          invocation.onLine?.(line);
+          if (line.trim() !== "") collected.push(line);
+        }
+      }
+      const proc = await subprocess;
+      watchdog.stop();
+      unregister();
+      const stdout = collected.join("\n");
+      const stderr = proc.stderr?.toString() ?? "";
+      const rawOutput = stdout + (stderr ? `
+${stderr}` : "");
+      const exitCode = proc.exitCode ?? 1;
+      const elapsedMs = Date.now() - startTime;
+      const parsed = parseCodexStream(collected, invocation.onEvent);
+      let lastMessage = "";
+      try {
+        lastMessage = (await readFile(outputFile, "utf-8")).trimEnd();
+      } catch {
+        lastMessage = "";
+      }
+      const resultText = lastMessage || parsed.lastAgentMessage;
+      if (watchdog.stalled) {
+        return {
+          success: false,
+          result: "",
+          rawOutput: describeStall(watchdog.silentMs, "codex"),
+          exitCode: exitCode === 0 ? 1 : exitCode,
+          usage: null,
+          error: describeStall(watchdog.silentMs, "codex"),
+          sessionId: parsed.sessionId,
+          ...base
+        };
+      }
+      const failureText = describeAgentFailure(
+        proc,
+        stderr || stdout,
+        invocation.timeout,
+        elapsedMs,
+        "codex"
+      );
+      if (exitCode !== 0 || parsed.failed) {
+        return {
+          success: false,
+          result: resultText,
+          rawOutput,
+          exitCode: exitCode === 0 ? 1 : exitCode,
+          usage: parsed.usage,
+          error: parsed.error ?? failureText,
+          sessionId: parsed.sessionId,
+          ...base
+        };
+      }
+      return {
+        success: parsed.completed && !parsed.failed,
+        result: resultText,
+        rawOutput,
+        exitCode,
+        usage: parsed.usage,
+        error: parsed.failed ? parsed.error : null,
+        sessionId: parsed.sessionId,
+        ...base
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const elapsedMs = Date.now() - startTime;
+      const timedOut = message.includes("timed out") || message.includes("ETIMEDOUT");
+      return {
+        success: false,
+        result: "",
+        rawOutput: message,
+        exitCode: 1,
+        usage: null,
+        error: timedOut ? describeAgentFailure(
+          { timedOut: reachedTimeout(invocation.timeout, elapsedMs) },
+          message,
+          invocation.timeout,
+          elapsedMs,
+          "codex"
+        ) : message,
+        ...base
+      };
+    } finally {
+      cleanup?.();
+      await rm(tmp, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+};
+
+// src/agents/cursor.ts
+import { execa as execa4 } from "execa";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function toolName(call) {
+  if (isRecord2(call.readToolCall)) {
+    const args = isRecord2(call.readToolCall.args) ? call.readToolCall.args : {};
+    return { name: "Read", detail: typeof args.path === "string" ? args.path : "" };
+  }
+  if (isRecord2(call.writeToolCall)) {
+    const args = isRecord2(call.writeToolCall.args) ? call.writeToolCall.args : {};
+    return { name: "Edit", detail: typeof args.path === "string" ? args.path : "" };
+  }
+  const key = Object.keys(call).find((name) => name.endsWith("ToolCall"));
+  return { name: key?.replace(/ToolCall$/, "") ?? "tool", detail: "" };
+}
+function consumeCursorEvent(event, onEvent) {
+  if (event.type === "system" && event.subtype === "init") {
+    return {
+      sessionId: typeof event.session_id === "string" ? event.session_id : void 0,
+      model: typeof event.model === "string" ? event.model : void 0
+    };
+  }
+  if (event.type === "assistant") {
+    const message = isRecord2(event.message) ? event.message : {};
+    const content = Array.isArray(message.content) ? message.content : [];
+    const texts = [];
+    for (const block of content) {
+      if (isRecord2(block) && typeof block.text === "string") texts.push(block.text);
+    }
+    const text = texts.join("");
+    if (text && onEvent) onEvent({ kind: "text", text });
+    return { text };
+  }
+  if (event.type === "tool_call" && event.subtype === "started") {
+    const call = isRecord2(event.tool_call) ? event.tool_call : {};
+    const { name, detail } = toolName(call);
+    onEvent?.({ kind: "tool", name, ...detail === "" ? {} : { detail } });
+    return {};
+  }
+  if (event.type === "result") {
+    return {
+      result: typeof event.result === "string" ? event.result : "",
+      sessionId: typeof event.session_id === "string" ? event.session_id : void 0,
+      isError: event.is_error === true
+    };
+  }
+  return {};
+}
+function parseCursorStream(raw, onEvent) {
+  let result = "";
+  let isError = false;
+  let sessionId = null;
+  let model = null;
+  const texts = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (!isRecord2(event)) continue;
+      const seen = consumeCursorEvent(event, onEvent);
+      if (seen.result !== void 0) result = seen.result;
+      if (seen.isError === true) isError = true;
+      if (seen.sessionId) sessionId = seen.sessionId;
+      if (seen.model) model = seen.model;
+      if (seen.text) texts.push(seen.text);
+    } catch {
+    }
+  }
+  return { result, isError, sessionId, model, text: texts.join("") };
+}
+function buildCursorArgv(invocation, settings) {
+  const args = ["-p", "--output-format", "stream-json"];
+  args.push("--workspace", invocation.workingDirectory ?? process.cwd());
+  if (settings.model) args.push("--model", settings.model);
+  if (invocation.permission === "read-only") {
+    args.push("--mode", "plan");
+  } else {
+    args.push("--force");
+  }
+  if (settings.cursor.sandbox !== void 0) {
+    args.push("--sandbox", settings.cursor.sandbox);
+  }
+  if (settings.cursor.approveMcps === true) {
+    args.push("--approve-mcps");
+  }
+  args.push(invocation.prompt);
+  return { command: "cursor-agent", args };
+}
+var CursorRunner = class {
+  id = "cursor";
+  capabilities = CURSOR_CAPABILITIES;
+  versionCommand() {
+    return { command: "cursor-agent", args: ["--version"] };
+  }
+  authCommand() {
+    return { command: "cursor-agent", args: ["status"] };
+  }
+  async run(invocation, settings) {
+    const { command, args } = buildCursorArgv(invocation, settings);
+    const startTime = Date.now();
+    const agent = { provider: this.id, model: settings.model };
+    let cleanup = null;
+    try {
+      const subprocess = execa4(command, args, {
+        reject: false,
+        timeout: invocation.timeout,
+        stripFinalNewline: false,
+        stdin: "ignore",
+        ...invocation.workingDirectory ? { cwd: invocation.workingDirectory } : {}
+      });
+      const unregister = registerChild({
+        kill: (signal) => subprocess.kill(signal),
+        done: subprocess.then(
+          () => void 0,
+          () => void 0
+        )
+      });
+      const watchdog = createWatchdog({
+        ...invocation.inactivityTimeoutMs === void 0 ? {} : { inactivityTimeoutMs: invocation.inactivityTimeoutMs },
+        child: {
+          kill: (signal) => subprocess.kill(signal),
+          done: subprocess.then(
+            () => void 0,
+            () => void 0
+          )
+        }
+      });
+      cleanup = () => {
+        watchdog.stop();
+        unregister();
+      };
+      const chunks = [];
+      if (subprocess.stdout) {
+        subprocess.stdout.on("data", (chunk) => {
+          watchdog.beat();
+          const text = chunk.toString();
+          chunks.push(text);
+          invocation.onLine?.(text);
+        });
+      }
+      if (subprocess.stderr) {
+        subprocess.stderr.on("data", () => {
+          watchdog.beat();
+        });
+      }
+      const proc = await subprocess;
+      watchdog.stop();
+      unregister();
+      const stdout = chunks.join("") || proc.stdout?.toString() || "";
+      const stderr = proc.stderr?.toString() ?? "";
+      const parsed = parseCursorStream(stdout, invocation.onEvent);
+      const rawOutput = stdout + (stderr ? `
+${stderr}` : "");
+      const exitCode = proc.exitCode ?? 1;
+      const elapsedMs = Date.now() - startTime;
+      const timedOut = wasTimedOut(proc, invocation.timeout, elapsedMs);
+      const authFailed = /authentication required/i.test(stderr) && stdout.trim() === "";
+      const stalled = watchdog.stalled;
+      const success = exitCode === 0 && parsed.result !== "" && !parsed.isError && !timedOut;
+      if (stalled) {
+        return {
+          success: false,
+          result: "",
+          rawOutput: describeStall(watchdog.silentMs, "cursor-agent"),
+          exitCode: exitCode === 0 ? 1 : exitCode,
+          usage: null,
+          error: describeStall(watchdog.silentMs, "cursor-agent"),
+          agent: { provider: this.id, model: parsed.model ?? settings.model },
+          sessionId: parsed.sessionId ?? void 0,
+          harnessVersion: peekHarnessVersion(this.id)
+        };
+      }
+      return {
+        success,
+        result: parsed.result || parsed.text,
+        rawOutput,
+        exitCode: timedOut ? 1 : exitCode,
+        usage: null,
+        error: success ? null : authFailed ? stderr.trim() : describeAgentFailure(
+          proc,
+          stderr || rawOutput,
+          invocation.timeout,
+          elapsedMs,
+          command
+        ),
+        agent: { provider: this.id, model: parsed.model ?? settings.model },
+        sessionId: parsed.sessionId ?? void 0,
+        harnessVersion: peekHarnessVersion(this.id)
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        result: "",
+        rawOutput: message,
+        exitCode: 1,
+        usage: null,
+        error: message,
+        agent,
+        harnessVersion: peekHarnessVersion(this.id)
+      };
+    } finally {
+      cleanup?.();
+    }
+  }
+};
+
+// src/agents/registry.ts
+var runners = /* @__PURE__ */ new Map();
+function registerRunner(runner) {
+  runners.set(runner.id, runner);
+}
+function getRegisteredProviders() {
+  return [...runners.keys()];
+}
+function ensureRunnersRegistered() {
+  const registered = new Set(getRegisteredProviders());
+  if (!registered.has("claude")) registerRunner(new ClaudeCodeRunner());
+  if (!registered.has("codex")) registerRunner(new CodexRunner());
+  if (!registered.has("cursor")) registerRunner(new CursorRunner());
+  if (!registered.has("antigravity")) registerRunner(new AntigravityRunner());
+}
+function runnerFor(providerId) {
+  ensureRunnersRegistered();
+  const runner = runners.get(providerId);
+  if (runner === void 0) {
+    const available = getRegisteredProviders();
+    const hint = available.length > 0 ? `Available providers: ${available.join(", ")}.` : "No agent runners are registered.";
+    throw new Error(`Unknown agent provider: '${providerId}'. ${hint}`);
+  }
+  return runner;
+}
+async function ensureHarnessVersion(providerId) {
+  const cached = peekHarnessVersion(providerId);
+  if (cached !== void 0) return cached;
+  const runner = runnerFor(providerId);
+  const { command, args } = runner.versionCommand();
+  try {
+    const proc = await execa5(command, args, { reject: false, timeout: 1e4 });
+    const version = proc.exitCode === 0 ? proc.stdout?.toString().trim() ?? null : null;
+    cacheHarnessVersion(providerId, version);
+    return version;
+  } catch {
+    cacheHarnessVersion(providerId, null);
+    return null;
+  }
+}
+
+// src/agents/origins.ts
+var trackedOrigins = null;
+function setTrackedOrigins(origins) {
+  trackedOrigins = origins;
+}
+function getTrackedOrigins() {
+  return trackedOrigins;
+}
+
+// src/agents/resolve.ts
+function mergeAgentBlocks(base, overlay) {
+  if (overlay === void 0) return { ...base };
+  return {
+    ...base,
+    ...dropUndefined(overlay),
+    claude: { ...base.claude, ...dropUndefined(overlay.claude ?? {}) },
+    codex: { ...base.codex, ...dropUndefined(overlay.codex ?? {}) },
+    cursor: { ...base.cursor, ...dropUndefined(overlay.cursor ?? {}) },
+    antigravity: { ...base.antigravity, ...dropUndefined(overlay.antigravity ?? {}) }
+  };
+}
+function dropUndefined(value) {
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0) result[key] = item;
+  }
+  return result;
+}
+async function resolveAgentFor(phase, options = {}) {
+  const { getAgentCliOverrides: getAgentCliOverrides2, loadAgentConfig: loadAgentConfig2 } = await import("./config-HMFMCY2M.js");
+  const config = options.config ?? await loadAgentConfig2();
+  const cli = options.cli ?? getAgentCliOverrides2();
+  const defaultBlock = {
+    provider: config.provider,
+    model: config.model,
+    claude: config.claude,
+    codex: config.codex,
+    cursor: config.cursor,
+    antigravity: config.antigravity
+  };
+  const phaseBlock = mergeAgentBlocks(config.phases[phase] ?? {}, cli.phases?.[phase]);
+  const merged = mergeAgentBlocks(defaultBlock, phaseBlock);
+  const inspected = await inspectAgentResolution(phase, config, cli);
+  let provider = merged.provider ?? "claude";
+  let model = merged.model ?? null;
+  let providerOrigin = inspected.providerOrigin;
+  let modelOrigin = inspected.modelOrigin;
+  if (cli?.forceProvider !== void 0) {
+    provider = cli.forceProvider;
+    providerOrigin = "cli";
+  }
+  if (cli?.forceModel !== void 0) {
+    model = cli.forceModel;
+    modelOrigin = "cli";
+  }
+  return {
+    provider,
+    model,
+    claude: merged.claude ?? {},
+    codex: merged.codex ?? {},
+    cursor: merged.cursor ?? {},
+    antigravity: merged.antigravity ?? {},
+    origin: { provider: providerOrigin, model: modelOrigin }
+  };
+}
+async function inspectAgentResolution(phase, config, cli) {
+  const overlay = config.phases[phase];
+  const provider = overlay?.provider ?? config.provider;
+  const model = overlay?.model !== void 0 ? overlay.model : config.model;
+  let providerOrigin = provider === "claude" && overlay?.provider === void 0 ? "default" : "project";
+  let modelOrigin = model === null && overlay?.model === void 0 ? "default" : "project";
+  const tracked = getTrackedOrigins();
+  if (tracked) {
+    providerOrigin = overlay?.provider !== void 0 ? tracked.phases[phase]?.provider ?? tracked.provider : tracked.provider;
+    modelOrigin = overlay?.model !== void 0 ? tracked.phases[phase]?.model ?? tracked.model : tracked.model;
+  }
+  if (cli?.forceProvider !== void 0) providerOrigin = "cli";
+  if (cli?.forceModel !== void 0) modelOrigin = "cli";
+  return {
+    provider,
+    model,
+    providerOrigin,
+    modelOrigin,
+    claude: { ...config.claude, ...overlay?.claude },
+    codex: { ...config.codex, ...overlay?.codex }
+  };
+}
+function parseAgentPhaseFlag(value) {
+  const eq = value.indexOf("=");
+  if (eq <= 0) {
+    throw new Error(
+      `Invalid --agent-phase value "${value}". Expected <phase>=<provider>[:<model>].`
+    );
+  }
+  const phase = value.slice(0, eq);
+  const rest = value.slice(eq + 1);
+  if (!isAgentPhase(phase)) {
+    throw new Error(
+      `Unknown agent phase "${phase}". Valid phases: analyze, generate, prd, plan, execute, review, pr, pr-review.`
+    );
+  }
+  const [providerRaw, ...modelParts] = rest.split(":");
+  if (!providerRaw || !isAgentProviderId(providerRaw)) {
+    throw new Error(
+      `Unknown agent provider "${providerRaw ?? ""}". Valid providers: claude, codex, cursor, antigravity.`
+    );
+  }
+  const model = modelParts.length > 0 ? modelParts.join(":") : void 0;
+  return {
+    phase,
+    block: {
+      provider: providerRaw,
+      ...model ? { model } : {}
+    }
+  };
+}
+async function describeRunAgents(phases = AGENT_PHASES) {
+  const target = phases.length > 0 ? phases : AGENT_PHASES;
+  const byPhase = {};
+  let defaultProvider = "claude";
+  let defaultModel = null;
+  const providers = /* @__PURE__ */ new Set();
+  for (const phase of target) {
+    const settings = await resolveAgentFor(phase);
+    byPhase[phase] = {
+      provider: settings.provider,
+      model: settings.model,
+      origin: settings.origin
+    };
+    providers.add(settings.provider);
+    if (phase === target[0]) {
+      defaultProvider = settings.provider;
+      defaultModel = settings.model;
+    }
+  }
+  const { loadAgentConfig: loadAgentConfig2 } = await import("./config-HMFMCY2M.js");
+  const config = await loadAgentConfig2();
+  defaultProvider = config.provider;
+  defaultModel = config.model;
+  const tracked = getTrackedOrigins();
+  return {
+    label: providers.size > 1 ? "misto" : providers.values().next().value ?? defaultProvider,
+    defaultProvider,
+    defaultModel,
+    defaultOrigin: {
+      provider: tracked?.provider ?? (defaultProvider === "claude" ? "default" : "project"),
+      model: tracked?.model ?? (defaultModel === null ? "default" : "project")
+    },
+    byPhase
+  };
+}
+function hasExplicitAgentSelection(config, cli) {
+  if (cli?.forceProvider !== void 0 || cli?.forceModel !== void 0) return true;
+  if (cli?.phases && Object.keys(cli.phases).length > 0) return true;
+  if (config.provider !== "claude") return true;
+  if (config.model !== null) return true;
+  if (Object.keys(config.phases).length > 0) return true;
+  if (config.claude.ignoreUserConfig !== void 0) return true;
+  if (Object.keys(config.codex).length > 0) return true;
+  return false;
+}
+
+// src/agents/availability.ts
+var probeCache = /* @__PURE__ */ new Map();
+async function probeAgent(id) {
+  const cached = probeCache.get(id);
+  if (cached) return cached;
+  const pending = probeAgentUncached(id);
+  probeCache.set(id, pending);
+  return pending;
+}
+async function probeAgentUncached(id) {
+  ensureRunnersRegistered();
+  const runner = runnerFor(id);
+  let version = null;
+  let installed2 = false;
+  try {
+    const { command, args } = runner.versionCommand();
+    const proc = await execa6(command, args, { reject: false, timeout: 1e4 });
+    installed2 = proc.exitCode === 0;
+    version = installed2 ? proc.stdout?.toString().trim() || "unknown" : null;
+  } catch {
+    installed2 = false;
+  }
+  let authenticated = installed2;
+  let detail = installed2 ? version ?? "installed" : "not found";
+  if (installed2 && runner.authCommand && runner.capabilities.authProbe !== "none") {
+    try {
+      const { command, args } = runner.authCommand();
+      const auth = await execa6(command, args, { reject: false, timeout: 1e4 });
+      const text = `${auth.stdout?.toString() ?? ""}
+${auth.stderr?.toString() ?? ""}`;
+      authenticated = runner.capabilities.authProbe === "text" ? !/not logged in|not authenticated|no models available/i.test(text) : auth.exitCode === 0;
+      detail = authenticated ? `${version} (authenticated)` : `${version} (not authenticated)`;
+    } catch {
+      authenticated = false;
+      detail = `${version} (not authenticated)`;
+    }
+  }
+  return { id, installed: installed2, version, authenticated, detail };
+}
+function installHint(id) {
+  if (id === "codex") {
+    return "Install Codex CLI: https://developers.openai.com/codex/noninteractive";
+  }
+  if (id === "cursor") {
+    return "Install Cursor CLI: curl https://cursor.com/install -fsS | bash";
+  }
+  if (id === "antigravity") {
+    return "Install Antigravity CLI: https://antigravity.google/docs/cli/install/";
+  }
+  return "Install Claude Code: https://docs.anthropic.com/en/docs/claude-code";
+}
+
+// src/config.ts
+var DEFAULTS = {
+  retryLimit: 10,
+  retryForever: false,
+  backoffBaseSeconds: 30,
+  backoffMaxSeconds: 900
+};
+function createConfig(options) {
+  return {
+    issueNumber: options.issueNumber,
+    maxIterations: options.maxIterations,
+    retryLimit: options.retryLimit ?? DEFAULTS.retryLimit,
+    retryForever: options.retryForever ?? DEFAULTS.retryForever,
+    backoffBaseSeconds: options.backoffBaseSeconds ?? DEFAULTS.backoffBaseSeconds,
+    backoffMaxSeconds: options.backoffMaxSeconds ?? DEFAULTS.backoffMaxSeconds,
+    // Left absent (rather than defaulted to an empty string) so the execute
+    // prompt keeps its historical commit format unless a queue asks otherwise.
+    ...options.commitScope === void 0 ? {} : { commitScope: options.commitScope },
+    storiesPerIteration: options.storiesPerIteration ?? 1
+  };
+}
+async function resolvePaths(config, scriptDir) {
+  const projectRoot = await getProjectRoot();
+  if (config.issueNumber) {
+    const issuePaths = await resolveIssuePaths(config.issueNumber, { projectRoot });
+    return {
+      prdFile: issuePaths.tasksFile,
+      progressFile: issuePaths.progressFile,
+      archiveDir: issuePaths.archiveDir,
+      lastBranchFile: issuePaths.lastBranchFile,
+      projectRoot
+    };
+  }
+  const base = scriptDir ?? projectRoot;
+  const standalone = {
+    prdFile: join2(base, "prd.json"),
+    progressFile: join2(base, "progress.txt"),
+    archiveDir: join2(base, "archive"),
+    lastBranchFile: join2(base, ".last-branch"),
+    projectRoot
+  };
+  const { bindTelemetry } = await import("./recorder-KCCPMKQG.js");
+  bindTelemetry({ tasksPath: standalone.prdFile });
+  return standalone;
+}
+function getInstallHint(pkg) {
+  const os = platform();
+  if (os === "darwin") {
+    return `brew install ${pkg}`;
+  }
+  if (os === "linux") {
+    return `apt install ${pkg}  (or your distro's package manager)`;
+  }
+  if (os === "win32") {
+    return `winget install ${pkg}  (or choco install ${pkg})`;
+  }
+  return `install ${pkg} using your system package manager`;
+}
+async function validateDependencies() {
+  const errors = [];
+  const gitResult = await run("git", ["--version"]);
+  if (gitResult.exitCode !== 0) {
+    errors.push(`  - git  (install with: ${getInstallHint("git")})`);
+  }
+  const agent = await loadAgentConfig();
+  const needed = /* @__PURE__ */ new Set([agent.provider]);
+  for (const phase of AGENT_PHASES) {
+    const provider = agent.phases[phase]?.provider;
+    if (provider !== void 0) needed.add(provider);
+  }
+  for (const id of needed) {
+    const { command, args } = runnerFor(id).versionCommand();
+    const result = await run(command, args);
+    if (result.exitCode !== 0) {
+      errors.push(`  - ${command}  (${installHint(id)})`);
+    }
+  }
+  return errors;
+}
+var PROJECT_CONFIG_FILENAME = ".issue-flow.json";
+var WEB_CONFIG_FILENAME = PROJECT_CONFIG_FILENAME;
+function findProjectRootFromCwd(start = process.cwd()) {
+  let dir = start;
+  while (true) {
+    if (existsSync(join2(dir, PROJECT_CONFIG_FILENAME)) || existsSync(join2(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+async function readProjectConfigFile(projectRoot, warn) {
+  const root = projectRoot ?? findProjectRootFromCwd();
+  if (root === void 0) {
+    return null;
+  }
+  const filePath = join2(root, PROJECT_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: invalid JSON.`);
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: expected a JSON object.`);
+    return null;
+  }
+  return parsed;
+}
+var GLOBAL_CONFIG_FILENAME = "config.json";
+async function loadGlobalConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  let root;
+  try {
+    root = options.globalRoot ?? getGlobalRoot({ env: options.env ?? process.env });
+  } catch (err) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    return {};
+  }
+  const filePath = join2(root, GLOBAL_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    }
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: invalid JSON.`);
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: expected a JSON object.`);
+    return {};
+  }
+  const config = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    const result = globalConfigSchema.safeParse({ [key]: value });
+    if (!result.success) {
+      warn(
+        `Ignoring "${key}" key of ${GLOBAL_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+      );
+      continue;
+    }
+    Object.assign(config, result.data);
+  }
+  return config;
+}
+function mergeConfigLayers(layers) {
+  const merged = {};
+  for (const layer of [
+    layers.defaults,
+    layers.discovered,
+    layers.global,
+    layers.project,
+    layers.env,
+    layers.cli
+  ]) {
+    for (const [key, value] of Object.entries(layer ?? {})) {
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+var webCliOverrides = {};
+function setWebCliOverrides(overrides) {
+  webCliOverrides = overrides;
+}
+var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+function parseBooleanEnv(value) {
+  return !FALSY_ENV_VALUES.has(value.trim().toLowerCase());
+}
+function readNumberEnv(env, name, warn) {
+  const raw = env[name];
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`Ignoring ${name}="${raw}": not a number.`);
+    return void 0;
+  }
+  return parsed;
+}
+function readWebConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_WEB !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_WEB);
+  }
+  const port = readNumberEnv(env, "ISSUE_FLOW_WEB_PORT", warn);
+  if (port !== void 0) {
+    layer.port = port;
+  }
+  if (env.ISSUE_FLOW_WEB_HOST !== void 0) {
+    layer.host = env.ISSUE_FLOW_WEB_HOST;
+  }
+  const refresh = readNumberEnv(env, "ISSUE_FLOW_WEB_REFRESH", warn);
+  if (refresh !== void 0) {
+    layer.refreshSeconds = refresh;
+  }
+  const logLimit = readNumberEnv(env, "ISSUE_FLOW_WEB_LOG_LIMIT", warn);
+  if (logLimit !== void 0) {
+    layer.logLimit = logLimit;
+  }
+  return layer;
+}
+async function readWebConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const web = file?.web;
+  if (web === void 0) {
+    return {};
+  }
+  const result = webConfigSchema.partial().safeParse(web);
+  if (!result.success) {
+    warn(
+      `Ignoring "web" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadWebConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? webCliOverrides;
+  const env = options.env ?? process.env;
+  const fileLayer = await readWebConfigFile(options.projectRoot, warn);
+  const envLayer = readWebConfigEnv(env, warn);
+  const merged = { ...fileLayer, ...envLayer, ...cli };
+  const result = webConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid web monitoring configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return webConfigSchema.parse({});
+}
+var issuesCliOverrides = {};
+function setIssuesCliOverrides(overrides) {
+  issuesCliOverrides = overrides;
+}
+async function readIssuesConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const issues = file?.issues;
+  if (issues === void 0) {
+    return {};
+  }
+  const result = issuesConfigSchema.partial().safeParse(issues);
+  if (!result.success) {
+    warn(
+      `Ignoring "issues" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadIssuesConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? issuesCliOverrides;
+  const fileLayer = await readIssuesConfigFile(options.projectRoot, warn);
+  const merged = { ...fileLayer, ...cli };
+  const result = issuesConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid Issue provider configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return issuesConfigSchema.parse({});
+}
+function readPrReviewConfigEnv(env) {
+  const publisher = env.ISSUE_FLOW_PR_REVIEW_PUBLISHER;
+  return publisher === void 0 ? {} : { publisher };
+}
+async function readPrReviewConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const prReview = file?.prReview;
+  if (prReview === void 0) {
+    return {};
+  }
+  const result = prReviewConfigSchema.partial().safeParse(prReview);
+  if (!result.success) {
+    warn(
+      `Ignoring "prReview" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadPrReviewConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const fileLayer = await readPrReviewConfigFile(options.projectRoot, warn);
+  const envLayer = readPrReviewConfigEnv(env);
+  const merged = { ...fileLayer, ...envLayer, ...options.cli ?? {} };
+  const result = prReviewConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid PR review configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return prReviewConfigSchema.parse({});
+}
+var policyCliOverrides = {};
+function setPolicyCliOverrides(overrides) {
+  policyCliOverrides = overrides;
+}
+function dropNullish(layer) {
+  const result = {};
+  for (const [key, value] of Object.entries(layer ?? {})) {
+    if (value !== void 0 && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function readPolicyConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_POLICY !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_POLICY);
+  }
+  const budget = readNumberEnv(env, "ISSUE_FLOW_POLICY_CONTEXT_BUDGET", warn);
+  if (budget !== void 0) {
+    layer.contextBudget = budget;
+  }
+  const issues = {};
+  if (env.ISSUE_FLOW_POLICY_ISSUE_TITLE_CONVENTION !== void 0) {
+    issues.titleConvention = env.ISSUE_FLOW_POLICY_ISSUE_TITLE_CONVENTION;
+  }
+  if (Object.keys(issues).length > 0) layer.issues = issues;
+  const pullRequests = {};
+  if (env.ISSUE_FLOW_POLICY_BASE_BRANCH !== void 0) {
+    pullRequests.baseBranch = env.ISSUE_FLOW_POLICY_BASE_BRANCH;
+  }
+  if (env.ISSUE_FLOW_POLICY_PR_TITLE_CONVENTION !== void 0) {
+    pullRequests.titleConvention = env.ISSUE_FLOW_POLICY_PR_TITLE_CONVENTION;
+  }
+  if (Object.keys(pullRequests).length > 0) layer.pullRequests = pullRequests;
+  const git = {};
+  if (env.ISSUE_FLOW_POLICY_BRANCH_CONVENTION !== void 0) {
+    git.branchConvention = env.ISSUE_FLOW_POLICY_BRANCH_CONVENTION;
+  }
+  if (env.ISSUE_FLOW_POLICY_COMMIT_CONVENTION !== void 0) {
+    git.commitConvention = env.ISSUE_FLOW_POLICY_COMMIT_CONVENTION;
+  }
+  if (Object.keys(git).length > 0) layer.git = git;
+  const invalid = Object.entries(layer).find(
+    ([, value]) => typeof value === "object" && value !== null && Object.values(value).includes("")
+  );
+  if (invalid !== void 0) {
+    warn(`Ignoring empty ISSUE_FLOW_POLICY_* value in "${invalid[0]}".`);
+  }
+  return layer;
+}
+async function readPolicyConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const policy = file?.policy;
+  if (policy === void 0) {
+    return {};
+  }
+  const result = policyConfigInputSchema.safeParse(policy);
+  if (!result.success) {
+    warn(
+      `Ignoring "policy" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadPolicyConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? policyCliOverrides;
+  const env = options.env ?? process.env;
+  const fileLayer = await readPolicyConfigFile(options.projectRoot, warn);
+  const envLayer = readPolicyConfigEnv(env, warn);
+  const merged = {
+    ...mergeConfigLayers({
+      project: dropNullish({ enabled: fileLayer.enabled, contextBudget: fileLayer.contextBudget }),
+      env: dropNullish({ enabled: envLayer.enabled, contextBudget: envLayer.contextBudget }),
+      cli: dropNullish({ enabled: cli.enabled, contextBudget: cli.contextBudget })
+    }),
+    discovery: mergeConfigLayers({
+      project: dropNullish(fileLayer.discovery),
+      env: dropNullish(envLayer.discovery),
+      cli: dropNullish(cli.discovery)
+    }),
+    issues: mergeConfigLayers({
+      project: dropNullish(fileLayer.issues),
+      env: dropNullish(envLayer.issues),
+      cli: dropNullish(cli.issues)
+    }),
+    pullRequests: mergeConfigLayers({
+      project: dropNullish(fileLayer.pullRequests),
+      env: dropNullish(envLayer.pullRequests),
+      cli: dropNullish(cli.pullRequests)
+    }),
+    git: mergeConfigLayers({
+      project: dropNullish(fileLayer.git),
+      env: dropNullish(envLayer.git),
+      cli: dropNullish(cli.git)
+    })
+  };
+  const result = policyConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid repository policy configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return policyConfigSchema.parse({});
+}
+function parseTelemetryLayer(value, source, warn) {
+  if (value === void 0) return {};
+  const result = telemetryConfigInputSchema.safeParse(value);
+  if (result.success) return result.data;
+  warn(
+    `Ignoring "telemetry" key of ${source}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+  );
+  return {};
+}
+function readTelemetryEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_TELEMETRY !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_TELEMETRY);
+  }
+  const max = readNumberEnv(env, "ISSUE_FLOW_TELEMETRY_MAX_EXECUTIONS", warn);
+  if (max !== void 0) layer.maxExecutions = max;
+  if (env.ISSUE_FLOW_TELEMETRY_ESTIMATE !== void 0) {
+    layer.pricing = { estimate: parseBooleanEnv(env.ISSUE_FLOW_TELEMETRY_ESTIMATE) };
+  }
+  return layer;
+}
+async function loadTelemetryConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const globalFile = options.global ?? (await loadGlobalConfig({
+    env,
+    ...options.globalRoot === void 0 ? {} : { globalRoot: options.globalRoot },
+    warn
+  })).telemetry;
+  const projectFile = await readProjectConfigFile(options.projectRoot, warn);
+  const project = parseTelemetryLayer(projectFile?.telemetry, PROJECT_CONFIG_FILENAME, warn);
+  const envLayer = readTelemetryEnv(env, warn);
+  const pricing = mergeConfigLayers({
+    defaults: DEFAULT_TELEMETRY_CONFIG.pricing,
+    global: globalFile?.pricing,
+    project: project.pricing,
+    env: envLayer.pricing
+  });
+  const overrides = {
+    ...DEFAULT_TELEMETRY_CONFIG.pricing.overrides,
+    ...globalFile?.pricing?.overrides,
+    ...project.pricing?.overrides,
+    ...envLayer.pricing?.overrides
+  };
+  const scalars = mergeConfigLayers({
+    defaults: {
+      enabled: DEFAULT_TELEMETRY_CONFIG.enabled,
+      maxExecutions: DEFAULT_TELEMETRY_CONFIG.maxExecutions
+    },
+    global: {
+      ...globalFile?.enabled === void 0 ? {} : { enabled: globalFile.enabled },
+      ...globalFile?.maxExecutions === void 0 ? {} : { maxExecutions: globalFile.maxExecutions }
+    },
+    project: {
+      ...project.enabled === void 0 ? {} : { enabled: project.enabled },
+      ...project.maxExecutions === void 0 ? {} : { maxExecutions: project.maxExecutions }
+    },
+    env: {
+      ...envLayer.enabled === void 0 ? {} : { enabled: envLayer.enabled },
+      ...envLayer.maxExecutions === void 0 ? {} : { maxExecutions: envLayer.maxExecutions }
+    }
+  });
+  return {
+    enabled: scalars.enabled ?? DEFAULT_TELEMETRY_CONFIG.enabled,
+    maxExecutions: scalars.maxExecutions ?? DEFAULT_TELEMETRY_CONFIG.maxExecutions,
+    pricing: {
+      estimate: pricing.estimate ?? DEFAULT_TELEMETRY_CONFIG.pricing.estimate,
+      overrides
+    }
+  };
+}
+var resilienceCliOverrides = {};
+function setResilienceCliOverrides(overrides) {
+  resilienceCliOverrides = overrides;
+}
+function mergeResilienceSection(layers) {
+  const merged = mergeConfigLayers({
+    global: layers[0],
+    project: layers[1],
+    env: layers[2],
+    cli: layers[3]
+  });
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeResilienceRetry(layers) {
+  const merged = {};
+  for (const key of RETRY_CONFIG_KEYS) {
+    const entry = mergeResilienceSection(layers.map((layer) => layer?.[key]));
+    if (entry !== void 0) {
+      merged[key] = entry;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function parseResilienceLayer(value, origin, warn) {
+  const result = resilienceConfigSchema.safeParse(value);
+  if (!result.success) {
+    warn(
+      `Ignoring "resilience" key of ${origin}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function readResilienceConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const resilience = file?.resilience;
+  if (resilience === void 0) {
+    return {};
+  }
+  return parseResilienceLayer(resilience, PROJECT_CONFIG_FILENAME, warn);
+}
+function readResilienceConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_RESILIENCE_PROFILE !== void 0) {
+    layer.profile = env.ISSUE_FLOW_RESILIENCE_PROFILE;
+  }
+  if (env.ISSUE_FLOW_RESILIENCE_FAILOVER_ON_AUTH !== void 0) {
+    layer.failoverOnAuth = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_FAILOVER_ON_AUTH);
+  }
+  const retry = env.ISSUE_FLOW_RESILIENCE_RETRY;
+  if (retry !== void 0) {
+    try {
+      layer.retry = JSON.parse(retry);
+    } catch {
+      warn("Ignoring ISSUE_FLOW_RESILIENCE_RETRY: invalid JSON.");
+    }
+  }
+  const providers = {};
+  if (env.ISSUE_FLOW_RESILIENCE_FAILOVER !== void 0) {
+    providers.failover = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_FAILOVER);
+  }
+  if (env.ISSUE_FLOW_RESILIENCE_PROVIDER_CHAIN !== void 0) {
+    providers.chain = env.ISSUE_FLOW_RESILIENCE_PROVIDER_CHAIN.split(",").map((name) => name.trim()).filter((name) => name !== "");
+  }
+  const cooldown = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_PROVIDER_COOLDOWN_MS", warn);
+  if (cooldown !== void 0) {
+    providers.cooldownMs = cooldown;
+  }
+  const maxCooldown = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_PROVIDER_MAX_COOLDOWN_MS", warn);
+  if (maxCooldown !== void 0) {
+    providers.maxCooldownMs = maxCooldown;
+  }
+  const failureWindow = readNumberEnv(
+    env,
+    "ISSUE_FLOW_RESILIENCE_PROVIDER_FAILURE_WINDOW_MS",
+    warn
+  );
+  if (failureWindow !== void 0) {
+    providers.failureWindowMs = failureWindow;
+  }
+  const failuresToTrip = readNumberEnv(
+    env,
+    "ISSUE_FLOW_RESILIENCE_PROVIDER_FAILURES_TO_TRIP",
+    warn
+  );
+  if (failuresToTrip !== void 0) {
+    providers.failuresToTrip = failuresToTrip;
+  }
+  if (Object.keys(providers).length > 0) layer.providers = providers;
+  const queue = {};
+  if (env.ISSUE_FLOW_RESILIENCE_ON_ISSUE_FAILURE !== void 0) {
+    queue.onIssueFailure = env.ISSUE_FLOW_RESILIENCE_ON_ISSUE_FAILURE;
+  }
+  const maxIssueAttempts = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_MAX_ISSUE_ATTEMPTS", warn);
+  if (maxIssueAttempts !== void 0) {
+    queue.maxIssueAttempts = maxIssueAttempts;
+  }
+  if (Object.keys(queue).length > 0) layer.queue = queue;
+  const inactivity = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_INACTIVITY_TIMEOUT_MS", warn);
+  if (inactivity !== void 0) {
+    layer.watchdog = { inactivityTimeoutMs: inactivity };
+  }
+  const journal = {};
+  if (env.ISSUE_FLOW_RESILIENCE_JOURNAL !== void 0) {
+    journal.enabled = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_JOURNAL);
+  }
+  const journalBytes = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_JOURNAL_MAX_BYTES", warn);
+  if (journalBytes !== void 0) {
+    journal.maxFileBytes = journalBytes;
+  }
+  if (Object.keys(journal).length > 0) layer.journal = journal;
+  if (env.ISSUE_FLOW_RESILIENCE_AUTO_DECOMPOSE !== void 0) {
+    layer.decompose = { auto: parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_AUTO_DECOMPOSE) };
+  }
+  if (Object.keys(layer).length === 0) {
+    return {};
+  }
+  return parseResilienceLayer(layer, "the ISSUE_FLOW_RESILIENCE_* environment", warn);
+}
+async function loadResilienceConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const cli = options.cli ?? resilienceCliOverrides;
+  const globalLayer = options.global ?? (await loadGlobalConfig({
+    env,
+    ...options.globalRoot === void 0 ? {} : { globalRoot: options.globalRoot },
+    warn
+  })).resilience ?? {};
+  const projectLayer = await readResilienceConfigFile(options.projectRoot, warn);
+  const envLayer = readResilienceConfigEnv(env, warn);
+  const layers = [globalLayer, projectLayer, envLayer, cli];
+  const scalars = mergeConfigLayers({
+    global: { profile: globalLayer.profile, failoverOnAuth: globalLayer.failoverOnAuth },
+    project: { profile: projectLayer.profile, failoverOnAuth: projectLayer.failoverOnAuth },
+    env: { profile: envLayer.profile, failoverOnAuth: envLayer.failoverOnAuth },
+    cli: { profile: cli.profile, failoverOnAuth: cli.failoverOnAuth }
+  });
+  const retry = mergeResilienceRetry(layers.map((layer) => layer.retry));
+  const providers = mergeResilienceSection(layers.map((layer) => layer.providers));
+  const queue = mergeResilienceSection(layers.map((layer) => layer.queue));
+  const watchdog = mergeResilienceSection(layers.map((layer) => layer.watchdog));
+  const journal = mergeResilienceSection(layers.map((layer) => layer.journal));
+  const decompose = mergeResilienceSection(layers.map((layer) => layer.decompose));
+  return {
+    ...scalars,
+    ...retry === void 0 ? {} : { retry },
+    ...providers === void 0 ? {} : { providers },
+    ...queue === void 0 ? {} : { queue },
+    ...watchdog === void 0 ? {} : { watchdog },
+    ...journal === void 0 ? {} : { journal },
+    ...decompose === void 0 ? {} : { decompose }
+  };
+}
+var activeResilienceConfig = {};
+function getActiveResilienceConfig() {
+  return activeResilienceConfig;
+}
+function setActiveResilienceConfig(config) {
+  activeResilienceConfig = config;
+}
+async function initResilienceConfig(options = {}) {
+  try {
+    activeResilienceConfig = await loadResilienceConfig(options);
+  } catch {
+    activeResilienceConfig = {};
+  }
+  return activeResilienceConfig;
+}
+var agentCliOverrides = {};
+var cachedAgentConfig;
+function setAgentCliOverrides(overrides) {
+  agentCliOverrides = overrides;
+  cachedAgentConfig = void 0;
+}
+function getAgentCliOverrides() {
+  return agentCliOverrides;
+}
+function readAgentEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_AGENT !== void 0) {
+    if (isAgentProviderId(env.ISSUE_FLOW_AGENT)) {
+      layer.provider = env.ISSUE_FLOW_AGENT;
+    } else {
+      warn(
+        `Ignoring ISSUE_FLOW_AGENT="${env.ISSUE_FLOW_AGENT}": expected claude, codex, cursor or antigravity.`
+      );
+    }
+  }
+  if (env.ISSUE_FLOW_AGENT_MODEL !== void 0 && env.ISSUE_FLOW_AGENT_MODEL !== "") {
+    layer.model = env.ISSUE_FLOW_AGENT_MODEL;
+  }
+  const codex = {};
+  if (env.ISSUE_FLOW_CODEX_SANDBOX !== void 0) {
+    if (env.ISSUE_FLOW_CODEX_SANDBOX === "read-only" || env.ISSUE_FLOW_CODEX_SANDBOX === "workspace-write" || env.ISSUE_FLOW_CODEX_SANDBOX === "danger-full-access") {
+      codex.sandbox = env.ISSUE_FLOW_CODEX_SANDBOX;
+    } else {
+      warn(`Ignoring ISSUE_FLOW_CODEX_SANDBOX="${env.ISSUE_FLOW_CODEX_SANDBOX}".`);
+    }
+  }
+  if (env.ISSUE_FLOW_CODEX_REASONING_EFFORT !== void 0) {
+    const effort = env.ISSUE_FLOW_CODEX_REASONING_EFFORT;
+    if (effort === "minimal" || effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh") {
+      codex.reasoningEffort = effort;
+    } else {
+      warn(`Ignoring ISSUE_FLOW_CODEX_REASONING_EFFORT="${effort}".`);
+    }
+  }
+  if (env.ISSUE_FLOW_CODEX_IGNORE_USER_CONFIG !== void 0) {
+    codex.ignoreUserConfig = parseBooleanEnv(env.ISSUE_FLOW_CODEX_IGNORE_USER_CONFIG);
+  }
+  if (Object.keys(codex).length > 0) layer.codex = codex;
+  const cursor = {};
+  if (env.ISSUE_FLOW_CURSOR_SANDBOX !== void 0) {
+    if (env.ISSUE_FLOW_CURSOR_SANDBOX === "enabled" || env.ISSUE_FLOW_CURSOR_SANDBOX === "disabled") {
+      cursor.sandbox = env.ISSUE_FLOW_CURSOR_SANDBOX;
+    } else {
+      warn(`Ignoring ISSUE_FLOW_CURSOR_SANDBOX="${env.ISSUE_FLOW_CURSOR_SANDBOX}".`);
+    }
+  }
+  if (env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE !== void 0) {
+    if (env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE === "global" || env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE === "project" || env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE === "none") {
+      cursor.permissionsFile = env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE;
+    } else {
+      warn(
+        `Ignoring ISSUE_FLOW_CURSOR_PERMISSIONS_FILE="${env.ISSUE_FLOW_CURSOR_PERMISSIONS_FILE}".`
+      );
+    }
+  }
+  if (Object.keys(cursor).length > 0) layer.cursor = cursor;
+  const antigravity = {};
+  if (env.ISSUE_FLOW_ANTIGRAVITY_EFFORT !== void 0) {
+    const effort = env.ISSUE_FLOW_ANTIGRAVITY_EFFORT;
+    if (effort === "low" || effort === "medium" || effort === "high") {
+      antigravity.effort = effort;
+    } else {
+      warn(`Ignoring ISSUE_FLOW_ANTIGRAVITY_EFFORT="${effort}".`);
+    }
+  }
+  if (env.ISSUE_FLOW_ANTIGRAVITY_SANDBOX !== void 0) {
+    antigravity.sandbox = parseBooleanEnv(env.ISSUE_FLOW_ANTIGRAVITY_SANDBOX);
+  }
+  if (env.ISSUE_FLOW_ANTIGRAVITY_EXECUTE_TIMEOUT !== void 0) {
+    antigravity.executeTimeout = env.ISSUE_FLOW_ANTIGRAVITY_EXECUTE_TIMEOUT;
+  }
+  if (Object.keys(antigravity).length > 0) layer.antigravity = antigravity;
+  return layer;
+}
+function readAgentKey(raw, label, warn) {
+  if (raw === void 0) return {};
+  const parsed = agentConfigInputSchema.safeParse(raw);
+  if (!parsed.success) {
+    warn(
+      `Ignoring "agent" key of ${label}: ${parsed.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  const phases = parsePhasesInput(
+    raw !== null && typeof raw === "object" && "phases" in raw ? raw.phases : void 0,
+    warn
+  );
+  return {
+    ...parsed.data.provider !== void 0 ? { provider: parsed.data.provider } : {},
+    ...parsed.data.model !== void 0 ? { model: parsed.data.model } : {},
+    ...parsed.data.claude !== void 0 ? { claude: parsed.data.claude } : {},
+    ...parsed.data.codex !== void 0 ? { codex: parsed.data.codex } : {},
+    ...parsed.data.cursor !== void 0 ? { cursor: parsed.data.cursor } : {},
+    ...parsed.data.antigravity !== void 0 ? { antigravity: parsed.data.antigravity } : {},
+    ...Object.keys(phases).length > 0 ? { phases } : {}
+  };
+}
+function pickOrigin(layers) {
+  let current = "default";
+  for (const layer of layers) {
+    if (layer.value !== void 0) current = layer.origin;
+  }
+  return current;
+}
+function mergeAgentBlockLayers(layers) {
+  let merged = {};
+  let any = false;
+  for (const layer of layers) {
+    if (layer.block === void 0) continue;
+    any = true;
+    merged = {
+      ...merged,
+      ...dropUndefinedBlock(layer.block),
+      claude: { ...merged.claude, ...layer.block.claude },
+      codex: { ...merged.codex, ...layer.block.codex },
+      cursor: { ...merged.cursor, ...layer.block.cursor },
+      antigravity: { ...merged.antigravity, ...layer.block.antigravity }
+    };
+  }
+  return any ? merged : void 0;
+}
+function dropUndefinedBlock(block) {
+  const result = {};
+  if (block.provider !== void 0) result.provider = block.provider;
+  if (block.model !== void 0) result.model = block.model;
+  if (block.claude !== void 0) result.claude = block.claude;
+  if (block.codex !== void 0) result.codex = block.codex;
+  if (block.cursor !== void 0) result.cursor = block.cursor;
+  if (block.antigravity !== void 0) result.antigravity = block.antigravity;
+  return result;
+}
+async function loadAgentConfig(options = {}) {
+  const canCache = options.cli === void 0 && options.env === void 0 && options.projectRoot === void 0 && options.globalRoot === void 0 && options.warn === void 0;
+  if (canCache && cachedAgentConfig !== void 0) return cachedAgentConfig;
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? agentCliOverrides;
+  const env = options.env ?? process.env;
+  const globalFile = await loadGlobalConfig({
+    env,
+    globalRoot: options.globalRoot,
+    warn
+  });
+  const globalLayer = readAgentKey(globalFile.agent, GLOBAL_CONFIG_FILENAME, warn);
+  const projectFile = await readProjectConfigFile(options.projectRoot, warn);
+  const projectLayer = readAgentKey(projectFile?.agent, PROJECT_CONFIG_FILENAME, warn);
+  const envLayer = readAgentEnv(env, warn);
+  const provider = cli.forceProvider ?? cli.provider ?? envLayer.provider ?? projectLayer.provider ?? globalLayer.provider ?? "claude";
+  const model = cli.forceModel ?? cli.model ?? envLayer.model ?? projectLayer.model ?? globalLayer.model ?? null;
+  const claude = mergeConfigLayers({
+    global: globalLayer.claude,
+    project: projectLayer.claude,
+    env: envLayer.claude,
+    cli: cli.claude
+  });
+  const codex = mergeConfigLayers({
+    global: globalLayer.codex,
+    project: projectLayer.codex,
+    env: envLayer.codex,
+    cli: cli.codex
+  });
+  const cursor = mergeConfigLayers({
+    global: globalLayer.cursor,
+    project: projectLayer.cursor,
+    env: envLayer.cursor,
+    cli: cli.cursor
+  });
+  const antigravity = mergeConfigLayers({
+    global: globalLayer.antigravity,
+    project: projectLayer.antigravity,
+    env: envLayer.antigravity,
+    cli: cli.antigravity
+  });
+  const phases = {};
+  const phaseOrigins = {};
+  for (const phase of AGENT_PHASES) {
+    const block = mergeAgentBlockLayers([
+      { origin: "global", block: globalLayer.phases?.[phase] },
+      { origin: "project", block: projectLayer.phases?.[phase] },
+      { origin: "env", block: envLayer.phases?.[phase] },
+      { origin: "cli", block: cli.phases?.[phase] }
+    ]);
+    if (block && Object.keys(block).length > 0) {
+      phases[phase] = block;
+      phaseOrigins[phase] = {
+        provider: block.provider !== void 0 ? pickOrigin([
+          { origin: "global", value: globalLayer.phases?.[phase]?.provider },
+          { origin: "project", value: projectLayer.phases?.[phase]?.provider },
+          { origin: "env", value: envLayer.phases?.[phase]?.provider },
+          { origin: "cli", value: cli.phases?.[phase]?.provider }
+        ]) : void 0,
+        model: block.model !== void 0 ? pickOrigin([
+          { origin: "global", value: globalLayer.phases?.[phase]?.model },
+          { origin: "project", value: projectLayer.phases?.[phase]?.model },
+          { origin: "env", value: envLayer.phases?.[phase]?.model },
+          { origin: "cli", value: cli.phases?.[phase]?.model }
+        ]) : void 0
+      };
+    }
+  }
+  setTrackedOrigins({
+    provider: pickOrigin([
+      { origin: "default", value: "claude" },
+      { origin: "global", value: globalLayer.provider },
+      { origin: "project", value: projectLayer.provider },
+      { origin: "env", value: envLayer.provider },
+      { origin: "cli", value: cli.forceProvider ?? cli.provider }
+    ]),
+    model: pickOrigin([
+      { origin: "default", value: void 0 },
+      { origin: "global", value: globalLayer.model },
+      { origin: "project", value: projectLayer.model },
+      { origin: "env", value: envLayer.model },
+      { origin: "cli", value: cli.forceModel ?? cli.model }
+    ]),
+    phases: phaseOrigins
+  });
+  const resolved = { provider, model, claude, codex, cursor, antigravity, phases };
+  if (canCache) cachedAgentConfig = resolved;
+  return resolved;
+}
+var verifyCliOverrides = {};
+function setVerifyCliOverrides(overrides) {
+  verifyCliOverrides = overrides;
+}
+async function readVerifyConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const verify = file?.verify;
+  if (verify === void 0) return {};
+  const result = verifyConfigSchema.partial().safeParse(verify);
+  if (!result.success) {
+    warn(
+      `Ignoring "verify" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadVerifyConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? verifyCliOverrides;
+  const fileLayer = await readVerifyConfigFile(options.projectRoot, warn);
+  const merged = { ...fileLayer, ...cli };
+  const result = verifyConfigSchema.safeParse(merged);
+  if (result.success) return result.data;
+  warn(
+    `Invalid verify configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return verifyConfigSchema.parse({});
+}
+var routingCliOverrides = {};
+function setRoutingCliOverrides(overrides) {
+  routingCliOverrides = overrides;
+}
+async function loadRoutingConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const file = await readProjectConfigFile(options.projectRoot, warn);
+  const raw = file?.routing;
+  const parsed = raw === void 0 ? {} : routingConfigSchema.partial().safeParse(raw).data ?? {};
+  const result = routingConfigSchema.safeParse({
+    ...parsed,
+    ...options.cli ?? routingCliOverrides
+  });
+  return result.success ? result.data : routingConfigSchema.parse({});
+}
+
+export {
+  getShutdownSignal,
+  onShutdown,
+  installShutdownHandlers,
+  DEFAULT_INACTIVITY_TIMEOUT_MS,
+  peekHarnessVersion,
+  resolveAntigravityTimeoutMs,
+  getRegisteredProviders,
+  ensureRunnersRegistered,
+  runnerFor,
+  ensureHarnessVersion,
+  probeAgent,
+  DEFAULTS,
+  createConfig,
+  resolvePaths,
+  getInstallHint,
+  validateDependencies,
+  PROJECT_CONFIG_FILENAME,
+  WEB_CONFIG_FILENAME,
+  GLOBAL_CONFIG_FILENAME,
+  loadGlobalConfig,
+  mergeConfigLayers,
+  setWebCliOverrides,
+  loadWebConfig,
+  setIssuesCliOverrides,
+  loadIssuesConfig,
+  loadPrReviewConfig,
+  setPolicyCliOverrides,
+  loadPolicyConfig,
+  loadTelemetryConfig,
+  setResilienceCliOverrides,
+  loadResilienceConfig,
+  getActiveResilienceConfig,
+  setActiveResilienceConfig,
+  initResilienceConfig,
+  setAgentCliOverrides,
+  getAgentCliOverrides,
+  loadAgentConfig,
+  setVerifyCliOverrides,
+  loadVerifyConfig,
+  setRoutingCliOverrides,
+  loadRoutingConfig,
+  resolveAgentFor,
+  parseAgentPhaseFlag,
+  describeRunAgents,
+  hasExplicitAgentSelection
+};
+//# sourceMappingURL=chunk-QJ5UZAH5.js.map