poe-code 3.0.168 → 3.0.170

package/dist/providers/goose.js

@@ -0,0 +1,2514 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC = "\x1B";
+    var CSI = `${ESC}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x, y) {
+        if (!y) return `${CSI}${x + 1}G`;
+        return `${CSI}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0) ret += `${CSI}${-x}D`;
+        else if (x > 0) ret += `${CSI}${x}C`;
+        if (y < 0) ret += `${CSI}${-y}A`;
+        else if (y > 0) ret += `${CSI}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI}${count}A`,
+      down: (count = 1) => `${CSI}${count}B`,
+      forward: (count = 1) => `${CSI}${count}C`,
+      backward: (count = 1) => `${CSI}${count}D`,
+      nextLine: (count = 1) => `${CSI}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI}F`.repeat(count),
+      left: `${CSI}G`,
+      hide: `${CSI}?25l`,
+      show: `${CSI}?25h`,
+      save: `${ESC}7`,
+      restore: `${ESC}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI}S`.repeat(count),
+      down: (count = 1) => `${CSI}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI}2J`,
+      up: (count = 1) => `${CSI}1J`.repeat(count),
+      down: (count = 1) => `${CSI}J`.repeat(count),
+      line: `${CSI}2K`,
+      lineEnd: `${CSI}K`,
+      lineStart: `${CSI}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor, scroll, erase, beep };
+  }
+});
+
+// src/templates/py-poe-spawn/env.hbs
+var require_env = __commonJS({
+  "src/templates/py-poe-spawn/env.hbs"(exports, module) {
+    module.exports = "POE_API_KEY={{apiKey}}\nPOE_BASE_URL=https://api.poe.com/v1\nMODEL={{model}}\n";
+  }
+});
+
+// src/templates/py-poe-spawn/main.py.hbs
+var require_main_py = __commonJS({
+  "src/templates/py-poe-spawn/main.py.hbs"(exports, module) {
+    module.exports = 'import os\nfrom openai import OpenAI\nfrom dotenv import load_dotenv\n\nload_dotenv()\n\nclient = OpenAI(\n    api_key=os.getenv("POE_API_KEY"),\n    base_url=os.getenv("POE_BASE_URL")\n)\n\nresponse = client.chat.completions.create(\n    model=os.getenv("MODEL", "{{model}}"),\n    messages=[{"role": "user", "content": "Tell me a joke"}]\n)\n\nprint(response.choices[0].message.content)\n';
+  }
+});
+
+// src/templates/py-poe-spawn/requirements.txt.hbs
+var require_requirements_txt = __commonJS({
+  "src/templates/py-poe-spawn/requirements.txt.hbs"(exports, module) {
+    module.exports = "openai>=1.0.0\npython-dotenv>=1.0.0\n";
+  }
+});
+
+// src/templates/codex/config.toml.hbs
+var require_config_toml = __commonJS({
+  "src/templates/codex/config.toml.hbs"(exports, module) {
+    module.exports = 'model_provider = "poe"\n\n[profiles."{{{profileName}}}"]\nmodel = "{{{model}}}"\nmodel_provider = "poe"\nmodel_reasoning_effort = "{{reasoningEffort}}"\nmodel_verbosity = "medium"\n\n[model_providers.poe]\nname = "poe"\nbase_url = "{{{baseUrl}}}"\nwire_api = "responses"\nexperimental_bearer_token = "{{apiKey}}"\nrequires_openai_auth = false\nsupports_websockets = false\n';
+  }
+});
+
+// packages/agent-spawn/src/run-command.ts
+import { spawn } from "node:child_process";
+
+// packages/agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/goose.ts
+var gooseAgent = {
+  id: "goose",
+  name: "goose",
+  label: "Goose",
+  summary: "Block's open-source AI agent with ACP support.",
+  binaryName: "goose",
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent,
+  gooseAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
+    }
+  }
+}
+
+// packages/agent-spawn/src/configs/mcp.ts
+function toJsonMcpServers(servers) {
+  const out = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const mapped = { command: server.command };
+    if (server.args && server.args.length > 0) {
+      mapped.args = server.args;
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      mapped.env = server.env;
+    }
+    out[name] = mapped;
+  }
+  return out;
+}
+function toTomlString(value) {
+  return JSON.stringify(value);
+}
+function toTomlArray(values) {
+  const serialized = values.map((value) => toTomlString(value));
+  return `[${serialized.join(", ")}]`;
+}
+function toTomlInlineTable(values) {
+  const parts = [];
+  for (const [key, value] of Object.entries(values)) {
+    parts.push(`${JSON.stringify(key)}=${toTomlString(value)}`);
+  }
+  return `{${parts.join(", ")}}`;
+}
+function serializeJsonMcpArgs(servers) {
+  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
+}
+function serializeOpenCodeMcpEnv(servers) {
+  const mcp = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const entry = { type: "local", command: [server.command, ...server.args ?? []] };
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.environment = server.env;
+    }
+    mcp[name] = entry;
+  }
+  return { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp }) };
+}
+function serializeCodexMcpArgs(servers) {
+  const args = [];
+  for (const [name, server] of Object.entries(servers)) {
+    const prefix = `mcp_servers.${name}`;
+    args.push("-c", `${prefix}.command=${toTomlString(server.command)}`);
+    if (server.args && server.args.length > 0) {
+      args.push("-c", `${prefix}.args=${toTomlArray(server.args)}`);
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      args.push("-c", `${prefix}.env=${toTomlInlineTable(server.env)}`);
+    }
+  }
+  return args;
+}
+function serializeGooseMcpArgs(servers) {
+  return Object.values(servers).flatMap((server) => [
+    "--with-extension",
+    [server.command, ...server.args ?? []].join(" ")
+  ]);
+}
+
+// packages/agent-spawn/src/configs/claude-code.ts
+var claudeCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "claude-code",
+  // ACP adapter support: yes (adapter: "claude")
+  adapter: "claude",
+  promptFlag: "-p",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  modelTransform: (model) => model.replaceAll(".", "-"),
+  defaultArgs: [
+    "--output-format",
+    "stream-json",
+    "--verbose"
+  ],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--dangerously-skip-permissions"],
+    edit: ["--permission-mode", "acceptEdits", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,NotebookEdit"],
+    read: ["--permission-mode", "plan"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "text"]
+  },
+  interactive: {
+    defaultArgs: []
+  },
+  resumeCommand: (threadId) => ["--resume", threadId]
+};
+
+// packages/agent-spawn/src/configs/codex.ts
+var codexSpawnConfig = {
+  kind: "cli",
+  agentId: "codex",
+  // ACP adapter support: yes (adapter: "codex")
+  adapter: "codex",
+  promptFlag: "exec",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--skip-git-repo-check", "--json"],
+  mcpArgs: serializeCodexMcpArgs,
+  mcpArgsBeforeCommand: true,
+  modes: {
+    yolo: ["-s", "danger-full-access"],
+    edit: ["-s", "workspace-write"],
+    read: ["-s", "read-only"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["-"]
+  },
+  interactive: {
+    defaultArgs: ["-a", "never"]
+  },
+  resumeCommand: (threadId, cwd) => ["resume", "-C", cwd, threadId]
+};
+
+// packages/agent-spawn/src/configs/opencode.ts
+var openCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "opencode",
+  // ACP adapter support: yes (adapter: "opencode").
+  // OpenCode's `--format json` emits NDJSON events with `{ type, sessionID, part }`
+  // (no `{ event, ... }` field), so it needs the OpenCode adapter (not "native").
+  adapter: "opencode",
+  promptFlag: "run",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  modelTransform: (model) => {
+    return model.startsWith("poe/") ? model : `poe/${model}`;
+  },
+  defaultArgs: ["--format", "json"],
+  modes: {
+    yolo: [],
+    edit: [],
+    read: ["--agent", "plan"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "--prompt"
+  },
+  resumeCommand: (threadId, cwd) => [cwd, "--session", threadId],
+  mcpEnv: serializeOpenCodeMcpEnv
+};
+var openCodeAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "opencode",
+  acpArgs: ["acp"],
+  skipAuth: true,
+  mcpEnv: serializeOpenCodeMcpEnv
+};
+
+// packages/agent-spawn/src/configs/kimi.ts
+var kimiSpawnConfig = {
+  kind: "cli",
+  agentId: "kimi",
+  // ACP adapter support: yes (adapter: "kimi").
+  // Kimi's `--output-format stream-json` emits OpenAI-style `{ role, content }` JSON
+  // (no `{ event, ... }` field), so it needs the Kimi adapter (not "native").
+  adapter: "kimi",
+  promptFlag: "-p",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--print", "--output-format", "stream-json"],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--yolo"],
+    edit: [],
+    read: []
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "stream-json"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "-p"
+  },
+  resumeCommand: (threadId, cwd) => ["--session", threadId, "--work-dir", cwd]
+};
+var kimiAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "kimi",
+  acpArgs: ["acp"]
+};
+
+// packages/agent-spawn/src/configs/goose.ts
+var gooseSpawnConfig = {
+  kind: "cli",
+  agentId: "goose",
+  adapter: "native",
+  promptFlag: "--text",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  defaultArgs: ["run", "--output-format", "stream-json"],
+  defaultArgsPosition: "beforePrompt",
+  mcpArgs: serializeGooseMcpArgs,
+  mcpArgsPosition: "beforePrompt",
+  modes: {
+    yolo: { env: { GOOSE_MODE: "auto" } },
+    edit: { env: { GOOSE_MODE: "smart_approve" } },
+    read: { env: { GOOSE_MODE: "chat" } }
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--instructions", "-"]
+  },
+  interactive: {
+    defaultArgs: ["session"],
+    defaultArgsPosition: "beforePrompt"
+  },
+  resumeCommand: () => ["run", "--resume", "--text", "continue"]
+};
+var gooseAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "goose",
+  acpArgs: ["acp"],
+  skipAuth: true
+};
+
+// packages/agent-spawn/src/configs/index.ts
+var allSpawnConfigs = [
+  claudeCodeSpawnConfig,
+  codexSpawnConfig,
+  openCodeSpawnConfig,
+  kimiSpawnConfig,
+  gooseSpawnConfig
+];
+var lookup2 = /* @__PURE__ */ new Map();
+for (const config of allSpawnConfigs) {
+  lookup2.set(config.agentId, config);
+}
+var acpLookup = /* @__PURE__ */ new Map();
+acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
+acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
+acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
+
+// packages/agent-spawn/src/spawn.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+
+// packages/agent-spawn/src/spawn-interactive.ts
+import { spawn as spawnChildProcess2 } from "node:child_process";
+
+// packages/design-system/src/tokens/colors.ts
+import chalk from "chalk";
+var dark = {
+  header: (text4) => chalk.magentaBright.bold(text4),
+  divider: (text4) => chalk.dim(text4),
+  prompt: (text4) => chalk.cyan(text4),
+  number: (text4) => chalk.cyanBright(text4),
+  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.magenta("\u25C7"),
+  errorSymbol: chalk.red("\u25A0"),
+  accent: (text4) => chalk.cyan(text4),
+  muted: (text4) => chalk.dim(text4),
+  success: (text4) => chalk.green(text4),
+  warning: (text4) => chalk.yellow(text4),
+  error: (text4) => chalk.red(text4),
+  info: (text4) => chalk.magenta(text4),
+  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
+};
+var light = {
+  header: (text4) => chalk.hex("#a200ff").bold(text4),
+  divider: (text4) => chalk.hex("#666666")(text4),
+  prompt: (text4) => chalk.hex("#006699").bold(text4),
+  number: (text4) => chalk.hex("#0077cc").bold(text4),
+  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
+  errorSymbol: chalk.hex("#cc0000")("\u25A0"),
+  accent: (text4) => chalk.hex("#006699").bold(text4),
+  muted: (text4) => chalk.hex("#666666")(text4),
+  success: (text4) => chalk.hex("#008800")(text4),
+  warning: (text4) => chalk.hex("#cc6600")(text4),
+  error: (text4) => chalk.hex("#cc0000")(text4),
+  info: (text4) => chalk.hex("#a200ff")(text4),
+  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+};
+
+// packages/design-system/src/tokens/typography.ts
+import chalk2 from "chalk";
+
+// packages/design-system/src/components/text.ts
+import chalk3 from "chalk";
+
+// packages/design-system/src/internal/output-format.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
+var formatStorage = new AsyncLocalStorage();
+var cached;
+function resolveOutputFormat(env = process.env) {
+  const scoped = formatStorage.getStore();
+  if (scoped) {
+    return scoped;
+  }
+  if (cached) {
+    return cached;
+  }
+  const raw = env.OUTPUT_FORMAT?.toLowerCase();
+  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
+  return cached;
+}
+
+// packages/design-system/src/internal/theme-detect.ts
+function detectThemeFromEnv(env) {
+  const apple = env.APPLE_INTERFACE_STYLE;
+  if (typeof apple === "string") {
+    return apple.toLowerCase() === "dark" ? "dark" : "light";
+  }
+  const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
+  if (typeof vscodeKind === "string") {
+    const normalized = vscodeKind.toLowerCase();
+    if (normalized.includes("light")) {
+      return "light";
+    }
+    if (normalized.includes("dark")) {
+      return "dark";
+    }
+  }
+  const colorFGBG = env.COLORFGBG;
+  if (typeof colorFGBG === "string") {
+    const parts = colorFGBG.split(";").map((part) => Number.parseInt(part, 10));
+    const background = parts.at(-1);
+    if (Number.isFinite(background)) {
+      return background >= 8 ? "light" : "dark";
+    }
+  }
+  return void 0;
+}
+function resolveThemeName(env = process.env) {
+  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
+  if (raw === "light" || raw === "dark") {
+    return raw;
+  }
+  const detected = detectThemeFromEnv(env);
+  if (detected) {
+    return detected;
+  }
+  return "dark";
+}
+var cachedTheme;
+function getTheme(env) {
+  if (cachedTheme) {
+    return cachedTheme;
+  }
+  const themeName = resolveThemeName(env);
+  cachedTheme = themeName === "light" ? light : dark;
+  return cachedTheme;
+}
+
+// packages/design-system/src/components/symbols.ts
+import chalk4 from "chalk";
+var symbols = {
+  get info() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "info";
+    if (format === "markdown") return "(i)";
+    return chalk4.magenta("\u25CF");
+  },
+  get success() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "success";
+    if (format === "markdown") return "[ok]";
+    return chalk4.magenta("\u25C6");
+  },
+  get resolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "resolved";
+    if (format === "markdown") return ">";
+    return getTheme().resolvedSymbol;
+  },
+  get errorResolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "error";
+    if (format === "markdown") return "[!]";
+    return getTheme().errorSymbol;
+  },
+  get bar() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "";
+    if (format === "markdown") return "|";
+    return "\u2502";
+  },
+  cornerTopRight: "\u256E",
+  cornerBottomRight: "\u256F",
+  get warning() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "warning";
+    if (format === "markdown") return "[!]";
+    return "\u25B2";
+  },
+  get active() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "active";
+    if (format === "markdown") return "[x]";
+    return "\u25C6";
+  },
+  get inactive() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "inactive";
+    if (format === "markdown") return "[ ]";
+    return "\u25CB";
+  }
+};
+
+// packages/design-system/src/components/logger.ts
+import chalk6 from "chalk";
+
+// packages/design-system/src/prompts/primitives/log.ts
+import chalk5 from "chalk";
+
+// packages/design-system/src/internal/strip-ansi.ts
+function stripAnsi(value) {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+// packages/design-system/src/prompts/primitives/log.ts
+function writeTerminalMessage(msg, {
+  symbol = chalk5.gray("\u2502"),
+  secondarySymbol = chalk5.gray("\u2502"),
+  spacing: spacing2 = 1,
+  withGuide = true
+} = {}) {
+  const lines = [];
+  const showGuide = withGuide !== false;
+  const contentLines = msg.split("\n");
+  const prefix = showGuide ? `${symbol}  ` : "";
+  const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
+  const emptyGuide = showGuide ? secondarySymbol : "";
+  for (let index = 0; index < spacing2; index += 1) {
+    lines.push(emptyGuide);
+  }
+  if (contentLines.length === 0) {
+    process.stdout.write("\n");
+    return;
+  }
+  const [firstLine = "", ...continuationLines] = contentLines;
+  if (firstLine.length > 0) {
+    lines.push(`${prefix}${firstLine}`);
+  } else {
+    lines.push(showGuide ? symbol : "");
+  }
+  for (const line of continuationLines) {
+    if (line.length > 0) {
+      lines.push(`${continuationPrefix}${line}`);
+      continue;
+    }
+    lines.push(emptyGuide);
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function message(msg, options) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "message", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  writeTerminalMessage(msg, options);
+}
+function info(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **info:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "info", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: symbols.info });
+}
+function success(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **success:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "success", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: symbols.success });
+}
+function warn(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **warning:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: chalk5.yellow("\u25B2") });
+}
+function error(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **error:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: chalk5.red("\u25A0") });
+}
+var log = {
+  info,
+  success,
+  message,
+  warn,
+  error
+};
+
+// packages/design-system/src/components/logger.ts
+function createLogger(emitter) {
+  const emit = (level, message2) => {
+    if (emitter) {
+      emitter(message2);
+      return;
+    }
+    if (level === "success") {
+      log.success(message2);
+      return;
+    }
+    if (level === "warn") {
+      log.warn(message2);
+      return;
+    }
+    if (level === "error") {
+      log.error(message2);
+      return;
+    }
+    log.info(message2);
+  };
+  return {
+    info(message2) {
+      emit("info", message2);
+    },
+    success(message2) {
+      emit("success", message2);
+    },
+    warn(message2) {
+      emit("warn", message2);
+    },
+    error(message2) {
+      emit("error", message2);
+    },
+    resolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.resolved });
+    },
+    errorResolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.errorResolved });
+    },
+    message(message2, symbol) {
+      if (emitter) {
+        emitter(message2);
+        return;
+      }
+      log.message(message2, { symbol: symbol ?? chalk6.gray("\u2502") });
+    }
+  };
+}
+var logger = createLogger();
+
+// packages/design-system/src/components/table.ts
+import { Table } from "console-table-printer";
+
+// packages/design-system/src/acp/components.ts
+import chalk7 from "chalk";
+var AGENT_PREFIX = `${chalk7.green.bold("\u2713")} agent: `;
+
+// packages/design-system/src/dashboard/buffer.ts
+import chalk8 from "chalk";
+
+// packages/design-system/src/dashboard/terminal.ts
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+
+// packages/design-system/src/prompts/index.ts
+import chalk15 from "chalk";
+import * as clack from "@clack/prompts";
+
+// packages/design-system/src/prompts/primitives/cancel.ts
+import chalk9 from "chalk";
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { stdout as R, stdin as q } from "node:process";
+import * as k from "node:readline";
+import ot from "node:readline";
+import { ReadStream as J } from "node:tty";
+var P = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var ct = new RegExp("\\p{M}+", "gu");
+var pt = { limit: 1 / 0, ellipsis: "" };
+var ft = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
+var j = "\x07";
+var Q = "[";
+var dt = "]";
+var U = `${dt}8;;`;
+var et = new RegExp(`(?:\\${Q}(?<code>\\d+)m|\\${U}(?<uri>.*)${j})`, "y");
+var At = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var _ = { actions: new Set(At), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true };
+var bt = globalThis.process.platform.startsWith("win");
+
+// packages/design-system/src/prompts/primitives/intro.ts
+import chalk10 from "chalk";
+
+// packages/design-system/src/prompts/primitives/note.ts
+import chalk11 from "chalk";
+
+// packages/design-system/src/prompts/primitives/outro.ts
+import chalk12 from "chalk";
+
+// packages/design-system/src/prompts/primitives/spinner.ts
+import chalk14 from "chalk";
+
+// packages/design-system/src/static/spinner.ts
+import chalk13 from "chalk";
+
+// packages/design-system/src/static/menu.ts
+import chalk16 from "chalk";
+
+// packages/agent-spawn/src/acp/replay.ts
+import path from "node:path";
+import { homedir } from "node:os";
+import { open, readdir } from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline";
+
+// packages/agent-spawn/src/acp/spawn.ts
+import { spawn as spawnChildProcess3 } from "node:child_process";
+
+// packages/poe-acp-client/src/acp-client.ts
+import { isAbsolute } from "node:path";
+
+// packages/poe-acp-client/src/acp-transport.ts
+import {
+  spawn as spawnChildProcess4
+} from "node:child_process";
+
+// packages/poe-acp-client/src/run-report.ts
+import * as fsPromises from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join } from "node:path";
+
+// packages/agent-spawn/src/acp/middlewares/spawn-log.ts
+import path2 from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { mkdir, open as open2 } from "node:fs/promises";
+
+// src/utils/command-checks.ts
+function formatCommandRunnerResult(result) {
+  const stdout = result.stdout.length > 0 ? result.stdout : "<empty>";
+  const stderr = result.stderr.length > 0 ? result.stderr : "<empty>";
+  return `stdout:
+${stdout}
+stderr:
+${stderr}`;
+}
+function describeCommandExpectation(command, args, expectedOutput) {
+  return `${renderCommandLine(command, args)} (expecting "${expectedOutput}")`;
+}
+function createCommandExpectationCheck(options) {
+  return {
+    id: options.id,
+    description: describeCommandExpectation(
+      options.command,
+      options.args,
+      options.expectedOutput
+    ),
+    async run(context) {
+      await runAndMatchOutput(context, options);
+    }
+  };
+}
+async function runAndMatchOutput(context, options) {
+  const rendered = renderCommandLine(options.command, options.args);
+  if (options.skipOnDryRun !== false && context.isDryRun) {
+    if (context.logDryRun) {
+      context.logDryRun(
+        `Dry run: ${rendered} (expecting "${options.expectedOutput}")`
+      );
+    }
+    return;
+  }
+  const result = await context.runCommand(options.command, options.args);
+  if (result.exitCode !== 0) {
+    const detail = formatCommandRunnerResult(result);
+    throw new Error(
+      [`Command ${rendered} failed with exit code ${result.exitCode}.`, detail].join("\n")
+    );
+  }
+  if (!stdoutMatchesExpected(result.stdout, options.expectedOutput)) {
+    const detail = formatCommandRunnerResult(result);
+    const received = result.stdout.trim();
+    throw new Error(
+      [
+        `Command ${rendered} failed: expected "${options.expectedOutput}" but received "${received}".`,
+        detail
+      ].join("\n")
+    );
+  }
+}
+function stdoutMatchesExpected(stdout, expected) {
+  const trimmed = stdout.trim();
+  if (trimmed === expected) {
+    return true;
+  }
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.some((line) => line === expected)) {
+    return true;
+  }
+  for (const line of lines) {
+    if (line[0] !== "{") continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.type === "result" && parsed.result === expected) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function renderCommandLine(command, args) {
+  return [command, ...args].map(quoteIfNeeded).join(" ").trim();
+}
+function quoteIfNeeded(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (needsQuoting(value)) {
+    return `"${value.replaceAll('"', '\\"')}"`;
+  }
+  return value;
+}
+function needsQuoting(value) {
+  return value.includes(" ") || value.includes("	") || value.includes("\n");
+}
+function createBinaryExistsCheck(binaryName, id, description) {
+  return {
+    id,
+    description,
+    async run({ runCommand: runCommand2 }) {
+      const commonPaths = [
+        `/usr/local/bin/${binaryName}`,
+        `/usr/bin/${binaryName}`,
+        `$HOME/.local/bin/${binaryName}`,
+        `$HOME/.claude/local/bin/${binaryName}`
+      ];
+      const detectors = [
+        {
+          command: "which",
+          args: [binaryName],
+          validate: (result) => result.exitCode === 0
+        },
+        {
+          command: "where",
+          args: [binaryName],
+          validate: (result) => result.exitCode === 0 && result.stdout.trim().length > 0
+        },
+        // Check common installation paths using shell expansion for $HOME
+        {
+          command: "sh",
+          args: [
+            "-c",
+            commonPaths.map((p) => `test -f "${p}"`).join(" || ")
+          ],
+          validate: (result) => result.exitCode === 0
+        }
+      ];
+      for (const detector of detectors) {
+        const result = await runCommand2(detector.command, detector.args);
+        if (detector.validate(result)) {
+          return;
+        }
+      }
+      throw new Error(`${binaryName} CLI binary not found on PATH.`);
+    }
+  };
+}
+
+// packages/config-mutations/src/mutations/config-mutation.ts
+function merge(options) {
+  return {
+    kind: "configMerge",
+    target: options.target,
+    value: options.value,
+    format: options.format,
+    pruneByPrefix: options.pruneByPrefix,
+    label: options.label
+  };
+}
+function prune(options) {
+  return {
+    kind: "configPrune",
+    target: options.target,
+    shape: options.shape,
+    format: options.format,
+    onlyIf: options.onlyIf,
+    label: options.label
+  };
+}
+function transform(options) {
+  return {
+    kind: "configTransform",
+    target: options.target,
+    format: options.format,
+    transform: options.transform,
+    label: options.label
+  };
+}
+var configMutation = {
+  merge,
+  prune,
+  transform
+};
+
+// packages/config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
+}
+function remove(options) {
+  return {
+    kind: "removeFile",
+    target: options.target,
+    whenEmpty: options.whenEmpty,
+    whenContentMatches: options.whenContentMatches,
+    label: options.label
+  };
+}
+function removeDirectory(options) {
+  return {
+    kind: "removeDirectory",
+    path: options.path,
+    force: options.force,
+    label: options.label
+  };
+}
+function chmod(options) {
+  return {
+    kind: "chmod",
+    target: options.target,
+    mode: options.mode,
+    label: options.label
+  };
+}
+function backup(options) {
+  return {
+    kind: "backup",
+    target: options.target,
+    label: options.label
+  };
+}
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup
+};
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const errors = [];
+  const parsed = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var jsonFormat = {
+  parse: parse3,
+  serialize,
+  merge: merge2,
+  prune: prune2
+};
+
+// packages/config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse4(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return parsed;
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge3(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge3(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune3(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune3(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse4,
+  serialize: serialize2,
+  merge: merge3,
+  prune: prune3
+};
+
+// packages/config-mutations/src/formats/yaml.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse5(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseYaml(content);
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject3(parsed)) {
+    throw new Error("Expected YAML object.");
+  }
+  return parsed;
+}
+function serialize3(obj) {
+  const serialized = stringifyYaml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge4(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject3(existing) && isConfigObject3(value)) {
+      result[key] = merge4(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune4(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject3(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject3(pattern) && isConfigObject3(current)) {
+      const { changed: childChanged, result: childResult } = prune4(current, pattern);
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var yamlFormat = {
+  parse: parse5,
+  serialize: serialize3,
+  merge: merge4,
+  prune: prune4
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat,
+  yaml: yamlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
+  }
+  const ext = getExtension(pathOrFormat);
+  const formatName = extensionMap[ext];
+  if (!formatName) {
+    throw new Error(
+      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
+    );
+  }
+  return formatRegistry[formatName];
+}
+function detectFormat(path4) {
+  const ext = getExtension(path4);
+  return extensionMap[ext];
+}
+function getExtension(path4) {
+  const lastDot = path4.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path4.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path3 from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path3.join(homeDir, remainder);
+}
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
+  }
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
+    );
+  }
+}
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path3.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path3.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path3.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+}
+async function readFileIfExists(fs, target) {
+  try {
+    return await fs.readFile(target, "utf8");
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return null;
+    }
+    throw error2;
+  }
+}
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return false;
+    }
+    throw error2;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isConfigObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject4(current) && isConfigObject4(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
+  return {
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
+    },
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error2;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat = await context.fs.stat(targetPath);
+    const currentMode = typeof stat.mode === "number" ? stat.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error2;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error2) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error2}`,
+      { cause: error2 }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+
+// packages/config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error2) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error2
+    );
+    throw error2;
+  }
+}
+
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// src/services/service-install.ts
+async function runServiceInstall(definition, context) {
+  const checkContext = {
+    isDryRun: context.isDryRun,
+    runCommand: context.runCommand
+  };
+  let needsInstall = false;
+  try {
+    await definition.check.run(checkContext);
+    context.logger(`${definition.summary} already installed.`);
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    context.logger(`${definition.summary} not detected: ${detail}`);
+    needsInstall = true;
+  }
+  if (!needsInstall) {
+    return false;
+  }
+  if (context.isDryRun) {
+    logInstallDryRun(definition, context);
+    return true;
+  }
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    await runInstallStep(step, context);
+  }
+  await definition.check.run(checkContext);
+  if (definition.postChecks) {
+    for (const postCheck of definition.postChecks) {
+      await postCheck.run(checkContext);
+    }
+  }
+  context.logger(
+    definition.successMessage ?? `${definition.summary} installed.`
+  );
+  return true;
+}
+function describeInstallCommand(step) {
+  return `[${step.id}] ${formatCommand2(step.command, step.args)}`;
+}
+function formatCommand2(command, args) {
+  return [command, ...args.map(quoteIfNeeded2)].join(" ");
+}
+function quoteIfNeeded2(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (value.includes(" ") || value.includes("	") || value.includes("\n")) {
+    return `"${value.replaceAll('"', '\\"')}"`;
+  }
+  return value;
+}
+function filterStepsByPlatform(steps, platform) {
+  return steps.filter(
+    (step) => !step.platforms || step.platforms.includes(platform)
+  );
+}
+function logInstallDryRun(definition, context) {
+  context.logger(`Dry run: would install ${definition.summary}.`);
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    context.logger(`Dry run: ${describeInstallCommand(step)}`);
+  }
+}
+async function runInstallStep(step, context) {
+  context.logger(`Running ${describeInstallCommand(step)}`);
+  const result = await context.runCommand(step.command, step.args);
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.trim();
+    const suffix = stderr.length > 0 ? `: ${stderr}` : "";
+    throw new Error(
+      `${describeInstallCommand(step)} failed with exit code ${result.exitCode}${suffix}`
+    );
+  }
+}
+
+// src/providers/create-provider.ts
+var templateImports = {
+  "py-poe-spawn/env.hbs": () => Promise.resolve().then(() => __toESM(require_env(), 1)),
+  "py-poe-spawn/main.py.hbs": () => Promise.resolve().then(() => __toESM(require_main_py(), 1)),
+  "py-poe-spawn/requirements.txt.hbs": () => Promise.resolve().then(() => __toESM(require_requirements_txt(), 1)),
+  "codex/config.toml.hbs": () => Promise.resolve().then(() => __toESM(require_config_toml(), 1))
+};
+async function loadTemplate(templateId) {
+  const loader = templateImports[templateId];
+  if (!loader) {
+    throw new Error(`Template not found: ${templateId}`);
+  }
+  const module = await loader();
+  return module.default;
+}
+function createProvider(opts) {
+  const provider2 = {
+    id: opts.id,
+    summary: opts.summary,
+    name: opts.name,
+    aliases: opts.aliases,
+    label: opts.label,
+    branding: opts.branding,
+    disabled: opts.disabled,
+    supportsStdinPrompt: opts.supportsStdinPrompt,
+    supportsMcpSpawn: opts.supportsMcpSpawn,
+    configurePrompts: opts.configurePrompts,
+    postConfigureMessages: opts.postConfigureMessages,
+    extendConfigurePayload: opts.extendConfigurePayload,
+    isolatedEnv: opts.isolatedEnv,
+    async configure(context, runOptions) {
+      await runMutations(opts.manifest.configure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+    },
+    async unconfigure(context, runOptions) {
+      if (!opts.manifest.unconfigure) {
+        return false;
+      }
+      const result = await runMutations(opts.manifest.unconfigure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+      return result.changed;
+    }
+  };
+  if (opts.install) {
+    provider2.install = createInstallRunner(opts.install);
+  }
+  if (opts.test) {
+    provider2.test = opts.test;
+  }
+  if (opts.spawn) {
+    provider2.spawn = opts.spawn;
+  }
+  return provider2;
+}
+function createInstallRunner(definition) {
+  return async (context) => {
+    await runServiceInstall(definition, {
+      isDryRun: context.logger.context.dryRun,
+      runCommand: context.command.runCommand,
+      logger: (message2) => context.logger.verbose(message2),
+      platform: context.env.platform
+    });
+  };
+}
+
+// src/cli/constants.ts
+var FRONTIER_MODELS = [
+  "anthropic/claude-opus-4.6",
+  "anthropic/claude-sonnet-4.6",
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.4",
+  "google/gemini-3.1-pro"
+];
+var DEFAULT_FRONTIER_MODEL = "anthropic/claude-sonnet-4.6";
+var CLAUDE_CODE_VARIANTS = {
+  haiku: "anthropic/claude-haiku-4.5",
+  sonnet: "anthropic/claude-sonnet-4.6",
+  opus: "anthropic/claude-opus-4.6"
+};
+var DEFAULT_CLAUDE_CODE_MODEL = CLAUDE_CODE_VARIANTS.sonnet;
+function stripModelNamespace2(model) {
+  const slashIndex = model.indexOf("/");
+  const id = slashIndex === -1 ? model : model.slice(slashIndex + 1);
+  return id.toLowerCase();
+}
+var CODEX_MODELS = [
+  "openai/gpt-5.4",
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.3-codex-spark",
+  "openai/gpt-5.2-codex",
+  "openai/gpt-5.2",
+  "openai/gpt-5.2-chat",
+  "openai/gpt-5.2-pro",
+  "openai/gpt-5.1",
+  "openai/gpt-5.1-codex-mini",
+  "anthropic/claude-opus-4.6"
+];
+var DEFAULT_CODEX_MODEL = CODEX_MODELS[0];
+var KIMI_MODELS = [
+  "novitaai/kimi-k2.5",
+  "novitaai/kimi-k2-thinking",
+  "novitaai/kimi-k2.5-fw"
+];
+var DEFAULT_KIMI_MODEL = KIMI_MODELS[0];
+var GOOSE_MODELS = FRONTIER_MODELS;
+var DEFAULT_GOOSE_MODEL = DEFAULT_FRONTIER_MODEL;
+
+// src/providers/goose.ts
+var CUSTOM_PROVIDER_ID = "custom_poe";
+var CUSTOM_PROVIDER_FILE = "~/.config/goose/custom_providers/custom_poe.json";
+var GOOSE_CONFIG_FILE = "~/.config/goose/config.yaml";
+var GOOSE_SECRETS_FILE = "~/.config/goose/secrets.yaml";
+var CUSTOM_PROVIDER_API_KEY_ENV = "CUSTOM_POE_API_KEY";
+var HEALTH_CHECK_PROMPT = "Reply with exactly: GOOSE_OK";
+var GOOSE_INSTALL_DEFINITION = {
+  id: "goose",
+  summary: "Goose CLI",
+  check: createBinaryExistsCheck(
+    "goose",
+    "goose-cli-binary",
+    "Goose CLI binary must exist"
+  ),
+  steps: [
+    {
+      id: "install-goose-cli-homebrew-or-script",
+      command: "sh",
+      args: [
+        "-c",
+        [
+          "if command -v brew >/dev/null 2>&1; then",
+          "  brew install block-goose-cli || curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | CONFIGURE=false bash;",
+          "else",
+          "  curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | CONFIGURE=false bash;",
+          "fi"
+        ].join(" ")
+      ],
+      platforms: ["darwin"]
+    },
+    {
+      id: "install-goose-cli-script-unix",
+      command: "sh",
+      args: [
+        "-c",
+        "curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | CONFIGURE=false bash"
+      ],
+      platforms: ["linux"]
+    },
+    {
+      id: "install-goose-cli-script-windows",
+      command: "powershell",
+      args: [
+        "-Command",
+        "irm https://github.com/block/goose/releases/download/stable/download_cli.ps1 | iex"
+      ],
+      platforms: ["win32"]
+    }
+  ],
+  successMessage: "Installed Goose CLI."
+};
+function buildCustomProvider(baseUrl, modelContextLimits = {}) {
+  return {
+    name: CUSTOM_PROVIDER_ID,
+    engine: "openai",
+    display_name: "Poe",
+    description: "Poe OpenAI-compatible API",
+    api_key_env: CUSTOM_PROVIDER_API_KEY_ENV,
+    base_url: `${baseUrl}/chat/completions`,
+    models: GOOSE_MODELS.map((name) => ({
+      name,
+      context_limit: resolveGooseModelContextLimit(name, modelContextLimits)
+    })),
+    supports_streaming: true,
+    requires_auth: true
+  };
+}
+function resolveGooseModelContextLimit(model, modelContextLimits) {
+  const stripped = stripModelNamespace2(model);
+  const dynamicValue = modelContextLimits[model] ?? modelContextLimits[stripped];
+  if (typeof dynamicValue === "number" && Number.isFinite(dynamicValue) && dynamicValue > 0) {
+    return dynamicValue;
+  }
+  throw new Error(`Missing Goose model context limit for ${model}.`);
+}
+function extractGooseModelContextLimits(response) {
+  const entries = Array.isArray(response.data) ? response.data : [];
+  const wanted = new Map(GOOSE_MODELS.map((model) => [stripModelNamespace2(model), model]));
+  const limits = {};
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const rawId = entry.id;
+    const resolvedModel = typeof rawId === "string" ? wanted.get(rawId) : void 0;
+    if (!resolvedModel) {
+      continue;
+    }
+    const rawContextLength = entry.context_window?.context_length;
+    if (typeof rawContextLength !== "number" || !Number.isFinite(rawContextLength) || rawContextLength <= 0) {
+      continue;
+    }
+    limits[resolvedModel] = rawContextLength;
+  }
+  return limits;
+}
+async function fetchGooseModelContextLimits(input) {
+  const response = await input.httpClient(`${input.apiBaseUrl}/models`, {
+    headers: {
+      Authorization: `Bearer ${input.apiKey}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch Poe model catalog for Goose configuration (status ${response.status}).`
+    );
+  }
+  const modelContextLimits = extractGooseModelContextLimits(
+    await response.json()
+  );
+  const missing = GOOSE_MODELS.filter((model) => modelContextLimits[model] == null);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing Goose model context limit for ${missing[0]}.`
+    );
+  }
+  return modelContextLimits;
+}
+var GOOSE_MODE_ENV = {
+  yolo: "auto",
+  edit: "smart_approve",
+  read: "chat"
+};
+function buildRunOptions(options, model) {
+  const baseArgs = [
+    "run",
+    "--provider",
+    CUSTOM_PROVIDER_ID,
+    "--model",
+    model,
+    "--output-format",
+    "text"
+  ];
+  const mcpArgs = options.mcpServers ? serializeGooseMcpArgs(options.mcpServers) : [];
+  const modeEnv = options.mode && GOOSE_MODE_ENV[options.mode] ? { GOOSE_MODE: GOOSE_MODE_ENV[options.mode] } : void 0;
+  if (options.useStdin) {
+    return {
+      args: [...baseArgs, ...mcpArgs, "--instructions", "-", ...options.args ?? []],
+      commandOptions: {
+        ...options.cwd ? { cwd: options.cwd } : {},
+        ...modeEnv ? { env: modeEnv } : {},
+        stdin: options.prompt
+      }
+    };
+  }
+  return {
+    args: [...baseArgs, ...mcpArgs, "--text", options.prompt, ...options.args ?? []],
+    commandOptions: options.cwd || modeEnv ? { ...options.cwd ? { cwd: options.cwd } : {}, ...modeEnv ? { env: modeEnv } : {} } : void 0
+  };
+}
+var gooseService = createProvider({
+  ...gooseAgent,
+  supportsStdinPrompt: true,
+  supportsMcpSpawn: true,
+  configurePrompts: {
+    model: {
+      label: "Goose default model",
+      defaultValue: DEFAULT_GOOSE_MODEL,
+      choices: GOOSE_MODELS.map((id) => ({
+        title: id,
+        value: id
+      }))
+    }
+  },
+  async extendConfigurePayload(context) {
+    const { apiKey } = context.payload;
+    const modelContextLimits = await fetchGooseModelContextLimits({
+      apiBaseUrl: context.env.poeApiBaseUrl,
+      apiKey,
+      httpClient: context.httpClient
+    });
+    return {
+      modelContextLimits
+    };
+  },
+  isolatedEnv: {
+    agentBinary: gooseAgent.binaryName,
+    configProbe: { kind: "isolatedFile", relativePath: ".config/goose/config.yaml" },
+    env: {
+      HOME: { kind: "isolatedDir", relativePath: "" },
+      XDG_CONFIG_HOME: { kind: "isolatedDir", relativePath: ".config" }
+    }
+  },
+  manifest: {
+    configure: [
+      fileMutation.ensureDirectory({ path: "~/.config/goose/custom_providers" }),
+      configMutation.merge({
+        target: CUSTOM_PROVIDER_FILE,
+        value: (ctx) => {
+          const { env, modelContextLimits } = ctx ?? {};
+          return buildCustomProvider(env.poeApiBaseUrl, modelContextLimits);
+        }
+      }),
+      configMutation.merge({
+        target: GOOSE_CONFIG_FILE,
+        format: "yaml",
+        value: (ctx) => {
+          const { model } = ctx ?? {};
+          return {
+            GOOSE_PROVIDER: CUSTOM_PROVIDER_ID,
+            GOOSE_MODEL: model ?? DEFAULT_GOOSE_MODEL,
+            GOOSE_DISABLE_KEYRING: true
+          };
+        }
+      }),
+      configMutation.merge({
+        target: GOOSE_SECRETS_FILE,
+        format: "yaml",
+        value: (ctx) => {
+          const { apiKey } = ctx ?? {};
+          return {
+            [CUSTOM_PROVIDER_API_KEY_ENV]: apiKey
+          };
+        }
+      })
+    ],
+    unconfigure: [
+      fileMutation.remove({ target: CUSTOM_PROVIDER_FILE }),
+      configMutation.prune({
+        target: GOOSE_CONFIG_FILE,
+        format: "yaml",
+        onlyIf: (document) => document.GOOSE_PROVIDER === CUSTOM_PROVIDER_ID,
+        shape: {
+          GOOSE_PROVIDER: true,
+          GOOSE_MODEL: true,
+          GOOSE_DISABLE_KEYRING: true
+        }
+      }),
+      configMutation.prune({
+        target: GOOSE_SECRETS_FILE,
+        format: "yaml",
+        shape: {
+          [CUSTOM_PROVIDER_API_KEY_ENV]: true
+        }
+      })
+    ]
+  },
+  install: GOOSE_INSTALL_DEFINITION,
+  test(context) {
+    return context.runCheck(
+      createCommandExpectationCheck({
+        id: "goose-cli-health",
+        command: "goose",
+        args: ["run", "--text", HEALTH_CHECK_PROMPT, "--output-format", "text"],
+        expectedOutput: "GOOSE_OK"
+      })
+    );
+  },
+  spawn(context, options) {
+    const model = options.model ?? DEFAULT_GOOSE_MODEL;
+    const { args, commandOptions } = buildRunOptions(options, model);
+    return commandOptions ? context.command.runCommand("goose", args, commandOptions) : context.command.runCommand("goose", args);
+  }
+});
+var provider = gooseService;
+export {
+  GOOSE_INSTALL_DEFINITION,
+  gooseService,
+  provider
+};
+//# sourceMappingURL=goose.js.map