@whittlelabs/sifter 0.30.23 → 0.32.0

package/bin.js

@@ -9876,7 +9876,7 @@ var require_progress = __commonJS({
   "../../packages/shuttle/dist/executors/progress.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.StreamJsonTap = exports2.ProgressReporter = void 0;
+    exports2.JsonLineTap = exports2.StreamJsonTap = exports2.ProgressReporter = void 0;
     var ProgressReporter = class {
       sink;
       seq = 0;
@@ -10017,112 +10017,1300 @@ var require_progress = __commonJS({
       }
       return void 0;
     }
+    var JsonLineTap = class {
+      onEvent;
+      buf = "";
+      constructor(onEvent) {
+        this.onEvent = onEvent;
+      }
+      push(chunk) {
+        this.buf += chunk;
+        let nl;
+        while ((nl = this.buf.indexOf("\n")) !== -1) {
+          const line = this.buf.slice(0, nl);
+          this.buf = this.buf.slice(nl + 1);
+          this.consume(line);
+        }
+      }
+      end() {
+        if (this.buf.trim().length > 0)
+          this.consume(this.buf);
+        this.buf = "";
+      }
+      consume(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+          return;
+        let event;
+        try {
+          event = JSON.parse(trimmed);
+        } catch {
+          return;
+        }
+        try {
+          this.onEvent(event);
+        } catch {
+        }
+      }
+    };
+    exports2.JsonLineTap = JsonLineTap;
+  }
+});
+
+// ../../packages/shuttle/dist/executors/agent-process.js
+var require_agent_process = __commonJS({
+  "../../packages/shuttle/dist/executors/agent-process.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.STDERR_LIMIT = void 0;
+    exports2.runAgentProcess = runAgentProcess;
+    exports2.firstLine = firstLine;
+    exports2.keepTranscript = keepTranscript;
+    exports2.classifyAgentFault = classifyAgentFault;
+    exports2.agentFailure = agentFailure;
+    var types_1 = require_types2();
+    var child_process_1 = require("child_process");
+    var fs_1 = require("fs");
+    var path_1 = __importDefault(require("path"));
+    var string_decoder_1 = require("string_decoder");
+    exports2.STDERR_LIMIT = 4e3;
+    function runAgentProcess(opts) {
+      return new Promise((resolve, reject) => {
+        let child;
+        try {
+          child = (0, child_process_1.spawn)(opts.bin, opts.args, {
+            cwd: opts.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            ...opts.env ? { env: opts.env } : {}
+          });
+        } catch (err) {
+          const e = err;
+          resolve({ code: null, stdout: "", stderr: "", spawnError: { code: e.code ?? null, message: e.message } });
+          return;
+        }
+        const stdoutChunks = [];
+        let stderr = "";
+        let settled = false;
+        let timer;
+        const decoder = opts.onStdout ? new string_decoder_1.StringDecoder("utf8") : null;
+        const finish = (fn) => {
+          if (settled)
+            return;
+          settled = true;
+          if (timer)
+            clearTimeout(timer);
+          opts.signal.removeEventListener("abort", onAbort);
+          fn();
+        };
+        function onAbort() {
+          child.kill("SIGTERM");
+          finish(() => reject(new Error("Dispatch aborted")));
+        }
+        if (opts.signal.aborted) {
+          child.kill("SIGTERM");
+          finish(() => reject(new Error("Dispatch aborted")));
+          return;
+        }
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        const armIdleTimer = () => {
+          if (settled)
+            return;
+          if (timer)
+            clearTimeout(timer);
+          timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            finish(() => reject(new Error(`${opts.toolName} produced no output for ${opts.idleTimeoutMs}ms; killed as hung`)));
+          }, opts.idleTimeoutMs);
+        };
+        armIdleTimer();
+        child.stdout?.on("data", (chunk) => {
+          stdoutChunks.push(chunk);
+          armIdleTimer();
+          if (decoder && opts.onStdout)
+            opts.onStdout(decoder.write(chunk));
+        });
+        child.stderr?.on("data", (chunk) => {
+          if (stderr.length < exports2.STDERR_LIMIT)
+            stderr += chunk.toString("utf-8");
+        });
+        child.stdin?.on("error", () => {
+        });
+        if (opts.stdin !== void 0)
+          child.stdin?.write(opts.stdin);
+        child.stdin?.end();
+        child.on("error", (err) => {
+          const code = err.code ?? null;
+          finish(() => resolve({
+            code: null,
+            stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+            stderr,
+            spawnError: { code, message: err.message }
+          }));
+        });
+        child.on("close", (code) => {
+          if (decoder && opts.onStdout)
+            opts.onStdout(decoder.end());
+          finish(() => resolve({ code, stdout: Buffer.concat(stdoutChunks).toString("utf-8"), stderr }));
+        });
+      });
+    }
+    function firstLine(text) {
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+          return trimmed.length > 300 ? `${trimmed.slice(0, 300)}...` : trimmed;
+      }
+      return null;
+    }
+    async function keepTranscript(dir, name, stdout) {
+      try {
+        await fs_1.promises.mkdir(dir, { recursive: true });
+        const safe = name.replace(/[^A-Za-z0-9._-]/g, "_");
+        await fs_1.promises.writeFile(path_1.default.join(dir, `${safe}.jsonl`), stdout);
+      } catch (err) {
+        console.warn(`[shuttle] could not keep the transcript for ${name} under ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    function classifyAgentFault(failure, vocab) {
+      if (failure.spawnErrorCode === "ENOENT")
+        return vocab.installRemedy;
+      const text = failure.text ?? "";
+      if (failure.apiErrorStatus === 401 || vocab.signedOut.test(text))
+        return vocab.loginRemedy;
+      if (vocab.notEntitled?.pattern.test(text))
+        return vocab.notEntitled.remedy;
+      if (failure.apiErrorStatus === 402 || failure.apiErrorStatus === 429 || vocab.outOfUsage.test(text)) {
+        return vocab.limitRemedy;
+      }
+      return null;
+    }
+    function agentFailure(local, message, facts, vocab) {
+      if (!local)
+        return new Error(message);
+      const remedy = classifyAgentFault(facts, vocab);
+      return remedy ? new types_1.ExecutorEnvironmentError(message, remedy) : new Error(message);
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/json-answer.js
+var require_json_answer = __commonJS({
+  "../../packages/shuttle/dist/executors/json-answer.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.extractJsonObject = extractJsonObject;
+    function extractJsonObject(s) {
+      const exact = tryParseObject(s);
+      if (exact)
+        return exact;
+      let last;
+      let i = 0;
+      while (i < s.length) {
+        if (s[i] !== "{") {
+          i++;
+          continue;
+        }
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let end = -1;
+        for (let j = i; j < s.length; j++) {
+          const ch = s[j];
+          if (escaped) {
+            escaped = false;
+            continue;
+          }
+          if (ch === "\\") {
+            escaped = inString;
+            continue;
+          }
+          if (ch === '"') {
+            inString = !inString;
+            continue;
+          }
+          if (inString)
+            continue;
+          if (ch === "{")
+            depth++;
+          else if (ch === "}") {
+            depth--;
+            if (depth === 0) {
+              end = j;
+              break;
+            }
+          }
+        }
+        if (end === -1)
+          break;
+        const candidate = tryParseObject(s.slice(i, end + 1));
+        if (candidate)
+          last = candidate;
+        i = end + 1;
+      }
+      return last;
+    }
+    function tryParseObject(s) {
+      try {
+        const parsed = JSON.parse(s);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/models.js
+var require_models = __commonJS({
+  "../../packages/shuttle/dist/executors/models.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LIST_MODELS_TIMEOUT_MS = exports2.CLAUDE_CODE_EFFORTS = exports2.REASONING_EFFORTS = void 0;
+    exports2.parseReasoningEffort = parseReasoningEffort;
+    exports2.hintedEffort = hintedEffort;
+    exports2.runListing = runListing;
+    var os_1 = __importDefault(require("os"));
+    var agent_process_1 = require_agent_process();
+    exports2.REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+    exports2.CLAUDE_CODE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+    function parseReasoningEffort(value, levels) {
+      if (value === void 0)
+        return void 0;
+      if (!levels.includes(value)) {
+        throw new Error(`"reasoningEffort" must be one of ${levels.join(", ")}`);
+      }
+      return value;
+    }
+    function hintedEffort(hints) {
+      const effort = hints.effort;
+      return typeof effort === "string" && /^[a-z]+$/.test(effort) ? effort : void 0;
+    }
+    exports2.LIST_MODELS_TIMEOUT_MS = 15e3;
+    async function runListing(bin, args, signal, env) {
+      try {
+        const run = await (0, agent_process_1.runAgentProcess)({
+          bin,
+          args,
+          cwd: os_1.default.tmpdir(),
+          ...env ? { env } : {},
+          idleTimeoutMs: exports2.LIST_MODELS_TIMEOUT_MS,
+          toolName: bin,
+          signal
+        });
+        return run.spawnError || run.code !== 0 ? null : run.stdout;
+      } catch {
+        return null;
+      }
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/workspace-telemetry.js
+var require_workspace_telemetry = __commonJS({
+  "../../packages/shuttle/dist/executors/workspace-telemetry.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.workspaceOutputs = workspaceOutputs;
+    exports2.relativeWorkspaceReads = relativeWorkspaceReads;
+    exports2.globToRegExp = globToRegExp;
+    exports2.creditOverlayReads = creditOverlayReads;
+    exports2.shellReadPaths = shellReadPaths;
+    var fs_1 = require("fs");
+    var path_1 = __importDefault(require("path"));
+    function workspaceOutputs(workspace, runCwd, readPaths, toolInputs) {
+      const reads = [...readPaths];
+      for (const rel of creditOverlayReads(toolInputs, workspace.overlay?.writtenPaths ?? [], runCwd)) {
+        reads.push(path_1.default.join(runCwd, rel));
+      }
+      return [
+        { label: "workspace_reads", content: { paths: relativeWorkspaceReads(reads, runCwd) } },
+        {
+          // Structured audit trail: reviewers and operators can see whether a
+          // given review actually explored the checkout or fell back to the
+          // diff (and why, including a failed private-repo auth), plus which
+          // overlay files landed.
+          label: "workspace",
+          content: {
+            materialized: workspace.materialized,
+            ...workspace.warning ? { warning: workspace.warning } : {},
+            ...workspace.context.length > 0 ? {
+              context: workspace.context.map((c) => ({
+                name: c.requestedName,
+                materialized: c.materialized,
+                ...c.warning ? { warning: c.warning } : {}
+              }))
+            } : {},
+            ...workspace.overlay ? {
+              overlay: {
+                written: workspace.overlay.written,
+                ...workspace.overlay.skipped.length > 0 ? { skipped: workspace.overlay.skipped } : {}
+              }
+            } : {}
+          }
+        }
+      ];
+    }
+    var MAX_REPORTED_READS = 2e3;
+    function workspaceRoots(cwd) {
+      const root = path_1.default.resolve(cwd);
+      const roots = [root];
+      try {
+        const real = (0, fs_1.realpathSync)(root);
+        if (real !== root)
+          roots.push(real);
+      } catch {
+      }
+      return roots;
+    }
+    function relativeWorkspaceReads(readPaths, cwd) {
+      const roots = workspaceRoots(cwd);
+      const root = roots[0];
+      const out = /* @__PURE__ */ new Set();
+      for (const p of readPaths) {
+        const resolved = path_1.default.resolve(root, p);
+        for (const r of roots) {
+          if (resolved === r)
+            break;
+          if (!resolved.startsWith(r + path_1.default.sep))
+            continue;
+          out.add(resolved.slice(r.length + 1));
+          break;
+        }
+        if (out.size >= MAX_REPORTED_READS)
+          break;
+      }
+      return [...out].sort();
+    }
+    var GLOB_CHARS = /[*?[{]/;
+    function escapeRegExp(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function globToRegExp(glob) {
+      let re = "^";
+      for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === "*") {
+          if (glob[i + 1] === "*") {
+            if (glob[i + 2] === "/") {
+              re += "(?:.*/)?";
+              i += 2;
+            } else {
+              re += ".*";
+              i += 1;
+            }
+          } else {
+            re += "[^/]*";
+          }
+        } else if (ch === "?") {
+          re += "[^/]";
+        } else if (ch === "[") {
+          const end = glob.indexOf("]", i + 1);
+          if (end === -1)
+            return null;
+          let cls = glob.slice(i + 1, end);
+          if (cls.startsWith("!"))
+            cls = `^${cls.slice(1)}`;
+          re += `[${cls.replace(/\\/g, "\\\\")}]`;
+          i = end;
+        } else if (ch === "{") {
+          const end = glob.indexOf("}", i + 1);
+          if (end === -1)
+            return null;
+          re += `(?:${glob.slice(i + 1, end).split(",").map(escapeRegExp).join("|")})`;
+          i = end;
+        } else {
+          re += escapeRegExp(ch);
+        }
+      }
+      return new RegExp(`${re}$`);
+    }
+    function creditOverlayReads(toolInputs, writtenPaths, runCwd) {
+      if (writtenPaths.length === 0 || toolInputs.length === 0)
+        return [];
+      const roots = runCwd ? workspaceRoots(runCwd) : [];
+      const dirs = /* @__PURE__ */ new Set();
+      for (const rel of writtenPaths) {
+        const parts = rel.split("/");
+        for (let i = 1; i < parts.length; i++)
+          dirs.add(`${parts.slice(0, i).join("/")}/`);
+      }
+      const dirAlt = [...dirs].map(escapeRegExp).join("|");
+      const wordRe = dirs.size > 0 ? new RegExp(`(?:${dirAlt})[^\\s"'\`;|&<>()\\\\]*`, "g") : null;
+      const findRe = dirs.size > 0 ? new RegExp(`\\bfind\\s+(?:\\./)?(${[...dirs].map((d) => escapeRegExp(d.slice(0, -1))).join("|")})/?(?=\\s|$)`, "g") : null;
+      const readerRe = new RegExp(`(?:^|[\\s"])(?:-exec|-execdir|xargs)\\b[^;|&]*\\b${READERS}\\b`);
+      const credited = /* @__PURE__ */ new Set();
+      for (const raw of toolInputs) {
+        const input = roots.reduce((s, r) => s.split(`${r}/`).join(""), raw);
+        for (const rel of writtenPaths) {
+          if (input.includes(rel))
+            credited.add(rel);
+        }
+        if (wordRe) {
+          for (const match of input.matchAll(wordRe)) {
+            const word = match[0];
+            if (!GLOB_CHARS.test(word))
+              continue;
+            const re = globToRegExp(word);
+            if (!re)
+              continue;
+            for (const rel of writtenPaths) {
+              if (re.test(rel))
+                credited.add(rel);
+            }
+          }
+        }
+        if (findRe && readerRe.test(input)) {
+          for (const match of input.matchAll(findRe)) {
+            const dir = `${match[1]}/`;
+            for (const rel of writtenPaths) {
+              if (rel.startsWith(dir))
+                credited.add(rel);
+            }
+          }
+        }
+        if (!PLAIN_READER_RE.test(input))
+          continue;
+        for (const match of input.matchAll(CD_RE)) {
+          const target = match[1].replace(/^\.\//, "").replace(/\/+$/, "");
+          const base = target.length > 0 ? `${target}/` : "";
+          for (const rel of writtenPaths) {
+            if (!rel.startsWith(base))
+              continue;
+            if (namesBareWord(input, rel.slice(base.length)))
+              credited.add(rel);
+          }
+        }
+      }
+      return [...credited].sort();
+    }
+    var READERS = "(?:cat|head|tail|sed|awk|less|more|bat)";
+    var PLAIN_READER_RE = new RegExp(`(?:^|[\\s"'\`;|&(])${READERS}\\b`);
+    var CD_RE = /(?:^|[\s"'`;|&(])cd\s+(?:--\s+)?["']?([^\s"'`;|&<>()\\]+)/g;
+    function namesBareWord(input, word) {
+      const edge = String.raw`[\s"'\`;|&<>(),\\]`;
+      return new RegExp(`(?:^|${edge})${escapeRegExp(word)}(?=$|${edge})`).test(input);
+    }
+    function shellReadPaths(commands, runCwd) {
+      const roots = workspaceRoots(runCwd);
+      const out = /* @__PURE__ */ new Set();
+      for (const command of commands) {
+        if (!PLAIN_READER_RE.test(command))
+          continue;
+        for (const raw of command.split(/[\s"'`;|&<>()]+/)) {
+          const word = raw.replace(/^\.\//, "");
+          if (word.length === 0 || word.startsWith("-") || GLOB_CHARS.test(word))
+            continue;
+          const abs = path_1.default.resolve(roots[0], roots.reduce((w, r) => w.startsWith(`${r}/`) ? w.slice(r.length + 1) : w, word));
+          if (!roots.some((r) => abs.startsWith(r + path_1.default.sep)))
+            continue;
+          try {
+            if ((0, fs_1.statSync)(abs).isFile())
+              out.add(abs);
+          } catch {
+          }
+          if (out.size >= MAX_REPORTED_READS)
+            return [...out];
+        }
+      }
+      return [...out];
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/claude-code.js
+var require_claude_code = __commonJS({
+  "../../packages/shuttle/dist/executors/claude-code.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.classifyEnvironmentFault = classifyEnvironmentFault;
+    exports2.createClaudeCodeExecutor = createClaudeCodeExecutor;
+    exports2.checkoutScopedTools = checkoutScopedTools;
+    exports2.parseStreamJson = parseStreamJson;
+    var fs_1 = require("fs");
+    var os_1 = __importDefault(require("os"));
+    var path_1 = __importDefault(require("path"));
+    var loom_1 = require_dist();
+    var types_1 = require_types2();
+    var validate_output_1 = require_validate_output();
+    var progress_1 = require_progress();
+    var agent_process_1 = require_agent_process();
+    var json_answer_1 = require_json_answer();
+    var models_1 = require_models();
+    var workspace_telemetry_1 = require_workspace_telemetry();
+    var apply_1 = require_apply();
+    var DEFAULT_TIMEOUT = 6e5;
+    var REVIEW_TOOLS = ["Read", "Grep", "Glob"];
+    function reviewRunArgs(settingSources) {
+      return [
+        "--setting-sources",
+        settingSources,
+        "--strict-mcp-config",
+        "--tools",
+        REVIEW_TOOLS.join(","),
+        "--permission-mode",
+        "default",
+        "--settings",
+        JSON.stringify({ disableAllHooks: true })
+      ];
+    }
+    var RETIRED_READ_TOOLS = ["LS"];
+    var HOSTED_ENV_PASSTHROUGH = [
+      "PATH",
+      "HOME",
+      "TMPDIR",
+      "LANG",
+      "LC_ALL",
+      "LC_CTYPE",
+      "TZ",
+      "NODE_EXTRA_CA_CERTS",
+      "SSL_CERT_FILE",
+      "SSL_CERT_DIR",
+      "HTTPS_PROXY",
+      "HTTP_PROXY",
+      "NO_PROXY",
+      "https_proxy",
+      "http_proxy",
+      "no_proxy"
+    ];
+    function describeClaudeFailure(meta, fallback) {
+      if (!meta)
+        return fallback;
+      const status = meta.apiErrorStatus !== null ? ` (provider HTTP ${meta.apiErrorStatus})` : "";
+      if (meta.detail)
+        return `${meta.detail}${status}`;
+      const subtype = meta.subtype && meta.subtype !== "success" ? `: ${meta.subtype}` : "";
+      return `${fallback}${subtype}${status}`;
+    }
+    var CLAUDE_CODE_MODELS = [
+      { id: "opus", label: "Claude Opus (latest)", efforts: [...models_1.CLAUDE_CODE_EFFORTS] },
+      { id: "fable", label: "Claude Fable (latest)", efforts: [...models_1.CLAUDE_CODE_EFFORTS] },
+      { id: "sonnet", label: "Claude Sonnet (latest)", efforts: [...models_1.CLAUDE_CODE_EFFORTS] },
+      { id: "haiku", label: "Claude Haiku (latest)", efforts: [...models_1.CLAUDE_CODE_EFFORTS] }
+    ];
+    var READINESS_PROMPT = "Reply with the single word: ok";
+    var READINESS_TIMEOUT_MS = 12e4;
+    var INSTALL_REMEDY = "install Claude Code (npm install -g @anthropic-ai/claude-code) where this process can find it on PATH";
+    var LOGIN_REMEDY = "run `claude` once and sign in (or set a valid ANTHROPIC_API_KEY); if your login or provider is configured in Claude Code settings (apiKeyHelper, or an env block), set `claudeSettings: user` on the claude-code executor, since a review loads no settings file without it";
+    var LIMIT_REMEDY = "wait for the plan's usage limit to reset, or raise it";
+    var SIGNED_OUT = /invalid api key|please run \/login|not (?:logged|signed) in|oauth token (?:has )?expired|authentication_error|invalid x-api-key/i;
+    var OUT_OF_USAGE = /usage limit|credit balance is too low|out of (?:extra )?usage|hit your (?:\w+ )?(?:usage |spend )?limit|5-hour limit/i;
+    var CLAUDE_FAULTS = {
+      installRemedy: INSTALL_REMEDY,
+      loginRemedy: LOGIN_REMEDY,
+      limitRemedy: LIMIT_REMEDY,
+      signedOut: SIGNED_OUT,
+      outOfUsage: OUT_OF_USAGE
+    };
+    function classifyEnvironmentFault(failure) {
+      return (0, agent_process_1.classifyAgentFault)(failure, CLAUDE_FAULTS);
+    }
+    function runFailure(local, message, facts) {
+      return (0, agent_process_1.agentFailure)(local, message, facts, CLAUDE_FAULTS);
+    }
+    var ClaudeCodeExecutor = class {
+      capability;
+      strategies = [loom_1.PROMPT_EXECUTION_STRATEGY];
+      config;
+      constructor(config) {
+        this.config = config;
+        this.capability = { id: config.capabilityId };
+      }
+      estimate(dispatch) {
+        const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+        return {
+          inputTokens: spec.costCapHint?.estimatedInputTokens,
+          outputTokens: spec.costCapHint?.estimatedOutputTokens
+        };
+      }
+      /**
+       * Declare the run environment to the runner (ADR 0026): the opaque workspace
+       * bag plus the materialization config (tmp dir, overlay allowlist). No
+       * credentials here (ADR 0027) — the runner's broker reveals them on demand:
+       * this executor pulls its model key from `ctx.credentials` in `execute()`,
+       * and the git request references its own fetch credential. The executor
+       * touches neither git nor Keep.
+       */
+      async prepareEnvironment(dispatch) {
+        const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : void 0;
+        return {
+          ...spec.workspace ? { workspaceRequest: spec.workspace } : {},
+          materializeOptions: {
+            ...tmpBase ? { tmpDir: tmpBase } : {},
+            overlayAllowedHosts: this.config.overlayAllowedHosts ?? []
+          }
+        };
+      }
+      async execute(dispatch, signal, ctx) {
+        const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
+        const workspace = ctx?.workspace ?? null;
+        let modelKey = null;
+        if (ctx?.credentials) {
+          const hints = (0, loom_1.pickProviderHints)(spec, "anthropic-api");
+          const customerId = typeof hints.customerId === "string" ? hints.customerId : void 0;
+          if (!customerId) {
+            throw new Error("claude-code dynamic-key mode requires providerHints.anthropicApi.customerId on every job");
+          }
+          modelKey = await ctx.credentials.reveal({ name: "managed-model-key", principal: customerId });
+        }
+        let jobScratch = null;
+        let configDir;
+        if (modelKey) {
+          jobScratch = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "shuttle-cc-"));
+          configDir = path_1.default.join(jobScratch, "claude-config");
+          await fs_1.promises.mkdir(configDir);
+        }
+        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
+        let promptOnlyScratch = null;
+        const reporter = spec.progressChannel && ctx?.reportProgress ? new progress_1.ProgressReporter((frames) => ctx.reportProgress(spec.progressChannel, frames)) : null;
+        try {
+          const childEnv = buildChildEnv(modelKey, configDir);
+          const claudeHints = (0, loom_1.pickProviderHints)(spec, "claude-code");
+          const hintedModel = typeof claudeHints.model === "string" && claudeHints.model.length > 0 ? claudeHints.model : void 0;
+          const effort = (0, models_1.hintedEffort)(claudeHints);
+          if (!workspace) {
+            promptOnlyScratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-run-"));
+          }
+          const runCwd = workspace?.cwd ?? promptOnlyScratch;
+          const { response, readPaths, toolInputs } = await this.runClaude(
+            prompt,
+            spec,
+            runCwd,
+            childEnv,
+            signal,
+            hintedModel,
+            reporter,
+            void 0,
+            dispatch.job.id,
+            // Local mode is the operator's own login: a failure of THAT is the
+            // machine's, and the runner pauses on it. With a revealed key it is one
+            // customer's, and only their job fails.
+            modelKey === null,
+            effort
+          );
+          if (workspace) {
+            response.outputs.push(...(0, workspace_telemetry_1.workspaceOutputs)(workspace, runCwd, readPaths, toolInputs));
+          }
+          return response;
+        } finally {
+          reporter?.close();
+          if (promptOnlyScratch)
+            await fs_1.promises.rm(promptOnlyScratch, { recursive: true, force: true }).catch(() => {
+            });
+          if (jobScratch)
+            await fs_1.promises.rm(jobScratch, { recursive: true, force: true }).catch(() => {
+            });
+        }
+      }
+      /**
+       * In-session gate repair (ADR 0017): resume the session `execute()` returned a
+       * handle for and correct its output. The repair turn works from the resumed
+       * session's own context (no checkout needed), under the same `--json-schema`
+       * constraint. A throwaway cwd hosts the run; the same handle rides back out so
+       * a second repair round can resume again.
+       */
+      async continue(continuation, followUp, signal, _ctx) {
+        const handle = continuation;
+        if (!handle || typeof handle.sessionId !== "string") {
+          throw new Error("claude-code continue: missing session to resume");
+        }
+        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-resume-"));
+        try {
+          const spec = {
+            rendering: "producer",
+            outputLabel: handle.outputLabel,
+            outputSchema: handle.outputSchema
+          };
+          const { response } = await this.runClaude(followUp, spec, scratch, handle.childEnv, signal, handle.model, null, handle.sessionId, `${handle.sessionId}-repair`, handle.childEnv === void 0, handle.effort);
+          return response;
+        } finally {
+          await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+      /**
+       * Can this machine run a job now? One real one-turn call through the CLI,
+       * the same probe `doctor --deep` makes. The runner asks it only while
+       * claiming is paused on an `ExecutorEnvironmentError`, and only in local
+       * mode. A signed-out or missing CLI fails before any model call, so the
+       * re-check spends nothing until the login works again, and then one turn.
+       */
+      async checkReadiness(signal) {
+        let run;
+        try {
+          run = await (0, agent_process_1.runAgentProcess)({
+            bin: "claude",
+            args: ["--print", "--output-format", "stream-json", "--verbose", "--max-turns", "1", READINESS_PROMPT],
+            cwd: process.cwd(),
+            idleTimeoutMs: READINESS_TIMEOUT_MS,
+            toolName: "the claude CLI",
+            signal
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { ready: false, reason: message === "Dispatch aborted" ? "readiness check aborted" : message };
+        }
+        if (run.spawnError) {
+          return {
+            ready: false,
+            reason: run.spawnError.code === "ENOENT" ? `the claude CLI is not on this machine's PATH (${run.spawnError.message})` : run.spawnError.message
+          };
+        }
+        let meta = null;
+        try {
+          meta = parseStreamJson(run.stdout).resultMeta;
+        } catch {
+          meta = null;
+        }
+        if (run.code === 0 && !meta?.isError)
+          return { ready: true };
+        const said = meta?.detail ?? (0, agent_process_1.firstLine)(run.stderr) ?? (0, agent_process_1.firstLine)(run.stdout);
+        return { ready: false, reason: said ?? `the claude CLI exited with code ${run.code}` };
+      }
+      /** The CLI's aliases (see CLAUDE_CODE_MODELS); nothing to ask, so nothing can fail. */
+      async listModels() {
+        return CLAUDE_CODE_MODELS;
+      }
+      async runClaude(prompt, spec, cwd, childEnv, signal, modelOverride, reporter, resumeSessionId, transcriptName, local = false, effortOverride) {
+        const outputLabel = spec.outputLabel;
+        const model = modelOverride ?? this.config.model;
+        const effort = effortOverride ?? this.config.reasoningEffort;
+        const allowedTools = local ? this.config.allowedTools : checkoutScopedTools(this.config.allowedTools);
+        if (!local && this.config.claudeSettings === "user") {
+          throw new Error("claude-code: `claudeSettings: user` is for an installed Sifter whose login lives in Claude Code settings; a hosted run authenticates with the key it is handed and loads no settings");
+        }
+        const settingSources = local && this.config.claudeSettings === "user" ? "user" : "";
+        const args = ["--print", "--output-format", "stream-json", "--verbose", ...reviewRunArgs(settingSources)];
+        if (resumeSessionId)
+          args.push("--resume", resumeSessionId);
+        if (spec.outputSchema && typeof spec.outputSchema === "object" && Object.keys(spec.outputSchema).length > 0) {
+          args.push("--json-schema", JSON.stringify(spec.outputSchema));
+        }
+        if (model)
+          args.push("--model", model);
+        if (effort)
+          args.push("--effort", effort);
+        if (this.config.maxTurns !== void 0)
+          args.push("--max-turns", String(this.config.maxTurns));
+        if (allowedTools && allowedTools.length > 0) {
+          args.push("--allowedTools", allowedTools.join(","));
+        }
+        const tap = reporter ? new progress_1.StreamJsonTap({
+          onReasoning: (t) => reporter.reasoning(t),
+          onTool: (name, target) => reporter.tool(name, target),
+          onResult: () => reporter.flush()
+        }) : null;
+        const run = await (0, agent_process_1.runAgentProcess)({
+          bin: "claude",
+          args,
+          cwd,
+          // Undefined in local mode → inherit the ambient env (and its
+          // `~/.claude` login) unchanged.
+          env: childEnv,
+          stdin: prompt,
+          idleTimeoutMs: this.config.timeout ?? DEFAULT_TIMEOUT,
+          toolName: "Claude Code",
+          signal,
+          ...tap ? { onStdout: (text) => tap.push(text) } : {}
+        });
+        tap?.end();
+        if (run.spawnError) {
+          if (local && run.spawnError.code === "ENOENT") {
+            throw new types_1.ExecutorEnvironmentError(`the claude CLI is not on this machine's PATH (${run.spawnError.message})`, INSTALL_REMEDY);
+          }
+          throw new Error(run.spawnError.message);
+        }
+        const { stdout, stderr: stderrText, code } = run;
+        if (this.config.keepTranscripts && transcriptName) {
+          void (0, agent_process_1.keepTranscript)((0, apply_1.expandHome)(this.config.keepTranscripts), transcriptName, stdout);
+        }
+        if (code !== 0) {
+          let meta = null;
+          try {
+            meta = parseStreamJson(stdout).resultMeta;
+          } catch {
+          }
+          const said = meta?.detail ?? (0, agent_process_1.firstLine)(stderrText) ?? (0, agent_process_1.firstLine)(stdout);
+          const fallback = `Claude Code exited with code ${code}`;
+          const failure = runFailure(local, describeClaudeFailure(meta, fallback), {
+            apiErrorStatus: meta?.apiErrorStatus ?? null,
+            text: said
+          });
+          if (failure instanceof types_1.ExecutorEnvironmentError && !meta && said) {
+            throw new types_1.ExecutorEnvironmentError(`${fallback}: ${said}`, failure.remedy);
+          }
+          throw failure;
+        }
+        const stream = parseStreamJson(stdout);
+        if (stream.resultMeta?.isError) {
+          throw runFailure(local, describeClaudeFailure(stream.resultMeta, "Claude Code reported a failure"), {
+            apiErrorStatus: stream.resultMeta.apiErrorStatus,
+            text: stream.resultMeta.detail ?? (0, agent_process_1.firstLine)(stderrText)
+          });
+        }
+        const answerText = stream.finalText ?? stdout;
+        const parsed = stream.structuredOutput ?? (0, json_answer_1.extractJsonObject)(answerText);
+        if (parsed === void 0 && stream.resultMeta) {
+          throw new Error(`claude's final message contained no JSON object (result subtype=${stream.resultMeta.subtype ?? "unknown"}; message head: ${JSON.stringify(answerText.slice(0, 160))})`);
+        }
+        (0, validate_output_1.assertOutputValid)(spec, parsed);
+        return {
+          response: {
+            outputs: [{ label: outputLabel, content: parsed ?? { raw: answerText } }],
+            rawText: answerText,
+            parsed,
+            usage: {
+              aiProvider: "claude-code",
+              // The model that ran (an alias resolved), over the one asked for.
+              ...stream.model ?? model ? { aiModel: stream.model ?? model } : {},
+              ...effort ? { aiEffort: effort } : {},
+              ...stream.usage ?? {}
+            },
+            // In-session repair handle (ADR 0017): present only when the run
+            // reported a session id, so the runner can `--resume` it.
+            ...stream.sessionId ? {
+              continuation: {
+                sessionId: stream.sessionId,
+                model,
+                effort,
+                childEnv,
+                outputLabel,
+                outputSchema: spec.outputSchema
+              }
+            } : {}
+          },
+          readPaths: stream.readPaths,
+          toolInputs: stream.toolInputs
+        };
+      }
+    };
+    function createClaudeCodeExecutor(config, capabilityId = "claude-code") {
+      const validated = { capabilityId };
+      if (config.tmpDir !== void 0) {
+        if (typeof config.tmpDir !== "string" || config.tmpDir.length === 0) {
+          throw new Error('"tmpDir" must be a non-empty string');
+        }
+        validated.tmpDir = config.tmpDir;
+      }
+      if (config.model !== void 0) {
+        if (typeof config.model !== "string")
+          throw new Error('"model" must be a string');
+        validated.model = config.model;
+      }
+      const effort = (0, models_1.parseReasoningEffort)(config.reasoningEffort, models_1.CLAUDE_CODE_EFFORTS);
+      if (effort)
+        validated.reasoningEffort = effort;
+      if (config.maxTurns !== void 0) {
+        if (typeof config.maxTurns !== "number" || !Number.isInteger(config.maxTurns) || config.maxTurns < 1) {
+          throw new Error('"maxTurns" must be a positive integer');
+        }
+        validated.maxTurns = config.maxTurns;
+      }
+      if (config.allowedTools !== void 0) {
+        if (!Array.isArray(config.allowedTools) || !config.allowedTools.every((t) => typeof t === "string")) {
+          throw new Error('"allowedTools" must be an array of strings');
+        }
+        validated.allowedTools = config.allowedTools;
+      }
+      if (config.timeout !== void 0) {
+        if (typeof config.timeout !== "number" || config.timeout <= 0) {
+          throw new Error('"timeout" must be a positive number');
+        }
+        validated.timeout = config.timeout;
+      }
+      if (config.keepTranscripts !== void 0) {
+        if (typeof config.keepTranscripts !== "string" || config.keepTranscripts.length === 0) {
+          throw new Error('"keepTranscripts" must be a non-empty directory path');
+        }
+        validated.keepTranscripts = config.keepTranscripts;
+      }
+      if (config.claudeSettings !== void 0) {
+        if (config.claudeSettings !== "user") {
+          throw new Error('"claudeSettings" may only be "user" (leave it unset to load no settings file)');
+        }
+        validated.claudeSettings = "user";
+      }
+      if (config.overlayAllowedHosts !== void 0) {
+        if (!Array.isArray(config.overlayAllowedHosts) || !config.overlayAllowedHosts.every((h) => typeof h === "string")) {
+          throw new Error('"overlayAllowedHosts" must be an array of strings');
+        }
+        validated.overlayAllowedHosts = config.overlayAllowedHosts;
+      }
+      return new ClaudeCodeExecutor(validated);
+    }
+    function checkoutScopedTools(tools) {
+      if (!tools)
+        return void 0;
+      const scoped = [];
+      for (const tool of tools) {
+        if (RETIRED_READ_TOOLS.some((t) => tool === t || tool === `${t}(./**)`))
+          continue;
+        const name = REVIEW_TOOLS.find((t) => tool === t || tool === `${t}(./**)`);
+        if (!name) {
+          throw new Error(`claude-code: a hosted run may use only ${REVIEW_TOOLS.join(", ")} inside the checkout; "${tool}" is not allowed`);
+        }
+        scoped.push(`${name}(./**)`);
+      }
+      return scoped;
+    }
+    function buildChildEnv(modelKey, configDir) {
+      if (!modelKey && !configDir)
+        return void 0;
+      const env = {};
+      for (const name of HOSTED_ENV_PASSTHROUGH) {
+        if (process.env[name] !== void 0)
+          env[name] = process.env[name];
+      }
+      return {
+        ...env,
+        ...modelKey ? { ANTHROPIC_API_KEY: modelKey } : {},
+        ...configDir ? { CLAUDE_CONFIG_DIR: configDir } : {}
+      };
+    }
+    function parseStreamJson(stdout) {
+      let finalText = null;
+      const readPaths = [];
+      let usage = null;
+      let resultMeta = null;
+      let structuredOutput = null;
+      let sessionId = null;
+      let model = null;
+      const toolInputs = [];
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+          continue;
+        let event;
+        try {
+          event = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (typeof event.session_id === "string")
+          sessionId = event.session_id;
+        if (event.type === "system" && event.subtype === "init" && typeof event.model === "string" && event.model) {
+          model = event.model;
+        } else if (event.type === "assistant") {
+          const content = event.message?.content;
+          if (!Array.isArray(content))
+            continue;
+          for (const block of content) {
+            const b = block;
+            if (b?.type !== "tool_use")
+              continue;
+            const fp = b.input?.file_path;
+            if (b.name === "Read" && typeof fp === "string") {
+              readPaths.push(fp);
+            }
+            if (b.input && typeof b.input === "object")
+              toolInputs.push(JSON.stringify(b.input));
+          }
+        } else if (event.type === "result") {
+          if (typeof event.result === "string" && event.result.trim().length > 0) {
+            finalText = event.result;
+          }
+          resultMeta = {
+            subtype: typeof event.subtype === "string" ? event.subtype : null,
+            isError: event.is_error === true,
+            // On a failure the CLI puts a human-readable reason in `result` — the
+            // model was unavailable, spend limit hit, and so on. It is the only
+            // place that reason exists, so keep it for the failure message.
+            detail: typeof event.result === "string" && event.result.trim().length > 0 ? event.result.trim() : null,
+            apiErrorStatus: typeof event.api_error_status === "number" ? event.api_error_status : null
+          };
+          const so = event.structured_output;
+          if (so && typeof so === "object" && !Array.isArray(so)) {
+            structuredOutput = so;
+          }
+          const u = event.usage;
+          const cost = event.total_cost_usd;
+          usage = {
+            ...typeof u?.input_tokens === "number" ? { inputTokens: u.input_tokens } : {},
+            ...typeof u?.output_tokens === "number" ? { outputTokens: u.output_tokens } : {},
+            ...typeof cost === "number" ? { costUsd: cost } : {}
+          };
+        }
+      }
+      return { finalText, readPaths, usage, resultMeta, structuredOutput, sessionId, model, toolInputs };
+    }
   }
 });
 
-// ../../packages/shuttle/dist/executors/claude-code.js
-var require_claude_code = __commonJS({
-  "../../packages/shuttle/dist/executors/claude-code.js"(exports2) {
+// ../../packages/shuttle/dist/executors/agent-common.js
+var require_agent_common = __commonJS({
+  "../../packages/shuttle/dist/executors/agent-common.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_AGENT_TIMEOUT = void 0;
+    exports2.parseAgentCommonConfig = parseAgentCommonConfig;
+    exports2.agentEnvironment = agentEnvironment;
+    exports2.refuseHosted = refuseHosted;
+    var loom_1 = require_dist();
+    var apply_1 = require_apply();
+    exports2.DEFAULT_AGENT_TIMEOUT = 6e5;
+    function parseAgentCommonConfig(config, capabilityId) {
+      const out = { capabilityId };
+      if (config.tmpDir !== void 0) {
+        if (typeof config.tmpDir !== "string" || config.tmpDir.length === 0) {
+          throw new Error('"tmpDir" must be a non-empty string');
+        }
+        out.tmpDir = config.tmpDir;
+      }
+      if (config.model !== void 0) {
+        if (typeof config.model !== "string" || config.model.length === 0) {
+          throw new Error('"model" must be a non-empty string');
+        }
+        out.model = config.model;
+      }
+      if (config.timeout !== void 0) {
+        if (typeof config.timeout !== "number" || config.timeout <= 0) {
+          throw new Error('"timeout" must be a positive number');
+        }
+        out.timeout = config.timeout;
+      }
+      if (config.keepTranscripts !== void 0) {
+        if (typeof config.keepTranscripts !== "string" || config.keepTranscripts.length === 0) {
+          throw new Error('"keepTranscripts" must be a non-empty directory path');
+        }
+        out.keepTranscripts = config.keepTranscripts;
+      }
+      if (config.overlayAllowedHosts !== void 0) {
+        if (!Array.isArray(config.overlayAllowedHosts) || !config.overlayAllowedHosts.every((h) => typeof h === "string")) {
+          throw new Error('"overlayAllowedHosts" must be an array of strings');
+        }
+        out.overlayAllowedHosts = config.overlayAllowedHosts;
+      }
+      return out;
+    }
+    function agentEnvironment(dispatch, config) {
+      const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+      const tmpBase = config.tmpDir ? (0, apply_1.expandHome)(config.tmpDir) : void 0;
+      return {
+        ...spec.workspace ? { workspaceRequest: spec.workspace } : {},
+        materializeOptions: {
+          ...tmpBase ? { tmpDir: tmpBase } : {},
+          overlayAllowedHosts: config.overlayAllowedHosts ?? []
+        }
+      };
+    }
+    function refuseHosted(executor, hosted) {
+      if (hosted) {
+        throw new Error(`${executor}: this executor runs on an installed Sifter only, on the operator's own login; a hosted Sifter has no managed credential for it`);
+      }
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/strict-schema.js
+var require_strict_schema = __commonJS({
+  "../../packages/shuttle/dist/executors/strict-schema.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.toStrict = toStrict;
+    exports2.dropNulls = dropNulls;
+    var UNSUPPORTED = ["format", "default", "$schema"];
+    function toStrict(schema) {
+      if (Array.isArray(schema))
+        return schema.map(toStrict);
+      if (!isSchema(schema))
+        return schema;
+      const out = {};
+      for (const [key, value] of Object.entries(schema)) {
+        if (UNSUPPORTED.includes(key))
+          continue;
+        if (key === "properties" && isSchema(value)) {
+          const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+          const props = {};
+          for (const [name, prop] of Object.entries(value)) {
+            const strict = toStrict(prop);
+            props[name] = required.has(name) ? strict : nullable(strict);
+          }
+          out.properties = props;
+          out.required = Object.keys(value);
+          continue;
+        }
+        if (key === "required")
+          continue;
+        out[key] = SUBSCHEMA_KEYS.has(key) ? toStrict(value) : value;
+      }
+      if (out.type === "object" || out.properties !== void 0)
+        out.additionalProperties = false;
+      return out;
+    }
+    function dropNulls(value, schema) {
+      if (!isSchema(schema))
+        return value;
+      if (Array.isArray(value)) {
+        return isSchema(schema.items) ? value.map((v) => dropNulls(v, schema.items)) : value;
+      }
+      if (!isSchema(value)) {
+        return value;
+      }
+      const branches = [schema.anyOf, schema.oneOf].find(Array.isArray);
+      if (branches) {
+        const branch = branches.find((b) => isSchema(b) && (b.type === "object" || isSchema(b.properties)));
+        return branch ? dropNulls(value, branch) : value;
+      }
+      if (!isSchema(schema.properties))
+        return value;
+      const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+      const out = {};
+      for (const [name, v] of Object.entries(value)) {
+        const prop = schema.properties[name];
+        if (v === null && !required.has(name) && !allowsNull(prop))
+          continue;
+        out[name] = dropNulls(v, prop);
+      }
+      return out;
+    }
+    var SUBSCHEMA_KEYS = /* @__PURE__ */ new Set(["items", "anyOf", "oneOf", "allOf", "not", "additionalProperties", "definitions", "$defs"]);
+    function nullable(schema) {
+      if (!isSchema(schema) || allowsNull(schema))
+        return schema;
+      if (typeof schema.type === "string" && schema.anyOf === void 0 && schema.oneOf === void 0) {
+        const out = { ...schema, type: [schema.type, "null"] };
+        if (Array.isArray(schema.enum))
+          out.enum = [...schema.enum, null];
+        return out;
+      }
+      return { anyOf: [schema, { type: "null" }] };
+    }
+    function allowsNull(schema) {
+      if (!isSchema(schema))
+        return false;
+      if (schema.type === "null")
+        return true;
+      if (Array.isArray(schema.type) && schema.type.includes("null"))
+        return true;
+      const branches = [schema.anyOf, schema.oneOf].find(Array.isArray);
+      return branches?.some(allowsNull) ?? false;
+    }
+    function isSchema(v) {
+      return typeof v === "object" && v !== null && !Array.isArray(v);
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/executors/codex.js
+var require_codex = __commonJS({
+  "../../packages/shuttle/dist/executors/codex.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.classifyEnvironmentFault = classifyEnvironmentFault;
-    exports2.createClaudeCodeExecutor = createClaudeCodeExecutor;
-    exports2.checkoutScopedTools = checkoutScopedTools;
-    exports2.parseStreamJson = parseStreamJson;
-    exports2.relativeWorkspaceReads = relativeWorkspaceReads;
-    exports2.globToRegExp = globToRegExp;
-    exports2.creditOverlayReads = creditOverlayReads;
-    exports2.extractJsonObject = extractJsonObject;
-    var child_process_1 = require("child_process");
+    exports2.resolveCodex = resolveCodex;
+    exports2.codexReviewArgs = codexReviewArgs;
+    exports2.parseCodexEvents = parseCodexEvents;
+    exports2.parseCodexModels = parseCodexModels;
+    exports2.createCodexExecutor = createCodexExecutor;
     var fs_1 = require("fs");
     var os_1 = __importDefault(require("os"));
     var path_1 = __importDefault(require("path"));
-    var string_decoder_1 = require("string_decoder");
     var loom_1 = require_dist();
     var types_1 = require_types2();
     var validate_output_1 = require_validate_output();
     var progress_1 = require_progress();
+    var agent_process_1 = require_agent_process();
+    var agent_common_1 = require_agent_common();
+    var json_answer_1 = require_json_answer();
+    var models_1 = require_models();
+    var strict_schema_1 = require_strict_schema();
+    var workspace_telemetry_1 = require_workspace_telemetry();
     var apply_1 = require_apply();
-    var DEFAULT_TIMEOUT = 6e5;
-    var REVIEW_TOOLS = ["Read", "Grep", "Glob"];
-    function reviewRunArgs(settingSources) {
-      return [
-        "--setting-sources",
-        settingSources,
-        "--strict-mcp-config",
-        "--tools",
-        REVIEW_TOOLS.join(","),
-        "--permission-mode",
-        "default",
-        "--settings",
-        JSON.stringify({ disableAllHooks: true })
-      ];
+    var CODEX_PROFILE = "sift-review";
+    function reviewProfile(installDir, platform = process.platform) {
+      const rules = ['":root"="deny"', '":minimal"="read"', '":workspace_roots"="read"', `${JSON.stringify(installDir)}="read"`];
+      if (platform === "linux") {
+        rules.push(`${JSON.stringify(path_1.default.join(codexHome(), "tmp", "arg0"))}="read"`);
+      } else {
+        rules.push('":tmpdir"="deny"', '":slash_tmp"="deny"');
+      }
+      return `permissions.${CODEX_PROFILE}={extends=":read-only", filesystem={${rules.join(", ")}}}`;
     }
-    var RETIRED_READ_TOOLS = ["LS"];
-    var HOSTED_ENV_PASSTHROUGH = [
-      "PATH",
-      "HOME",
-      "TMPDIR",
-      "LANG",
-      "LC_ALL",
-      "LC_CTYPE",
-      "TZ",
-      "NODE_EXTRA_CA_CERTS",
-      "SSL_CERT_FILE",
-      "SSL_CERT_DIR",
-      "HTTPS_PROXY",
-      "HTTP_PROXY",
-      "NO_PROXY",
-      "https_proxy",
-      "http_proxy",
-      "no_proxy"
-    ];
-    function describeClaudeFailure(meta, fallback) {
-      if (!meta)
-        return fallback;
-      const status = meta.apiErrorStatus !== null ? ` (provider HTTP ${meta.apiErrorStatus})` : "";
-      if (meta.detail)
-        return `${meta.detail}${status}`;
-      const subtype = meta.subtype && meta.subtype !== "success" ? `: ${meta.subtype}` : "";
-      return `${fallback}${subtype}${status}`;
+    function codexHome() {
+      return process.env.CODEX_HOME ?? path_1.default.join(os_1.default.homedir(), ".codex");
     }
-    var READINESS_PROMPT = "Reply with the single word: ok";
-    var READINESS_TIMEOUT_MS = 12e4;
-    var STDERR_LIMIT = 4e3;
-    var INSTALL_REMEDY = "install Claude Code (npm install -g @anthropic-ai/claude-code) where this process can find it on PATH";
-    var LOGIN_REMEDY = "run `claude` once and sign in (or set a valid ANTHROPIC_API_KEY); if your login or provider is configured in Claude Code settings (apiKeyHelper, or an env block), set `claudeSettings: user` on the claude-code executor, since a review loads no settings file without it";
-    var LIMIT_REMEDY = "wait for the plan's usage limit to reset, or raise it";
-    var SIGNED_OUT = /invalid api key|please run \/login|not (?:logged|signed) in|oauth token (?:has )?expired|authentication_error|invalid x-api-key/i;
-    var OUT_OF_USAGE = /usage limit|credit balance is too low|out of (?:extra )?usage|hit your (?:\w+ )?(?:usage |spend )?limit|5-hour limit/i;
-    function classifyEnvironmentFault(failure) {
-      if (failure.spawnErrorCode === "ENOENT")
-        return INSTALL_REMEDY;
-      const text = failure.text ?? "";
-      if (failure.apiErrorStatus === 401 || SIGNED_OUT.test(text))
-        return LOGIN_REMEDY;
-      if (failure.apiErrorStatus === 402 || failure.apiErrorStatus === 429 || OUT_OF_USAGE.test(text)) {
-        return LIMIT_REMEDY;
+    function resolveCodex(pathEnv = process.env.PATH ?? "") {
+      for (const dir of pathEnv.split(path_1.default.delimiter)) {
+        if (!dir)
+          continue;
+        const candidate = path_1.default.join(dir, "codex");
+        let real;
+        try {
+          real = (0, fs_1.realpathSync)(candidate);
+          if (!(0, fs_1.statSync)(real).isFile())
+            continue;
+        } catch {
+          continue;
+        }
+        const installDir = real.endsWith(".js") ? path_1.default.dirname(path_1.default.dirname(real)) : path_1.default.dirname(real);
+        return { bin: real.endsWith(".js") ? candidate : real, installDir };
       }
       return null;
     }
-    function firstLine(text) {
-      for (const line of text.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed.length > 0)
-          return trimmed.length > 300 ? `${trimmed.slice(0, 300)}...` : trimmed;
+    var DISABLED_FEATURES = [
+      "hooks",
+      "apps",
+      "plugins",
+      "remote_plugin",
+      "plugin_sharing",
+      "skill_mcp_dependency_install",
+      "browser_use",
+      "browser_use_external",
+      "browser_use_full_cdp_access",
+      "browser_annotation_api",
+      "computer_use",
+      "image_generation",
+      "workspace_dependencies"
+    ];
+    function requireCodex() {
+      const codex = resolveCodex();
+      if (!codex) {
+        throw new types_1.ExecutorEnvironmentError("the codex CLI is not on this machine's PATH", CODEX_FAULTS.installRemedy);
       }
-      return null;
+      return codex;
     }
-    function runFailure(local, message, facts) {
-      if (!local)
-        return new Error(message);
-      const remedy = classifyEnvironmentFault(facts);
-      return remedy ? new types_1.ExecutorEnvironmentError(message, remedy) : new Error(message);
+    function codexReviewArgs(installDir, platform = process.platform) {
+      return [
+        "--json",
+        "--skip-git-repo-check",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "-c",
+        reviewProfile(installDir, platform),
+        "-c",
+        `default_permissions="${CODEX_PROFILE}"`,
+        "-c",
+        'approval_policy="never"',
+        "-c",
+        'web_search="disabled"',
+        ...DISABLED_FEATURES.flatMap((f) => ["--disable", f])
+      ];
     }
-    var ClaudeCodeExecutor = class {
+    var CODEX_FAULTS = {
+      installRemedy: "install Codex (brew install codex, or npm install -g @openai/codex) where this process can find it on PATH",
+      loginRemedy: "run `codex login` and sign in (or `codex login --with-api-key`)",
+      limitRemedy: "wait for the plan's usage limit to reset, or raise it",
+      signedOut: /not logged in|run `?codex login|401 unauthorized|invalid api key|refresh token|token (?:has )?expired|sign in again/i,
+      outOfUsage: /usage limit|hit your (?:\w+ )?limit|insufficient_quota|exceeded your current quota|429 too many requests/i
+    };
+    var READINESS_PROMPT = "Reply with the single word: ok";
+    var READINESS_TIMEOUT_MS = 12e4;
+    var CodexExecutor = class {
       capability;
       strategies = [loom_1.PROMPT_EXECUTION_STRATEGY];
       config;
@@ -10137,132 +11325,81 @@ var require_claude_code = __commonJS({
           outputTokens: spec.costCapHint?.estimatedOutputTokens
         };
       }
-      /**
-       * Declare the run environment to the runner (ADR 0026): the opaque workspace
-       * bag plus the materialization config (tmp dir, overlay allowlist). No
-       * credentials here (ADR 0027) — the runner's broker reveals them on demand:
-       * this executor pulls its model key from `ctx.credentials` in `execute()`,
-       * and the git request references its own fetch credential. The executor
-       * touches neither git nor Keep.
-       */
       async prepareEnvironment(dispatch) {
-        const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
-        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : void 0;
-        return {
-          ...spec.workspace ? { workspaceRequest: spec.workspace } : {},
-          materializeOptions: {
-            ...tmpBase ? { tmpDir: tmpBase } : {},
-            overlayAllowedHosts: this.config.overlayAllowedHosts ?? []
-          }
-        };
+        return (0, agent_common_1.agentEnvironment)(dispatch, this.config);
       }
       async execute(dispatch, signal, ctx) {
+        (0, agent_common_1.refuseHosted)("codex", Boolean(ctx?.credentials));
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
         const workspace = ctx?.workspace ?? null;
-        let modelKey = null;
-        if (ctx?.credentials) {
-          const hints = (0, loom_1.pickProviderHints)(spec, "anthropic-api");
-          const customerId = typeof hints.customerId === "string" ? hints.customerId : void 0;
-          if (!customerId) {
-            throw new Error("claude-code dynamic-key mode requires providerHints.anthropicApi.customerId on every job");
-          }
-          modelKey = await ctx.credentials.reveal({ name: "managed-model-key", principal: customerId });
-        }
-        let jobScratch = null;
-        let configDir;
-        if (modelKey) {
-          jobScratch = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "shuttle-cc-"));
-          configDir = path_1.default.join(jobScratch, "claude-config");
-          await fs_1.promises.mkdir(configDir);
-        }
-        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
-        let promptOnlyScratch = null;
+        const hints = (0, loom_1.pickProviderHints)(spec, "codex");
+        const model = typeof hints.model === "string" && hints.model.length > 0 ? hints.model : this.config.model;
+        const effort = (0, models_1.hintedEffort)(hints) ?? this.config.reasoningEffort;
         const reporter = spec.progressChannel && ctx?.reportProgress ? new progress_1.ProgressReporter((frames) => ctx.reportProgress(spec.progressChannel, frames)) : null;
+        const codex = requireCodex();
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(this.tmpBase(), "shuttle-codex-"));
         try {
-          const childEnv = buildChildEnv(modelKey, configDir);
-          const claudeHints = (0, loom_1.pickProviderHints)(spec, "claude-code");
-          const hintedModel = typeof claudeHints.model === "string" && claudeHints.model.length > 0 ? claudeHints.model : void 0;
-          if (!workspace) {
-            promptOnlyScratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-run-"));
-          }
-          const runCwd = workspace?.cwd ?? promptOnlyScratch;
-          const { response, readPaths, toolInputs } = await this.runClaude(
+          let runCwd = workspace?.cwd;
+          if (!runCwd) {
+            runCwd = path_1.default.join(scratch, "run");
+            await fs_1.promises.mkdir(runCwd);
+          }
+          const { response, commands } = await this.runCodex({
+            codex,
+            args: ["exec", ...codexReviewArgs(codex.installDir), "-C", runCwd],
             prompt,
             spec,
-            runCwd,
-            childEnv,
+            cwd: runCwd,
+            scratch,
+            model,
+            effort,
             signal,
-            hintedModel,
             reporter,
-            void 0,
-            dispatch.job.id,
-            // Local mode is the operator's own login: a failure of THAT is the
-            // machine's, and the runner pauses on it. With a revealed key it is one
-            // customer's, and only their job fails.
-            modelKey === null
-          );
+            transcriptName: dispatch.job.id
+          });
           if (workspace) {
-            const reads = [...readPaths];
-            for (const rel of creditOverlayReads(toolInputs, workspace.overlay?.writtenPaths ?? [], runCwd)) {
-              reads.push(path_1.default.join(runCwd, rel));
-            }
-            response.outputs.push({
-              label: "workspace_reads",
-              content: { paths: relativeWorkspaceReads(reads, runCwd) }
-            });
-            response.outputs.push({
-              label: "workspace",
-              content: {
-                materialized: workspace.materialized,
-                ...workspace.warning ? { warning: workspace.warning } : {},
-                ...workspace.context.length > 0 ? {
-                  context: workspace.context.map((c) => ({
-                    name: c.requestedName,
-                    materialized: c.materialized,
-                    ...c.warning ? { warning: c.warning } : {}
-                  }))
-                } : {},
-                ...workspace.overlay ? {
-                  overlay: {
-                    written: workspace.overlay.written,
-                    ...workspace.overlay.skipped.length > 0 ? { skipped: workspace.overlay.skipped } : {}
-                  }
-                } : {}
-              }
-            });
+            response.outputs.push(...(0, workspace_telemetry_1.workspaceOutputs)(workspace, runCwd, (0, workspace_telemetry_1.shellReadPaths)(commands, runCwd), commands.map((command) => JSON.stringify({ command }))));
           }
           return response;
         } finally {
           reporter?.close();
-          if (promptOnlyScratch)
-            await fs_1.promises.rm(promptOnlyScratch, { recursive: true, force: true }).catch(() => {
-            });
-          if (jobScratch)
-            await fs_1.promises.rm(jobScratch, { recursive: true, force: true }).catch(() => {
-            });
+          await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
+          });
         }
       }
       /**
-       * In-session gate repair (ADR 0017): resume the session `execute()` returned a
-       * handle for and correct its output. The repair turn works from the resumed
-       * session's own context (no checkout needed), under the same `--json-schema`
-       * constraint. A throwaway cwd hosts the run; the same handle rides back out so
-       * a second repair round can resume again.
+       * In-session gate repair (ADR 0017): resume the thread and send the
+       * follow-up under the same schema. The checkout is gone by now (the runner
+       * cleans up before gates run), so the repair works from the thread's own
+       * context in a scratch dir, as claude-code's does.
        */
-      async continue(continuation, followUp, signal, _ctx) {
+      async continue(continuation, followUp, signal, ctx) {
+        (0, agent_common_1.refuseHosted)("codex", Boolean(ctx?.credentials));
         const handle = continuation;
-        if (!handle || typeof handle.sessionId !== "string") {
-          throw new Error("claude-code continue: missing session to resume");
+        if (!handle || typeof handle.threadId !== "string") {
+          throw new Error("codex continue: missing thread to resume");
         }
-        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
-        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-resume-"));
+        const codex = requireCodex();
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(this.tmpBase(), "shuttle-codex-resume-"));
         try {
           const spec = {
             rendering: "producer",
             outputLabel: handle.outputLabel,
             outputSchema: handle.outputSchema
           };
-          const { response } = await this.runClaude(followUp, spec, scratch, handle.childEnv, signal, handle.model, null, handle.sessionId, `${handle.sessionId}-repair`, handle.childEnv === void 0);
+          const { response } = await this.runCodex({
+            codex,
+            args: ["exec", "resume", handle.threadId, ...codexReviewArgs(codex.installDir)],
+            prompt: followUp,
+            spec,
+            cwd: scratch,
+            scratch,
+            model: handle.model,
+            effort: handle.effort,
+            signal,
+            reporter: null,
+            transcriptName: `${handle.threadId}-repair`
+          });
           return response;
         } finally {
           await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
@@ -10270,335 +11407,168 @@ var require_claude_code = __commonJS({
         }
       }
       /**
-       * Can this machine run a job now? One real one-turn call through the CLI,
-       * the same probe `doctor --deep` makes. The runner asks it only while
-       * claiming is paused on an `ExecutorEnvironmentError`, and only in local
-       * mode. A signed-out or missing CLI fails before any model call, so the
-       * re-check spends nothing until the login works again, and then one turn.
+       * One real turn under the review flags, in a throwaway dir. A signed-out
+       * CLI fails before any model call, so the re-check spends nothing until the
+       * login works again; a spent plan is only visible to a real call.
        */
       async checkReadiness(signal) {
-        return new Promise((resolve) => {
-          let child;
+        const codex = resolveCodex();
+        if (!codex)
+          return { ready: false, reason: "the codex CLI is not on this machine's PATH" };
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(this.tmpBase(), "shuttle-codex-ready-"));
+        try {
+          let run;
           try {
-            child = (0, child_process_1.spawn)("claude", ["--print", "--output-format", "stream-json", "--verbose", "--max-turns", "1", READINESS_PROMPT], { stdio: ["ignore", "pipe", "pipe"] });
+            run = await (0, agent_process_1.runAgentProcess)({
+              bin: codex.bin,
+              args: ["exec", ...codexReviewArgs(codex.installDir), "--ephemeral", "-C", scratch, "-"],
+              cwd: scratch,
+              stdin: READINESS_PROMPT,
+              idleTimeoutMs: READINESS_TIMEOUT_MS,
+              toolName: "the codex CLI",
+              signal
+            });
           } catch (err) {
-            resolve({ ready: false, reason: err instanceof Error ? err.message : String(err) });
-            return;
-          }
-          let stdout = "";
-          let stderr = "";
-          let settled = false;
-          const settle = (value) => {
-            if (settled)
-              return;
-            settled = true;
-            clearTimeout(timer);
-            signal.removeEventListener("abort", onAbort);
-            resolve(value);
-          };
-          const timer = setTimeout(() => {
-            child.kill("SIGKILL");
-            settle({ ready: false, reason: `the claude CLI did not answer within ${READINESS_TIMEOUT_MS / 1e3}s` });
-          }, READINESS_TIMEOUT_MS);
-          function onAbort() {
-            child.kill("SIGTERM");
-            settle({ ready: false, reason: "readiness check aborted" });
-          }
-          if (signal.aborted) {
-            onAbort();
-            return;
+            const message = err instanceof Error ? err.message : String(err);
+            return { ready: false, reason: message === "Dispatch aborted" ? "readiness check aborted" : message };
           }
-          signal.addEventListener("abort", onAbort, { once: true });
-          child.stdout?.on("data", (chunk) => {
-            stdout += chunk.toString("utf-8");
-          });
-          child.stderr?.on("data", (chunk) => {
-            if (stderr.length < STDERR_LIMIT)
-              stderr += chunk.toString("utf-8");
-          });
-          child.on("error", (err) => {
-            const code = err.code;
-            settle({
+          if (run.spawnError) {
+            return {
               ready: false,
-              reason: code === "ENOENT" ? `the claude CLI is not on this machine's PATH (${err.message})` : err.message
-            });
-          });
-          child.on("close", (code) => {
-            let meta = null;
-            try {
-              meta = parseStreamJson(stdout).resultMeta;
-            } catch {
-              meta = null;
-            }
-            if (code === 0 && !meta?.isError) {
-              settle({ ready: true });
-              return;
-            }
-            const said = meta?.detail ?? firstLine(stderr) ?? firstLine(stdout);
-            settle({ ready: false, reason: said ?? `the claude CLI exited with code ${code}` });
-          });
-        });
-      }
-      runClaude(prompt, spec, cwd, childEnv, signal, modelOverride, reporter, resumeSessionId, transcriptName, local = false) {
-        const outputLabel = spec.outputLabel;
-        const model = modelOverride ?? this.config.model;
-        const allowedTools = local ? this.config.allowedTools : checkoutScopedTools(this.config.allowedTools);
-        if (!local && this.config.claudeSettings === "user") {
-          throw new Error("claude-code: `claudeSettings: user` is for an installed Sifter whose login lives in Claude Code settings; a hosted run authenticates with the key it is handed and loads no settings");
-        }
-        const settingSources = local && this.config.claudeSettings === "user" ? "user" : "";
-        return new Promise((resolve, reject) => {
-          const args = ["--print", "--output-format", "stream-json", "--verbose", ...reviewRunArgs(settingSources)];
-          if (resumeSessionId)
-            args.push("--resume", resumeSessionId);
-          if (spec.outputSchema && typeof spec.outputSchema === "object" && Object.keys(spec.outputSchema).length > 0) {
-            args.push("--json-schema", JSON.stringify(spec.outputSchema));
-          }
-          if (model)
-            args.push("--model", model);
-          if (this.config.maxTurns !== void 0)
-            args.push("--max-turns", String(this.config.maxTurns));
-          if (allowedTools && allowedTools.length > 0) {
-            args.push("--allowedTools", allowedTools.join(","));
-          }
-          let child;
-          try {
-            child = (0, child_process_1.spawn)("claude", args, {
-              cwd,
-              stdio: ["pipe", "pipe", "pipe"],
-              // Undefined in local mode → inherit the ambient env (and its
-              // `~/.claude` login) unchanged.
-              ...childEnv ? { env: childEnv } : {}
-            });
-          } catch (err) {
-            reject(err);
-            return;
+              reason: run.spawnError.code === "ENOENT" ? `the codex CLI is not on this machine's PATH (${run.spawnError.message})` : run.spawnError.message
+            };
           }
-          const stdoutChunks = [];
-          let stderrText = "";
-          let settled = false;
-          const settle = (fn) => {
-            if (settled)
-              return;
-            settled = true;
-            fn();
-          };
-          const tap = reporter ? new progress_1.StreamJsonTap({
-            onReasoning: (t) => reporter.reasoning(t),
-            onTool: (name, target) => reporter.tool(name, target),
-            onResult: () => reporter.flush()
-          }) : null;
-          const decoder = tap ? new string_decoder_1.StringDecoder("utf8") : null;
-          child.stdin.write(prompt);
-          child.stdin.end();
-          const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
-          let timer;
-          const armIdleTimer = () => {
-            if (settled)
-              return;
-            if (timer)
-              clearTimeout(timer);
-            timer = setTimeout(() => {
-              child.kill("SIGTERM");
-              settle(() => reject(new Error(`Claude Code produced no output for ${timeout}ms; killed as hung`)));
-            }, timeout);
+          const events = parseCodexEvents(run.stdout);
+          if (run.code === 0 && !events.failure)
+            return { ready: true };
+          return {
+            ready: false,
+            reason: events.failure ?? (0, agent_process_1.firstLine)(run.stderr) ?? `the codex CLI exited with code ${run.code}`
           };
-          armIdleTimer();
-          child.stdout.on("data", (chunk) => {
-            stdoutChunks.push(chunk);
-            armIdleTimer();
-            if (tap && decoder)
-              tap.push(decoder.write(chunk));
-          });
-          child.stderr?.on("data", (chunk) => {
-            if (stderrText.length < STDERR_LIMIT)
-              stderrText += chunk.toString("utf-8");
-          });
-          function onAbort() {
-            child.kill("SIGTERM");
-            settle(() => reject(new Error("Dispatch aborted")));
-          }
-          if (signal.aborted) {
-            clearTimeout(timer);
-            child.kill("SIGTERM");
-            settle(() => reject(new Error("Dispatch aborted")));
-            return;
-          }
-          signal.addEventListener("abort", onAbort, { once: true });
-          child.on("error", (err) => {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", onAbort);
-            const code = err.code;
-            if (local && code === "ENOENT") {
-              settle(() => reject(new types_1.ExecutorEnvironmentError(`the claude CLI is not on this machine's PATH (${err.message})`, INSTALL_REMEDY)));
-              return;
-            }
-            settle(() => reject(err));
-          });
-          child.on("close", (code) => {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", onAbort);
-            if (tap && decoder) {
-              tap.push(decoder.end());
-              tap.end();
-            }
-            const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
-            if (this.config.keepTranscripts && transcriptName) {
-              void keepTranscript((0, apply_1.expandHome)(this.config.keepTranscripts), transcriptName, stdout);
-            }
-            if (code === 0) {
-              try {
-                const stream = parseStreamJson(stdout);
-                if (stream.resultMeta?.isError) {
-                  throw runFailure(local, describeClaudeFailure(stream.resultMeta, "Claude Code reported a failure"), {
-                    apiErrorStatus: stream.resultMeta.apiErrorStatus,
-                    text: stream.resultMeta.detail ?? firstLine(stderrText)
-                  });
-                }
-                const answerText = stream.finalText ?? stdout;
-                const parsed = stream.structuredOutput ?? extractJsonObject(answerText);
-                if (parsed === void 0 && stream.resultMeta) {
-                  throw new Error(`claude's final message contained no JSON object (result subtype=${stream.resultMeta.subtype ?? "unknown"}; message head: ${JSON.stringify(answerText.slice(0, 160))})`);
-                }
-                (0, validate_output_1.assertOutputValid)(spec, parsed);
-                settle(() => resolve({
-                  response: {
-                    outputs: [{ label: outputLabel, content: parsed ?? { raw: answerText } }],
-                    rawText: answerText,
-                    parsed,
-                    usage: {
-                      aiProvider: "claude-code",
-                      ...model ? { aiModel: model } : {},
-                      ...stream.usage ?? {}
-                    },
-                    // In-session repair handle (ADR 0017): present only when the run
-                    // reported a session id, so the runner can `--resume` it.
-                    ...stream.sessionId ? {
-                      continuation: {
-                        sessionId: stream.sessionId,
-                        model,
-                        childEnv,
-                        outputLabel,
-                        outputSchema: spec.outputSchema
-                      }
-                    } : {}
-                  },
-                  readPaths: stream.readPaths,
-                  toolInputs: stream.toolInputs
-                }));
-              } catch (err) {
-                settle(() => reject(err instanceof Error ? err : new Error(String(err))));
-              }
-            } else {
-              let meta = null;
-              try {
-                meta = parseStreamJson(stdout).resultMeta;
-              } catch {
-              }
-              const said = meta?.detail ?? firstLine(stderrText) ?? firstLine(stdout);
-              const fallback = `Claude Code exited with code ${code}`;
-              const failure = runFailure(local, describeClaudeFailure(meta, fallback), {
-                apiErrorStatus: meta?.apiErrorStatus ?? null,
-                text: said
-              });
-              if (failure instanceof types_1.ExecutorEnvironmentError && !meta && said) {
-                settle(() => reject(new types_1.ExecutorEnvironmentError(`${fallback}: ${said}`, failure.remedy)));
-                return;
-              }
-              settle(() => reject(failure));
-            }
+        } finally {
+          await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
           });
-        });
-      }
-    };
-    function createClaudeCodeExecutor(config, capabilityId = "claude-code") {
-      const validated = { capabilityId };
-      if (config.tmpDir !== void 0) {
-        if (typeof config.tmpDir !== "string" || config.tmpDir.length === 0) {
-          throw new Error('"tmpDir" must be a non-empty string');
-        }
-        validated.tmpDir = config.tmpDir;
-      }
-      if (config.model !== void 0) {
-        if (typeof config.model !== "string")
-          throw new Error('"model" must be a string');
-        validated.model = config.model;
-      }
-      if (config.maxTurns !== void 0) {
-        if (typeof config.maxTurns !== "number" || !Number.isInteger(config.maxTurns) || config.maxTurns < 1) {
-          throw new Error('"maxTurns" must be a positive integer');
-        }
-        validated.maxTurns = config.maxTurns;
-      }
-      if (config.allowedTools !== void 0) {
-        if (!Array.isArray(config.allowedTools) || !config.allowedTools.every((t) => typeof t === "string")) {
-          throw new Error('"allowedTools" must be an array of strings');
-        }
-        validated.allowedTools = config.allowedTools;
-      }
-      if (config.timeout !== void 0) {
-        if (typeof config.timeout !== "number" || config.timeout <= 0) {
-          throw new Error('"timeout" must be a positive number');
-        }
-        validated.timeout = config.timeout;
-      }
-      if (config.keepTranscripts !== void 0) {
-        if (typeof config.keepTranscripts !== "string" || config.keepTranscripts.length === 0) {
-          throw new Error('"keepTranscripts" must be a non-empty directory path');
-        }
-        validated.keepTranscripts = config.keepTranscripts;
-      }
-      if (config.claudeSettings !== void 0) {
-        if (config.claudeSettings !== "user") {
-          throw new Error('"claudeSettings" may only be "user" (leave it unset to load no settings file)');
         }
-        validated.claudeSettings = "user";
       }
-      if (config.overlayAllowedHosts !== void 0) {
-        if (!Array.isArray(config.overlayAllowedHosts) || !config.overlayAllowedHosts.every((h) => typeof h === "string")) {
-          throw new Error('"overlayAllowedHosts" must be an array of strings');
+      /**
+       * The catalog `codex debug models` prints: the models codex itself offers
+       * in its picker, each with the reasoning levels it supports. A `debug`
+       * subcommand, so not a stable contract; any failure or unknown shape
+       * reports nothing.
+       */
+      async listModels(signal) {
+        const codex = resolveCodex();
+        if (!codex)
+          return [];
+        const stdout = await (0, models_1.runListing)(codex.bin, ["debug", "models"], signal);
+        return stdout === null ? [] : parseCodexModels(stdout);
+      }
+      tmpBase() {
+        return this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
+      }
+      async runCodex(opts) {
+        const { spec, model, effort } = opts;
+        const args = [...opts.args];
+        const hasSchema = spec.outputSchema && typeof spec.outputSchema === "object" && Object.keys(spec.outputSchema).length > 0;
+        if (hasSchema) {
+          const schemaFile = path_1.default.join(opts.scratch, "output-schema.json");
+          await fs_1.promises.writeFile(schemaFile, JSON.stringify((0, strict_schema_1.toStrict)(spec.outputSchema)));
+          args.push("--output-schema", schemaFile);
+        }
+        if (model)
+          args.push("-m", model);
+        if (effort)
+          args.push("-c", `model_reasoning_effort="${effort}"`);
+        args.push("-");
+        const tap = opts.reporter ? codexProgressTap(opts.reporter) : null;
+        const run = await (0, agent_process_1.runAgentProcess)({
+          bin: opts.codex.bin,
+          args,
+          cwd: opts.cwd,
+          stdin: opts.prompt,
+          idleTimeoutMs: this.config.timeout ?? agent_common_1.DEFAULT_AGENT_TIMEOUT,
+          toolName: "Codex",
+          signal: opts.signal,
+          ...tap ? { onStdout: (text) => tap.push(text) } : {}
+        });
+        tap?.end();
+        if (run.spawnError) {
+          if (run.spawnError.code === "ENOENT") {
+            throw new types_1.ExecutorEnvironmentError(`the codex CLI is not on this machine's PATH (${run.spawnError.message})`, CODEX_FAULTS.installRemedy);
+          }
+          throw new Error(run.spawnError.message);
         }
-        validated.overlayAllowedHosts = config.overlayAllowedHosts;
-      }
-      return new ClaudeCodeExecutor(validated);
-    }
-    function checkoutScopedTools(tools) {
-      if (!tools)
-        return void 0;
-      const scoped = [];
-      for (const tool of tools) {
-        if (RETIRED_READ_TOOLS.some((t) => tool === t || tool === `${t}(./**)`))
-          continue;
-        const name = REVIEW_TOOLS.find((t) => tool === t || tool === `${t}(./**)`);
-        if (!name) {
-          throw new Error(`claude-code: a hosted run may use only ${REVIEW_TOOLS.join(", ")} inside the checkout; "${tool}" is not allowed`);
+        if (this.config.keepTranscripts) {
+          void (0, agent_process_1.keepTranscript)((0, apply_1.expandHome)(this.config.keepTranscripts), opts.transcriptName, run.stdout);
         }
-        scoped.push(`${name}(./**)`);
+        const events = parseCodexEvents(run.stdout);
+        if (run.code !== 0 || events.failure) {
+          const said = events.failure ?? (0, agent_process_1.firstLine)(run.stderr) ?? (0, agent_process_1.firstLine)(run.stdout);
+          const message = said ? `Codex ${run.code === 0 ? "reported a failure" : `exited with code ${run.code}`}: ${said}` : `Codex exited with code ${run.code}`;
+          throw (0, agent_process_1.agentFailure)(true, message, { apiErrorStatus: null, text: said }, CODEX_FAULTS);
+        }
+        if (events.finalText === null) {
+          throw new Error("Codex finished without a final message");
+        }
+        const answerText = events.finalText;
+        const raw = (0, json_answer_1.extractJsonObject)(answerText);
+        if (raw === void 0 && hasSchema) {
+          throw new Error(`codex's final message contained no JSON object (message head: ${JSON.stringify(answerText.slice(0, 160))})`);
+        }
+        const parsed = raw === void 0 ? void 0 : (0, strict_schema_1.dropNulls)(raw, spec.outputSchema);
+        (0, validate_output_1.assertOutputValid)(spec, parsed);
+        return {
+          response: {
+            outputs: [{ label: spec.outputLabel, content: parsed ?? { raw: answerText } }],
+            rawText: answerText,
+            parsed,
+            usage: {
+              aiProvider: "codex",
+              ...model ? { aiModel: model } : {},
+              ...effort ? { aiEffort: effort } : {},
+              ...events.usage ?? {}
+            },
+            ...events.threadId ? {
+              continuation: {
+                threadId: events.threadId,
+                model,
+                effort,
+                outputLabel: spec.outputLabel,
+                outputSchema: spec.outputSchema
+              }
+            } : {}
+          },
+          commands: events.commands
+        };
       }
-      return scoped;
+    };
+    function codexProgressTap(reporter) {
+      return new progress_1.JsonLineTap((event) => {
+        const item = event.item;
+        const kind = item ? itemKind(item) : null;
+        if (event.type === "item.started" && kind === "command_execution" && typeof item?.command === "string") {
+          reporter.tool("shell", item.command);
+        } else if (event.type === "item.completed" && kind === "reasoning" && typeof item?.text === "string") {
+          reporter.reasoning(item.text);
+        } else if (event.type === "turn.completed") {
+          reporter.flush();
+        }
+      });
     }
-    function buildChildEnv(modelKey, configDir) {
-      if (!modelKey && !configDir)
-        return void 0;
-      const env = {};
-      for (const name of HOSTED_ENV_PASSTHROUGH) {
-        if (process.env[name] !== void 0)
-          env[name] = process.env[name];
-      }
-      return {
-        ...env,
-        ...modelKey ? { ANTHROPIC_API_KEY: modelKey } : {},
-        ...configDir ? { CLAUDE_CONFIG_DIR: configDir } : {}
-      };
+    function itemKind(item) {
+      const kind = typeof item.type === "string" ? item.type : typeof item.item_type === "string" ? item.item_type : null;
+      return kind === "assistant_message" ? "agent_message" : kind;
     }
-    function parseStreamJson(stdout) {
+    function parseCodexEvents(stdout) {
+      let threadId = null;
       let finalText = null;
-      const readPaths = [];
-      let usage = null;
-      let resultMeta = null;
-      let structuredOutput = null;
-      let sessionId = null;
-      const toolInputs = [];
+      const commands = [];
+      const seenCommands = /* @__PURE__ */ new Set();
+      let input = 0;
+      let output = 0;
+      let sawUsage = false;
+      let turnFailure = null;
+      let lastError = null;
       for (const line of stdout.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed.startsWith("{"))
@@ -10609,257 +11579,580 @@ var require_claude_code = __commonJS({
         } catch {
           continue;
         }
-        if (typeof event.session_id === "string")
-          sessionId = event.session_id;
-        if (event.type === "assistant") {
-          const content = event.message?.content;
-          if (!Array.isArray(content))
-            continue;
-          for (const block of content) {
-            const b = block;
-            if (b?.type !== "tool_use")
-              continue;
-            const fp = b.input?.file_path;
-            if (b.name === "Read" && typeof fp === "string") {
-              readPaths.push(fp);
+        switch (event.type) {
+          case "thread.started":
+            if (typeof event.thread_id === "string")
+              threadId = event.thread_id;
+            break;
+          case "item.started":
+          case "item.updated":
+          case "item.completed": {
+            const item = event.item;
+            if (!item)
+              break;
+            const kind = itemKind(item);
+            if (kind === "agent_message" && event.type === "item.completed" && typeof item.text === "string") {
+              finalText = item.text;
+              lastError = null;
+            } else if (kind === "command_execution" && typeof item.command === "string") {
+              const key = typeof item.id === "string" ? item.id : item.command;
+              if (!seenCommands.has(key)) {
+                seenCommands.add(key);
+                commands.push(item.command);
+              }
             }
-            if (b.input && typeof b.input === "object")
-              toolInputs.push(JSON.stringify(b.input));
+            break;
           }
-        } else if (event.type === "result") {
-          if (typeof event.result === "string" && event.result.trim().length > 0) {
-            finalText = event.result;
+          case "turn.completed": {
+            const u = event.usage;
+            if (typeof u?.input_tokens === "number") {
+              input += u.input_tokens;
+              sawUsage = true;
+            }
+            if (typeof u?.output_tokens === "number") {
+              output += u.output_tokens;
+              sawUsage = true;
+            }
+            break;
           }
-          resultMeta = {
-            subtype: typeof event.subtype === "string" ? event.subtype : null,
-            isError: event.is_error === true,
-            // On a failure the CLI puts a human-readable reason in `result` — the
-            // model was unavailable, spend limit hit, and so on. It is the only
-            // place that reason exists, so keep it for the failure message.
-            detail: typeof event.result === "string" && event.result.trim().length > 0 ? event.result.trim() : null,
-            apiErrorStatus: typeof event.api_error_status === "number" ? event.api_error_status : null
-          };
-          const so = event.structured_output;
-          if (so && typeof so === "object" && !Array.isArray(so)) {
-            structuredOutput = so;
+          case "turn.failed": {
+            const err = event.error;
+            turnFailure = typeof err?.message === "string" ? err.message : "the turn failed";
+            break;
           }
-          const u = event.usage;
-          const cost = event.total_cost_usd;
-          usage = {
-            ...typeof u?.input_tokens === "number" ? { inputTokens: u.input_tokens } : {},
-            ...typeof u?.output_tokens === "number" ? { outputTokens: u.output_tokens } : {},
-            ...typeof cost === "number" ? { costUsd: cost } : {}
-          };
+          case "error":
+            if (typeof event.message === "string")
+              lastError = event.message;
+            break;
+          default:
+            break;
         }
       }
-      return { finalText, readPaths, usage, resultMeta, structuredOutput, sessionId, toolInputs };
+      return {
+        threadId,
+        finalText,
+        commands,
+        usage: sawUsage ? { inputTokens: input, outputTokens: output } : null,
+        failure: turnFailure ?? (finalText === null ? lastError : null)
+      };
     }
-    var MAX_REPORTED_READS = 2e3;
-    function workspaceRoots(cwd) {
-      const root = path_1.default.resolve(cwd);
-      const roots = [root];
+    function parseCodexModels(stdout) {
+      let body;
       try {
-        const real = (0, fs_1.realpathSync)(root);
-        if (real !== root)
-          roots.push(real);
+        body = JSON.parse(stdout);
       } catch {
+        return [];
       }
-      return roots;
+      const entries = body?.models;
+      if (!Array.isArray(entries))
+        return [];
+      const listed = entries.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+          return [];
+        const e = entry;
+        if (typeof e.slug !== "string" || e.slug.length === 0 || e.visibility !== "list")
+          return [];
+        const levels = Array.isArray(e.supported_reasoning_levels) ? e.supported_reasoning_levels.flatMap((level) => {
+          const effort = level?.effort;
+          return typeof effort === "string" && /^[a-z]+$/.test(effort) ? [effort] : [];
+        }) : [];
+        const model = {
+          id: e.slug,
+          label: typeof e.display_name === "string" && e.display_name ? e.display_name : e.slug,
+          ...levels.length > 0 ? { efforts: levels } : {}
+        };
+        return [{ model, priority: typeof e.priority === "number" ? e.priority : Number.MAX_SAFE_INTEGER }];
+      });
+      return listed.sort((a, b) => a.priority - b.priority).map((entry) => entry.model);
     }
-    function relativeWorkspaceReads(readPaths, cwd) {
-      const roots = workspaceRoots(cwd);
-      const root = roots[0];
-      const out = /* @__PURE__ */ new Set();
-      for (const p of readPaths) {
-        const resolved = path_1.default.resolve(root, p);
-        for (const r of roots) {
-          if (resolved === r)
-            break;
-          if (!resolved.startsWith(r + path_1.default.sep))
-            continue;
-          out.add(resolved.slice(r.length + 1));
-          break;
-        }
-        if (out.size >= MAX_REPORTED_READS)
-          break;
-      }
-      return [...out].sort();
+    function createCodexExecutor(config, capabilityId = "codex") {
+      const validated = (0, agent_common_1.parseAgentCommonConfig)(config, capabilityId);
+      const effort = (0, models_1.parseReasoningEffort)(config.reasoningEffort, models_1.REASONING_EFFORTS);
+      if (effort)
+        validated.reasoningEffort = effort;
+      return new CodexExecutor(validated);
     }
-    var GLOB_CHARS = /[*?[{]/;
-    function escapeRegExp(s) {
-      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+});
+
+// ../../packages/shuttle/dist/executors/copilot.js
+var require_copilot = __commonJS({
+  "../../packages/shuttle/dist/executors/copilot.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.copilotReviewArgs = copilotReviewArgs;
+    exports2.withSchema = withSchema;
+    exports2.usageOf = usageOf;
+    exports2.parseCopilotEvents = parseCopilotEvents;
+    exports2.parseCopilotModels = parseCopilotModels;
+    exports2.createCopilotExecutor = createCopilotExecutor;
+    var crypto_1 = require("crypto");
+    var fs_1 = require("fs");
+    var os_1 = __importDefault(require("os"));
+    var path_1 = __importDefault(require("path"));
+    var loom_1 = require_dist();
+    var types_1 = require_types2();
+    var validate_output_1 = require_validate_output();
+    var progress_1 = require_progress();
+    var agent_process_1 = require_agent_process();
+    var agent_common_1 = require_agent_common();
+    var json_answer_1 = require_json_answer();
+    var models_1 = require_models();
+    var workspace_telemetry_1 = require_workspace_telemetry();
+    var apply_1 = require_apply();
+    var REVIEW_TOOLS = ["view", "grep", "glob"];
+    var DENIED_TOOLS = ["shell", "write"];
+    function copilotReviewArgs() {
+      return [
+        "--output-format",
+        "json",
+        "--no-color",
+        "--allow-all-tools",
+        `--available-tools=${REVIEW_TOOLS.join(",")}`,
+        ...DENIED_TOOLS.map((t) => `--deny-tool=${t}`),
+        "--disable-builtin-mcps",
+        "--disallow-temp-dir",
+        "--no-ask-user",
+        "--no-auto-update",
+        "--no-remote"
+      ];
     }
-    function globToRegExp(glob) {
-      let re = "^";
-      for (let i = 0; i < glob.length; i++) {
-        const ch = glob[i];
-        if (ch === "*") {
-          if (glob[i + 1] === "*") {
-            if (glob[i + 2] === "/") {
-              re += "(?:.*/)?";
-              i += 2;
-            } else {
-              re += ".*";
-              i += 1;
-            }
-          } else {
-            re += "[^/]*";
-          }
-        } else if (ch === "?") {
-          re += "[^/]";
-        } else if (ch === "[") {
-          const end = glob.indexOf("]", i + 1);
-          if (end === -1)
-            return null;
-          let cls = glob.slice(i + 1, end);
-          if (cls.startsWith("!"))
-            cls = `^${cls.slice(1)}`;
-          re += `[${cls.replace(/\\/g, "\\\\")}]`;
-          i = end;
-        } else if (ch === "{") {
-          const end = glob.indexOf("}", i + 1);
-          if (end === -1)
-            return null;
-          re += `(?:${glob.slice(i + 1, end).split(",").map(escapeRegExp).join("|")})`;
-          i = end;
-        } else {
-          re += escapeRegExp(ch);
-        }
+    var RUN_SETTINGS = { disableAllHooks: true, autoUpdate: false };
+    var COPILOT_FAULTS = {
+      installRemedy: "install GitHub Copilot CLI (brew install --cask copilot-cli, or npm install -g @github/copilot) where this process can find it on PATH",
+      loginRemedy: "run `copilot login` and sign in with a GitHub account that has a Copilot seat (a COPILOT_GITHUB_TOKEN, GH_TOKEN or GITHUB_TOKEN in the environment wins over that login)",
+      limitRemedy: "the account has no Copilot allowance left: on an organization seat, an owner must allow paid usage in the organization's Copilot policies and fund a budget for it; otherwise wait for the monthly reset",
+      signedOut: /not (?:logged|signed) in|run `?copilot login|no authentication|authentication (?:failed|required)|bad credentials/i,
+      outOfUsage: /exceeded your monthly quota|premium request|usage limit|hit your (?:\w+ )?limit|exceeded .*(?:allowance|limit)/i,
+      notEntitled: {
+        pattern: /access denied by policy|not authorized to use this copilot feature/i,
+        remedy: "this account's Copilot does not allow the Copilot CLI: on an organization seat, an owner must assign the seat and enable the Copilot CLI policy, then run `copilot login` again so the new seat is picked up"
       }
-      return new RegExp(`${re}$`);
-    }
-    function creditOverlayReads(toolInputs, writtenPaths, runCwd) {
-      if (writtenPaths.length === 0 || toolInputs.length === 0)
-        return [];
-      const roots = runCwd ? workspaceRoots(runCwd) : [];
-      const dirs = /* @__PURE__ */ new Set();
-      for (const rel of writtenPaths) {
-        const parts = rel.split("/");
-        for (let i = 1; i < parts.length; i++)
-          dirs.add(`${parts.slice(0, i).join("/")}/`);
+    };
+    var READINESS_PROMPT = "Reply with the single word: ok";
+    var READINESS_TIMEOUT_MS = 12e4;
+    var CopilotExecutor = class {
+      capability;
+      strategies = [loom_1.PROMPT_EXECUTION_STRATEGY];
+      config;
+      constructor(config) {
+        this.config = config;
+        this.capability = { id: config.capabilityId };
       }
-      const dirAlt = [...dirs].map(escapeRegExp).join("|");
-      const wordRe = dirs.size > 0 ? new RegExp(`(?:${dirAlt})[^\\s"'\`;|&<>()\\\\]*`, "g") : null;
-      const findRe = dirs.size > 0 ? new RegExp(`\\bfind\\s+(?:\\./)?(${[...dirs].map((d) => escapeRegExp(d.slice(0, -1))).join("|")})/?(?=\\s|$)`, "g") : null;
-      const readerRe = new RegExp(`(?:^|[\\s"])(?:-exec|-execdir|xargs)\\b[^;|&]*\\b${READERS}\\b`);
-      const plainReaderRe = new RegExp(`(?:^|[\\s"'\`;|&(])${READERS}\\b`);
-      const credited = /* @__PURE__ */ new Set();
-      for (const raw of toolInputs) {
-        const input = roots.reduce((s, r) => s.split(`${r}/`).join(""), raw);
-        for (const rel of writtenPaths) {
-          if (input.includes(rel))
-            credited.add(rel);
+      estimate(dispatch) {
+        const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+        return {
+          inputTokens: spec.costCapHint?.estimatedInputTokens,
+          outputTokens: spec.costCapHint?.estimatedOutputTokens
+        };
+      }
+      async prepareEnvironment(dispatch) {
+        return (0, agent_common_1.agentEnvironment)(dispatch, this.config);
+      }
+      async execute(dispatch, signal, ctx) {
+        (0, agent_common_1.refuseHosted)("copilot", Boolean(ctx?.credentials));
+        const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
+        const workspace = ctx?.workspace ?? null;
+        const hints = (0, loom_1.pickProviderHints)(spec, "copilot");
+        const model = typeof hints.model === "string" && hints.model.length > 0 ? hints.model : this.config.model;
+        const effort = (0, models_1.hintedEffort)(hints) ?? this.config.reasoningEffort;
+        const reporter = spec.progressChannel && ctx?.reportProgress ? new progress_1.ProgressReporter((frames) => ctx.reportProgress(spec.progressChannel, frames)) : null;
+        const runs = path_1.default.join(this.tmpBase(), "shuttle-copilot-runs");
+        await fs_1.promises.mkdir(runs, { recursive: true, mode: 448 });
+        await pruneRuns(runs);
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(runs, "run-"));
+        let keep = false;
+        try {
+          const home = await makeRunHome(scratch);
+          let runCwd = workspace?.cwd;
+          if (!runCwd) {
+            runCwd = path_1.default.join(scratch, "run");
+            await fs_1.promises.mkdir(runCwd);
+          }
+          const sessionId = (0, crypto_1.randomUUID)();
+          const { response, reads, toolInputs } = await this.runCopilot({
+            args: [...copilotReviewArgs(), `--session-id=${sessionId}`, "-C", runCwd],
+            prompt: withSchema(prompt, spec),
+            spec,
+            cwd: runCwd,
+            home,
+            scratch,
+            model,
+            effort,
+            signal,
+            reporter,
+            transcriptName: dispatch.job.id
+          });
+          response.continuation = {
+            sessionId,
+            home,
+            model,
+            effort,
+            outputLabel: spec.outputLabel,
+            outputSchema: spec.outputSchema
+          };
+          keep = true;
+          if (workspace)
+            response.outputs.push(...(0, workspace_telemetry_1.workspaceOutputs)(workspace, runCwd, reads, toolInputs));
+          return response;
+        } finally {
+          reporter?.close();
+          if (!keep)
+            await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
+            });
         }
-        if (wordRe) {
-          for (const match of input.matchAll(wordRe)) {
-            const word = match[0];
-            if (!GLOB_CHARS.test(word))
-              continue;
-            const re = globToRegExp(word);
-            if (!re)
-              continue;
-            for (const rel of writtenPaths) {
-              if (re.test(rel))
-                credited.add(rel);
-            }
-          }
+      }
+      /** In-session gate repair (ADR 0017): resume the session this executor named, from the run's own COPILOT_HOME. */
+      async continue(continuation, followUp, signal, ctx) {
+        (0, agent_common_1.refuseHosted)("copilot", Boolean(ctx?.credentials));
+        const handle = continuation;
+        if (!handle || typeof handle.sessionId !== "string" || typeof handle.home !== "string") {
+          throw new Error("copilot continue: missing session to resume");
         }
-        if (findRe && readerRe.test(input)) {
-          for (const match of input.matchAll(findRe)) {
-            const dir = `${match[1]}/`;
-            for (const rel of writtenPaths) {
-              if (rel.startsWith(dir))
-                credited.add(rel);
-            }
+        const scratch = path_1.default.dirname(handle.home);
+        const cwd = path_1.default.join(scratch, "resume");
+        await fs_1.promises.mkdir(cwd, { recursive: true });
+        const spec = {
+          rendering: "producer",
+          outputLabel: handle.outputLabel,
+          outputSchema: handle.outputSchema
+        };
+        const { response } = await this.runCopilot({
+          args: [...copilotReviewArgs(), `--resume=${handle.sessionId}`, "-C", cwd],
+          prompt: followUp,
+          spec,
+          cwd,
+          home: handle.home,
+          scratch,
+          model: handle.model,
+          effort: handle.effort,
+          signal,
+          reporter: null,
+          transcriptName: `${handle.sessionId}-repair`
+        });
+        response.continuation = handle;
+        return response;
+      }
+      /** One real turn under the review flags. A signed-out CLI fails before any model call. */
+      async checkReadiness(signal) {
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(this.tmpBase(), "shuttle-copilot-ready-"));
+        try {
+          const home = await makeRunHome(scratch);
+          let run;
+          try {
+            run = await withOperatorLogin(home, () => (0, agent_process_1.runAgentProcess)({
+              bin: "copilot",
+              args: [...copilotReviewArgs(), "-C", scratch, "-p", READINESS_PROMPT],
+              cwd: scratch,
+              env: runEnv(home),
+              idleTimeoutMs: READINESS_TIMEOUT_MS,
+              toolName: "the copilot CLI",
+              signal
+            }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ready: false, reason: message === "Dispatch aborted" ? "readiness check aborted" : message };
           }
-        }
-        if (!plainReaderRe.test(input))
-          continue;
-        for (const match of input.matchAll(CD_RE)) {
-          const target = match[1].replace(/^\.\//, "").replace(/\/+$/, "");
-          const base = target.length > 0 ? `${target}/` : "";
-          for (const rel of writtenPaths) {
-            if (!rel.startsWith(base))
-              continue;
-            if (namesBareWord(input, rel.slice(base.length)))
-              credited.add(rel);
+          if (run.spawnError) {
+            return {
+              ready: false,
+              reason: run.spawnError.code === "ENOENT" ? `the copilot CLI is not on this machine's PATH (${run.spawnError.message})` : run.spawnError.message
+            };
           }
+          const events = parseCopilotEvents(run.stdout);
+          if (run.code === 0 && !events.failure)
+            return { ready: true };
+          return {
+            ready: false,
+            reason: events.failure ?? (0, agent_process_1.firstLine)(run.stderr) ?? `the copilot CLI exited with code ${run.code}`
+          };
+        } finally {
+          await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
+          });
         }
       }
-      return [...credited].sort();
+      /**
+       * The `model` setting's values as `copilot help config` lists them: the
+       * CLI's built-in set. It does not reflect an organization's model policy,
+       * so a model listed here can still be refused for one account, and that
+       * review fails in copilot's own words. Each takes the CLI-wide effort list.
+       */
+      async listModels(signal) {
+        const stdout = await (0, models_1.runListing)("copilot", ["help", "config"], signal);
+        return stdout === null ? [] : parseCopilotModels(stdout);
+      }
+      tmpBase() {
+        return this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
+      }
+      async runCopilot(opts) {
+        const { spec, model, effort } = opts;
+        const usageFile = path_1.default.join(opts.scratch, `usage-${(0, crypto_1.randomUUID)()}.json`);
+        const args = [...opts.args, `--usage-output-file=${usageFile}`, `--log-dir=${path_1.default.join(opts.home, "logs")}`];
+        if (model)
+          args.push(`--model=${model}`);
+        if (effort)
+          args.push(`--reasoning-effort=${effort}`);
+        const tap = opts.reporter ? copilotProgressTap(opts.reporter) : null;
+        const run = await withOperatorLogin(opts.home, () => (0, agent_process_1.runAgentProcess)({
+          bin: "copilot",
+          args,
+          cwd: opts.cwd,
+          env: runEnv(opts.home),
+          // The prompt comes from stdin: a review prompt carries the diff, far
+          // past what argv should hold, and argv is visible to every process.
+          stdin: opts.prompt,
+          idleTimeoutMs: this.config.timeout ?? agent_common_1.DEFAULT_AGENT_TIMEOUT,
+          toolName: "Copilot",
+          signal: opts.signal,
+          ...tap ? { onStdout: (text) => tap.push(text) } : {}
+        }));
+        tap?.end();
+        if (run.spawnError) {
+          if (run.spawnError.code === "ENOENT") {
+            throw new types_1.ExecutorEnvironmentError(`the copilot CLI is not on this machine's PATH (${run.spawnError.message})`, COPILOT_FAULTS.installRemedy);
+          }
+          throw new Error(run.spawnError.message);
+        }
+        if (this.config.keepTranscripts) {
+          void (0, agent_process_1.keepTranscript)((0, apply_1.expandHome)(this.config.keepTranscripts), opts.transcriptName, run.stdout);
+        }
+        const events = parseCopilotEvents(run.stdout);
+        if (run.code !== 0 || events.failure) {
+          const said = events.failure ?? (0, agent_process_1.firstLine)(run.stderr) ?? (0, agent_process_1.firstLine)(run.stdout);
+          const message = said ? `Copilot ${run.code === 0 ? "reported a failure" : `exited with code ${run.code}`}: ${said}` : `Copilot exited with code ${run.code}`;
+          throw (0, agent_process_1.agentFailure)(true, message, { apiErrorStatus: null, text: said }, COPILOT_FAULTS);
+        }
+        if (events.finalText === null)
+          throw new Error("Copilot finished without a final message");
+        const answerText = events.finalText;
+        const parsed = (0, json_answer_1.extractJsonObject)(answerText);
+        if (parsed === void 0 && hasSchema(spec)) {
+          throw new Error(`copilot's final message contained no JSON object (message head: ${JSON.stringify(answerText.slice(0, 160))})`);
+        }
+        (0, validate_output_1.assertOutputValid)(spec, parsed);
+        const usage = await readUsage(usageFile);
+        return {
+          response: {
+            outputs: [{ label: spec.outputLabel, content: parsed ?? { raw: answerText } }],
+            rawText: answerText,
+            parsed,
+            // The model the session actually ran, from its usage file, over the one asked for.
+            usage: {
+              aiProvider: "copilot",
+              ...model ? { aiModel: model } : {},
+              ...effort ? { aiEffort: effort } : {},
+              ...usage ?? {}
+            }
+          },
+          reads: events.readPaths,
+          toolInputs: events.toolInputs
+        };
+      }
+    };
+    function hasSchema(spec) {
+      return Boolean(spec.outputSchema && typeof spec.outputSchema === "object" && Object.keys(spec.outputSchema).length > 0);
     }
-    var READERS = "(?:cat|head|tail|sed|awk|less|more|bat)";
-    var CD_RE = /(?:^|[\s"'`;|&(])cd\s+(?:--\s+)?["']?([^\s"'`;|&<>()\\]+)/g;
-    function namesBareWord(input, word) {
-      const edge = String.raw`[\s"'\`;|&<>(),\\]`;
-      return new RegExp(`(?:^|${edge})${escapeRegExp(word)}(?=$|${edge})`).test(input);
+    function withSchema(prompt, spec) {
+      if (!hasSchema(spec))
+        return prompt;
+      return `${prompt}
+
+---
+
+Your final message must be one JSON object, and nothing else, that validates against this JSON Schema:
+
+${JSON.stringify(spec.outputSchema)}
+`;
     }
-    async function keepTranscript(dir, name, stdout) {
+    var RUN_RETENTION_MS = 24 * 60 * 60 * 1e3;
+    async function pruneRuns(runs) {
+      let entries;
       try {
-        await fs_1.promises.mkdir(dir, { recursive: true });
-        const safe = name.replace(/[^A-Za-z0-9._-]/g, "_");
-        await fs_1.promises.writeFile(path_1.default.join(dir, `${safe}.jsonl`), stdout);
+        entries = await fs_1.promises.readdir(runs);
+      } catch {
+        return;
+      }
+      const cutoff = Date.now() - RUN_RETENTION_MS;
+      await Promise.all(entries.map(async (name) => {
+        const dir = path_1.default.join(runs, name);
+        try {
+          if ((await fs_1.promises.stat(dir)).mtimeMs < cutoff)
+            await fs_1.promises.rm(dir, { recursive: true, force: true });
+        } catch {
+        }
+      }));
+    }
+    async function makeRunHome(scratch) {
+      const home = path_1.default.join(scratch, "copilot-home");
+      await fs_1.promises.mkdir(home, { mode: 448 });
+      await fs_1.promises.writeFile(path_1.default.join(home, "settings.json"), JSON.stringify(RUN_SETTINGS));
+      const bin = path_1.default.join(scratch, "bin");
+      await fs_1.promises.mkdir(bin, { recursive: true });
+      await fs_1.promises.writeFile(path_1.default.join(bin, "gh"), REFUSING_GH, { mode: 493 });
+      return home;
+    }
+    var REFUSING_GH = '#!/bin/sh\necho "gh is not available to a Sifter review" >&2\nexit 1\n';
+    var LOGIN_POINTER_KEYS = ["lastLoggedInUser", "loggedInUsers"];
+    var LOGIN_TOKEN_KEYS = ["authTokens"];
+    async function withOperatorLogin(home, fn) {
+      const file = path_1.default.join(home, "config.json");
+      const login = await operatorLogin();
+      if (login)
+        await fs_1.promises.writeFile(file, JSON.stringify(login), { mode: 384 });
+      else
+        await fs_1.promises.rm(file, { force: true });
+      try {
+        return await fn();
+      } finally {
+        await forgetToken(file);
+      }
+    }
+    async function forgetToken(file) {
+      let config;
+      try {
+        config = await readJsonc(file);
       } catch (err) {
-        console.warn(`[shuttle] could not keep the transcript for ${name} under ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+        if (err.code !== "ENOENT")
+          await fs_1.promises.rm(file, { force: true }).catch(() => {
+          });
+        return;
       }
+      if (!LOGIN_TOKEN_KEYS.some((k) => k in config))
+        return;
+      for (const k of LOGIN_TOKEN_KEYS)
+        delete config[k];
+      await fs_1.promises.writeFile(file, JSON.stringify(config), { mode: 384 }).catch(() => fs_1.promises.rm(file, { force: true }));
     }
-    function extractJsonObject(s) {
-      const exact = tryParseObject(s);
-      if (exact)
-        return exact;
-      let last;
-      let i = 0;
-      while (i < s.length) {
-        if (s[i] !== "{") {
-          i++;
+    async function operatorLogin() {
+      const home = process.env.COPILOT_HOME ?? path_1.default.join(os_1.default.homedir(), ".copilot");
+      try {
+        const parsed = await readJsonc(path_1.default.join(home, "config.json"));
+        const keys = [...LOGIN_POINTER_KEYS, ...LOGIN_TOKEN_KEYS].filter((k) => k in parsed);
+        return keys.length > 0 ? Object.fromEntries(keys.map((k) => [k, parsed[k]])) : null;
+      } catch {
+        return null;
+      }
+    }
+    async function readJsonc(file) {
+      const raw = await fs_1.promises.readFile(file, "utf8");
+      return JSON.parse(raw.split("\n").filter((line) => !line.trim().startsWith("//")).join("\n"));
+    }
+    function runEnv(home) {
+      const bin = path_1.default.join(path_1.default.dirname(home), "bin");
+      return {
+        ...process.env,
+        PATH: `${bin}${path_1.default.delimiter}${process.env.PATH ?? ""}`,
+        COPILOT_HOME: home,
+        COPILOT_AUTO_UPDATE: "false"
+      };
+    }
+    async function readUsage(file) {
+      try {
+        const raw = JSON.parse(await fs_1.promises.readFile(file, "utf8"));
+        return usageOf(raw);
+      } catch {
+        return null;
+      }
+    }
+    function usageOf(raw) {
+      const models = Object.entries(raw.modelMetrics ?? {});
+      if (models.length === 0)
+        return null;
+      const num = (v) => typeof v === "number" ? v : 0;
+      let input = 0;
+      let output = 0;
+      for (const [, m] of models) {
+        input += num(m.usage?.inputTokens) + num(m.usage?.cacheReadTokens);
+        output += num(m.usage?.outputTokens);
+      }
+      return { inputTokens: input, outputTokens: output, ...models.length === 1 ? { aiModel: models[0][0] } : {} };
+    }
+    function copilotProgressTap(reporter) {
+      return new progress_1.JsonLineTap((event) => {
+        const data = event.data ?? {};
+        if (event.type === "tool.execution_start" && typeof data.toolName === "string") {
+          const args = data.arguments ?? {};
+          const target = [args.path, args.pattern].find((v) => typeof v === "string");
+          reporter.tool(data.toolName, target);
+        } else if (event.type === "assistant.reasoning" && typeof data.content === "string") {
+          reporter.reasoning(data.content);
+        } else if (event.type === "assistant.turn_end") {
+          reporter.flush();
+        }
+      });
+    }
+    function parseCopilotEvents(stdout) {
+      let finalText = null;
+      const readPaths = [];
+      const toolInputs = [];
+      const started = /* @__PURE__ */ new Map();
+      let lastError = null;
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+          continue;
+        let event;
+        try {
+          event = JSON.parse(trimmed);
+        } catch {
           continue;
         }
-        let depth = 0;
-        let inString = false;
-        let escaped = false;
-        let end = -1;
-        for (let j = i; j < s.length; j++) {
-          const ch = s[j];
-          if (escaped) {
-            escaped = false;
-            continue;
-          }
-          if (ch === "\\") {
-            escaped = inString;
-            continue;
-          }
-          if (ch === '"') {
-            inString = !inString;
-            continue;
-          }
-          if (inString)
-            continue;
-          if (ch === "{")
-            depth++;
-          else if (ch === "}") {
-            depth--;
-            if (depth === 0) {
-              end = j;
+        const data = event.data ?? {};
+        switch (event.type) {
+          case "tool.execution_start": {
+            if (typeof data.toolCallId !== "string" || typeof data.toolName !== "string")
               break;
+            const args = data.arguments ?? {};
+            started.set(data.toolCallId, { name: data.toolName, args });
+            toolInputs.push(JSON.stringify(args));
+            break;
+          }
+          case "tool.execution_complete": {
+            const call = typeof data.toolCallId === "string" ? started.get(data.toolCallId) : void 0;
+            if (call && data.success === true && call.name === "view" && typeof call.args.path === "string") {
+              readPaths.push(call.args.path);
             }
+            break;
           }
+          case "assistant.message":
+            if (typeof data.content === "string" && data.content.trim().length > 0) {
+              finalText = data.content;
+              lastError = null;
+            }
+            break;
+          default:
+            if (typeof event.type === "string" && /(^|\.)error$/.test(event.type)) {
+              const message = [data.message, data.error?.message].find((v) => typeof v === "string");
+              if (message)
+                lastError = message;
+            }
         }
-        if (end === -1)
-          break;
-        const candidate = tryParseObject(s.slice(i, end + 1));
-        if (candidate)
-          last = candidate;
-        i = end + 1;
       }
-      return last;
+      return { finalText, readPaths, toolInputs, failure: finalText === null ? lastError : null };
     }
-    function tryParseObject(s) {
-      try {
-        const parsed = JSON.parse(s);
-        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
-      } catch {
-        return void 0;
+    function parseCopilotModels(helpText) {
+      const lines = helpText.split("\n");
+      const start = lines.findIndex((line) => /^\s*`model`:/.test(line));
+      if (start === -1)
+        return [];
+      const models = [];
+      for (const line of lines.slice(start + 1)) {
+        const value = /^\s+-\s+"([^"]+)"\s*$/.exec(line);
+        if (!value)
+          break;
+        models.push({ id: value[1], label: value[1], efforts: [...models_1.REASONING_EFFORTS] });
       }
+      return models;
+    }
+    function createCopilotExecutor(config, capabilityId = "copilot") {
+      const validated = (0, agent_common_1.parseAgentCommonConfig)(config, capabilityId);
+      const effort = (0, models_1.parseReasoningEffort)(config.reasoningEffort, models_1.REASONING_EFFORTS);
+      if (effort)
+        validated.reasoningEffort = effort;
+      return new CopilotExecutor(validated);
     }
   }
 });
@@ -10889,6 +12182,14 @@ var require_http_api = __commonJS({
           outputTokens: spec.costCapHint?.estimatedOutputTokens
         };
       }
+      /**
+       * The one model it runs. This executor takes no model hint (every call
+       * names the configured model), so reporting the endpoint's catalog would
+       * offer picks it would silently ignore.
+       */
+      async listModels() {
+        return [{ id: this.config.model, label: this.config.model }];
+      }
       async execute(dispatch, signal) {
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
         const outputLabel = spec.outputLabel;
@@ -11829,10 +13130,12 @@ var require_anthropic_api = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createAnthropicApiExecutor = createAnthropicApiExecutor;
+    exports2.parseAnthropicModels = parseAnthropicModels;
     var loom_1 = require_dist();
     var keep_1 = require_dist2();
     var env_ref_1 = require_env_ref();
     var validate_output_1 = require_validate_output();
+    var models_1 = require_models();
     var DEFAULT_BASE_URL = "https://api.anthropic.com/v1/messages";
     var DEFAULT_MODEL = "claude-sonnet-4-6";
     var DEFAULT_MAX_TOKENS = 4096;
@@ -11888,6 +13191,37 @@ var require_anthropic_api = __commonJS({
         };
         return this.callApi(handle.apiKey, body, spec, handle.outputLabel, signal);
       }
+      /**
+       * The provider's own catalog, `/v1/models` beside the configured Messages
+       * URL, asked with the operator's key. Dynamic mode reports nothing: its key
+       * is a customer's, revealed per job, and there is none to ask with at start.
+       */
+      async listModels(signal) {
+        const apiKey = this.instance.staticKey;
+        if (!apiKey)
+          return [];
+        const url = modelsUrl(this.instance.baseUrl);
+        if (!url)
+          return [];
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        const timer = setTimeout(abort, models_1.LIST_MODELS_TIMEOUT_MS);
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+          const response = await fetch(url, {
+            headers: { "x-api-key": apiKey, "anthropic-version": ANTHROPIC_API_VERSION },
+            signal: controller.signal
+          });
+          if (!response.ok)
+            return [];
+          return parseAnthropicModels(await response.json());
+        } catch {
+          return [];
+        } finally {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", abort);
+        }
+      }
       /** Shared Messages-API call + parse + validate, used by execute and continue. */
       async callApi(apiKey, body, spec, outputLabel, signal) {
         const timeoutController = new AbortController();
@@ -11929,7 +13263,8 @@ var require_anthropic_api = __commonJS({
             inputTokens: u.input_tokens,
             outputTokens: u.output_tokens,
             aiProvider: "anthropic",
-            aiModel: this.instance.model
+            // The model this call ran, which a hint may have chosen.
+            aiModel: body.model
           } : void 0;
           const parsed = safeJsonParse(rawText);
           (0, validate_output_1.assertOutputValid)(spec, parsed);
@@ -11961,7 +13296,8 @@ var require_anthropic_api = __commonJS({
       if (rawApiKeyFrom !== void 0 && rawApiKey !== void 0) {
         throw new Error('AnthropicApiExecutor accepts either "apiKey" (static) or "apiKeyFrom" (dynamic), not both');
       }
-      const resolveKey = rawApiKeyFrom !== void 0 ? buildDynamicResolver(config, deps) : buildStaticResolver(rawApiKey);
+      const staticKey = rawApiKeyFrom === void 0 ? resolveStaticKey(rawApiKey) : null;
+      const resolveKey = staticKey === null ? buildDynamicResolver(config, deps) : async () => staticKey;
       let baseUrl = DEFAULT_BASE_URL;
       if (config.baseUrl !== void 0) {
         if (typeof config.baseUrl !== "string" || config.baseUrl.length === 0) {
@@ -11992,6 +13328,7 @@ var require_anthropic_api = __commonJS({
       }
       return new AnthropicApiExecutor({
         resolveKey,
+        staticKey,
         baseUrl,
         model,
         maxTokens,
@@ -11999,12 +13336,25 @@ var require_anthropic_api = __commonJS({
         capabilityId
       });
     }
-    function buildStaticResolver(rawApiKey) {
+    function resolveStaticKey(rawApiKey) {
       if (typeof rawApiKey !== "string" || rawApiKey.length === 0) {
         throw new Error('AnthropicApiExecutor requires a non-empty "apiKey" string in config (or "apiKeyFrom: \\"job-metadata\\"" for dynamic key mode)');
       }
-      const resolved = (0, env_ref_1.resolveEnvRef)(rawApiKey, "apiKey");
-      return async () => resolved;
+      return (0, env_ref_1.resolveEnvRef)(rawApiKey, "apiKey");
+    }
+    function modelsUrl(messagesUrl) {
+      return /\/messages\/?$/.test(messagesUrl) ? messagesUrl.replace(/\/messages\/?$/, "/models") : null;
+    }
+    function parseAnthropicModels(body) {
+      const data = body?.data;
+      if (!Array.isArray(data))
+        return [];
+      return data.flatMap((entry) => {
+        const { id, display_name: displayName } = entry ?? {};
+        if (typeof id !== "string" || id.length === 0)
+          return [];
+        return [{ id, label: typeof displayName === "string" && displayName ? displayName : id }];
+      });
     }
     function buildDynamicResolver(config, deps) {
       if (config.apiKeyFrom !== "job-metadata") {
@@ -12502,6 +13852,8 @@ var require_checks = __commonJS({
     var path_1 = require("path");
     var registry_1 = require_registry();
     var claude_code_1 = require_claude_code();
+    var codex_1 = require_codex();
+    var copilot_1 = require_copilot();
     var http_api_1 = require_http_api();
     var anthropic_api_1 = require_anthropic_api();
     var webhook_1 = require_webhook();
@@ -12513,9 +13865,21 @@ var require_checks = __commonJS({
     var scaffold_1 = require_scaffold();
     var NODE_FLOOR = "20.0.0";
     var DISK_FLOOR_BYTES = 1024 * 1024 * 1024;
-    var WORKSPACE_EXECUTOR = "claude-code";
+    var AGENTS = [
+      { executor: "claude-code", bin: "claude", install: "install Claude Code (npm install -g @anthropic-ai/claude-code)" },
+      { executor: "codex", bin: "codex", install: "install Codex (brew install codex, or npm install -g @openai/codex)" },
+      {
+        executor: "copilot",
+        bin: "copilot",
+        install: "install GitHub Copilot CLI (brew install --cask copilot-cli, or npm install -g @github/copilot)"
+      }
+    ];
+    var AGENT_EXECUTORS2 = AGENTS.map((a) => a.executor);
+    var DEFAULT_AGENT = "claude-code";
     var BUILT_IN_EXECUTORS = [
       ["claude-code", claude_code_1.createClaudeCodeExecutor],
+      ["codex", codex_1.createCodexExecutor],
+      ["copilot", copilot_1.createCopilotExecutor],
       ["http-api", http_api_1.createHttpApiExecutor],
       ["anthropic-api", anthropic_api_1.createAnthropicApiExecutor],
       ["webhook", webhook_1.createWebhookExecutor],
@@ -12544,22 +13908,27 @@ var require_checks = __commonJS({
     function configuredExecutors(config) {
       return Object.keys(config.executors ?? {});
     }
-    function claudeCodeSettings(config, subject) {
-      const user = config.executors[WORKSPACE_EXECUTOR];
-      if (user === void 0)
+    function activeAgent(config) {
+      const configured = configuredExecutors(config);
+      const pooled = config.pools.map((p) => p.executor).find((e) => AGENT_EXECUTORS2.includes(e) && configured.includes(e));
+      return pooled ?? configured.find((e) => AGENT_EXECUTORS2.includes(e)) ?? null;
+    }
+    function agentSettings(config, subject) {
+      const executor = activeAgent(config);
+      if (executor === null)
         return null;
-      const defaults = (0, environment_1.executorDefaultsFor)(subject.brand, config.auth.jobsApiUrl)?.[WORKSPACE_EXECUTOR] ?? {};
-      return { ...defaults, ...user };
+      const user = config.executors[executor] ?? {};
+      const defaults = (0, environment_1.executorDefaultsFor)(subject.brand, config.auth.jobsApiUrl)?.[executor] ?? {};
+      return { executor, settings: { ...defaults, ...user } };
     }
     function claudeSettingsOf(config) {
-      return config.executors[WORKSPACE_EXECUTOR]?.claudeSettings;
+      return config.executors["claude-code"]?.claudeSettings;
     }
     function describeLogin(status) {
       return [status.authMethod ?? "unknown method", status.subscriptionType].filter((part) => part !== null).join(", ");
     }
     function runRoot(config, subject, osTmpDir) {
-      const settings = claudeCodeSettings(config, subject);
-      const tmpDir = settings?.tmpDir;
+      const tmpDir = agentSettings(config, subject)?.settings.tmpDir;
       return typeof tmpDir === "string" && tmpDir.length > 0 ? (0, apply_1.expandHome)(tmpDir) : osTmpDir;
     }
     async function withConfig(name, probes, body) {
@@ -12585,13 +13954,13 @@ var require_checks = __commonJS({
       };
     }
     function initRunRoot(plan, subject, osTmpDir) {
-      if (plan.executor !== WORKSPACE_EXECUTOR)
+      if (plan.executor === void 0 || !AGENT_EXECUTORS2.includes(plan.executor))
         return osTmpDir;
       if (subject.requestedTmpDir !== void 0 && subject.requestedTmpDir.length > 0) {
         return (0, apply_1.expandHome)(subject.requestedTmpDir);
       }
       const settings = {
-        ...(0, environment_1.executorDefaultsFor)(subject.brand, subject.brand.keepRegistration.jobsApiUrl)?.[WORKSPACE_EXECUTOR] ?? {},
+        ...(0, environment_1.executorDefaultsFor)(subject.brand, subject.brand.keepRegistration.jobsApiUrl)?.[plan.executor] ?? {},
         ...plan.keptBlock ?? {}
       };
       const tmpDir = settings.tmpDir;
@@ -12787,7 +14156,7 @@ var require_checks = __commonJS({
           }
           const covering = built.filter((e) => e.strategies.includes(loom_1.PROMPT_EXECUTION_STRATEGY));
           if (covering.length === 0) {
-            return fail("executor-coverage", `no configured executor handles the "${loom_1.PROMPT_EXECUTION_STRATEGY}" strategy every review job carries`, `configure an executor that runs prompts, e.g. ${WORKSPACE_EXECUTOR}`);
+            return fail("executor-coverage", `no configured executor handles the "${loom_1.PROMPT_EXECUTION_STRATEGY}" strategy every review job carries`, `configure an executor that runs prompts, e.g. ${DEFAULT_AGENT}`);
           }
           return pass("executor-coverage", `${covering.map((e) => e.capability.id).join(", ")} handle${covering.length === 1 ? "s" : ""} ${loom_1.PROMPT_EXECUTION_STRATEGY}`);
         });
@@ -12798,13 +14167,13 @@ var require_checks = __commonJS({
       phases: ["init", "run", "doctor"],
       async run(probes, subject) {
         if (subject.phase === "init") {
-          return atInit("git-cli", probes, subject, () => toolVerdict("git-cli", "git", probes, subject, {
+          return atInit("git-cli", AGENT_EXECUTORS2, probes, subject, () => toolVerdict("git-cli", "git", probes, subject, {
             missingRemedy: "install git, or configure an executor that needs no checkout"
           }));
         }
         return withConfig("git-cli", probes, async (config) => {
-          if (!configuredExecutors(config).includes(WORKSPACE_EXECUTOR)) {
-            return skip("git-cli", `no ${WORKSPACE_EXECUTOR} executor configured; nothing checks out a workspace`);
+          if (activeAgent(config) === null) {
+            return skip("git-cli", "no agent executor configured; nothing checks out a workspace");
           }
           return toolVerdict("git-cli", "git", probes, subject, {
             missingRemedy: "install git, or configure an executor that needs no checkout"
@@ -12812,28 +14181,32 @@ var require_checks = __commonJS({
         });
       }
     };
-    var claudeCli = {
-      name: "claude-cli",
-      phases: ["init", "run", "doctor"],
-      async run(probes, subject) {
-        if (subject.phase === "init") {
-          return atInit("claude-cli", probes, subject, () => toolVerdict("claude-cli", "claude", probes, subject, { missingRemedy: CLAUDE_INSTALL }));
-        }
-        return withConfig("claude-cli", probes, async (config) => {
-          if (!configuredExecutors(config).includes(WORKSPACE_EXECUTOR)) {
-            return skip("claude-cli", `no ${WORKSPACE_EXECUTOR} executor configured`);
+    function agentCli(agent) {
+      const name = `${agent.bin}-cli`;
+      return {
+        name,
+        phases: ["init", "run", "doctor"],
+        async run(probes, subject) {
+          if (subject.phase === "init") {
+            return atInit(name, [agent.executor], probes, subject, () => toolVerdict(name, agent.bin, probes, subject, { missingRemedy: agent.install }));
           }
-          return toolVerdict("claude-cli", "claude", probes, subject, { missingRemedy: CLAUDE_INSTALL });
-        });
-      }
-    };
+          return withConfig(name, probes, async (config) => {
+            if (!configuredExecutors(config).includes(agent.executor)) {
+              return skip(name, `no ${agent.executor} executor configured`);
+            }
+            return toolVerdict(name, agent.bin, probes, subject, { missingRemedy: agent.install });
+          });
+        }
+      };
+    }
+    var [CLAUDE, CODEX, COPILOT] = AGENTS;
     var claudeAuth = {
       name: "claude-auth",
       phases: ["run", "doctor"],
       async run(probes, subject) {
         return withConfig("claude-auth", probes, async (config) => {
-          if (!configuredExecutors(config).includes(WORKSPACE_EXECUTOR)) {
-            return skip("claude-auth", `no ${WORKSPACE_EXECUTOR} executor configured`);
+          if (!configuredExecutors(config).includes(CLAUDE.executor)) {
+            return skip("claude-auth", `no ${CLAUDE.executor} executor configured`);
           }
           if (config.credentials !== void 0) {
             return skip("claude-auth", "hosted mode: the model key is revealed per job, not read from a login");
@@ -12867,6 +14240,64 @@ var require_checks = __commonJS({
         });
       }
     };
+    var codexAuth = {
+      name: "codex-auth",
+      phases: ["run", "doctor"],
+      async run(probes, subject) {
+        return withConfig("codex-auth", probes, async (config) => {
+          const gate = await agentAuthGate("codex-auth", CODEX, config, probes);
+          if (gate)
+            return gate;
+          if (subject.deep)
+            return roundTripVerdict("codex-auth", CODEX, probes, "run `codex login`");
+          const status = await probes.codexLoginStatus();
+          if (status === null) {
+            return warn("codex-auth", "`codex login status` gave no answer", "run `codex login status` to see why, or doctor --deep");
+          }
+          if (!status.loggedIn) {
+            return fail("codex-auth", "the codex CLI is not signed in", "run `codex login`");
+          }
+          return pass("codex-auth", `${status.detail} (not verified)`);
+        });
+      }
+    };
+    var copilotAuth = {
+      name: "copilot-auth",
+      phases: ["run", "doctor"],
+      async run(probes, subject) {
+        return withConfig("copilot-auth", probes, async (config) => {
+          const gate = await agentAuthGate("copilot-auth", COPILOT, config, probes);
+          if (gate)
+            return gate;
+          if (subject.deep)
+            return roundTripVerdict("copilot-auth", COPILOT, probes, "run `copilot login`");
+          const token = probes.ambientCopilotToken();
+          if (token !== null) {
+            return warn("copilot-auth", `${token} is set and Copilot uses it ahead of any \`copilot login\``, `unset ${token} for this process if it is not a token with Copilot access, or run doctor --deep to prove it`);
+          }
+          return pass("copilot-auth", "no token in the environment; the copilot login is used (not verified; doctor --deep spends one turn to prove it)");
+        });
+      }
+    };
+    async function agentAuthGate(name, agent, config, probes) {
+      if (!configuredExecutors(config).includes(agent.executor)) {
+        return skip(name, `no ${agent.executor} executor configured`);
+      }
+      if (config.credentials !== void 0) {
+        return skip(name, `hosted mode: the ${agent.executor} executor refuses hosted runs`);
+      }
+      if (await probes.which(agent.bin) === null || !(await probes.versionOf(agent.bin)).ran) {
+        return skip(name, `no working ${agent.bin} CLI to be signed in to; see ${agent.bin}-cli`);
+      }
+      return null;
+    }
+    async function roundTripVerdict(name, agent, probes, signIn) {
+      const round = await probes.agentRoundTrip(agent.executor);
+      if (!round.ok) {
+        return fail(name, `the ${agent.bin} CLI refused a one-turn call: ${oneLine(round.error)}`, `${signIn}, then re-run doctor --deep`);
+      }
+      return pass(name, `one-turn call through the ${agent.bin} CLI succeeded`);
+    }
     var runRootWritable = {
       name: "run-root-writable",
       phases: ["init", "run", "doctor"],
@@ -12930,15 +14361,15 @@ var require_checks = __commonJS({
       phases: ["run", "doctor"],
       async run(probes, subject) {
         return withConfig("overlay-hosts", probes, (config) => {
-          const settings = claudeCodeSettings(config, subject);
-          if (settings === null) {
-            return skip("overlay-hosts", `no ${WORKSPACE_EXECUTOR} executor configured`);
+          const agent = agentSettings(config, subject);
+          if (agent === null) {
+            return skip("overlay-hosts", "no agent executor configured");
           }
-          const hosts = settings.overlayAllowedHosts;
+          const hosts = agent.settings.overlayAllowedHosts;
           const origins = Array.isArray(hosts) ? hosts.filter((h) => typeof h === "string") : [];
           if (origins.length === 0) {
-            const fallback = (0, environment_1.executorDefaultsFor)(subject.brand, config.auth.jobsApiUrl)?.[WORKSPACE_EXECUTOR]?.overlayAllowedHosts;
-            return warn("overlay-hosts", "the overlay allowlist is empty, so every review will run standards-blind", Array.isArray(fallback) && fallback.length > 0 ? `remove overlayAllowedHosts from the ${WORKSPACE_EXECUTOR} executor to use this tier's default` : `add overlayAllowedHosts to the ${WORKSPACE_EXECUTOR} executor, naming the origin your backend signs standards URLs with (this build names none for Jobs at ${(0, environment_1.hostOf)(config.auth.jobsApiUrl)})`);
+            const fallback = (0, environment_1.executorDefaultsFor)(subject.brand, config.auth.jobsApiUrl)?.[agent.executor]?.overlayAllowedHosts;
+            return warn("overlay-hosts", "the overlay allowlist is empty, so every review will run standards-blind", Array.isArray(fallback) && fallback.length > 0 ? `remove overlayAllowedHosts from the ${agent.executor} executor to use this tier's default` : `add overlayAllowedHosts to the ${agent.executor} executor, naming the origin your backend signs standards URLs with (this build names none for Jobs at ${(0, environment_1.hostOf)(config.auth.jobsApiUrl)})`);
           }
           return pass("overlay-hosts", origins.join(", "));
         });
@@ -12969,8 +14400,12 @@ var require_checks = __commonJS({
       needsFetch(keepReachable),
       executorCoverage,
       gitCli,
-      claudeCli,
+      agentCli(CLAUDE),
       claudeAuth,
+      agentCli(CODEX),
+      codexAuth,
+      agentCli(COPILOT),
+      copilotAuth,
       runRootWritable,
       diskSpace,
       overlayHosts,
@@ -13002,13 +14437,12 @@ var require_checks = __commonJS({
       }
       return `run \`${bin} --version\` to see why ${found} fails, then reinstall it (${missingRemedy})`;
     }
-    var CLAUDE_INSTALL = "install Claude Code (npm install -g @anthropic-ai/claude-code)";
-    async function atInit(name, probes, subject, body) {
+    async function atInit(name, needs, probes, subject, body) {
       const plan = initPlan(probes, subject);
       if (!plan.ok)
         return skip(name, "the existing config could not be read; see executor-coverage");
-      if (plan.value.executor !== WORKSPACE_EXECUTOR) {
-        return skip(name, plan.value.executor === void 0 ? "init configures no executor for this build" : `init configures ${plan.value.executor}, which needs no ${WORKSPACE_EXECUTOR} tools`);
+      if (plan.value.executor === void 0 || !needs.includes(plan.value.executor)) {
+        return skip(name, plan.value.executor === void 0 ? "init configures no executor for this build" : `init configures ${plan.value.executor}, which does not need this tool`);
       }
       return body();
     }
@@ -20914,12 +22348,14 @@ var require_subscribe = __commonJS({
             if (id === STOPPED)
               return;
             resolvedPoolIds.push(id);
+            const perPool = opts.subscriber.poolMetadata?.(ref);
+            const metadata = opts.subscriber.metadata !== void 0 || perPool !== void 0 ? { ...opts.subscriber.metadata, ...perPool } : void 0;
             const registered = await untilAvailable(() => opts.jobsClient.registerMember(id, {
               identityType: opts.subscriber.identityType,
               identityId: opts.subscriber.identityId,
               intelligence: opts.subscriber.intelligence,
               ...opts.subscriber.displayName !== void 0 ? { displayName: opts.subscriber.displayName } : {},
-              ...opts.subscriber.metadata !== void 0 ? { metadata: opts.subscriber.metadata } : {}
+              ...metadata !== void 0 ? { metadata } : {}
             }), mySession);
             if (registered === STOPPED)
               return;
@@ -21233,7 +22669,7 @@ var require_schema4 = __commonJS({
       message: 'Each pool must specify at least one of "id" or "name"'
     });
     var executorSchema = zod_1.z.object({
-      type: zod_1.z.enum(["claude-code", "http-api", "anthropic-api", "webhook", "custom-script"])
+      type: zod_1.z.enum(["claude-code", "codex", "copilot", "http-api", "anthropic-api", "webhook", "custom-script"])
     }).passthrough();
     var shuttleConfigSchema = zod_1.z.object({
       auth: zod_1.z.object({
@@ -21483,11 +22919,14 @@ var require_probes = __commonJS({
     var jobs_1 = require_dist4();
     var scaffold_1 = require_scaffold();
     var loader_1 = require_loader();
+    var codex_1 = require_codex();
+    var copilot_1 = require_copilot();
     var store_1 = require_store();
     var version_check_1 = require_version_check();
     var PROBE_TIMEOUT_MS = 1e4;
     var VERSION_TIMEOUT_MS = 1e4;
     var DEEP_PROBE_PROMPT = "Reply with the single word: ok";
+    var COPILOT_TOKEN_VARS = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
     function createProbes(options) {
       let observedLatest = null;
       const observe = (response) => {
@@ -21708,6 +23147,24 @@ var require_probes = __commonJS({
           }
           return { ok: true, value: void 0 };
         },
+        async codexLoginStatus() {
+          const outcome = await runCapturing("codex", ["login", "status"], VERSION_TIMEOUT_MS);
+          if (outcome.ok) {
+            const line = `${outcome.stdout}
+${outcome.stderr}`.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+            return { loggedIn: true, detail: line ?? "signed in" };
+          }
+          if (outcome.exited && /not logged in/i.test(outcome.reason)) {
+            return { loggedIn: false, detail: "not logged in" };
+          }
+          return null;
+        },
+        ambientCopilotToken: () => COPILOT_TOKEN_VARS.find((name) => (process.env[name] ?? "").length > 0) ?? null,
+        async agentRoundTrip(agent) {
+          const executor = agent === "codex" ? (0, codex_1.createCodexExecutor)({}) : (0, copilot_1.createCopilotExecutor)({});
+          const readiness = await executor.checkReadiness(AbortSignal.timeout(18e4));
+          return readiness.ready ? { ok: true, value: void 0 } : { ok: false, error: readiness.reason };
+        },
         latestVersion: () => observedLatest
       };
     }
@@ -21774,7 +23231,7 @@ var require_probes = __commonJS({
         child.on("close", (code, signal) => {
           clearTimeout(timer);
           if (code === 0) {
-            settle({ ok: true, stdout: stdout.trim() });
+            settle({ ok: true, stdout: stdout.trim(), stderr: stderr.trim() });
             return;
           }
           const status = code === null ? `was killed by ${signal ?? "a signal"}` : `exited ${code}`;
@@ -25380,6 +26837,37 @@ var require_logger = __commonJS({
   }
 });
 
+// ../../packages/shuttle/dist/core/demux.js
+var require_demux = __commonJS({
+  "../../packages/shuttle/dist/core/demux.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createDemux = createDemux;
+    function createDemux(executors, pools) {
+      const byStrategy = /* @__PURE__ */ new Map();
+      for (const executor of executors) {
+        for (const strategy of executor.strategies)
+          byStrategy.set(strategy, executor);
+      }
+      const byName = new Map(executors.map((e) => [e.capability.id, e]));
+      const byPool = /* @__PURE__ */ new Map();
+      for (const pool of pools) {
+        const named = byName.get(pool.executor);
+        if (!named)
+          continue;
+        if (pool.id)
+          byPool.set(`id:${pool.id}`, named);
+        if (pool.name)
+          byPool.set(`name:${pool.name}`, named);
+      }
+      return (pool, strategy) => {
+        const named = byPool.get(`id:${pool.id}`) ?? byPool.get(`name:${pool.name}`);
+        return named && named.strategies.includes(strategy) ? named : byStrategy.get(strategy);
+      };
+    }
+  }
+});
+
 // ../../packages/shuttle/dist/observers/logger.js
 var require_logger2 = __commonJS({
   "../../packages/shuttle/dist/observers/logger.js"(exports2) {
@@ -25901,6 +27389,9 @@ var require_shuttle = __commonJS({
     var logger_1 = require_logger();
     var registry_1 = require_registry();
     var claude_code_1 = require_claude_code();
+    var demux_1 = require_demux();
+    var codex_1 = require_codex();
+    var copilot_1 = require_copilot();
     var http_api_1 = require_http_api();
     var anthropic_api_1 = require_anthropic_api();
     var webhook_1 = require_webhook();
@@ -25951,6 +27442,13 @@ var require_shuttle = __commonJS({
       });
       return { promise, resolve, reject };
     }
+    async function listExecutorModels(executors, signal) {
+      const listed = await Promise.all(executors.map(async (executor) => {
+        const models = executor.listModels ? await executor.listModels(signal).catch(() => []) : [];
+        return [executor.capability.id, models];
+      }));
+      return new Map(listed);
+    }
     function isKeepUnavailable(err) {
       return err instanceof Error && err.name === "KeepUnavailableError";
     }
@@ -26098,11 +27596,11 @@ var require_shuttle = __commonJS({
         const registry = new registry_1.ExecutorRegistry(this.brand.executorAllowlist);
         registerBuiltInExecutors(registry, this.brand.executorAllowlist);
         const executors = registry.build(mergeExecutorDefaults((0, environment_1.executorDefaultsFor)(this.brand, this.config.auth.jobsApiUrl), this.config.executors));
-        const byStrategy = /* @__PURE__ */ new Map();
-        for (const executor of executors) {
-          for (const strategy of executor.strategies)
-            byStrategy.set(strategy, executor);
-        }
+        const executorFor = (0, demux_1.createDemux)(executors, this.config.pools);
+        const modelsByExecutor = await listExecutorModels(executors, this.stopping.signal);
+        if (this.stopping.signal.aborted)
+          return;
+        logger.info("executor models listed", Object.fromEntries([...modelsByExecutor].map(([id, m]) => [id, m.length])));
         this.spendTracker = (0, spend_tracker_1.createSpendTrackerObserver)(this.brand, paths.spendStateFile);
         const observers = [
           (0, logger_2.createLoggerObserver)(),
@@ -26123,7 +27621,7 @@ var require_shuttle = __commonJS({
           const attendanceId = dispatch.attendanceId;
           const startedAt = Date.now();
           const strategy = (0, loom_1.readShuttleStrategy)(dispatch.inputs) ?? "";
-          const executor = byStrategy.get(strategy);
+          const executor = executorFor(dispatch.pool, strategy);
           if (!executor) {
             const reason = `no executor for shuttle strategy "${strategy}"`;
             await observerChain.notify({ kind: "attendance.closed", jobId, attendanceId, status: "failed", reason, totalDurationMs: Date.now() - startedAt }, onObserverError);
@@ -26218,6 +27716,14 @@ var require_shuttle = __commonJS({
           return { status: "completed", outputs };
         };
         const pools = this.config.pools.map((p) => p.id ? { id: p.id } : { name: p.name });
+        const poolExecutors = new Map(pools.map((ref, i) => [ref, this.config.pools[i].executor]));
+        const poolMetadata = (ref) => {
+          const executor = poolExecutors.get(ref);
+          const models = executor ? modelsByExecutor.get(executor) : void 0;
+          if (!executor || !models)
+            return void 0;
+          return { executor, ...models.length > 0 ? { models } : {} };
+        };
         const attemptedUpgrades = /* @__PURE__ */ new Set();
         this.subscription = (0, jobs_1.subscribe)({
           jobsClient,
@@ -26234,7 +27740,8 @@ var require_shuttle = __commonJS({
               ...this.config.agent.metadata,
               client_version: this.brand.product.version,
               hostname: (0, os_1.hostname)()
-            }
+            },
+            poolMetadata
           },
           onJob,
           onDirectives: async (directives) => {
@@ -26378,6 +27885,8 @@ var require_shuttle = __commonJS({
     function registerBuiltInExecutors(registry, allowlist) {
       const all = [
         ["claude-code", claude_code_1.createClaudeCodeExecutor],
+        ["codex", codex_1.createCodexExecutor],
+        ["copilot", copilot_1.createCopilotExecutor],
         ["http-api", http_api_1.createHttpApiExecutor],
         ["anthropic-api", anthropic_api_1.createAnthropicApiExecutor],
         ["webhook", webhook_1.createWebhookExecutor],
@@ -26880,8 +28389,8 @@ var require_dist5 = __commonJS({
   "../../packages/shuttle/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DEFAULT_REFUSAL_MESSAGE = exports2.DEFAULT_MONTHLY_PERIOD = exports2.DEFAULT_DAILY_PERIOD = exports2.SUBSTRATE_BRAND = exports2.verificationJson = exports2.resolveEnvironment = exports2.renderVerificationLine = exports2.renderEnvironmentReport = exports2.isWorthReporting = exports2.hostOf = exports2.executorDefaultsFor = exports2.environmentReportJson = exports2.environmentPolledBy = exports2.applyEnvironment = exports2.renderTemplate = exports2.expandHome = exports2.resolvePaths = exports2.SpendStore = exports2.AuditLogStore = exports2.createSpendTrackerObserver = exports2.createAuditLogObserver = exports2.createLoggerObserver = exports2.SpendCapExceeded = exports2.ObserverChain = exports2.createCustomScriptExecutor = exports2.createWebhookExecutor = exports2.createHttpApiExecutor = exports2.createClaudeCodeExecutor = exports2.ExecutorEnvironmentError = exports2.ExecutorRegistry = exports2.AgentCredentialRevokedError = exports2.runPreflight = exports2.renderLines = exports2.renderJson = exports2.printReport = exports2.hasFailure = exports2.createProbes = exports2.checksFor = exports2.PREFLIGHT_FLOORS = exports2.PREFLIGHT_EXIT_CODE = exports2.CHECKS = exports2.readResponseLatestVersion = exports2.checkResponseMinVersion = exports2.compareSemver = exports2.UpgradeRequiredError = exports2.LATEST_VERSION_HEADER = exports2.MIN_VERSION_HEADER = exports2.loadConfig = exports2.Shuttle = exports2.createCli = void 0;
-    exports2.revokePairing = exports2.listPairings = exports2.PairingConfigStore = exports2.pair = exports2.scaffoldedConfigPath = exports2.planScaffold = void 0;
+    exports2.DEFAULT_DAILY_PERIOD = exports2.SUBSTRATE_BRAND = exports2.verificationJson = exports2.resolveEnvironment = exports2.renderVerificationLine = exports2.renderEnvironmentReport = exports2.isWorthReporting = exports2.hostOf = exports2.executorDefaultsFor = exports2.environmentReportJson = exports2.environmentPolledBy = exports2.applyEnvironment = exports2.renderTemplate = exports2.expandHome = exports2.resolvePaths = exports2.SpendStore = exports2.AuditLogStore = exports2.createSpendTrackerObserver = exports2.createAuditLogObserver = exports2.createLoggerObserver = exports2.SpendCapExceeded = exports2.ObserverChain = exports2.createCustomScriptExecutor = exports2.createWebhookExecutor = exports2.createHttpApiExecutor = exports2.createCopilotExecutor = exports2.createCodexExecutor = exports2.createClaudeCodeExecutor = exports2.ExecutorEnvironmentError = exports2.ExecutorRegistry = exports2.AgentCredentialRevokedError = exports2.runPreflight = exports2.renderLines = exports2.renderJson = exports2.printReport = exports2.hasFailure = exports2.createProbes = exports2.checksFor = exports2.PREFLIGHT_FLOORS = exports2.PREFLIGHT_EXIT_CODE = exports2.CHECKS = exports2.readResponseLatestVersion = exports2.checkResponseMinVersion = exports2.compareSemver = exports2.UpgradeRequiredError = exports2.LATEST_VERSION_HEADER = exports2.MIN_VERSION_HEADER = exports2.loadConfig = exports2.Shuttle = exports2.createCli = void 0;
+    exports2.revokePairing = exports2.listPairings = exports2.PairingConfigStore = exports2.pair = exports2.scaffoldedConfigPath = exports2.planScaffold = exports2.DEFAULT_REFUSAL_MESSAGE = exports2.DEFAULT_MONTHLY_PERIOD = void 0;
     var cli_1 = require_cli();
     Object.defineProperty(exports2, "createCli", { enumerable: true, get: function() {
       return cli_1.createCli;
@@ -26960,6 +28469,14 @@ var require_dist5 = __commonJS({
     Object.defineProperty(exports2, "createClaudeCodeExecutor", { enumerable: true, get: function() {
       return claude_code_1.createClaudeCodeExecutor;
     } });
+    var codex_1 = require_codex();
+    Object.defineProperty(exports2, "createCodexExecutor", { enumerable: true, get: function() {
+      return codex_1.createCodexExecutor;
+    } });
+    var copilot_1 = require_copilot();
+    Object.defineProperty(exports2, "createCopilotExecutor", { enumerable: true, get: function() {
+      return copilot_1.createCopilotExecutor;
+    } });
     var http_api_1 = require_http_api();
     Object.defineProperty(exports2, "createHttpApiExecutor", { enumerable: true, get: function() {
       return http_api_1.createHttpApiExecutor;
@@ -27086,7 +28603,8 @@ var import_path = require("path");
 var import_promises = require("fs/promises");
 var import_yaml = __toESM(require_dist3());
 var import_shuttle = __toESM(require_dist5());
-var buildVersion = true ? "0.30.23" : pkg.version;
+var buildVersion = true ? "0.32.0" : pkg.version;
+var AGENT_EXECUTORS = ["claude-code", "codex", "copilot"];
 var sifterBrand = {
   product: {
     id: "sifter",
@@ -27109,7 +28627,7 @@ var sifterBrand = {
     // shared config across multiple machines.
     configSearchPaths: ["~/.sifter/sifter.yaml"]
   },
-  executorAllowlist: ["claude-code", "anthropic-api", "http-api", "webhook", "custom-script"],
+  executorAllowlist: ["claude-code", "codex", "copilot", "anthropic-api", "http-api", "webhook", "custom-script"],
   // What `init` configures when neither --executor nor an existing
   // sifter.yaml names one. The init pre-flight reads it too, to check git and
   // claude before the pairing code is spent.
@@ -27123,23 +28641,35 @@ var sifterBrand = {
   // newest of the flags every review passes (`--tools` arrived in 2.0.31;
   // the executor's REVIEW_RUN_ARGS names them all), and the hosted image pins
   // 2.1.x. Below it a review fails on an unknown option.
+  //
+  // `codex` and `copilot` are floored at the releases their containment was
+  // verified against, and the floor is a containment rule rather than a
+  // compatibility one: an older codex that does not know permission profiles
+  // ignores the review's profile and falls back to a sandbox that reads the
+  // whole disk, and an older copilot may not know a flag that keeps a tool or
+  // a hook out of the run. Both executors are local only.
   minimumToolVersions: {
     git: "2.20.0",
-    claude: "2.0.45"
+    claude: "2.0.45",
+    codex: "0.162.0",
+    copilot: "1.0.97"
   },
   // The overlay-fetch allowlist is NOT here: each tier signs its standards
   // URLs with its own Sift origin (SIFT_PUBLIC_API_URL), so the origin is a
   // property of the tier and lives on its `environments` entry below. A
   // Sifter paired to production allows production's origin and nothing else.
-  executorDefaults: {
-    "claude-code": {
-      // Transcript retention is a diagnostic switch a person flips for one
-      // session, so it rides the environment rather than a file they would
-      // have to remember to unset. The shared package reads no env of its
-      // own (BE-005); this brand is where the variable becomes config.
-      ...process.env.SHUTTLE_KEEP_TRANSCRIPTS ? { keepTranscripts: process.env.SHUTTLE_KEEP_TRANSCRIPTS } : {}
-    }
-  },
+  executorDefaults: Object.fromEntries(
+    AGENT_EXECUTORS.map((executor) => [
+      executor,
+      {
+        // Transcript retention is a diagnostic switch a person flips for one
+        // session, so it rides the environment rather than a file they would
+        // have to remember to unset. The shared package reads no env of its
+        // own (BE-005); this brand is where the variable becomes config.
+        ...process.env.SHUTTLE_KEEP_TRANSCRIPTS ? { keepTranscripts: process.env.SHUTTLE_KEEP_TRANSCRIPTS } : {}
+      }
+    ])
+  ),
   // The environments Whittle Labs operates, keyed by the profile name that
   // selects one. `init --profile stage` resolves both URLs from here, so a
   // non-prod pairing is one flag instead of three and there is no host to
@@ -27244,7 +28774,7 @@ var sifterBrand = {
         }
         const executorBlock = plan.keptBlock !== void 0 ? {
           ...plan.keptBlock,
-          ...executor === "claude-code" && ctx.setupOptions.tmpDir ? { tmpDir: ctx.setupOptions.tmpDir } : {}
+          ...AGENT_EXECUTORS.includes(executor) && ctx.setupOptions.tmpDir ? { tmpDir: ctx.setupOptions.tmpDir } : {}
         } : await buildExecutorBlock(executor, ctx);
         const doc = {
           auth: {
@@ -27278,13 +28808,15 @@ var sifterBrand = {
   ]
 };
 function overlayOrigin(origin) {
-  return { "claude-code": { overlayAllowedHosts: [origin] } };
+  return Object.fromEntries(AGENT_EXECUTORS.map((e) => [e, { overlayAllowedHosts: [origin] }]));
 }
 async function buildExecutorBlock(executor, ctx) {
   switch (executor) {
-    case "claude-code": {
+    case "claude-code":
+    case "codex":
+    case "copilot": {
       return {
-        type: "claude-code",
+        type: executor,
         ...ctx.setupOptions.tmpDir ? { tmpDir: ctx.setupOptions.tmpDir } : {}
       };
     }