@yul-labs/agent-relay 0.1.1

package/dist/index.js

@@ -0,0 +1,2571 @@
+import fs3, { promises, constants, statSync, chmodSync } from 'fs';
+import path7 from 'path';
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+import { execa } from 'execa';
+import os from 'os';
+import * as nodePty from 'node-pty';
+import { createRequire } from 'module';
+
+// src/core/config.ts
+
+// src/core/errors.ts
+var AgentRelayError = class extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.name = "AgentRelayError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+var ConfigError = class extends AgentRelayError {
+  constructor(message, hint) {
+    super(message, "CONFIG_ERROR", hint);
+    this.name = "ConfigError";
+  }
+};
+var UnknownAdapterError = class extends AgentRelayError {
+  constructor(name, available) {
+    super(
+      `Unknown adapter "${name}".`,
+      "UNKNOWN_ADAPTER",
+      available.length ? `Available adapters: ${available.join(", ")}.` : "No adapters are configured."
+    );
+    this.name = "UnknownAdapterError";
+  }
+};
+var SessionNotFoundError = class extends AgentRelayError {
+  constructor(sessionId) {
+    super(
+      `Session "${sessionId}" not found.`,
+      "SESSION_NOT_FOUND",
+      "Use `agent-relay run` to create a session first."
+    );
+    this.name = "SessionNotFoundError";
+  }
+};
+
+// src/core/config.ts
+var CONFIG_FILENAME = "agent-relay.config.json";
+var adapterModeSchema = z.enum(["pty", "test"]);
+var approvalPolicySchema = z.enum(["auto", "gated", "readonly"]);
+var sandboxSchema = z.enum([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var adapterConfigSchema = z.object({
+  type: z.string().min(1),
+  mode: adapterModeSchema,
+  command: z.string().min(1).optional(),
+  args: z.array(z.string()).default([]),
+  /** Extra env vars to inject when spawning. */
+  env: z.record(z.string()).optional(),
+  /** Per-adapter approval override (falls back to defaults). */
+  approvalPolicy: approvalPolicySchema.optional(),
+  /** Per-adapter sandbox override (falls back to defaults). */
+  sandbox: sandboxSchema.optional()
+}).strict();
+var defaultsSchema = z.object({
+  maxTurns: z.number().int().positive().default(20),
+  timeoutMs: z.number().int().positive().default(18e5),
+  idleTimeoutMs: z.number().int().positive().default(3e5),
+  /**
+   * Default autonomy level. `auto` (the default) makes runs fully
+   * unattended — the orchestrator auto-approves and the agent CLIs are
+   * launched with their non-interactive "don't ask" flags.
+   */
+  approvalPolicy: approvalPolicySchema.optional(),
+  /** Default sandbox strength for process-spawning agents. */
+  sandbox: sandboxSchema.optional(),
+  /** Interactive: idle window before a finished agent's TUI is quit (ms). */
+  completionIdleMs: z.number().int().positive().optional(),
+  /**
+   * Legacy flag. When `approvalPolicy` is unset, `true` -> `gated` and
+   * `false` -> `auto`. Kept for back-compat; prefer `approvalPolicy`.
+   */
+  requireApprovalOnRiskyActions: z.boolean().default(false)
+}).strict();
+function resolveApprovalMode(defaults, adapter) {
+  return adapter?.approvalPolicy ?? defaults.approvalPolicy ?? (defaults.requireApprovalOnRiskyActions ? "gated" : "auto");
+}
+function resolveSandbox(defaults, adapter) {
+  return adapter?.sandbox ?? defaults.sandbox ?? "workspace-write";
+}
+var hooksSchema = z.object({
+  /** Shell command run just before the agent starts. */
+  onStart: z.string().min(1).optional(),
+  /** Shell command run after the run reaches a terminal status. */
+  onComplete: z.string().min(1).optional()
+}).strict();
+var deciderSchema = z.object({
+  type: z.enum(["rule", "always-approve", "command", "api"]).default("rule"),
+  /** rule: regex strings that trigger deny / a negative choice. */
+  denyPatterns: z.array(z.string()).optional(),
+  /** rule: stance for non-dangerous approvals. */
+  defaultApproval: z.enum(["approve", "deny"]).optional(),
+  /** rule: default answer for free-text input prompts. */
+  defaultAnswer: z.string().optional(),
+  /** command: the decider model CLI + args (e.g. claude -p / codex exec). */
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional(),
+  timeoutMs: z.number().int().positive().optional(),
+  /** api: OpenAI-compatible chat-completions endpoint + model. */
+  url: z.string().url().optional(),
+  model: z.string().optional(),
+  apiKey: z.string().optional(),
+  maxTokens: z.number().int().positive().optional()
+}).strict();
+var configSchema = z.object({
+  defaultAdapter: z.string().min(1),
+  sessionsDir: z.string().min(1).default(".agent-relay/sessions"),
+  logsDir: z.string().min(1).default(".agent-relay/logs"),
+  defaults: defaultsSchema.default({}),
+  adapters: z.record(adapterConfigSchema),
+  /** Which decider answers interactive prompts. */
+  decider: deciderSchema.optional(),
+  /** Optional shell-command lifecycle hooks. */
+  hooks: hooksSchema.optional()
+}).strict().superRefine((cfg, ctx) => {
+  if (!cfg.adapters[cfg.defaultAdapter]) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["defaultAdapter"],
+      message: `defaultAdapter "${cfg.defaultAdapter}" is not present in "adapters".`
+    });
+  }
+});
+function createDefaultConfig() {
+  return configSchema.parse({
+    defaultAdapter: "claude",
+    sessionsDir: ".agent-relay/sessions",
+    logsDir: ".agent-relay/logs",
+    defaults: {
+      maxTurns: 20,
+      timeoutMs: 18e5,
+      idleTimeoutMs: 3e5,
+      // Autonomous by default: agents run unattended without asking.
+      approvalPolicy: "auto",
+      sandbox: "workspace-write",
+      requireApprovalOnRiskyActions: false
+    },
+    // Interactive (PTY) is the default mode: the agent runs in its real TUI and
+    // its approval/choice prompts are answered by the decider.
+    decider: { type: "rule" },
+    adapters: {
+      claude: { type: "claude", mode: "pty", command: "claude", args: [] },
+      codex: { type: "codex", mode: "pty", command: "codex", args: [] },
+      fake: { type: "fake", mode: "test", args: [] }
+    }
+  });
+}
+function parseConfig(value) {
+  const result = configSchema.safeParse(value);
+  if (!result.success) {
+    const detail = result.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new ConfigError(
+      `Invalid agent-relay config:
+${detail}`,
+      "Run `agent-relay init` to regenerate a valid config, or fix the listed fields."
+    );
+  }
+  return result.data;
+}
+function parseDeciderConfig(value) {
+  const result = deciderSchema.safeParse(value);
+  if (!result.success) {
+    const detail = result.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new ConfigError(
+      `Invalid decider options:
+${detail}`,
+      "Check the --decider* flags (e.g. --decider api --decider-url <url>)."
+    );
+  }
+  return result.data;
+}
+function configPath(rootDir) {
+  return path7.resolve(rootDir, CONFIG_FILENAME);
+}
+async function loadConfig(rootDir) {
+  const file = configPath(rootDir);
+  let raw;
+  try {
+    raw = await promises.readFile(file, "utf8");
+  } catch {
+    throw new ConfigError(
+      `Config file not found at ${file}.`,
+      "Run `agent-relay init` to create one."
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `Config file ${file} is not valid JSON: ${err.message}`,
+      "Fix the JSON syntax or run `agent-relay init` to regenerate it."
+    );
+  }
+  return parseConfig(json);
+}
+async function loadConfigOrDefault(rootDir, onDefault) {
+  const file = configPath(rootDir);
+  try {
+    await promises.access(file);
+  } catch {
+    onDefault?.();
+    return createDefaultConfig();
+  }
+  return loadConfig(rootDir);
+}
+function stringifyConfig(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+async function saveConfig(rootDir, config) {
+  const file = configPath(rootDir);
+  await promises.mkdir(path7.dirname(file), { recursive: true });
+  await promises.writeFile(file, stringifyConfig(config), "utf8");
+  return file;
+}
+var SessionManager = class {
+  constructor(sessionsDir) {
+    this.sessionsDir = sessionsDir;
+  }
+  sessionsDir;
+  /** Absolute path to a session's JSON metadata file. */
+  filePath(sessionId) {
+    return path7.join(this.sessionsDir, `${sessionId}.json`);
+  }
+  /** Build a fresh session record in the `created` state (not yet persisted). */
+  create(input) {
+    return {
+      sessionId: input.sessionId ?? randomUUID(),
+      prompt: input.prompt,
+      adapter: input.adapter,
+      mode: input.mode,
+      status: "created",
+      cwd: input.cwd,
+      dryRun: input.dryRun ?? false,
+      startedAt: input.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      logFile: input.logFile
+    };
+  }
+  /** Persist (create or overwrite) a session's metadata. */
+  async save(meta) {
+    await promises.mkdir(this.sessionsDir, { recursive: true });
+    const file = this.filePath(meta.sessionId);
+    await promises.writeFile(file, `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+    return file;
+  }
+  /** Load a session's metadata, throwing {@link SessionNotFoundError}. */
+  async load(sessionId) {
+    const file = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await promises.readFile(file, "utf8");
+    } catch {
+      throw new SessionNotFoundError(sessionId);
+    }
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new AgentRelayError(
+        `Session "${sessionId}" metadata is corrupt and could not be parsed.`,
+        "SESSION_CORRUPT",
+        `Delete ${file} and re-run, or restore it from a backup.`
+      );
+    }
+  }
+  /** Apply a partial update and persist; returns the updated record. */
+  async update(sessionId, patch) {
+    const current = await this.load(sessionId);
+    const next = { ...current, ...patch };
+    await this.save(next);
+    return next;
+  }
+  /** Convenience helper to set status (and optionally endedAt). */
+  async setStatus(sessionId, status, extra = {}) {
+    return this.update(sessionId, { status, ...extra });
+  }
+  /** List all sessions, newest first. Returns [] if the dir does not exist. */
+  async list() {
+    let entries;
+    try {
+      entries = await promises.readdir(this.sessionsDir);
+    } catch {
+      return [];
+    }
+    const metas = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      try {
+        const raw = await promises.readFile(
+          path7.join(this.sessionsDir, entry),
+          "utf8"
+        );
+        metas.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    metas.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    return metas;
+  }
+};
+var RunLogger = class {
+  constructor(logFile, opts = {}) {
+    this.logFile = logFile;
+    this.opts = opts;
+  }
+  logFile;
+  opts;
+  bytes = 0;
+  suppressed = 0;
+  truncated = false;
+  append(line) {
+    const text = line.endsWith("\n") ? line : `${line}
+`;
+    if (this.opts.maxBytes && this.bytes >= this.opts.maxBytes) {
+      if (!this.truncated) {
+        this.truncated = true;
+        fs3.appendFileSync(
+          this.logFile,
+          `... [log truncated at ${this.opts.maxBytes} bytes \u2014 raise --max-log-bytes for more]
+`
+        );
+      }
+      return;
+    }
+    fs3.appendFileSync(this.logFile, text);
+    this.bytes += Buffer.byteLength(text);
+  }
+  /** Ensure the log directory exists and write the run header. */
+  start(header) {
+    fs3.mkdirSync(path7.dirname(this.logFile), { recursive: true });
+    const lines = [
+      "================ agent-relay run ================",
+      `sessionId : ${header.sessionId}`,
+      `startedAt : ${header.startedAt}`,
+      `adapter   : ${header.adapter}`,
+      `mode      : ${header.mode}`,
+      `cwd       : ${header.cwd}`
+    ];
+    if (header.command) {
+      lines.push(`command   : ${header.command.display}`);
+    }
+    lines.push("---- prompt ----");
+    lines.push(header.prompt);
+    lines.push("---- events ----");
+    this.append(lines.join("\n"));
+  }
+  /** Record a single normalized event. */
+  event(event) {
+    if (!this.opts.verbose && (event.type === "stdout" || event.type === "stderr")) {
+      this.suppressed += 1;
+      return;
+    }
+    let detail = "";
+    if (event.text) {
+      detail = event.text.replace(/\s+$/g, "");
+    } else if (event.data !== void 0) {
+      try {
+        detail = JSON.stringify(event.data);
+      } catch {
+        detail = String(event.data);
+      }
+    } else if (event.raw) {
+      detail = event.raw;
+    }
+    const oneLine = detail.replace(/\r\n|\r|\n/g, "\\n");
+    this.append(`[${event.timestamp}] ${event.type.padEnd(18)} ${oneLine}`);
+  }
+  /** Write the run footer with terminal status and optional error. */
+  finish(status, endedAt, error) {
+    const lines = ["---- end ----", `status    : ${status}`, `endedAt   : ${endedAt}`];
+    if (error) {
+      lines.push(`error     : [${error.code ?? "ERROR"}] ${error.message}`);
+      if (error.hint) lines.push(`hint      : ${error.hint}`);
+    }
+    if (this.suppressed > 0) {
+      lines.push(
+        `note      : suppressed ${this.suppressed} raw output event(s) \u2014 re-run with --verbose to log them`
+      );
+    }
+    lines.push("================================================");
+    this.append(lines.join("\n"));
+  }
+};
+
+// src/core/completion.ts
+var DefaultCompletionDetector = class {
+  name = "default";
+  detect(ctx) {
+    if (ctx.abortReason) {
+      switch (ctx.abortReason) {
+        case "timeout":
+        case "idle":
+          return "timeout";
+        case "cancel":
+          return "cancelled";
+        case "maxTurns":
+          return "failed";
+      }
+    }
+    if (ctx.error) return "failed";
+    const result = ctx.result;
+    if (result) {
+      if (result.success) return "completed";
+      if (result.exitCode === 0 && !result.error) return "completed";
+    }
+    return "failed";
+  }
+};
+var CompositeCompletionDetector = class {
+  name = "composite";
+  detectors;
+  fallback = new DefaultCompletionDetector();
+  constructor(detectors = []) {
+    this.detectors = detectors;
+  }
+  detect(ctx) {
+    for (const detector of this.detectors) {
+      const verdict = detector.detect(ctx);
+      if (verdict) return verdict;
+    }
+    return this.fallback.detect(ctx);
+  }
+};
+var OutputPatternDetector = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  name = "output-pattern";
+  detect(ctx) {
+    const text = ctx.events.filter((e) => e.type === "assistant_message" || e.type === "stdout").map((e) => e.text ?? "").join("\n");
+    if (this.options.failurePattern?.test(text)) return "failed";
+    if (this.options.successPattern?.test(text)) return "completed";
+    return void 0;
+  }
+};
+
+// src/core/util/json.ts
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/decider.ts
+var DEFAULT_DENY_PATTERNS = [
+  // any `rm` with a recursive/force flag, in any flag order/combination
+  /\brm\s+(?:-[a-z]*[rf]|--(?:recursive|force))/i,
+  /\bsudo\b/i,
+  /\bgit\s+push\b[^\n]*--force\b|\bpush\s+-f\b/i,
+  /\bdrop\s+(table|database)\b/i,
+  /\bcurl\b[^\n]*\|\s*(sh|bash)\b/i,
+  /\bmkfs\b|\bdd\s+if=/i,
+  /:\s*\(\s*\)\s*\{/
+  // fork bomb-ish
+];
+var DEFAULT_AFFIRMATIVE = /\b(yes|proceed|approve|allow|accept|confirm|continue|ok)\b/i;
+var DEFAULT_NEGATIVE = /\b(no|cancel|reject|deny|abort|stop|decline)\b/i;
+var RuleDecider = class {
+  name;
+  opts;
+  constructor(options = {}) {
+    this.name = options.name ?? "rule";
+    this.opts = {
+      // Approve everything by DEFAULT so the agent's task actually progresses.
+      // Blocking on a danger-regex matched against mangled TUI text both breaks
+      // legitimate task work and misses real risks — so danger patterns are
+      // opt-in (pass `denyPatterns: DEFAULT_DENY_PATTERNS` to enable them). For
+      // task-aware "redirect only off-task danger", use an LLM decider instead.
+      // Setting `denyPatterns` ALSO switches choice menus from "confirm the
+      // recommended option" (the default) to label-aware affirmative/negative
+      // selection — see `decide()`.
+      denyPatterns: options.denyPatterns ?? [],
+      defaultApproval: options.defaultApproval ?? "approve",
+      affirmativePattern: options.affirmativePattern ?? DEFAULT_AFFIRMATIVE,
+      negativePattern: options.negativePattern ?? DEFAULT_NEGATIVE,
+      defaultAnswer: options.defaultAnswer ?? ""
+    };
+  }
+  isDangerous(text) {
+    return this.opts.denyPatterns.some((re) => re.test(text));
+  }
+  async decide(req) {
+    const haystack = `${req.prompt}
+${req.context ?? ""}`;
+    const hasDenyPolicy = this.opts.denyPatterns.length > 0;
+    const dangerous = this.isDangerous(haystack);
+    if (req.kind === "choice" && req.options && req.options.length > 0) {
+      if (req.multiSelect) {
+        const keep = (req.checked ?? []).flatMap((c, i) => c ? [i] : []);
+        return {
+          action: "select",
+          optionIndexes: keep,
+          reason: "rule: keep current multi-select & submit",
+          by: this.name
+        };
+      }
+      if (!hasDenyPolicy) {
+        return {
+          action: "select",
+          optionIndex: 0,
+          reason: "rule: confirm recommended (first) option",
+          by: this.name
+        };
+      }
+      if (dangerous) {
+        const negIdx = req.options.findIndex(
+          (o) => this.opts.negativePattern.test(o)
+        );
+        if (negIdx >= 0) {
+          return {
+            action: "select",
+            optionIndex: negIdx,
+            reason: "rule: dangerous prompt -> negative option",
+            by: this.name
+          };
+        }
+        return {
+          action: "deny",
+          reason: "rule: dangerous prompt, no negative option -> cancel",
+          by: this.name
+        };
+      }
+      const affIdx = req.options.findIndex(
+        (o) => this.opts.affirmativePattern.test(o)
+      );
+      return {
+        action: "select",
+        optionIndex: affIdx >= 0 ? affIdx : 0,
+        reason: "rule: affirmative option",
+        by: this.name
+      };
+    }
+    if (req.kind === "input") {
+      return {
+        action: "answer",
+        text: this.opts.defaultAnswer,
+        reason: "rule: default answer",
+        by: this.name
+      };
+    }
+    if (dangerous) {
+      return { action: "deny", reason: "rule: matched deny pattern", by: this.name };
+    }
+    return {
+      action: this.opts.defaultApproval,
+      reason: `rule: default ${this.opts.defaultApproval}`,
+      by: this.name
+    };
+  }
+};
+var AlwaysApproveDecider = class {
+  name = "always-approve";
+  async decide(req) {
+    if (req.kind === "choice" && req.options?.length) {
+      if (req.multiSelect) {
+        const keep = (req.checked ?? []).flatMap((c, i) => c ? [i] : []);
+        return { action: "select", optionIndexes: keep, by: this.name };
+      }
+      return { action: "select", optionIndex: 0, by: this.name };
+    }
+    if (req.kind === "input") return { action: "answer", text: "", by: this.name };
+    return { action: "approve", by: this.name };
+  }
+};
+var FunctionDecider = class {
+  constructor(fn, name = "function") {
+    this.fn = fn;
+    this.name = name;
+  }
+  fn;
+  name;
+  async decide(req) {
+    return this.fn(req);
+  }
+};
+function renderDecisionPrompt(req) {
+  const options = req.options && req.options.length ? `
+Options (0-indexed):
+${req.options.map(
+    (o, i) => req.multiSelect ? `  ${i}. [${req.checked?.[i] ? "x" : " "}] ${o}` : `  ${i}. ${o}`
+  ).join("\n")}` : "";
+  const multiNote = req.multiSelect ? `
+This is a MULTI-SELECT (checkboxes; [x] = currently checked). Return "optionIndexes" = the COMPLETE set of 0-based indices that should END UP checked to advance the TASK (keep already-good ones). The agent toggles the difference and submits.` : "";
+  return [
+    `You are the approval policy for an autonomous coding agent (${req.agent ?? "agent"}).`,
+    `The agent is working on this TASK:`,
+    `"""`,
+    (req.task ?? "(task not provided)").slice(0, 2e3),
+    `"""`,
+    ``,
+    `It paused and needs a decision (kind: "${req.kind}") on:`,
+    req.prompt,
+    options,
+    multiNote,
+    req.context ? `
+Recent terminal context:
+${req.context.slice(-800)}` : "",
+    ``,
+    `POLICY \u2014 bias strongly toward letting the agent finish the TASK:`,
+    `- DEFAULT TO APPROVING. Allow commands, file edits, installs and other actions that plausibly help complete the TASK, even risky-looking ones, so the project actually progresses.`,
+    `- ONLY deny (or pick the negative option) when the action is BOTH clearly dangerous AND unrelated to the TASK (off-task) \u2014 e.g. deleting unrelated data, modifying the system, or network exfiltration with no task purpose. Then put a short redirect in "text" telling the agent to get back to the TASK.`,
+    req.multiSelect ? `- For this multi-select, return "optionIndexes" with EXACTLY the options that advance the TASK (action "select").` : `- For a choice menu, pick the affirmative option that advances the TASK.`,
+    ``,
+    `Respond with ONLY a single JSON object, no prose:`,
+    `{"action":"approve|deny|select|answer|abort","optionIndex":<number?>,"optionIndexes":[<numbers?>],"text":"<answer or redirect comment?>","reason":"<short>"}`
+  ].filter(Boolean).join("\n");
+}
+function parseDecisionReply(reply) {
+  for (const candidate of reply.match(/\{[^{}]*\}/g) ?? []) {
+    const obj = safeJsonParse(candidate);
+    if (obj && typeof obj.action === "string") {
+      const action = obj.action;
+      if (["approve", "deny", "select", "answer", "abort"].includes(action)) {
+        return {
+          action,
+          optionIndex: typeof obj.optionIndex === "number" ? obj.optionIndex : void 0,
+          optionIndexes: Array.isArray(obj.optionIndexes) ? obj.optionIndexes.filter((x) => typeof x === "number") : void 0,
+          text: typeof obj.text === "string" ? obj.text : void 0,
+          reason: typeof obj.reason === "string" ? obj.reason : void 0
+        };
+      }
+    }
+  }
+  const lower = reply.toLowerCase();
+  const negative = /\b(deny|reject|no|abort)\b/.test(lower);
+  if (negative) {
+    return { action: "deny", reason: "keyword:deny" };
+  }
+  if (/\b(approve|allow|yes|proceed)\b/.test(lower)) {
+    return { action: "approve", reason: "keyword:approve" };
+  }
+  return void 0;
+}
+var CommandDecider = class {
+  name;
+  opts;
+  constructor(options) {
+    this.name = options.name ?? `command:${options.command}`;
+    this.opts = options;
+  }
+  async decide(req) {
+    const render = this.opts.renderPrompt ?? renderDecisionPrompt;
+    const prompt = render(req);
+    const fallback = this.opts.fallback ?? {
+      action: "deny",
+      reason: "decider unavailable -> safe deny",
+      by: this.name
+    };
+    try {
+      const result = await execa(this.opts.command, this.opts.args ?? [], {
+        input: prompt,
+        env: { ...process.env, ...this.opts.env },
+        reject: false,
+        timeout: this.opts.timeoutMs ?? 6e4,
+        stripFinalNewline: true
+      });
+      const stdout = typeof result.stdout === "string" ? result.stdout : "";
+      const parsed = parseDecisionReply(stdout);
+      if (parsed) return { ...parsed, by: this.name };
+      return fallback;
+    } catch {
+      return fallback;
+    }
+  }
+};
+var ApiDecider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.name = opts.name ?? `api:${opts.model ?? "model"}`;
+  }
+  opts;
+  name;
+  async decide(req) {
+    const render = this.opts.renderPrompt ?? renderDecisionPrompt;
+    const fallback = this.opts.fallback ?? {
+      action: "deny",
+      reason: "api decider unavailable -> safe deny",
+      by: this.name
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      this.opts.timeoutMs ?? 6e4
+    );
+    try {
+      const res = await fetch(this.opts.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          model: this.opts.model ?? "default",
+          messages: [{ role: "user", content: render(req) }],
+          max_tokens: this.opts.maxTokens ?? 2048,
+          temperature: this.opts.temperature ?? 0,
+          stream: false
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) return fallback;
+      const data = await res.json();
+      const msg = data.choices?.[0]?.message ?? {};
+      const parsed = parseDecisionReply(msg.content ?? "") ?? parseDecisionReply(msg.reasoning_content ?? "");
+      return parsed ? { ...parsed, by: this.name } : fallback;
+    } catch {
+      return fallback;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function createDecider(config) {
+  if (!config) return new RuleDecider();
+  switch (config.type) {
+    case "always-approve":
+      return new AlwaysApproveDecider();
+    case "command":
+      if (!config.command) {
+        return new RuleDecider();
+      }
+      return new CommandDecider({
+        command: config.command,
+        args: config.args,
+        env: config.env,
+        timeoutMs: config.timeoutMs
+      });
+    case "api":
+      if (!config.url) {
+        return new RuleDecider();
+      }
+      return new ApiDecider({
+        url: config.url,
+        model: config.model,
+        apiKey: config.apiKey,
+        maxTokens: config.maxTokens,
+        timeoutMs: config.timeoutMs
+      });
+    case "rule":
+    default:
+      return new RuleDecider({
+        denyPatterns: config.denyPatterns?.map((s) => new RegExp(s, "i")),
+        defaultApproval: config.defaultApproval,
+        defaultAnswer: config.defaultAnswer
+      });
+  }
+}
+async function runShellHook(command, ctx) {
+  try {
+    const result = await execa(command, {
+      shell: true,
+      cwd: ctx.cwd,
+      reject: false,
+      timeout: 6e4,
+      env: {
+        ...process.env,
+        AGENT_RELAY_SESSION_ID: ctx.sessionId,
+        AGENT_RELAY_ADAPTER: ctx.adapter,
+        AGENT_RELAY_STATUS: ctx.status,
+        AGENT_RELAY_CWD: ctx.cwd,
+        AGENT_RELAY_LOG_FILE: ctx.logFile,
+        AGENT_RELAY_EXIT_CODE: ctx.exitCode == null ? "" : String(ctx.exitCode)
+      }
+    });
+    const code = typeof result.exitCode === "number" ? result.exitCode : null;
+    return { ok: code === 0, exitCode: code };
+  } catch {
+    return { ok: false, exitCode: null };
+  }
+}
+async function safeHook(fn, arg) {
+  if (!fn) return;
+  try {
+    await fn(arg);
+  } catch {
+  }
+}
+async function runAgent(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const iso = () => now().toISOString();
+  const config = options.config;
+  const adapterName = options.adapterName ?? config.defaultAdapter;
+  const adapterConfig = config.adapters[adapterName];
+  if (!adapterConfig) {
+    throw new UnknownAdapterError(adapterName, Object.keys(config.adapters));
+  }
+  const adapter = options.resolveAdapter(adapterName, config);
+  const detector = options.detector ?? new CompositeCompletionDetector();
+  const rootDir = path7.resolve(options.rootDir);
+  const cwd = path7.resolve(options.cwd ?? rootDir);
+  const sessionsDir = path7.resolve(rootDir, config.sessionsDir);
+  const logsDir = path7.resolve(rootDir, config.logsDir);
+  const sessionId = options.sessionId ?? randomUUID();
+  const logFile = path7.join(logsDir, `${sessionId}.log`);
+  const sessions = new SessionManager(sessionsDir);
+  const startedAt = iso();
+  const session = sessions.create({
+    sessionId,
+    prompt: options.prompt,
+    adapter: adapterName,
+    mode: adapter.definition.mode,
+    cwd,
+    logFile,
+    dryRun: options.dryRun ?? false,
+    startedAt
+  });
+  await sessions.save(session);
+  await safeHook(options.hooks?.onSessionStart, session);
+  const finalize = async (outcome, runShellComplete) => {
+    await safeHook(options.hooks?.onComplete, outcome);
+    if (runShellComplete && config.hooks?.onComplete) {
+      await runShellHook(config.hooks.onComplete, {
+        sessionId: outcome.session.sessionId,
+        adapter: outcome.session.adapter,
+        status: outcome.status,
+        cwd: outcome.session.cwd,
+        logFile: outcome.logFile,
+        exitCode: outcome.session.exitCode
+      });
+    }
+    return outcome;
+  };
+  const persist = async (patch) => {
+    try {
+      return await sessions.update(sessionId, patch);
+    } catch {
+      return { ...session, ...patch };
+    }
+  };
+  const positiveOr = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+  const approvalMode = options.approvalMode ?? resolveApprovalMode(config.defaults, adapterConfig);
+  const sandbox = options.sandbox ?? resolveSandbox(config.defaults, adapterConfig);
+  const input = {
+    prompt: options.prompt,
+    cwd,
+    maxTurns: positiveOr(options.maxTurns, config.defaults.maxTurns),
+    timeoutMs: positiveOr(options.timeoutMs, config.defaults.timeoutMs),
+    idleTimeoutMs: positiveOr(options.idleTimeoutMs, config.defaults.idleTimeoutMs),
+    dryRun: options.dryRun ?? false,
+    // Per-adapter `args` from config (e.g. ["--effort","max"]) come first, then
+    // any per-run `--extra` flags — both are appended after the adapter's own
+    // pre-args and before the prompt when spawning.
+    extraArgs: [...adapterConfig.args ?? [], ...options.extraArgs ?? []],
+    approvalMode,
+    sandbox,
+    completionIdleMs: options.completionIdleMs ?? config.defaults.completionIdleMs,
+    ultracode: options.ultracode,
+    resume: options.resume
+  };
+  const preview = safeDescribe(adapter, input);
+  const logger = new RunLogger(logFile, {
+    verbose: options.verbose,
+    maxBytes: options.maxLogBytes
+  });
+  logger.start({
+    sessionId,
+    adapter: adapterName,
+    mode: adapter.definition.mode,
+    prompt: options.prompt,
+    cwd,
+    command: preview,
+    startedAt
+  });
+  if (input.dryRun) {
+    const endedAt2 = iso();
+    const result2 = {
+      success: true,
+      exitCode: null,
+      meta: { dryRun: true, command: preview }
+    };
+    logger.event({
+      type: "status",
+      timestamp: endedAt2,
+      text: `[dry-run] would execute: ${preview?.display ?? "(no command)"}`
+    });
+    logger.finish("completed", endedAt2);
+    const finalSession2 = await persist({
+      status: "completed",
+      endedAt: endedAt2,
+      exitCode: null,
+      meta: { dryRun: true }
+    });
+    return finalize(
+      {
+        session: finalSession2,
+        status: "completed",
+        result: result2,
+        events: [],
+        logFile
+      },
+      false
+    );
+  }
+  const availability = await adapter.isAvailable();
+  if (!availability.ok) {
+    const endedAt2 = iso();
+    const error2 = {
+      message: availability.reason ?? `Adapter "${adapterName}" is not available.`,
+      code: "ADAPTER_UNAVAILABLE",
+      hint: availability.hint
+    };
+    const errorEvent = {
+      type: "error",
+      timestamp: endedAt2,
+      text: error2.message,
+      data: error2
+    };
+    logger.event(errorEvent);
+    options.onEvent?.(errorEvent);
+    logger.finish("failed", endedAt2, error2);
+    const finalSession2 = await persist({
+      status: "failed",
+      endedAt: endedAt2,
+      error: error2
+    });
+    return finalize(
+      {
+        session: finalSession2,
+        status: "failed",
+        events: [errorEvent],
+        logFile
+      },
+      true
+    );
+  }
+  await sessions.setStatus(sessionId, "running");
+  if (config.hooks?.onStart) {
+    await runShellHook(config.hooks.onStart, {
+      sessionId,
+      adapter: adapterName,
+      status: "running",
+      cwd,
+      logFile,
+      exitCode: null
+    });
+  }
+  const controller = new AbortController();
+  const events = [];
+  let abortReason;
+  let turnCount = 0;
+  let hardTimer;
+  let idleTimer;
+  const abortWith = (reason) => {
+    if (!abortReason) abortReason = reason;
+    if (!controller.signal.aborted) controller.abort();
+  };
+  const clearIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = void 0;
+  };
+  const armIdle = () => {
+    clearIdle();
+    idleTimer = setTimeout(() => abortWith("idle"), input.idleTimeoutMs);
+    idleTimer.unref?.();
+  };
+  const onEvent = (event) => {
+    events.push(event);
+    try {
+      logger.event(event);
+    } catch {
+    }
+    options.onEvent?.(event);
+    if (options.hooks?.onEvent) {
+      void Promise.resolve(options.hooks.onEvent(event, session)).catch(
+        () => {
+        }
+      );
+    }
+    armIdle();
+    if (event.type === "assistant_message") {
+      turnCount += 1;
+      if (turnCount > input.maxTurns) abortWith("maxTurns");
+    }
+  };
+  hardTimer = setTimeout(() => abortWith("timeout"), input.timeoutMs);
+  hardTimer.unref?.();
+  armIdle();
+  const installSignals = options.installSignalHandlers ?? true;
+  const onSignal = () => abortWith("cancel");
+  if (installSignals) {
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  }
+  const externalSignal = options.signal;
+  const onExternalAbort = () => abortWith("cancel");
+  if (externalSignal) {
+    if (externalSignal.aborted) abortWith("cancel");
+    else externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const decider = options.decider ?? (options.hooks?.onApprovalRequest ? new FunctionDecider(options.hooks.onApprovalRequest, "hook") : createDecider(config.decider));
+  const ctx = {
+    signal: controller.signal,
+    onEvent,
+    cwd,
+    decider
+  };
+  let result;
+  let runError;
+  try {
+    result = input.resume && adapter.resume ? await adapter.resume(input.resume, input, ctx) : await adapter.run(input, ctx);
+  } catch (err) {
+    runError = err instanceof Error ? err : new Error(String(err));
+  } finally {
+    if (hardTimer) clearTimeout(hardTimer);
+    clearIdle();
+    if (installSignals) {
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+    }
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+  }
+  const status = detector.detect({ result, events, abortReason, error: runError }) ?? "failed";
+  const endedAt = iso();
+  const error = runError && !result?.error ? { message: runError.message, code: "ADAPTER_THREW" } : result?.error ?? (abortReason === "timeout" || abortReason === "idle" ? {
+    message: `Run aborted: ${abortReason} after waiting limit.`,
+    code: abortReason === "idle" ? "IDLE_TIMEOUT" : "TIMEOUT"
+  } : abortReason === "maxTurns" ? {
+    message: `Run stopped: reached maxTurns (${input.maxTurns}).`,
+    code: "MAX_TURNS"
+  } : void 0);
+  logger.finish(status, endedAt, error);
+  const finalSession = await persist({
+    status,
+    endedAt,
+    exitCode: result?.exitCode ?? null,
+    error,
+    sessionRef: result?.sessionRef,
+    meta: result?.meta
+  });
+  return finalize(
+    {
+      session: finalSession,
+      status,
+      result,
+      events,
+      abortReason,
+      logFile
+    },
+    true
+  );
+}
+function safeDescribe(adapter, input) {
+  try {
+    return adapter.describeCommand(input);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/fake-adapter.ts
+var DEFINITION = {
+  name: "fake",
+  type: "fake",
+  mode: "test",
+  description: "Deterministic in-process adapter for tests and dry runs.",
+  supportsResume: true
+};
+var FakeAgentAdapter = class {
+  definition = DEFINITION;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      scenario: options.scenario ?? "auto",
+      assistantMessages: options.assistantMessages,
+      emitTool: options.emitTool ?? false,
+      delayMs: options.delayMs ?? 0,
+      failureExitCode: options.failureExitCode ?? 1,
+      hangSafetyMs: options.hangSafetyMs ?? 6e4,
+      now: options.now ?? (() => /* @__PURE__ */ new Date())
+    };
+  }
+  async isAvailable() {
+    return { ok: true, version: "fake-1.0.0" };
+  }
+  describeCommand(input) {
+    return {
+      mode: this.definition.mode,
+      command: "(fake)",
+      args: [],
+      display: `fake-adapter scenario=${this.resolveScenario(input)} prompt=${JSON.stringify(
+        truncate(input.prompt, 60)
+      )}`
+    };
+  }
+  resolveScenario(input) {
+    if (this.options.scenario !== "auto") return this.options.scenario;
+    const p = input.prompt.toLowerCase();
+    if (p.includes("timeout") || p.includes("hang")) return "timeout";
+    if (p.includes("fail") || p.includes("error")) return "failure";
+    return "success";
+  }
+  emit(ctx, type, extra = {}) {
+    const event = {
+      type,
+      timestamp: this.options.now().toISOString(),
+      ...extra
+    };
+    ctx.onEvent(event);
+  }
+  async run(input, ctx) {
+    const scenario = this.resolveScenario(input);
+    const sessionRef = {
+      adapter: this.definition.name,
+      nativeSessionId: `fake-${scenario}`,
+      resumable: true
+    };
+    if (ctx.signal.aborted) {
+      return { success: false, exitCode: null, aborted: true, sessionRef };
+    }
+    this.emit(ctx, "start", { text: `fake run started (scenario=${scenario})` });
+    if (scenario === "timeout") {
+      return this.hangUntilAborted(ctx, sessionRef);
+    }
+    const messages = this.options.assistantMessages ?? (scenario === "failure" ? ["Attempting the task...", "Something went wrong."] : ["Working on the task...", "Task complete."]);
+    for (const message of messages) {
+      if (ctx.signal.aborted) {
+        return { success: false, exitCode: null, aborted: true, sessionRef };
+      }
+      this.emit(ctx, "assistant_message", { text: message });
+    }
+    if (this.options.emitTool && !ctx.signal.aborted) {
+      this.emit(ctx, "tool_call", {
+        data: { name: "write_file", input: { path: "out.txt" } }
+      });
+      this.emit(ctx, "tool_result", {
+        data: { name: "write_file", ok: true }
+      });
+    }
+    if (this.options.delayMs > 0) {
+      await this.sleep(this.options.delayMs, ctx.signal);
+      if (ctx.signal.aborted) {
+        return { success: false, exitCode: null, aborted: true, sessionRef };
+      }
+    }
+    if (scenario === "failure") {
+      const error = {
+        message: "Fake adapter failure scenario.",
+        code: "FAKE_FAILURE"
+      };
+      this.emit(ctx, "error", { text: error.message });
+      this.emit(ctx, "complete", { data: { success: false } });
+      return {
+        success: false,
+        exitCode: this.options.failureExitCode,
+        error,
+        sessionRef,
+        finalMessage: messages[messages.length - 1]
+      };
+    }
+    this.emit(ctx, "complete", { data: { success: true } });
+    return {
+      success: true,
+      exitCode: 0,
+      sessionRef,
+      finalMessage: messages[messages.length - 1],
+      meta: { turns: messages.length }
+    };
+  }
+  async resume(ref, input, ctx) {
+    this.emit(ctx, "status", {
+      text: `resuming fake session ${ref.nativeSessionId ?? "(none)"}`
+    });
+    return this.run(input, ctx);
+  }
+  hangUntilAborted(ctx, sessionRef) {
+    this.emit(ctx, "status", { text: "fake run is hanging (awaiting abort)" });
+    return new Promise((resolve) => {
+      const finish = (aborted) => {
+        clearTimeout(safety);
+        ctx.signal.removeEventListener("abort", onAbort);
+        resolve({ success: false, exitCode: null, aborted, sessionRef });
+      };
+      const onAbort = () => finish(true);
+      const safety = setTimeout(() => finish(false), this.options.hangSafetyMs);
+      safety.unref?.();
+      if (ctx.signal.aborted) return finish(true);
+      ctx.signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(done, ms);
+      timer.unref?.();
+      function done() {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        resolve();
+      }
+      if (signal.aborted) return done();
+      signal.addEventListener("abort", done, { once: true });
+    });
+  }
+};
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+}
+function pathExtensions() {
+  if (process.platform !== "win32") return [""];
+  const exts = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  return ["", ...exts];
+}
+async function isExecutableFile(file) {
+  try {
+    const stat = await promises.stat(file);
+    if (!stat.isFile()) return false;
+    if (process.platform === "win32") return true;
+    await promises.access(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function which(command) {
+  if (!command) return null;
+  const exts = pathExtensions();
+  if (command.includes(path7.sep) || command.includes("/")) {
+    const base = path7.resolve(command);
+    for (const ext of exts) {
+      const candidate = base + ext;
+      if (await isExecutableFile(candidate)) return candidate;
+    }
+    return null;
+  }
+  const pathEnv = process.env.PATH ?? process.env.Path ?? "";
+  const dirs = pathEnv.split(path7.delimiter).filter(Boolean);
+  const fallbacks = process.platform === "win32" ? [] : ["/usr/local/bin", "/opt/homebrew/bin", path7.join(os.homedir(), ".local/bin")];
+  for (const dir of [...dirs, ...fallbacks]) {
+    for (const ext of exts) {
+      const candidate = path7.join(dir, command + ext);
+      if (await isExecutableFile(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/core/util/ansi.ts
+var ANSI_PATTERN = [
+  "[\\u001B\\u009B][[\\]()#;?]*",
+  "(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*",
+  "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+  "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+].join("");
+var ANSI_RE = new RegExp(ANSI_PATTERN, "g");
+var CONTROL_RE = new RegExp("[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]", "g");
+function stripAnsi(input) {
+  return input.replace(ANSI_RE, "");
+}
+function cleanTerminalText(input) {
+  let text = stripAnsi(input).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  text = text.replace(CONTROL_RE, "");
+  return text;
+}
+function tailLines(text, n) {
+  const lines = text.split("\n").map((l) => l.replace(/\s+$/g, "")).filter((l) => l.trim().length > 0);
+  return lines.slice(-n);
+}
+
+// src/adapters/interactive/prompt-detector.ts
+function parseCheckbox(label) {
+  const bracket = /^\[\s*([ xX✓✔*])?\s*\]\s*(.*)$/.exec(label);
+  if (bracket) {
+    return { checked: /[xX✓✔*]/.test(bracket[1] ?? " "), label: (bracket[2] ?? "").trim() };
+  }
+  const glyph = /^([◉◯☑☐⊠☒□■●○])\s*(.*)$/.exec(label);
+  if (glyph) {
+    const checked = "\u25C9\u2611\u22A0\u2612\u25A0\u25CF".includes(glyph[1]);
+    return { checked, label: (glyph[2] ?? "").trim() };
+  }
+  return null;
+}
+var DEFAULT_APPROVAL = /(\[y\/n\]|\(y\/n\)|\[y\/N\]|\(y\/N\)|\[Y\/n\]|\byes\/no\b|do you want|allow this|proceed\?|approve\?|confirm\?)/i;
+var DEFAULT_OPTION_LINE = /^[ \t]*[>❯*]?[ \t]*(\d+)[.)][ \t]*(\S.*)$/;
+var PromptDetector = class {
+  opts;
+  constructor(options = {}) {
+    this.opts = {
+      approvalPattern: options.approvalPattern ?? DEFAULT_APPROVAL,
+      optionLine: options.optionLine ?? DEFAULT_OPTION_LINE,
+      inputPattern: options.inputPattern,
+      minOptions: options.minOptions ?? 2,
+      tailLines: options.tailLines ?? 12
+    };
+  }
+  /** Detect a settled prompt from raw terminal output, or null. */
+  detect(rawOutput) {
+    const clean = cleanTerminalText(rawOutput);
+    const lines = tailLines(clean, this.opts.tailLines);
+    if (lines.length === 0) return null;
+    const optionMatches = [];
+    for (const line of lines) {
+      const m = this.opts.optionLine.exec(line);
+      if (m) {
+        optionMatches.push({
+          number: Number(m[1]),
+          label: (m[2] ?? "").trim(),
+          line
+        });
+      }
+    }
+    if (optionMatches.length >= this.opts.minOptions) {
+      const firstOptIdx = lines.indexOf(optionMatches[0].line);
+      const question = lines.slice(0, firstOptIdx).slice(-2).join(" ").trim();
+      const prompt = question || "Choose an option";
+      const boxes = optionMatches.map((o) => parseCheckbox(o.label));
+      const boxed = boxes.filter(Boolean).length;
+      if (boxed >= 2 && boxed >= Math.ceil(optionMatches.length / 2)) {
+        const options = optionMatches.map((o, i) => boxes[i]?.label ?? o.label);
+        const checked = optionMatches.map((o, i) => boxes[i]?.checked ?? false);
+        const marked = optionMatches.findIndex((o) => /^[ \t]*[>❯]/.test(o.line));
+        return {
+          kind: "choice",
+          prompt,
+          options,
+          optionNumbers: optionMatches.map((o) => o.number),
+          multiSelect: true,
+          checked,
+          cursorIndex: marked >= 0 ? marked : 0,
+          // Signature includes the checked state so a toggled redraw is a new
+          // prompt, but an unchanged re-render is de-duped.
+          signature: `multi:${options.map((l, i) => `${checked[i] ? "x" : " "}.${l}`).join("|")}`
+        };
+      }
+      return {
+        kind: "choice",
+        prompt,
+        options: optionMatches.map((o) => o.label),
+        optionNumbers: optionMatches.map((o) => o.number),
+        signature: `choice:${optionMatches.map((o) => `${o.number}.${o.label}`).join("|")}`
+      };
+    }
+    const approvalLineIdx = lines.findIndex(
+      (l) => this.opts.approvalPattern.test(l)
+    );
+    if (approvalLineIdx >= 0) {
+      const prompt = lines.slice(Math.max(0, approvalLineIdx - 1)).join(" ").trim();
+      return { kind: "approval", prompt, signature: `approval:${prompt}` };
+    }
+    if (this.opts.inputPattern) {
+      const idx = lines.findIndex((l) => this.opts.inputPattern.test(l));
+      if (idx >= 0) {
+        const prompt = lines.slice(Math.max(0, idx - 1)).join(" ").trim();
+        return { kind: "input", prompt, signature: `input:${prompt}` };
+      }
+    }
+    return null;
+  }
+};
+var ensured = false;
+function ensurePtyHelperExecutable() {
+  if (ensured) return;
+  ensured = true;
+  if (process.platform === "win32") return;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const root = path7.dirname(require2.resolve("node-pty/package.json"));
+    const candidates = [
+      path7.join(root, "build", "Release", "spawn-helper"),
+      path7.join(root, "build", "Debug", "spawn-helper"),
+      path7.join(
+        root,
+        "prebuilds",
+        `${process.platform}-${process.arch}`,
+        "spawn-helper"
+      )
+    ];
+    for (const file of candidates) {
+      try {
+        const st = statSync(file);
+        if ((st.mode & 73) === 0) chmodSync(file, 493);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+// src/adapters/interactive/pty-session.ts
+var ENTER = "\r";
+var DOWN = "\x1B[B";
+var UP = "\x1B[A";
+var RIGHT = "\x1B[C";
+var ESC = "\x1B";
+var SPACE = " ";
+function multiSelectKeys(decision, prompt, submitKeys) {
+  const n = prompt.options?.length ?? 0;
+  const current = prompt.checked ?? new Array(n).fill(false);
+  const desired = new Set(
+    decision.optionIndexes ?? current.flatMap((c, i) => c ? [i] : [])
+  );
+  let pos = Math.min(Math.max(0, prompt.cursorIndex ?? 0), Math.max(0, n - 1));
+  let keys = "";
+  for (let i = 0; i < n; i++) {
+    if (desired.has(i) !== current[i]) {
+      const delta = i - pos;
+      keys += (delta >= 0 ? DOWN : UP).repeat(Math.abs(delta)) + SPACE;
+      pos = i;
+    }
+  }
+  return keys + submitKeys;
+}
+var DefaultKeymap = class {
+  constructor(multiSelectSubmit = RIGHT) {
+    this.multiSelectSubmit = multiSelectSubmit;
+  }
+  multiSelectSubmit;
+  keysFor(decision, prompt) {
+    if (prompt.multiSelect && (decision.action === "select" || decision.action === "approve")) {
+      return multiSelectKeys(decision, prompt, this.multiSelectSubmit);
+    }
+    switch (decision.action) {
+      case "approve":
+        return /\[y|\(y|y\/n/i.test(prompt.prompt) ? `y${ENTER}` : ENTER;
+      case "deny":
+        return prompt.kind === "choice" ? ESC : `n${ENTER}`;
+      case "select": {
+        const idx = decision.optionIndex ?? 0;
+        const num = prompt.optionNumbers && prompt.optionNumbers[idx] !== void 0 ? prompt.optionNumbers[idx] : idx + 1;
+        return `${num}${ENTER}`;
+      }
+      case "answer":
+        return `${decision.text ?? ""}${ENTER}`;
+      case "abort":
+        return null;
+      default:
+        return null;
+    }
+  }
+};
+var ArrowKeymap = class {
+  constructor(multiSelectSubmit = RIGHT) {
+    this.multiSelectSubmit = multiSelectSubmit;
+  }
+  multiSelectSubmit;
+  keysFor(decision, prompt) {
+    if (prompt.multiSelect && (decision.action === "select" || decision.action === "approve")) {
+      return multiSelectKeys(decision, prompt, this.multiSelectSubmit);
+    }
+    switch (decision.action) {
+      case "approve":
+        return ENTER;
+      case "select": {
+        const idx = Math.max(0, decision.optionIndex ?? 0);
+        return DOWN.repeat(idx) + ENTER;
+      }
+      case "deny": {
+        const opts = prompt.options;
+        if (prompt.kind === "choice" && opts && opts.length > 0) {
+          const negIdx = opts.findIndex(
+            (o) => /\b(no|cancel|reject|deny|do ?n['o]?t)\b/i.test(o)
+          );
+          const idx = negIdx >= 0 ? negIdx : opts.length - 1;
+          return DOWN.repeat(idx) + ENTER;
+        }
+        return ESC;
+      }
+      case "answer":
+        return `${decision.text ?? ""}${ENTER}`;
+      case "abort":
+        return null;
+      default:
+        return null;
+    }
+  }
+};
+function runPtySession(opts, ctx) {
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const keymap = opts.keymap ?? new DefaultKeymap();
+  const idleMs = opts.idleMs ?? 450;
+  const maxInteractions = opts.maxInteractions ?? 100;
+  const exitGraceMs = opts.exitGraceMs ?? 4e3;
+  const emit = (type, text, extra = {}) => {
+    ctx.onEvent({ type, timestamp: now().toISOString(), text, ...extra });
+  };
+  return new Promise((resolve) => {
+    if (ctx.signal.aborted) {
+      resolve({ success: false, exitCode: null, aborted: true });
+      return;
+    }
+    let child;
+    try {
+      ensurePtyHelperExecutable();
+      child = nodePty.spawn(opts.command, opts.args, {
+        name: "xterm-256color",
+        cols: opts.cols ?? 120,
+        rows: opts.rows ?? 34,
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env }
+      });
+    } catch (err) {
+      const code = err.code;
+      const error = code === "ENOENT" ? {
+        message: `Command "${opts.command}" was not found on your PATH.`,
+        code: "COMMAND_NOT_FOUND",
+        hint: opts.installHint
+      } : {
+        message: `Failed to start PTY for ${opts.command}: ${err.message}`,
+        code: "PTY_SPAWN_FAILED",
+        hint: opts.installHint
+      };
+      emit("error", error.message, { data: error });
+      resolve({ success: false, exitCode: null, error });
+      return;
+    }
+    let buffer = "";
+    let lastSig = "";
+    let bytesSinceHandled = 0;
+    let pendingComment;
+    const setupSteps = opts.setup ?? [];
+    let setupActive = setupSteps.length > 0 || opts.promptAfterSetup !== void 0;
+    let setupIdx = 0;
+    let setupStarted = false;
+    let setupWaiting = false;
+    let setupTimer;
+    let interactions = 0;
+    let settleTimer;
+    let exitTimer;
+    let completionTimer;
+    let handling = false;
+    let quitting = false;
+    let settled = false;
+    let finished = false;
+    let disposeData;
+    let disposeExit;
+    const clearTimers = () => {
+      if (settleTimer) clearTimeout(settleTimer);
+      if (exitTimer) clearTimeout(exitTimer);
+      if (completionTimer) clearTimeout(completionTimer);
+      if (setupTimer) clearTimeout(setupTimer);
+      settleTimer = void 0;
+      exitTimer = void 0;
+      completionTimer = void 0;
+      setupTimer = void 0;
+    };
+    const triggerQuit = (reason) => {
+      if (finished || quitting) return;
+      quitting = true;
+      if (completionTimer) clearTimeout(completionTimer);
+      completionTimer = void 0;
+      emit("status", `task appears complete (${reason})`);
+      if (opts.quitKeys) {
+        try {
+          child.write(opts.quitKeys);
+        } catch {
+        }
+      }
+      exitTimer = setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+        }
+      }, exitGraceMs);
+      exitTimer.unref?.();
+    };
+    const finish = (result) => {
+      if (finished) return;
+      finished = true;
+      clearTimers();
+      ctx.signal.removeEventListener("abort", onAbort);
+      try {
+        disposeData?.dispose();
+        disposeExit?.dispose();
+      } catch {
+      }
+      resolve(result);
+    };
+    const onAbort = () => {
+      try {
+        child.kill();
+      } catch {
+      }
+      finish({ success: false, exitCode: null, aborted: true });
+    };
+    const armSettle = () => {
+      if (settleTimer) clearTimeout(settleTimer);
+      if (completionTimer) {
+        clearTimeout(completionTimer);
+        completionTimer = void 0;
+      }
+      settleTimer = setTimeout(onSettle, idleMs);
+      settleTimer.unref?.();
+    };
+    const context = () => cleanTerminalText(buffer).slice(-1500);
+    const runNextSetup = () => {
+      if (finished || quitting) return;
+      if (setupIdx >= setupSteps.length) {
+        setupActive = false;
+        setupWaiting = false;
+        if (opts.promptAfterSetup) {
+          try {
+            child.write(`${opts.promptAfterSetup}\r`);
+            emit("status", "setup complete; sent task prompt");
+          } catch {
+          }
+        }
+        return;
+      }
+      const step = setupSteps[setupIdx];
+      const waitMs = step.waitMs ?? 8e3;
+      if (step.send) {
+        try {
+          child.write(`${step.send}\r`);
+        } catch {
+        }
+      }
+      emit("status", `setup: ${step.send ? `sent "${step.send}", ` : ""}waiting ${waitMs}ms`);
+      setupWaiting = true;
+      setupTimer = setTimeout(() => {
+        setupWaiting = false;
+        setupIdx += 1;
+        runNextSetup();
+      }, waitMs);
+      setupTimer.unref?.();
+    };
+    const onSettle = async () => {
+      if (finished || handling || quitting) return;
+      if (pendingComment !== void 0) {
+        const comment = pendingComment;
+        pendingComment = void 0;
+        try {
+          child.write(`${comment}\r`);
+          emit("tool_result", "sent redirect comment to the agent");
+        } catch {
+        }
+        return;
+      }
+      if (opts.completionPattern && opts.completionPattern.test(context())) {
+        triggerQuit("completion pattern");
+        return;
+      }
+      const prompt = opts.detector.detect(buffer);
+      if (setupActive) {
+        if (setupWaiting || setupStarted) return;
+        if (!prompt || prompt.signature === lastSig) {
+          setupStarted = true;
+          runNextSetup();
+          return;
+        }
+      }
+      if (!prompt || prompt.signature === lastSig) {
+        if (opts.completionIdleMs && !completionTimer) {
+          const working = opts.workingPattern?.test(
+            tailLines(cleanTerminalText(buffer), 8).join(" ")
+          ) ?? false;
+          const base = Math.max(0, opts.completionIdleMs - idleMs);
+          completionTimer = setTimeout(
+            () => triggerQuit("sustained idle"),
+            working ? base * 3 : base
+          );
+          completionTimer.unref?.();
+        }
+        return;
+      }
+      handling = true;
+      try {
+        interactions += 1;
+        settled = true;
+        if (interactions > maxInteractions) {
+          const error = {
+            message: `Exceeded max interactions (${maxInteractions}).`,
+            code: "MAX_INTERACTIONS"
+          };
+          emit("error", error.message);
+          try {
+            child.kill();
+          } catch {
+          }
+          finish({ success: false, exitCode: null, error });
+          return;
+        }
+        emit("status", `prompt[${prompt.kind}]: ${prompt.prompt.slice(0, 160)}`, {
+          data: { kind: prompt.kind, options: prompt.options }
+        });
+        const req = {
+          kind: prompt.kind,
+          prompt: prompt.prompt,
+          task: opts.task,
+          options: prompt.options,
+          multiSelect: prompt.multiSelect,
+          checked: prompt.checked,
+          context: context(),
+          cwd: opts.cwd,
+          agent: opts.agent
+        };
+        let decision;
+        try {
+          decision = await opts.decider.decide(req);
+        } catch (err) {
+          decision = {
+            action: "deny",
+            reason: `decider error: ${err.message}`
+          };
+        }
+        if (finished) return;
+        emit(
+          "tool_call",
+          `decision: ${decision.action}${decision.reason ? ` (${decision.reason})` : ""}`,
+          { data: decision }
+        );
+        if (decision.action === "abort") {
+          const error = {
+            message: `Decider aborted the run${decision.reason ? `: ${decision.reason}` : ""}.`,
+            code: "DECIDER_ABORT"
+          };
+          try {
+            child.kill();
+          } catch {
+          }
+          finish({ success: false, exitCode: null, error });
+          return;
+        }
+        const keys = keymap.keysFor(decision, prompt);
+        if (keys != null) {
+          try {
+            child.write(keys);
+            emit("tool_result", `sent response for ${prompt.kind}`);
+          } catch {
+          }
+        }
+        if (decision.action === "deny" && decision.text) {
+          pendingComment = decision.text;
+        }
+        lastSig = prompt.signature;
+        bytesSinceHandled = 0;
+        buffer = "";
+      } finally {
+        handling = false;
+        if (!finished && !quitting) armSettle();
+      }
+    };
+    emit("start", `[pty] ${opts.command} ${opts.args.join(" ")}`.trim());
+    disposeData = child.onData((data) => {
+      buffer = (buffer + data).slice(-65536);
+      const cleaned = cleanTerminalText(data).trim();
+      if (!cleaned) return;
+      bytesSinceHandled += cleaned.length;
+      if (lastSig && bytesSinceHandled > 40) lastSig = "";
+      emit("stdout", cleaned, { raw: data });
+      armSettle();
+    });
+    disposeExit = child.onExit(({ exitCode }) => {
+      const success = exitCode === 0;
+      const error = success ? void 0 : {
+        message: `${opts.agent ?? opts.command} exited with code ${exitCode}.`,
+        code: "NON_ZERO_EXIT"
+      };
+      emit("complete", void 0, { data: { exitCode, interactions } });
+      finish({
+        success,
+        exitCode,
+        error,
+        sessionRef: void 0,
+        meta: { interactions, settled }
+      });
+    });
+    if (ctx.signal.aborted) onAbort();
+    else ctx.signal.addEventListener("abort", onAbort, { once: true });
+    if (opts.initialInput) {
+      const t = setTimeout(() => {
+        try {
+          child.write(`${opts.initialInput}${ENTER}`);
+        } catch {
+        }
+      }, opts.initialDelayMs ?? 800);
+      t.unref?.();
+    }
+  });
+}
+
+// src/adapters/interactive/interactive-adapter.ts
+var InteractivePtyAdapter = class {
+  definition;
+  cfg;
+  detector;
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.definition = cfg.definition;
+    this.detector = new PromptDetector(cfg.detector);
+  }
+  async isAvailable() {
+    const resolved = await which(this.cfg.command);
+    if (resolved) return { ok: true, version: resolved };
+    return {
+      ok: false,
+      reason: `Command "${this.cfg.command}" was not found on your PATH.`,
+      hint: this.cfg.installHint
+    };
+  }
+  buildArgs(input) {
+    const args = [...this.cfg.preArgs(input)];
+    if (input.extraArgs?.length) args.push(...input.extraArgs);
+    if ((this.cfg.promptMode ?? "arg") === "type") {
+      return { args, initialInput: input.prompt };
+    }
+    args.push(input.prompt);
+    return { args };
+  }
+  describeCommand(input) {
+    const setup = this.cfg.setup?.(input);
+    let args;
+    if (setup && setup.length) {
+      args = [...this.cfg.preArgs(input)];
+      if (input.extraArgs?.length) args.push(...input.extraArgs);
+    } else {
+      ({ args } = this.buildArgs(input));
+    }
+    const shown = args.map((a) => /\s/.test(a) ? JSON.stringify(a) : a).join(" ");
+    return {
+      mode: this.definition.mode,
+      command: this.cfg.command,
+      args,
+      display: `[pty] ${this.cfg.command} ${shown}`.trim()
+    };
+  }
+  run(input, ctx) {
+    const setup = this.cfg.setup?.(input);
+    if (setup && setup.length) {
+      const args2 = [...this.cfg.preArgs(input)];
+      if (input.extraArgs?.length) args2.push(...input.extraArgs);
+      return this.spawn(args2, void 0, input, ctx, {
+        setup,
+        promptAfterSetup: input.prompt
+      });
+    }
+    const { args, initialInput } = this.buildArgs(input);
+    return this.spawn(args, initialInput, input, ctx);
+  }
+  resume(ref, input, ctx) {
+    if (!this.cfg.resumeArgs) {
+      return Promise.resolve({
+        success: false,
+        exitCode: null,
+        error: {
+          message: `The ${this.definition.name} adapter cannot resume in PTY mode.`,
+          code: "RESUME_UNSUPPORTED"
+        }
+      });
+    }
+    const args = [...this.cfg.resumeArgs(input, ref)];
+    if (input.extraArgs?.length) args.push(...input.extraArgs);
+    const typesPrompt = typeof this.cfg.resumeTypesPrompt === "function" ? this.cfg.resumeTypesPrompt(input, ref) : this.cfg.resumeTypesPrompt ?? false;
+    if (typesPrompt) {
+      return this.spawn(args, void 0, input, ctx, {
+        setup: this.cfg.resumeWarmupMs ? [{ send: "", waitMs: this.cfg.resumeWarmupMs }] : void 0,
+        promptAfterSetup: input.prompt
+      });
+    }
+    let initialInput;
+    if ((this.cfg.promptMode ?? "arg") === "type") initialInput = input.prompt;
+    else args.push(input.prompt);
+    return this.spawn(args, initialInput, input, ctx);
+  }
+  spawn(args, initialInput, input, ctx, extra) {
+    const decider = ctx.decider ?? new RuleDecider();
+    return runPtySession(
+      {
+        command: this.cfg.command,
+        args,
+        cwd: input.cwd,
+        env: this.cfg.env,
+        decider,
+        detector: this.detector,
+        keymap: this.cfg.keymap,
+        completionPattern: this.cfg.completionPattern,
+        completionIdleMs: input.completionIdleMs ?? this.cfg.completionIdleMs,
+        workingPattern: this.cfg.workingPattern,
+        quitKeys: this.cfg.quitKeys,
+        setup: extra?.setup,
+        promptAfterSetup: extra?.promptAfterSetup,
+        idleMs: this.cfg.idleMs,
+        agent: this.definition.name,
+        task: input.prompt,
+        maxInteractions: input.maxTurns,
+        initialInput,
+        installHint: this.cfg.installHint,
+        now: this.cfg.now
+      },
+      ctx
+    );
+  }
+};
+
+// src/adapters/interactive/claude-interactive.ts
+var DEFINITION2 = {
+  name: "claude",
+  type: "claude",
+  mode: "pty",
+  description: "Claude Code driven interactively in a PTY; permission prompts answered by the decider.",
+  supportsResume: true
+};
+var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends InteractivePtyAdapter {
+  constructor(opts = {}) {
+    super({
+      definition: DEFINITION2,
+      command: opts.command ?? "claude",
+      // Enable Claude Code's experimental agent-teams feature by default; a
+      // config `adapters.claude.env` can override (e.g. set it to "0").
+      env: { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1", ...opts.env },
+      now: opts.now,
+      installHint: "Install Claude Code (`npm i -g @anthropic-ai/claude-code`), authenticate (run `claude` once), and ensure `claude` is on your PATH.",
+      preArgs: (input) => {
+        const effort = ["--effort", "xhigh"];
+        const model = input.ultracode ? ["--model", "opus"] : [];
+        const head = [...model, ...effort];
+        if (input.approvalMode === "readonly")
+          return [...head, "--permission-mode", "plan"];
+        if (input.approvalMode === "gated")
+          return [...head, "--permission-mode", "acceptEdits"];
+        return [...head, "--dangerously-skip-permissions"];
+      },
+      // Resume the most recent conversation in the cwd and send the follow-up
+      // prompt. (`--continue` picks the latest session; the native id is not
+      // captured in PTY mode, so a specific `--resume <id>` is not used.)
+      resumeArgs: (input) => {
+        const mode = input.approvalMode === "readonly" ? ["--permission-mode", "plan"] : input.approvalMode === "gated" ? ["--permission-mode", "acceptEdits"] : ["--dangerously-skip-permissions"];
+        return ["--continue", "--effort", "xhigh", ...mode];
+      },
+      // Unattended ultracode: once Claude is idle (past the trust dialog), type
+      // `/effort ultracode`, wait for its animated picker to apply and revert,
+      // THEN the task is typed. Needs Opus (set in preArgs). Verified end-to-end.
+      setup: (input) => input.ultracode ? [{ send: "/effort ultracode", waitMs: 9e3 }] : void 0,
+      detector: {
+        // Substring keywords (TUI text runs words together after ANSI strip)
+        // anchored to a nearby '?' or [y/n] to avoid false positives on prose.
+        // Most Claude permission prompts are numbered menus, caught as choices.
+        approvalPattern: /(allow|grant|permission|approve|trust|proceed|do you want)[^\n]{0,60}\?|\[y\/n\]|\(y\/n\)/i
+      },
+      keymap: new ArrowKeymap(),
+      // Claude's TUI stays open after a task; quit once it's been idle a while.
+      completionIdleMs: 8e3,
+      // While Claude is ACTIVELY working it shows "(esc to interrupt)" — that is
+      // the reliable, verb-INDEPENDENT "still working" signal. Do NOT match the
+      // thinking-verb itself: Claude rotates whimsical gerunds (Cogitating,
+      // Beaming, Pondering…) and its DONE summary keeps the PAST tense of the same
+      // verb on screen ("Cogitated for 7s"), so a stem like /cogitat/ stays matched
+      // after the task finishes — completion never fires and the run hangs to the
+      // idle timeout. "interrupt" appears only in the active footer, never on the
+      // idle prompt, so it cleanly distinguishes working vs done.
+      workingPattern: /interrupt/i,
+      quitKeys: ""
+    });
+  }
+  static fromConfig(config) {
+    return new _ClaudeInteractiveAdapter({
+      command: config.command ?? "claude",
+      env: config.env
+    });
+  }
+};
+var ROLLOUT_UUID_RE = /-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/;
+async function realish(p) {
+  try {
+    return await promises.realpath(p);
+  } catch {
+    return p;
+  }
+}
+async function listRollouts(root) {
+  const out = [];
+  let years;
+  try {
+    years = await promises.readdir(root);
+  } catch {
+    return out;
+  }
+  for (const y of years) {
+    const yDir = path7.join(root, y);
+    let months;
+    try {
+      months = await promises.readdir(yDir);
+    } catch {
+      continue;
+    }
+    for (const m of months) {
+      const mDir = path7.join(yDir, m);
+      let days;
+      try {
+        days = await promises.readdir(mDir);
+      } catch {
+        continue;
+      }
+      for (const d of days) {
+        const dDir = path7.join(mDir, d);
+        let files;
+        try {
+          files = await promises.readdir(dDir);
+        } catch {
+          continue;
+        }
+        for (const f of files) {
+          if (!f.startsWith("rollout-") || !f.endsWith(".jsonl")) continue;
+          const file = path7.join(dDir, f);
+          try {
+            const st = await promises.stat(file);
+            out.push({ file, mtimeMs: st.mtimeMs });
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+async function readSessionMeta(file) {
+  let text;
+  try {
+    text = await promises.readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  const firstLine = text.split("\n", 1)[0];
+  if (!firstLine) return void 0;
+  try {
+    const rec = JSON.parse(firstLine);
+    if (rec.type !== "session_meta") return void 0;
+    const id = typeof rec.payload?.id === "string" ? rec.payload.id : void 0;
+    const cwd = typeof rec.payload?.cwd === "string" ? rec.payload.cwd : void 0;
+    return { id, cwd };
+  } catch {
+    return void 0;
+  }
+}
+function uuidFromRolloutFilename(file) {
+  const m = ROLLOUT_UUID_RE.exec(path7.basename(file));
+  return m?.[1];
+}
+async function findLatestCodexSessionId(opts) {
+  const root = opts.sessionsDir ?? path7.join(os.homedir(), ".codex", "sessions");
+  const since = opts.sinceMs ?? 0;
+  const targetCwd = await realish(opts.cwd);
+  const rollouts = await listRollouts(root);
+  for (const { file, mtimeMs } of rollouts) {
+    if (mtimeMs + 2e3 < since) continue;
+    const meta = await readSessionMeta(file);
+    if (!meta?.cwd) continue;
+    const metaCwd = await realish(meta.cwd);
+    if (metaCwd !== targetCwd) continue;
+    const id = meta.id ?? uuidFromRolloutFilename(file);
+    if (id) return id;
+  }
+  return void 0;
+}
+
+// src/adapters/interactive/codex-interactive.ts
+var DEFINITION3 = {
+  name: "codex",
+  type: "codex",
+  mode: "pty",
+  description: "Codex CLI driven interactively in a PTY; approvals answered by the decider.",
+  supportsResume: true
+};
+var CodexInteractiveAdapter = class _CodexInteractiveAdapter extends InteractivePtyAdapter {
+  clock;
+  /** Override the sessions root (~/.codex/sessions) for tests. */
+  sessionsDir;
+  constructor(opts = {}) {
+    super({
+      definition: DEFINITION3,
+      command: opts.command ?? "codex",
+      env: opts.env,
+      now: opts.now,
+      installHint: "Install the Codex CLI (`npm i -g @openai/codex`), run `codex login`, and ensure `codex` is on your PATH.",
+      preArgs: (input) => {
+        const sandbox = input.approvalMode === "readonly" ? "read-only" : input.sandbox ?? "workspace-write";
+        const approval = input.approvalMode === "gated" ? "on-request" : "never";
+        return ["-s", sandbox, "-a", approval];
+      },
+      // Resume by Codex's NATIVE session id (captured in run(), below) so the
+      // follow-up prompt rides along as a normal positional arg:
+      // `codex resume <SESSION_ID> "<prompt>"` (clap binds 1st->SESSION_ID,
+      // 2nd->PROMPT). When no id was captured (e.g. a session predating this
+      // capture), fall back to `resume --last` and TYPE the prompt instead, since
+      // `codex resume --last "<prompt>"` would misparse the prompt as SESSION_ID.
+      resumeArgs: (_input, ref) => ref.nativeSessionId ? ["resume", ref.nativeSessionId] : ["resume", "--last"],
+      // Pass the prompt as an arg when we have a native id; only type it on the
+      // legacy `--last` fallback (no id) to avoid the `--last "<prompt>"` misparse.
+      resumeTypesPrompt: (_input, ref) => !ref.nativeSessionId,
+      // Codex reloads MCP servers on resume; on the typed fallback, wait for that
+      // before typing the prompt. (Unused on the native-id arg path.)
+      resumeWarmupMs: 12e3,
+      detector: {
+        // Substring keywords (TUI collapses spaces) anchored to a nearby '?'
+        // or [y/n] affordance to avoid false positives on benign output.
+        approvalPattern: /(allow|approve|run this|apply|patch|grant|permission|trust|do you want)[^\n]{0,60}\?|\[y\/n\]/i
+      },
+      keymap: new ArrowKeymap(),
+      // Codex's TUI stays open after a task; quit once it's been idle a while.
+      // Tune per-run with --completion-idle-ms / config defaults.completionIdleMs.
+      completionIdleMs: 8e3,
+      // While Codex is working it shows an "(esc to interrupt)" indicator — match
+      // only that, not the thinking-verb (whose past tense can linger after the
+      // task finishes and wrongly suppress completion; see claude-interactive).
+      workingPattern: /interrupt/i,
+      quitKeys: ""
+    });
+    this.clock = opts.now ?? (() => /* @__PURE__ */ new Date());
+    this.sessionsDir = opts.sessionsDir;
+  }
+  /**
+   * Run Codex, then capture its NATIVE session id (the rollout UUID) for this
+   * cwd and attach it to the result's `sessionRef` so the runner persists it and
+   * a later resume can use `codex resume <id> "<prompt>"`. Capture is best-effort:
+   * if no rollout matches (or any I/O fails) the result is returned unchanged, so
+   * the run still resumes via the `--last` fallback.
+   */
+  async run(input, ctx) {
+    const startedAt = this.clock().getTime();
+    const result = await super.run(input, ctx);
+    if (result.error) return result;
+    const nativeSessionId = await findLatestCodexSessionId({
+      cwd: input.cwd,
+      sinceMs: startedAt,
+      sessionsDir: this.sessionsDir
+    });
+    if (!nativeSessionId) return result;
+    return {
+      ...result,
+      sessionRef: {
+        adapter: this.definition.name,
+        nativeSessionId,
+        resumable: true
+      }
+    };
+  }
+  static fromConfig(config) {
+    return new _CodexInteractiveAdapter({
+      command: config.command ?? "codex",
+      env: config.env
+    });
+  }
+};
+
+// src/adapters/registry.ts
+var BUILTIN_ADAPTER_DEFINITIONS = [
+  new ClaudeInteractiveAdapter().definition,
+  new CodexInteractiveAdapter().definition,
+  new FakeAgentAdapter().definition
+];
+var AdapterRegistry = class {
+  builders = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register("claude", (c) => ClaudeInteractiveAdapter.fromConfig(c));
+    this.register("codex", (c) => CodexInteractiveAdapter.fromConfig(c));
+    this.register("fake", () => new FakeAgentAdapter());
+  }
+  register(type, builder) {
+    this.builders.set(type, builder);
+  }
+  has(type) {
+    return this.builders.has(type);
+  }
+  /** List the adapter types this registry can build. */
+  types() {
+    return [...this.builders.keys()];
+  }
+  /** Build an adapter from a config entry, by its `type`. */
+  build(config) {
+    const builder = this.builders.get(config.type);
+    if (!builder) {
+      throw new UnknownAdapterError(config.type, this.types());
+    }
+    return builder(config);
+  }
+  /** Resolve an adapter by its config name within a {@link RelayConfig}. */
+  resolveByName(name, config) {
+    const entry = config.adapters[name];
+    if (!entry) {
+      throw new UnknownAdapterError(name, Object.keys(config.adapters));
+    }
+    return this.build(entry);
+  }
+};
+var defaultRegistry = new AdapterRegistry();
+function createAdapterFactory(registry = defaultRegistry) {
+  return (name, config) => registry.resolveByName(name, config);
+}
+async function dirExists(p) {
+  try {
+    const stat = await promises.stat(p);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function runInit(options) {
+  const rootDir = path7.resolve(options.rootDir);
+  const cfgPath = configPath(rootDir);
+  let configCreated = false;
+  let configExists = false;
+  try {
+    await promises.access(cfgPath);
+    configExists = true;
+  } catch {
+    configExists = false;
+  }
+  if (!configExists || options.force) {
+    await saveConfig(rootDir, createDefaultConfig());
+    configCreated = true;
+  }
+  const config = await loadConfig(rootDir);
+  const sessionsDir = path7.resolve(rootDir, config.sessionsDir);
+  const logsDir = path7.resolve(rootDir, config.logsDir);
+  const createdDirs = [];
+  for (const dir of [sessionsDir, logsDir]) {
+    if (!await dirExists(dir)) {
+      await promises.mkdir(dir, { recursive: true });
+      createdDirs.push(dir);
+    }
+  }
+  return {
+    configPath: cfgPath,
+    configCreated,
+    sessionsDir,
+    logsDir,
+    createdDirs
+  };
+}
+
+// src/commands/adapters.ts
+function listAdapters(config) {
+  const byType = new Map(
+    BUILTIN_ADAPTER_DEFINITIONS.map((d) => [d.type, d])
+  );
+  const items = [];
+  const seenTypes = /* @__PURE__ */ new Set();
+  if (config) {
+    for (const [name, entry] of Object.entries(config.adapters)) {
+      const def = byType.get(entry.type);
+      items.push({
+        name,
+        type: entry.type,
+        mode: entry.mode,
+        description: def?.description ?? `Custom "${entry.type}" adapter.`,
+        supportsResume: def?.supportsResume ?? false,
+        configured: true,
+        command: entry.command
+      });
+      seenTypes.add(entry.type);
+    }
+  }
+  for (const def of BUILTIN_ADAPTER_DEFINITIONS) {
+    if (seenTypes.has(def.type)) continue;
+    items.push({
+      name: def.name,
+      type: def.type,
+      mode: def.mode,
+      description: def.description,
+      supportsResume: def.supportsResume,
+      configured: false
+    });
+  }
+  return items;
+}
+var MIN_NODE = { major: 18, minor: 19 };
+function checkNode() {
+  const version = process.versions.node;
+  const [major = 0, minor = 0] = version.split(".").map((n) => Number(n));
+  const okVer = major > MIN_NODE.major || major === MIN_NODE.major && minor >= MIN_NODE.minor;
+  return {
+    name: "node",
+    level: okVer ? "ok" : "error",
+    detail: `Node.js ${version} (require >= ${MIN_NODE.major}.${MIN_NODE.minor})`,
+    hint: okVer ? void 0 : "Upgrade Node.js to a supported version."
+  };
+}
+async function dirCheck(name, dir) {
+  try {
+    const stat = await promises.stat(dir);
+    if (stat.isDirectory()) {
+      return { name, level: "ok", detail: `${dir} exists` };
+    }
+    return { name, level: "error", detail: `${dir} is not a directory` };
+  } catch {
+    return {
+      name,
+      level: "warn",
+      detail: `${dir} does not exist yet`,
+      hint: "Run `agent-relay init` (or any `run`) to create it."
+    };
+  }
+}
+async function commandCheck(name, command, installHint) {
+  const resolved = await which(command);
+  if (resolved) {
+    return { name, level: "ok", detail: `${command} found at ${resolved}` };
+  }
+  return {
+    name,
+    level: "warn",
+    detail: `${command} not found on PATH`,
+    hint: installHint
+  };
+}
+async function runDoctor(options) {
+  const rootDir = path7.resolve(options.rootDir);
+  const checks = [];
+  checks.push(checkNode());
+  let sessionsDir = path7.resolve(rootDir, ".agent-relay/sessions");
+  let logsDir = path7.resolve(rootDir, ".agent-relay/logs");
+  try {
+    const config = await loadConfig(rootDir);
+    checks.push({
+      name: "config",
+      level: "ok",
+      detail: `Valid config (defaultAdapter: ${config.defaultAdapter})`
+    });
+    sessionsDir = path7.resolve(rootDir, config.sessionsDir);
+    logsDir = path7.resolve(rootDir, config.logsDir);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const missing = message.includes("not found");
+    checks.push({
+      name: "config",
+      level: missing ? "warn" : "error",
+      detail: missing ? "No config file \u2014 built-in defaults will be used" : `Invalid config: ${message}`,
+      hint: missing ? "Optional: run `agent-relay init` to customize adapters/decider/dirs." : "Run `agent-relay init` to regenerate a valid config, or fix the listed fields."
+    });
+  }
+  checks.push(await dirCheck("sessionsDir", sessionsDir));
+  checks.push(await dirCheck("logsDir", logsDir));
+  checks.push(
+    await commandCheck(
+      "claude",
+      "claude",
+      "Install Claude Code (`npm i -g @anthropic-ai/claude-code`) to use the claude adapter."
+    )
+  );
+  checks.push(
+    await commandCheck(
+      "codex",
+      "codex",
+      "Install the Codex CLI (`npm i -g @openai/codex`) to use the codex adapter."
+    )
+  );
+  const ok = !checks.some((c) => c.level === "error");
+  return { checks, ok };
+}
+function deciderConfigFromFlags(flags) {
+  const anyGiven = flags.decider != null || flags.deciderCommand != null || flags.deciderUrl != null || flags.deciderModel != null || flags.deciderKey != null || flags.deciderMaxTokens != null || flags.deciderTimeoutMs != null;
+  if (!anyGiven) return void 0;
+  const type = flags.decider ?? (flags.deciderUrl ? "api" : flags.deciderCommand ? "command" : "rule");
+  const raw = { type };
+  if (type === "command") {
+    if (!flags.deciderCommand) {
+      throw new AgentRelayError(
+        '--decider command requires --decider-command "<cmd ...>".',
+        "INVALID_ARGS"
+      );
+    }
+    const parts = flags.deciderCommand.trim().split(/\s+/);
+    raw.command = parts[0];
+    if (parts.length > 1) raw.args = parts.slice(1);
+  }
+  if (type === "api") {
+    if (!flags.deciderUrl) {
+      throw new AgentRelayError(
+        "--decider api requires --decider-url <url>.",
+        "INVALID_ARGS"
+      );
+    }
+    raw.url = flags.deciderUrl;
+    if (flags.deciderModel) raw.model = flags.deciderModel;
+    if (flags.deciderKey) raw.apiKey = flags.deciderKey;
+    if (flags.deciderMaxTokens) raw.maxTokens = flags.deciderMaxTokens;
+  }
+  if (flags.deciderTimeoutMs) raw.timeoutMs = flags.deciderTimeoutMs;
+  return parseDeciderConfig(raw);
+}
+async function resolvePrompt(options) {
+  if (options.prompt && options.promptFile) {
+    throw new AgentRelayError(
+      "Provide either --prompt or --prompt-file, not both.",
+      "INVALID_ARGS"
+    );
+  }
+  if (options.promptFile) {
+    const file = path7.resolve(options.rootDir, options.promptFile);
+    try {
+      const text = await promises.readFile(file, "utf8");
+      if (!text.trim()) {
+        throw new AgentRelayError(
+          `Prompt file ${file} is empty.`,
+          "EMPTY_PROMPT"
+        );
+      }
+      return text;
+    } catch (err) {
+      if (err instanceof AgentRelayError) throw err;
+      throw new AgentRelayError(
+        `Could not read prompt file ${file}: ${err.message}`,
+        "PROMPT_FILE_ERROR"
+      );
+    }
+  }
+  if (options.prompt && options.prompt.trim()) {
+    return options.prompt;
+  }
+  throw new AgentRelayError(
+    'A prompt is required. Pass --prompt "..." or --prompt-file ./task.md.',
+    "MISSING_PROMPT"
+  );
+}
+async function runCommand(options) {
+  const rootDir = path7.resolve(options.rootDir);
+  const config = options.config ?? await loadConfigOrDefault(rootDir, options.onDefaultConfig);
+  const prompt = await resolvePrompt({
+    prompt: options.prompt,
+    promptFile: options.promptFile,
+    rootDir
+  });
+  const decider = options.deciderConfig ? createDecider(options.deciderConfig) : void 0;
+  return runAgent({
+    config,
+    rootDir,
+    adapterName: options.adapter,
+    prompt,
+    cwd: options.cwd,
+    decider,
+    maxTurns: options.maxTurns,
+    timeoutMs: options.timeoutMs,
+    idleTimeoutMs: options.idleTimeoutMs,
+    completionIdleMs: options.completionIdleMs,
+    approvalMode: options.approvalMode,
+    ultracode: options.ultracode,
+    dryRun: options.dryRun,
+    extraArgs: options.extraArgs,
+    verbose: options.verbose,
+    maxLogBytes: options.maxLogBytes,
+    resolveAdapter: options.resolveAdapter ?? createAdapterFactory(),
+    onEvent: options.onEvent,
+    installSignalHandlers: options.installSignalHandlers,
+    now: options.now
+  });
+}
+async function resumeCommand(options) {
+  const rootDir = path7.resolve(options.rootDir);
+  const config = options.config ?? await loadConfigOrDefault(rootDir, options.onDefaultConfig);
+  const sessionsDir = path7.resolve(rootDir, config.sessionsDir);
+  const sessions = new SessionManager(sessionsDir);
+  const session = await sessions.load(options.sessionId);
+  const resolveAdapter = options.resolveAdapter ?? createAdapterFactory();
+  let resumable = false;
+  try {
+    const adapter = resolveAdapter(session.adapter, config);
+    resumable = adapter.definition.supportsResume && Boolean(adapter.resume);
+  } catch {
+    resumable = false;
+  }
+  if (!options.prompt || !options.prompt.trim()) {
+    return {
+      session,
+      resumable,
+      resumed: false,
+      reason: "No follow-up prompt provided; showing session metadata only."
+    };
+  }
+  if (!resumable) {
+    return {
+      session,
+      resumable,
+      resumed: false,
+      reason: `Adapter "${session.adapter}" does not support resume.`
+    };
+  }
+  const outcome = await runAgent({
+    config,
+    rootDir,
+    adapterName: session.adapter,
+    prompt: options.prompt,
+    cwd: session.cwd,
+    maxTurns: options.maxTurns,
+    timeoutMs: options.timeoutMs,
+    idleTimeoutMs: options.idleTimeoutMs,
+    completionIdleMs: options.completionIdleMs,
+    decider: options.deciderConfig ? createDecider(options.deciderConfig) : void 0,
+    verbose: options.verbose,
+    maxLogBytes: options.maxLogBytes,
+    // If we never captured a native id, resume with no id; the adapter falls
+    // back to its "most recent session" behavior (codex --last / claude --continue).
+    resume: session.sessionRef ?? { adapter: session.adapter, resumable: true },
+    resolveAdapter,
+    onEvent: options.onEvent,
+    installSignalHandlers: options.installSignalHandlers,
+    now: options.now
+  });
+  return { session, resumable, resumed: true, outcome };
+}
+async function resolveManager(opts) {
+  const rootDir = path7.resolve(opts.rootDir);
+  const config = await loadConfigOrDefault(rootDir, opts.onDefaultConfig);
+  const sessionsDir = path7.resolve(rootDir, config.sessionsDir);
+  const sessions = new SessionManager(sessionsDir);
+  return { sessions, metas: await sessions.list() };
+}
+async function fileBytes(file) {
+  try {
+    return (await promises.stat(file)).size;
+  } catch {
+    return 0;
+  }
+}
+async function listSessions(opts) {
+  const { metas } = await resolveManager(opts);
+  const items = [];
+  let total = 0;
+  for (const m of metas) {
+    const logBytes = await fileBytes(m.logFile);
+    total += logBytes;
+    items.push({ ...m, logBytes });
+  }
+  return { items, totalLogBytes: total };
+}
+async function pruneSessions(opts) {
+  if (opts.keep === void 0 && opts.olderThanDays === void 0 && !opts.all) {
+    throw new AgentRelayError(
+      "Pruning needs a filter: --keep <n>, --older-than <days>, or --all.",
+      "INVALID_ARGS"
+    );
+  }
+  const { sessions, metas } = await resolveManager(opts);
+  const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+  const doomed = /* @__PURE__ */ new Set();
+  metas.forEach((m, i) => {
+    if (opts.all) return doomed.add(m.sessionId);
+    if (opts.keep !== void 0 && i >= opts.keep) doomed.add(m.sessionId);
+    if (opts.olderThanDays !== void 0) {
+      const ts = Date.parse(m.endedAt ?? m.startedAt);
+      const ageDays = (now.getTime() - ts) / 864e5;
+      if (Number.isFinite(ageDays) && ageDays > opts.olderThanDays) {
+        doomed.add(m.sessionId);
+      }
+    }
+  });
+  let freed = 0;
+  for (const m of metas) {
+    if (!doomed.has(m.sessionId)) continue;
+    freed += await fileBytes(m.logFile);
+    await promises.rm(m.logFile, { force: true }).catch(() => {
+    });
+    await promises.rm(sessions.filePath(m.sessionId), { force: true }).catch(() => {
+    });
+  }
+  return {
+    deleted: doomed.size,
+    freedBytes: freed,
+    kept: metas.length - doomed.size
+  };
+}
+
+export { AdapterRegistry, AgentRelayError, AlwaysApproveDecider, ApiDecider, BUILTIN_ADAPTER_DEFINITIONS, CONFIG_FILENAME, ClaudeInteractiveAdapter, CodexInteractiveAdapter, CommandDecider, CompositeCompletionDetector, ConfigError, DEFAULT_DENY_PATTERNS, DefaultCompletionDetector, DefaultKeymap, FakeAgentAdapter, FunctionDecider, InteractivePtyAdapter, OutputPatternDetector, PromptDetector, RuleDecider, RunLogger, SessionManager, SessionNotFoundError, UnknownAdapterError, adapterConfigSchema, approvalPolicySchema, cleanTerminalText, configPath, configSchema, createAdapterFactory, createDecider, createDefaultConfig, deciderConfigFromFlags, deciderSchema, defaultRegistry, defaultsSchema, hooksSchema, listAdapters, listSessions, loadConfig, loadConfigOrDefault, parseCheckbox, parseConfig, parseDecisionReply, pruneSessions, renderDecisionPrompt, resolveApprovalMode, resolvePrompt, resolveSandbox, resumeCommand, runAgent, runCommand, runDoctor, runInit, runPtySession, runShellHook, sandboxSchema, saveConfig, stringifyConfig, stripAnsi, tailLines };