poe-code 3.0.59 → 3.0.61

package/dist/providers/kimi.js

@@ -1,121 +1,1894 @@
-import { createBinaryExistsCheck, createSpawnHealthCheck } from "../utils/command-checks.js";
-import { configMutation, fileMutation } from "@poe-code/config-mutations";
-import { KIMI_MODELS, DEFAULT_KIMI_MODEL, PROVIDER_NAME, stripModelNamespace } from "../cli/constants.js";
-import { createProvider } from "./create-provider.js";
-import { kimiAgent } from "@poe-code/agent-defs";
-export const KIMI_INSTALL_DEFINITION = {
-    id: "kimi",
-    summary: "Kimi CLI",
-    check: createBinaryExistsCheck("kimi", "kimi-cli-binary", "Kimi CLI binary must exist"),
-    steps: [
+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
+));
+
+// src/templates/python/env.hbs
+var require_env = __commonJS({
+  "src/templates/python/env.hbs"(exports, module) {
+    module.exports = "POE_API_KEY={{apiKey}}\nPOE_BASE_URL=https://api.poe.com/v1\nMODEL={{model}}\n";
+  }
+});
+
+// src/templates/python/main.py.hbs
+var require_main_py = __commonJS({
+  "src/templates/python/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/python/requirements.txt.hbs
+var require_requirements_txt = __commonJS({
+  "src/templates/python/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"\nmodel = "{{{model}}}"\nmodel_reasoning_effort = "{{reasoningEffort}}"\n\n[model_providers.poe]\nname = "poe"\nbase_url = "{{{baseUrl}}}"\nwire_api = "responses"\nexperimental_bearer_token = "{{apiKey}}"\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/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent
+];
+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);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup.get(input.toLowerCase());
+}
+
+// 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"
+  ],
+  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"],
+  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]
+};
+
+// 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"],
+  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]
+};
+
+// packages/agent-spawn/src/configs/index.ts
+var allSpawnConfigs = [
+  claudeCodeSpawnConfig,
+  codexSpawnConfig,
+  openCodeSpawnConfig,
+  kimiSpawnConfig
+];
+var lookup2 = /* @__PURE__ */ new Map();
+for (const config of allSpawnConfigs) {
+  lookup2.set(config.agentId, config);
+}
+function getSpawnConfig(input) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return void 0;
+  }
+  return lookup2.get(resolvedId);
+}
+
+// packages/agent-spawn/src/spawn.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+
+// packages/agent-spawn/src/configs/resolve-config.ts
+function resolveConfig(agentId) {
+  const resolvedAgentId = resolveAgentId(agentId);
+  if (!resolvedAgentId) {
+    throw new Error(`Unknown agent "${agentId}".`);
+  }
+  const agentDefinition = allAgents.find((agent) => agent.id === resolvedAgentId);
+  if (!agentDefinition) {
+    throw new Error(`Unknown agent "${agentId}".`);
+  }
+  const spawnConfig = getSpawnConfig(resolvedAgentId);
+  const binaryName = agentDefinition.binaryName;
+  return { agentId: resolvedAgentId, binaryName, spawnConfig };
+}
+
+// packages/agent-spawn/src/model-utils.ts
+function stripModelNamespace(model) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex === -1 ? model : model.slice(slashIndex + 1);
+}
+
+// packages/agent-spawn/src/spawn.ts
+function resolveCliConfig(agentId) {
+  const resolved = resolveConfig(agentId);
+  if (!resolved.spawnConfig) {
+    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
+  }
+  if (resolved.spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  }
+  if (!resolved.binaryName) {
+    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
+  }
+  return {
+    agentId: resolved.agentId,
+    binaryName: resolved.binaryName,
+    spawnConfig: resolved.spawnConfig
+  };
+}
+function buildCliArgs(config, options, stdinMode) {
+  const args = stdinMode ? [
+    config.promptFlag,
+    ...stdinMode.omitPrompt ? [] : [options.prompt],
+    ...stdinMode.extraArgs
+  ] : [config.promptFlag, options.prompt];
+  if (options.model && config.modelFlag) {
+    let model = config.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
+    if (config.modelTransform) model = config.modelTransform(model);
+    args.push(config.modelFlag, model);
+  }
+  args.push(...config.defaultArgs);
+  args.push(...config.modes[options.mode ?? "yolo"]);
+  if (options.args && options.args.length > 0) {
+    args.push(...options.args);
+  }
+  return args;
+}
+function buildSpawnArgs(agentId, options) {
+  const { binaryName, spawnConfig } = resolveCliConfig(agentId);
+  const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
+  return { binaryName, args: buildCliArgs(spawnConfig, options, stdinMode) };
+}
+
+// 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/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?.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() {
+    return chalk4.magenta("\u25CF");
+  },
+  get success() {
+    return chalk4.magenta("\u25C6");
+  },
+  get resolved() {
+    const theme = getTheme();
+    return theme.resolvedSymbol;
+  },
+  get errorResolved() {
+    const theme = getTheme();
+    return theme.errorSymbol;
+  },
+  bar: "\u2502",
+  cornerTopRight: "\u256E",
+  cornerBottomRight: "\u256F",
+  warning: "\u25B2",
+  active: "\u25C6",
+  inactive: "\u25CB"
+};
+
+// packages/design-system/src/components/logger.ts
+import { log } from "@clack/prompts";
+import chalk5 from "chalk";
+
+// packages/design-system/src/internal/output-format.ts
+var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
+var cached;
+function resolveOutputFormat(env = process.env) {
+  if (cached) {
+    return cached;
+  }
+  const raw = env.OUTPUT_FORMAT?.toLowerCase();
+  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
+  return cached;
+}
+
+// packages/design-system/src/components/logger.ts
+function createLogger(emitter) {
+  const emit = (level, message) => {
+    if (emitter) {
+      emitter(message);
+      return;
+    }
+    if (resolveOutputFormat() !== "terminal") {
+      process.stdout.write(message + "\n");
+      return;
+    }
+    if (level === "success") {
+      log.message(message, { symbol: symbols.success });
+      return;
+    }
+    if (level === "warn") {
+      log.warn(message);
+      return;
+    }
+    if (level === "error") {
+      log.error(message);
+      return;
+    }
+    log.message(message, { symbol: symbols.info });
+  };
+  return {
+    info(message) {
+      emit("info", message);
+    },
+    success(message) {
+      emit("success", message);
+    },
+    warn(message) {
+      emit("warn", message);
+    },
+    error(message) {
+      emit("error", message);
+    },
+    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(message, symbol) {
+      if (emitter) {
+        emitter(message);
+        return;
+      }
+      log.message(message, { symbol: symbol ?? chalk5.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 chalk6 from "chalk";
+var AGENT_PREFIX = `${chalk6.green.bold("\u2713")} agent: `;
+
+// packages/design-system/src/prompts/index.ts
+import * as clack from "@clack/prompts";
+import { isCancel, cancel, log as log2 } from "@clack/prompts";
+
+// packages/design-system/src/static/spinner.ts
+import chalk7 from "chalk";
+
+// packages/design-system/src/static/menu.ts
+import chalk8 from "chalk";
+
+// packages/agent-spawn/src/acp/spawn.ts
+import { spawn as spawnChildProcess3 } from "node:child_process";
+
+// 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 createSpawnHealthCheck(agentId, options) {
+  const prompt = `Output exactly: ${options.expectedOutput}`;
+  const { binaryName, args } = buildSpawnArgs(agentId, {
+    prompt,
+    model: options.model,
+    mode: "yolo"
+  });
+  return {
+    id: `${agentId}-cli-health`,
+    description: `spawn ${agentId} (expecting "${options.expectedOutput}")`,
+    async run(context) {
+      if (context.isDryRun) {
+        context.logDryRun?.(
+          `Dry run: ${[binaryName, ...args].join(" ")} (expecting "${options.expectedOutput}")`
+        );
+        return;
+      }
+      const result = await context.runCommand(binaryName, args);
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `spawn ${agentId} failed with exit code ${result.exitCode}.
+${formatCommandRunnerResult(result)}`
+        );
+      }
+      if (!result.stdout.includes(options.expectedOutput)) {
+        throw new Error(
+          `spawn ${agentId}: expected "${options.expectedOutput}" in stdout.
+${formatCommandRunnerResult(result)}`
+        );
+      }
+    }
+  };
+}
+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 = [
         {
-            id: "install-kimi-cli-uv",
-            command: "uv",
-            args: ["tool", "install", "--python", "3.13", "kimi-cli"]
+          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
         }
-    ],
-    successMessage: "Installed Kimi CLI via uv."
+      ];
+      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
 };
-function providerModel(model) {
-    const stripped = stripModelNamespace(model);
-    return `${PROVIDER_NAME}/${stripped}`;
+
+// packages/config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
 }
-function buildKimiArgs(prompt, extraArgs) {
-    return ["--quiet", "-p", prompt, ...(extraArgs ?? [])];
-}
-export const kimiService = createProvider({
-    ...kimiAgent,
-    disabled: false,
-    supportsStdinPrompt: false,
-    configurePrompts: {
-        model: {
-            label: "Kimi default model",
-            defaultValue: DEFAULT_KIMI_MODEL,
-            choices: KIMI_MODELS.map((id) => ({
-                title: id,
-                value: id
-            }))
-        }
+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 parse2(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: parse2,
+  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 parse3(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: parse3,
+  serialize: serialize2,
+  merge: merge3,
+  prune: prune3
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml"
+};
+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(path2) {
+  const ext = getExtension(path2);
+  return extensionMap[ext];
+}
+function getExtension(path2) {
+  const lastDot = path2.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path2.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path 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 : path.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 = path.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readFileIfExists(fs, target) {
+  try {
+    return await fs.readFile(target, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+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 isConfigObject3(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 (isConfigObject3(current) && isConfigObject3(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"
     },
-    isolatedEnv: {
-        // Use "kimi-cli" to avoid stripAgentHome stripping ".kimi" from paths
-        agentBinary: "kimi-cli",
-        configProbe: { kind: "isolatedFile", relativePath: ".kimi/config.toml" },
-        env: {
-            HOME: { kind: "isolatedDir" }
-        }
+    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 (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+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 (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+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"
     },
-    test(context) {
-        return context.runCheck(createSpawnHealthCheck("kimi", {
-            model: context.model,
-            expectedOutput: "KIMI_OK"
-        }));
+    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 (error) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
+      { cause: error }
+    );
+  }
+  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"
     },
-    manifest: {
-        configure: [
-            fileMutation.ensureDirectory({ path: "~/.kimi" }),
-            configMutation.merge({
-                target: "~/.kimi/config.toml",
-                pruneByPrefix: { models: `${PROVIDER_NAME}/` },
-                value: (ctx) => {
-                    const { model, apiKey, env } = (ctx ?? {});
-                    const selectedModel = model ?? DEFAULT_KIMI_MODEL;
-                    const models = {};
-                    for (const m of KIMI_MODELS) {
-                        models[providerModel(m)] = {
-                            provider: PROVIDER_NAME,
-                            model: stripModelNamespace(m),
-                            max_context_size: 256000
-                        };
-                    }
-                    return {
-                        default_model: providerModel(selectedModel),
-                        default_thinking: true,
-                        models,
-                        providers: {
-                            [PROVIDER_NAME]: {
-                                type: "openai_legacy",
-                                base_url: env.poeApiBaseUrl,
-                                api_key: apiKey ?? ""
-                            }
-                        }
-                    };
-                }
-            })
-        ],
-        unconfigure: [
-            configMutation.transform({
-                target: "~/.kimi/config.toml",
-                transform: (document) => {
-                    const providers = document.providers;
-                    if (!providers || typeof providers !== "object") {
-                        return { changed: false, content: document };
-                    }
-                    if (!(PROVIDER_NAME in providers)) {
-                        return { changed: false, content: document };
-                    }
-                    const { [PROVIDER_NAME]: ignoredProvider, ...rest } = providers;
-                    void ignoredProvider;
-                    const updatedProviders = rest;
-                    if (Object.keys(updatedProviders).length === 0) {
-                        const { providers: ignoredProviders, ...docWithoutProviders } = document;
-                        void ignoredProviders;
-                        return { changed: true, content: docWithoutProviders };
-                    }
-                    return { changed: true, content: { ...document, providers: updatedProviders } };
-                }
-            })
-        ]
+    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 (error) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error
+    );
+    throw error;
+  }
+}
+
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// src/cli/constants.ts
+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.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"
+];
+var DEFAULT_CODEX_MODEL = CODEX_MODELS[0];
+var KIMI_MODELS = [
+  "novitaai/kimi-k2.5",
+  "novitaai/kimi-k2-thinking"
+];
+var DEFAULT_KIMI_MODEL = KIMI_MODELS[0];
+var PROVIDER_NAME = "poe";
+
+// 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 (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    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(quoteIfNeeded)].join(" ");
+}
+function quoteIfNeeded(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 = {
+  "python/env.hbs": () => Promise.resolve().then(() => __toESM(require_env(), 1)),
+  "python/main.py.hbs": () => Promise.resolve().then(() => __toESM(require_main_py(), 1)),
+  "python/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,
+    configurePrompts: opts.configurePrompts,
+    postConfigureMessages: opts.postConfigureMessages,
+    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 });
     },
-    install: KIMI_INSTALL_DEFINITION,
-    spawn(context, options) {
-        const args = buildKimiArgs(options.prompt, options.args);
-        if (options.cwd) {
-            return context.command.runCommand("kimi", args, {
-                cwd: options.cwd
-            });
+    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: (message) => context.logger.verbose(message),
+      platform: context.env.platform
+    });
+  };
+}
+
+// src/providers/kimi.ts
+var KIMI_INSTALL_DEFINITION = {
+  id: "kimi",
+  summary: "Kimi CLI",
+  check: createBinaryExistsCheck(
+    "kimi",
+    "kimi-cli-binary",
+    "Kimi CLI binary must exist"
+  ),
+  steps: [
+    {
+      id: "install-kimi-cli-uv",
+      command: "uv",
+      args: ["tool", "install", "--python", "3.13", "kimi-cli"]
+    }
+  ],
+  successMessage: "Installed Kimi CLI via uv."
+};
+function providerModel(model) {
+  const stripped = stripModelNamespace2(model);
+  return `${PROVIDER_NAME}/${stripped}`;
+}
+function buildKimiArgs(prompt, extraArgs) {
+  return ["--quiet", "-p", prompt, ...extraArgs ?? []];
+}
+var kimiService = createProvider({
+  ...kimiAgent,
+  disabled: false,
+  supportsStdinPrompt: false,
+  configurePrompts: {
+    model: {
+      label: "Kimi default model",
+      defaultValue: DEFAULT_KIMI_MODEL,
+      choices: KIMI_MODELS.map((id) => ({
+        title: id,
+        value: id
+      }))
+    }
+  },
+  isolatedEnv: {
+    // Use "kimi-cli" to avoid stripAgentHome stripping ".kimi" from paths
+    agentBinary: "kimi-cli",
+    configProbe: { kind: "isolatedFile", relativePath: ".kimi/config.toml" },
+    env: {
+      HOME: { kind: "isolatedDir" }
+    }
+  },
+  test(context) {
+    return context.runCheck(
+      createSpawnHealthCheck("kimi", {
+        model: context.model,
+        expectedOutput: "KIMI_OK"
+      })
+    );
+  },
+  manifest: {
+    configure: [
+      fileMutation.ensureDirectory({ path: "~/.kimi" }),
+      configMutation.merge({
+        target: "~/.kimi/config.toml",
+        pruneByPrefix: { models: `${PROVIDER_NAME}/` },
+        value: (ctx) => {
+          const { model, apiKey, env } = ctx ?? {};
+          const selectedModel = model ?? DEFAULT_KIMI_MODEL;
+          const models = {};
+          for (const m of KIMI_MODELS) {
+            models[providerModel(m)] = {
+              provider: PROVIDER_NAME,
+              model: stripModelNamespace2(m),
+              max_context_size: 256e3
+            };
+          }
+          return {
+            default_model: providerModel(selectedModel),
+            default_thinking: true,
+            models,
+            providers: {
+              [PROVIDER_NAME]: {
+                type: "openai_legacy",
+                base_url: env.poeApiBaseUrl,
+                api_key: apiKey ?? ""
+              }
+            }
+          };
         }
-        return context.command.runCommand("kimi", args);
+      })
+    ],
+    unconfigure: [
+      configMutation.transform({
+        target: "~/.kimi/config.toml",
+        transform: (document) => {
+          const providers = document.providers;
+          if (!providers || typeof providers !== "object") {
+            return { changed: false, content: document };
+          }
+          if (!(PROVIDER_NAME in providers)) {
+            return { changed: false, content: document };
+          }
+          const { [PROVIDER_NAME]: ignoredProvider, ...rest } = providers;
+          void ignoredProvider;
+          const updatedProviders = rest;
+          if (Object.keys(updatedProviders).length === 0) {
+            const { providers: ignoredProviders, ...docWithoutProviders } = document;
+            void ignoredProviders;
+            return { changed: true, content: docWithoutProviders };
+          }
+          return { changed: true, content: { ...document, providers: updatedProviders } };
+        }
+      })
+    ]
+  },
+  install: KIMI_INSTALL_DEFINITION,
+  spawn(context, options) {
+    const args = buildKimiArgs(options.prompt, options.args);
+    if (options.cwd) {
+      return context.command.runCommand("kimi", args, {
+        cwd: options.cwd
+      });
     }
+    return context.command.runCommand("kimi", args);
+  }
 });
-//# sourceMappingURL=kimi.js.map
+var provider = kimiService;
+export {
+  KIMI_INSTALL_DEFINITION,
+  kimiService,
+  provider
+};
+//# sourceMappingURL=kimi.js.map