poe-code 3.0.391 → 3.0.393

package/dist/skills.js

@@ -1,59 +1,2880 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { installSkill as installAgentSkill } from "@poe-code/agent-skill-config";
-function createNodeFileSystem() {
+// src/skills.ts
+import * as fs4 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path8 from "node:path";
+
+// packages/agent-skill-config/src/configs.ts
+import os from "node:os";
+import path from "node:path";
+
+// 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",
+  apiShapes: ["anthropic-messages"],
+  otelCapture: {
+    env: {
+      CLAUDE_CODE_ENABLE_TELEMETRY: "1"
+    }
+  },
+  configPath: "~/.claude.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: "~/.config/Claude/claude_desktop_config.json",
+  configPaths: {
+    darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+    linux: "~/.config/Claude/claude_desktop_config.json",
+    win32: "~/AppData/Roaming/Claude/claude_desktop_config.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",
+  apiShapes: ["openai-responses"],
+  otelCapture: {
+    args: (endpoint, content) => [
+      "-c",
+      `otel.trace_exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/traces`)},protocol="json"}}`,
+      "-c",
+      `otel.exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/logs`)},protocol="json"}}`,
+      "-c",
+      `otel.log_user_prompt=${content}`
+    ]
+  },
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/cursor.ts
+var cursorAgent = {
+  id: "cursor",
+  name: "cursor",
+  aliases: ["cursor-agent"],
+  label: "Cursor",
+  summary: "Cursor's CLI coding agent.",
+  binaryName: "cursor-agent",
+  configPath: "~/.cursor/mcp.json",
+  branding: {
+    colors: {
+      dark: "#FFFFFF",
+      light: "#000000"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/gemini-cli.ts
+var geminiCliAgent = {
+  id: "gemini-cli",
+  name: "gemini-cli",
+  aliases: ["gemini"],
+  label: "Gemini CLI",
+  summary: "Configure Google's Gemini CLI to use a compatible Google generations API.",
+  binaryName: "gemini",
+  configPath: "~/.gemini/settings.json",
+  apiShapes: ["google-generations"],
+  branding: {
+    colors: {
+      dark: "#8AB4F8",
+      light: "#1A73E8"
+    }
+  }
+};
+
+// 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",
+  apiShapes: ["openai-chat-completions"],
+  otelCapture: {
+    env: {
+      OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
+    }
+  },
+  configPath: "~/.config/opencode/opencode.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",
+  apiShapes: ["openai-chat-completions"],
+  configPath: "~/.kimi/mcp.json",
+  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",
+  apiShapes: ["openai-chat-completions"],
+  otelCapture: {},
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/poe-agent.ts
+var poeAgentAgent = {
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  apiShapes: ["openai-responses", "openai-chat-completions"],
+  configPath: "~/.poe-code/config.json",
+  branding: {
+    colors: {
+      dark: "#A465F7",
+      light: "#7A3FD3"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+function freezeAgent(agent) {
+  if (agent.aliases !== void 0) {
+    Object.freeze(agent.aliases);
+  }
+  if (agent.apiShapes !== void 0) {
+    Object.freeze(agent.apiShapes);
+  }
+  if (agent.otelCapture?.env !== void 0) {
+    Object.freeze(agent.otelCapture.env);
+  }
+  if (agent.otelCapture !== void 0) {
+    Object.freeze(agent.otelCapture);
+  }
+  Object.freeze(agent.branding.colors);
+  Object.freeze(agent.branding);
+  return Object.freeze(agent);
+}
+var allAgents = Object.freeze([
+  freezeAgent(claudeCodeAgent),
+  freezeAgent(claudeDesktopAgent),
+  freezeAgent(codexAgent),
+  freezeAgent(cursorAgent),
+  freezeAgent(geminiCliAgent),
+  freezeAgent(openCodeAgent),
+  freezeAgent(kimiAgent),
+  freezeAgent(gooseAgent),
+  freezeAgent(poeAgentAgent)
+]);
+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.trim().toLowerCase());
+}
+
+// packages/agent-skill-config/src/configs.ts
+var agentSkillConfigs = {
+  "claude-code": {
+    globalSkillDir: "~/.claude/skills",
+    localSkillDir: ".claude/skills"
+  },
+  codex: {
+    globalSkillDir: "~/.codex/skills",
+    localSkillDir: ".codex/skills"
+  },
+  cursor: {
+    globalSkillDir: "~/.cursor/skills-cursor",
+    localSkillDir: ".cursor/skills"
+  },
+  "gemini-cli": {
+    globalSkillDir: "~/.gemini/skills",
+    localSkillDir: ".gemini/skills"
+  },
+  opencode: {
+    globalSkillDir: "~/.config/opencode/skills",
+    localSkillDir: ".opencode/skills"
+  },
+  goose: {
+    globalSkillDir: "~/.agents/skills",
+    localSkillDir: ".agents/skills"
+  }
+};
+var supportedAgents = Object.freeze(Object.keys(agentSkillConfigs));
+function resolveAgentSupport(input, registry = agentSkillConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config2 = registry[resolvedId];
+  if (!config2) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config: { ...config2 } };
+}
+
+// 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,
+    once: options.once,
+    label: options.label
+  };
+}
+function restoreBackup(options) {
+  return {
+    kind: "restoreBackup",
+    target: options.target,
+    label: options.label
+  };
+}
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup,
+  restoreBackup
+};
+
+// packages/config-mutations/src/mutations/template-mutation.ts
+function write(options) {
+  return {
+    kind: "templateWrite",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeToml(options) {
+  return {
+    kind: "templateMergeToml",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeJson(options) {
+  return {
+    kind: "templateMergeJson",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+var templateMutation = {
+  write,
+  mergeToml,
+  mergeJson
+};
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+import { randomUUID } from "node:crypto";
+import path3 from "node:path";
+
+// packages/toolcraft-design/src/internal/color-support.ts
+function supportsColor(env = process.env, stream = process.stdout) {
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  if (env.NO_COLOR !== void 0) {
+    return false;
+  }
+  if (stream.isTTY !== true) {
+    return false;
+  }
+  return typeof env.TERM === "string" && env.TERM.length > 0 && env.TERM !== "dumb";
+}
+
+// packages/toolcraft-design/src/components/color.ts
+var reset = "\x1B[0m";
+var ansiStyles = {
+  reset: { open: reset },
+  bold: { open: "\x1B[1m" },
+  dim: { open: "\x1B[2m" },
+  italic: { open: "\x1B[3m" },
+  underline: { open: "\x1B[4m" },
+  inverse: { open: "\x1B[7m" },
+  strikethrough: { open: "\x1B[9m" },
+  black: { open: "\x1B[30m" },
+  red: { open: "\x1B[31m" },
+  green: { open: "\x1B[32m" },
+  yellow: { open: "\x1B[33m" },
+  blue: { open: "\x1B[34m" },
+  magenta: { open: "\x1B[35m" },
+  cyan: { open: "\x1B[36m" },
+  white: { open: "\x1B[37m" },
+  gray: { open: "\x1B[90m" },
+  magentaBright: { open: "\x1B[95m" },
+  cyanBright: { open: "\x1B[96m" },
+  bgRed: { open: "\x1B[41m" },
+  bgGreen: { open: "\x1B[42m" },
+  bgYellow: { open: "\x1B[43m" },
+  bgBlue: { open: "\x1B[44m" },
+  bgMagenta: { open: "\x1B[45m" }
+};
+var styleNames = Object.keys(ansiStyles);
+function replaceAll(value, search, replacement) {
+  return value.split(search).join(replacement);
+}
+function applyStyles(text3, styles) {
+  if (!supportsColor() || styles.length === 0) {
+    return text3;
+  }
+  const open = styles.map((style) => style.open).join("");
+  const output = text3.includes(reset) ? replaceAll(text3, reset, `${reset}${open}`) : text3;
+  return `${open}${output}${reset}`;
+}
+function clampRgb(value) {
+  if (Number.isNaN(value)) {
+    return 0;
+  }
+  return Math.min(255, Math.max(0, Math.round(value)));
+}
+function hexChannel(value, offset) {
+  return Number.parseInt(value.slice(offset, offset + 2), 16);
+}
+function normalizeHex(value) {
+  const normalized = value.startsWith("#") ? value.slice(1) : value;
+  if (normalized.length !== 3 && normalized.length !== 6 || Array.from(normalized).some((char) => !"0123456789abcdefABCDEF".includes(char))) {
+    throw new Error(`Invalid hexadecimal color: ${value}`);
+  }
+  if (normalized.length === 3) {
+    const red = normalized[0];
+    const green = normalized[1];
+    const blue = normalized[2];
+    return [
+      Number.parseInt(`${red}${red}`, 16),
+      Number.parseInt(`${green}${green}`, 16),
+      Number.parseInt(`${blue}${blue}`, 16)
+    ];
+  }
+  return [
+    hexChannel(normalized, 0),
+    hexChannel(normalized, 2),
+    hexChannel(normalized, 4)
+  ];
+}
+function rgbStyle(red, green, blue) {
+  return {
+    open: `\x1B[38;2;${clampRgb(red)};${clampRgb(green)};${clampRgb(blue)}m`
+  };
+}
+function bgRgbStyle(red, green, blue) {
+  return {
+    open: `\x1B[48;2;${clampRgb(red)};${clampRgb(green)};${clampRgb(blue)}m`
+  };
+}
+function createColor(styles = []) {
+  const builder = ((text3) => applyStyles(String(text3), styles));
+  for (const name of styleNames) {
+    Object.defineProperty(builder, name, {
+      configurable: true,
+      enumerable: true,
+      get: () => createColor([...styles, ansiStyles[name]])
+    });
+  }
+  builder.hex = (value) => {
+    const [red, green, blue] = normalizeHex(value);
+    return createColor([...styles, rgbStyle(red, green, blue)]);
+  };
+  builder.rgb = (red, green, blue) => createColor([...styles, rgbStyle(red, green, blue)]);
+  builder.bgHex = (value) => {
+    const [red, green, blue] = normalizeHex(value);
+    return createColor([...styles, bgRgbStyle(red, green, blue)]);
+  };
+  builder.bgRgb = (red, green, blue) => createColor([...styles, bgRgbStyle(red, green, blue)]);
+  return builder;
+}
+var color = createColor();
+
+// packages/toolcraft-design/src/tokens/brand.ts
+var brands = {
+  purple: { name: "purple", primary: "#a200ff" },
+  blue: { name: "blue", primary: "#2f6fed" },
+  green: { name: "green", primary: "#1f9d57" }
+};
+
+// packages/toolcraft-design/src/internal/theme-state.ts
+var defaults = {
+  brand: "purple",
+  label: "Poe"
+};
+var config = { ...defaults };
+var revision = 0;
+var brandConfigured = false;
+function getThemeConfig() {
+  return { ...config };
+}
+function getThemeRevision() {
+  return revision;
+}
+function isThemeBrandConfigured() {
+  return brandConfigured;
+}
+
+// packages/toolcraft-design/src/tokens/colors.ts
+var brand = brands.purple.primary;
+function withStyles(palette, styles) {
+  return Object.defineProperty(palette, "styles", {
+    value: styles,
+    enumerable: false
+  });
+}
+function brandColor(activeBrand, purple) {
+  return activeBrand.name === "purple" ? purple : color.hex(activeBrand.primary);
+}
+function brandBackground(activeBrand, purple) {
+  return activeBrand.name === "purple" ? purple : color.bgHex(activeBrand.primary);
+}
+function createPalette(activeBrand, mode) {
+  const isPurple = activeBrand.name === "purple";
+  if (mode === "light") {
+    const active2 = color.hex(activeBrand.primary);
+    const prompt2 = isPurple ? color.hex("#006699") : active2;
+    const number2 = isPurple ? color.hex("#0077cc") : active2;
+    return withStyles(
+      {
+        header: (text3) => active2.bold(text3),
+        divider: (text3) => color.hex("#666666")(text3),
+        prompt: (text3) => prompt2.bold(text3),
+        number: (text3) => number2.bold(text3),
+        intro: (text3) => color.bgHex(activeBrand.primary).white(` ${getThemeConfig().label} - ${text3} `),
+        get resolvedSymbol() {
+          return active2("\u25C7");
+        },
+        get errorSymbol() {
+          return color.hex("#cc0000")("\u25A0");
+        },
+        accent: (text3) => prompt2.bold(text3),
+        muted: (text3) => color.hex("#666666")(text3),
+        success: (text3) => color.hex("#008800")(text3),
+        warning: (text3) => color.hex("#cc6600")(text3),
+        error: (text3) => color.hex("#cc0000")(text3),
+        info: (text3) => active2(text3),
+        badge: (text3) => color.bgHex("#cc6600").white(` ${text3} `)
+      },
+      {
+        accent: { fg: isPurple ? "#006699" : activeBrand.primary, bold: true },
+        muted: { fg: "#666666" },
+        success: { fg: "#008800" },
+        warning: { fg: "#cc6600" },
+        error: { fg: "#cc0000" },
+        info: { fg: activeBrand.primary }
+      }
+    );
+  }
+  const active = brandColor(activeBrand, color.magenta);
+  const activeBright = brandColor(activeBrand, color.magentaBright);
+  const activeBackground = brandBackground(activeBrand, color.bgMagenta);
+  const prompt = isPurple ? color.cyan : active;
+  const number = isPurple ? color.cyanBright : active;
+  return withStyles(
+    {
+      header: (text3) => activeBright.bold(text3),
+      divider: (text3) => color.dim(text3),
+      prompt: (text3) => prompt(text3),
+      number: (text3) => number(text3),
+      intro: (text3) => activeBackground.white(` ${getThemeConfig().label} - ${text3} `),
+      get resolvedSymbol() {
+        return active("\u25C7");
+      },
+      get errorSymbol() {
+        return color.red("\u25A0");
+      },
+      accent: (text3) => prompt(text3),
+      muted: (text3) => color.dim(text3),
+      success: (text3) => color.green(text3),
+      warning: (text3) => color.yellow(text3),
+      error: (text3) => color.red(text3),
+      info: (text3) => active(text3),
+      badge: (text3) => color.bgYellow.black(` ${text3} `)
+    },
+    {
+      accent: { fg: isPurple ? "cyan" : activeBrand.primary, bold: true },
+      muted: { dim: true },
+      success: { fg: "green" },
+      warning: { fg: "yellow" },
+      error: { fg: "red" },
+      info: { fg: isPurple ? "magenta" : activeBrand.primary }
+    }
+  );
+}
+var dark = createPalette(brands.purple, "dark");
+var light = createPalette(brands.purple, "light");
+
+// packages/toolcraft-design/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/toolcraft-design/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 themeCache = /* @__PURE__ */ new Map();
+var cachedRevision = -1;
+function getTheme(env) {
+  const themeName = resolveThemeName(env);
+  const config2 = getThemeConfig();
+  const requestedBrand = env?.POE_BRAND?.toLowerCase();
+  const activeBrandName = !isThemeBrandConfigured() && requestedBrand && Object.hasOwn(brands, requestedBrand) ? requestedBrand : config2.brand;
+  const revision2 = getThemeRevision();
+  if (revision2 !== cachedRevision) {
+    themeCache.clear();
+    cachedRevision = revision2;
+  }
+  const cacheKey = `${activeBrandName}:${themeName}`;
+  const cachedTheme = themeCache.get(cacheKey);
+  if (cachedTheme) {
+    return cachedTheme;
+  }
+  const activeBrand = brands[activeBrandName];
+  const theme = activeBrandName === "purple" ? themeName === "light" ? light : dark : createPalette(activeBrand, themeName);
+  themeCache.set(cacheKey, theme);
+  return theme;
+}
+
+// packages/toolcraft-design/src/components/symbols.ts
+var symbols = {
+  get info() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "info";
+    if (format === "markdown") return "(i)";
+    return color.magenta("\u25CF");
+  },
+  get success() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "success";
+    if (format === "markdown") return "[ok]";
+    return color.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/toolcraft-design/src/internal/strip-ansi.ts
+function stripAnsi(value) {
+  let output = "";
+  let index = 0;
+  while (index < value.length) {
+    const char = value[index];
+    if (char === "\x1B") {
+      index = skipEscapeSequence(value, index);
+      continue;
+    }
+    if (char === "\x9B") {
+      index = skipCsiSequence(value, index + 1);
+      continue;
+    }
+    output += char;
+    index += char.length;
+  }
+  return output;
+}
+function skipEscapeSequence(value, index) {
+  const next = value[index + 1];
+  if (next === "[") {
+    return skipCsiSequence(value, index + 2);
+  }
+  if (next === "]") {
+    return skipOscSequence(value, index + 2);
+  }
+  return Math.min(value.length, index + 2);
+}
+function skipCsiSequence(value, index) {
+  while (index < value.length) {
+    const codePoint = value.charCodeAt(index);
+    index += 1;
+    if (codePoint >= 64 && codePoint <= 126) {
+      break;
+    }
+  }
+  return index;
+}
+function skipOscSequence(value, index) {
+  while (index < value.length) {
+    if (value[index] === "\x07") {
+      return index + 1;
+    }
+    if (value[index] === "\x1B" && value[index + 1] === "\\") {
+      return index + 2;
+    }
+    index += 1;
+  }
+  return index;
+}
+
+// packages/toolcraft-design/src/prompts/primitives/log.ts
+function renderMarkdownInline(value) {
+  return stripAnsi(value).replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+}
+function writeTerminalMessage(msg, {
+  symbol: symbol2 = color.gray("\u2502"),
+  secondarySymbol = color.gray("\u2502"),
+  spacing: spacing2 = 1,
+  withGuide = true
+} = {}) {
+  const lines = [];
+  const showGuide = withGuide !== false;
+  const contentLines = msg.split("\n");
+  const prefix = showGuide ? `${symbol2}  ` : "";
+  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 ? symbol2 : "");
+  }
+  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(`- ${renderMarkdownInline(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:** ${renderMarkdownInline(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:** ${renderMarkdownInline(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:** ${renderMarkdownInline(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: color.yellow("\u25B2") });
+}
+function error(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **error:** ${renderMarkdownInline(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: color.red("\u25A0") });
+}
+var log = {
+  info,
+  success,
+  message,
+  warn,
+  error
+};
+
+// packages/toolcraft-design/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, symbol2) {
+      if (emitter) {
+        emitter(message2);
+        return;
+      }
+      log.message(message2, { symbol: symbol2 ?? color.gray("\u2502") });
+    }
+  };
+}
+var logger = createLogger();
+
+// packages/toolcraft-design/src/components/help-formatter.ts
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+
+// packages/toolcraft-design/src/components/table.ts
+var graphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+
+// packages/toolcraft-design/src/components/detail-card.ts
+import stringWidth from "fast-string-width";
+import { wrapAnsi } from "fast-wrap-ansi";
+
+// packages/toolcraft-design/src/components/template.ts
+var MAX_PARTIAL_DEPTH = 100;
+var HTML_ESCAPE = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+function renderTemplate(template, view, options = {}) {
+  const prepared = options.yield === void 0 ? template : resolveTemplatePartials(template, options.partials ?? {}).split("{{yield}}").join(options.yield);
+  const tokens = parseTemplate(prepared);
+  validatePartialReferences(tokens, options.partials ?? {}, []);
+  if (options.validate === true) {
+    const expanded = resolveTemplatePartials(prepared, options.partials ?? {});
+    validateVariables(parseTemplate(expanded), { view });
+  }
+  const state = {
+    escape: options.escape === "none" ? String : escapeHtml,
+    partials: options.partials ?? {},
+    partialStack: [],
+    preserveMissing: options.yield !== void 0 && options.escape === "none",
+    validate: options.validate === true
+  };
+  return renderTokens(tokens, { view }, prepared, state);
+}
+function resolveTemplatePartials(template, partials) {
+  return expandTemplatePartials(template, partials, []);
+}
+function renderTemplateInContext(template, context, state) {
+  return renderTokens(parseTemplate(template), context, template, state);
+}
+function parseTemplate(template) {
+  const root = [];
+  const stack = [];
+  let tokens = root;
+  let index = 0;
+  while (index < template.length) {
+    const open = template.indexOf("{{", index);
+    if (open === -1) {
+      appendText(tokens, template.slice(index), index);
+      break;
+    }
+    appendText(tokens, template.slice(index, open), index);
+    const parsed = parseTag(template, open);
+    const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+    if (standalone !== void 0) {
+      trimTextAfter(tokens, standalone.lineStart);
+    }
+    if (parsed.kind === "comment") {
+      index = standalone?.nextIndex ?? parsed.end;
+      continue;
+    }
+    if (parsed.kind === "delimiter") {
+      throw new Error("Custom delimiters are not supported");
+    }
+    if (parsed.kind === "section" || parsed.kind === "inverted") {
+      const token = {
+        type: parsed.kind,
+        name: parsed.name,
+        children: [],
+        rawStart: parsed.end,
+        rawEnd: standalone?.lineStart ?? open
+      };
+      tokens.push(token);
+      stack.push({ token, parent: tokens });
+      tokens = token.children;
+      index = standalone?.nextIndex ?? parsed.end;
+      continue;
+    }
+    if (parsed.kind === "partial") {
+      tokens.push({
+        type: "partial",
+        name: parsed.name,
+        indent: standalone === void 0 ? "" : template.slice(standalone.lineStart, open)
+      });
+      index = standalone?.nextIndex ?? parsed.end;
+      continue;
+    }
+    if (parsed.kind === "close") {
+      const frame2 = stack.pop();
+      if (frame2 === void 0) {
+        throw new Error(`Closing unopened section "${parsed.name}"`);
+      }
+      if (frame2.token.name !== parsed.name) {
+        throw new Error(`Unclosed section "${frame2.token.name}" before closing "${parsed.name}"`);
+      }
+      frame2.token.rawEnd = open;
+      tokens = frame2.parent;
+      index = standalone?.nextIndex ?? parsed.end;
+      continue;
+    }
+    tokens.push({ type: parsed.kind, name: parsed.name, raw: template.slice(open, parsed.end) });
+    index = parsed.end;
+  }
+  const frame = stack.pop();
+  if (frame !== void 0) {
+    throw new Error(`Unclosed section "${frame.token.name}"`);
+  }
+  return root;
+}
+function parseTag(template, open) {
+  if (template.startsWith("{{{", open)) {
+    const close2 = template.indexOf("}}}", open + 3);
+    if (close2 === -1) {
+      throw new Error("Unclosed unescaped tag");
+    }
+    return { kind: "unescaped", name: template.slice(open + 3, close2).trim(), end: close2 + 3 };
+  }
+  const close = template.indexOf("}}", open + 2);
+  if (close === -1) {
+    throw new Error("Unclosed tag");
+  }
+  const raw = template.slice(open + 2, close).trim();
+  const sigil = raw[0];
+  const name = sigil === void 0 ? "" : raw.slice(1).trim();
+  const end = close + 2;
+  if (sigil === "#") return { kind: "section", name, end };
+  if (sigil === "^") return { kind: "inverted", name, end };
+  if (sigil === "/") return { kind: "close", name, end };
+  if (sigil === "!") return { kind: "comment", name, end };
+  if (sigil === "&") return { kind: "unescaped", name, end };
+  if (sigil === ">") return { kind: "partial", name, end };
+  if (sigil === "=" && raw.endsWith("=")) return { kind: "delimiter", name, end };
+  return { kind: "name", name: raw, end };
+}
+function getStandalone(template, tagStart, tagEnd, kind) {
+  if (!["section", "inverted", "close", "comment", "partial", "delimiter"].includes(kind)) {
+    return void 0;
+  }
+  const lineStart = template.lastIndexOf("\n", tagStart - 1) + 1;
+  if (!isWhitespace(template.slice(lineStart, tagStart))) {
+    return void 0;
+  }
+  let cursor = tagEnd;
+  while (cursor < template.length && (template[cursor] === " " || template[cursor] === "	")) {
+    cursor += 1;
+  }
+  if (template.startsWith("\r\n", cursor)) {
+    return { lineStart, nextIndex: cursor + 2 };
+  }
+  if (template[cursor] === "\n") {
+    return { lineStart, nextIndex: cursor + 1 };
+  }
+  if (cursor === template.length) {
+    return { lineStart, nextIndex: cursor };
+  }
+  return void 0;
+}
+function renderTokens(tokens, context, template, state) {
+  let output = "";
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text":
+        output += token.value;
+        continue;
+      case "name":
+      case "unescaped": {
+        const result = lookup2(context, token.name);
+        if (!result.hit || result.value == null) {
+          if (state.validate) {
+            throw new Error(`Template variable "${token.name}" not found.`);
+          }
+          if (state.preserveMissing) {
+            output += token.raw;
+          }
+          continue;
+        }
+        const rendered = String(result.value);
+        output += token.type === "name" ? state.escape(rendered) : rendered;
+        continue;
+      }
+      case "partial": {
+        if (!Object.hasOwn(state.partials, token.name)) {
+          throw new Error(`Partial "${token.name}" not found.`);
+        }
+        if (state.partialStack.includes(token.name)) {
+          throw new Error(
+            `Circular partial reference detected: ${[...state.partialStack, token.name].join(" -> ")}.`
+          );
+        }
+        if (state.partialStack.length >= MAX_PARTIAL_DEPTH) {
+          throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+        }
+        const partial = indentPartial(state.partials[token.name], token.indent);
+        output += renderTokens(parseTemplate(partial), context, partial, {
+          ...state,
+          partialStack: [...state.partialStack, token.name]
+        });
+        continue;
+      }
+      case "inverted": {
+        const result = lookup2(context, token.name);
+        if (!result.hit && state.validate) {
+          throw new Error(`Template variable "${token.name}" not found.`);
+        }
+        const value = result.value;
+        if (!value || Array.isArray(value) && value.length === 0) {
+          output += renderTokens(token.children, context, template, state);
+        }
+        continue;
+      }
+      case "section": {
+        const result = lookup2(context, token.name);
+        if (!result.hit && state.validate) {
+          throw new Error(`Template variable "${token.name}" not found.`);
+        }
+        const value = result.value;
+        if (!value) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            output += renderTokens(token.children, pushContext(context, item), template, state);
+          }
+          continue;
+        }
+        if (typeof value === "function") {
+          const raw = template.slice(token.rawStart, token.rawEnd);
+          const rendered = value.call(
+            context.view,
+            raw,
+            (nextTemplate) => renderTemplateInContext(nextTemplate, context, state)
+          );
+          if (rendered != null) {
+            output += String(rendered);
+          }
+          continue;
+        }
+        if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+          output += renderTokens(token.children, pushContext(context, value), template, state);
+          continue;
+        }
+        output += renderTokens(token.children, context, template, state);
+      }
+    }
+  }
+  return output;
+}
+function lookup2(context, name) {
+  if (name === ".") {
+    return { hit: true, value: callLambda(context.view, context.view) };
+  }
+  let cursor = context;
+  while (cursor !== void 0) {
+    const result = name.includes(".") ? lookupDotted(cursor.view, name) : lookupName(cursor.view, name);
+    if (result.hit) {
+      return { hit: true, value: callLambda(result.value, cursor.view) };
+    }
+    cursor = cursor.parent;
+  }
+  return { hit: false, value: void 0 };
+}
+function validateVariables(tokens, context) {
+  for (const token of tokens) {
+    if (token.type === "text" || token.type === "partial") {
+      continue;
+    }
+    if (token.type === "name" || token.type === "unescaped") {
+      if (!lookup2(context, token.name).hit) {
+        throw new Error(`Template variable "${token.name}" not found.`);
+      }
+      continue;
+    }
+    if (token.type !== "section" && token.type !== "inverted") {
+      continue;
+    }
+    const result = lookup2(context, token.name);
+    if (!result.hit) {
+      throw new Error(`Template variable "${token.name}" not found.`);
+    }
+    if (Array.isArray(result.value) && result.value.length > 0) {
+      for (const item of result.value) {
+        validateVariables(token.children, pushContext(context, item));
+      }
+      continue;
+    }
+    if (typeof result.value === "object" && result.value !== null || typeof result.value === "string" || typeof result.value === "number") {
+      validateVariables(token.children, pushContext(context, result.value));
+      continue;
+    }
+    validateVariables(token.children, context);
+  }
+}
+function validatePartialReferences(tokens, partials, partialStack) {
+  for (const token of tokens) {
+    if (token.type === "section" || token.type === "inverted") {
+      validatePartialReferences(token.children, partials, partialStack);
+      continue;
+    }
+    if (token.type !== "partial") {
+      continue;
+    }
+    if (!Object.hasOwn(partials, token.name)) {
+      throw new Error(`Partial "${token.name}" not found.`);
+    }
+    if (partialStack.includes(token.name)) {
+      throw new Error(
+        `Circular partial reference detected: ${[...partialStack, token.name].join(" -> ")}.`
+      );
+    }
+    if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+      throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+    }
+    validatePartialReferences(parseTemplate(partials[token.name]), partials, [
+      ...partialStack,
+      token.name
+    ]);
+  }
+}
+function indentPartial(partial, indent) {
+  if (indent === "") {
+    return partial;
+  }
+  return partial.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n");
+}
+function expandTemplatePartials(template, partials, partialStack) {
+  let output = "";
+  let index = 0;
+  while (index < template.length) {
+    const open = template.indexOf("{{", index);
+    if (open === -1) {
+      output += template.slice(index);
+      break;
+    }
+    const parsed = parseTag(template, open);
+    if (parsed.kind !== "partial") {
+      output += template.slice(index, parsed.end);
+      index = parsed.end;
+      continue;
+    }
+    if (!Object.hasOwn(partials, parsed.name)) {
+      throw new Error(`Partial "${parsed.name}" not found.`);
+    }
+    if (partialStack.includes(parsed.name)) {
+      throw new Error(
+        `Circular partial reference detected: ${[...partialStack, parsed.name].join(" -> ")}.`
+      );
+    }
+    if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+      throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+    }
+    const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+    const beforePartial = standalone === void 0 ? template.slice(index, open) : template.slice(index, standalone.lineStart);
+    const indent = standalone === void 0 ? "" : template.slice(standalone.lineStart, open);
+    const partial = indentPartial(partials[parsed.name], indent);
+    output += beforePartial + expandTemplatePartials(partial, partials, [...partialStack, parsed.name]);
+    index = standalone?.nextIndex ?? parsed.end;
+  }
+  return output;
+}
+function lookupName(view, name) {
+  if (!isPropertyContainer(view) || !hasProperty(view, name)) {
+    return { hit: false, value: void 0 };
+  }
+  return { hit: true, value: view[name] };
+}
+function lookupDotted(view, name) {
+  const parts = name.split(".");
+  let value = view;
+  for (const part of parts) {
+    if (!isPropertyContainer(value) || !hasProperty(value, part)) {
+      return { hit: false, value: void 0 };
+    }
+    value = Object(value)[part];
+  }
+  return { hit: true, value };
+}
+function callLambda(value, view) {
+  return typeof value === "function" ? value.call(view) : value;
+}
+function pushContext(parent, view) {
+  return { view, parent };
+}
+function appendText(tokens, value, start) {
+  if (value === "") {
+    return;
+  }
+  const previous = tokens[tokens.length - 1];
+  if (previous?.type === "text") {
+    previous.value += value;
+    return;
+  }
+  tokens.push({ type: "text", value, start });
+}
+function trimTextAfter(tokens, lineStart) {
+  const previous = tokens[tokens.length - 1];
+  if (previous?.type !== "text") {
+    return;
+  }
+  const keep = Math.max(0, lineStart - previous.start);
+  previous.value = previous.value.slice(0, keep);
+  if (previous.value === "") {
+    tokens.pop();
+  }
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"'`=/]/g, (char) => HTML_ESCAPE[char] ?? char);
+}
+function isWhitespace(value) {
+  return value.trim() === "";
+}
+function isPropertyContainer(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function hasProperty(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+// packages/toolcraft-design/src/components/browser.ts
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+
+// packages/frontmatter/src/parse.ts
+import { LineCounter, parse, parseDocument } from "yaml";
+
+// packages/frontmatter/src/stringify.ts
+import { stringify } from "yaml";
+
+// packages/toolcraft-design/src/dashboard/terminal-width.ts
+var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+
+// packages/toolcraft-design/src/acp/writer.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var storage = new AsyncLocalStorage2();
+
+// packages/toolcraft-design/src/dashboard/terminal.ts
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+
+// packages/toolcraft-design/src/explorer/state.ts
+var REGION_HEADER = 1 << 0;
+var REGION_LIST = 1 << 1;
+var REGION_DETAIL = 1 << 2;
+var REGION_FOOTER = 1 << 3;
+var REGION_MODAL = 1 << 4;
+var REGION_TOAST = 1 << 5;
+var REGION_ALL = REGION_HEADER | REGION_LIST | REGION_DETAIL | REGION_FOOTER | REGION_MODAL | REGION_TOAST;
+
+// packages/toolcraft-design/src/prompts/interactive/glyphs.ts
+function supportsUnicode() {
+  if (!process.platform.startsWith("win")) {
+    return process.env.TERM !== "linux";
+  }
+  return Boolean(
+    process.env.CI || process.env.WT_SESSION || process.env.TERMINUS_SUBLIME || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm"
+  );
+}
+var UNICODE = supportsUnicode();
+function glyph(unicode, ascii) {
+  return UNICODE ? unicode : ascii;
+}
+var GLYPHS = {
+  stepActive: glyph("\u25C6", "*"),
+  stepCancel: glyph("\u25A0", "x"),
+  stepError: glyph("\u25B2", "x"),
+  stepSubmit: glyph("\u25C7", "o"),
+  barStart: glyph("\u250C", "T"),
+  bar: glyph("\u2502", "|"),
+  barEnd: glyph("\u2514", "-"),
+  radioActive: glyph("\u25CF", ">"),
+  radioInactive: glyph("\u25CB", " "),
+  checkboxActive: glyph("\u25FB", "[ ]"),
+  checkboxSelected: glyph("\u25FC", "[+]"),
+  checkboxInactive: glyph("\u25FB", "[ ]"),
+  passwordMask: glyph("\u2022", "*"),
+  ellipsis: "..."
+};
+
+// packages/toolcraft-design/src/prompts/interactive/core.ts
+import { EventEmitter } from "node:events";
+import * as readline2 from "node:readline";
+
+// packages/toolcraft-design/src/prompts/interactive/wrap.ts
+import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+import stringWidth2 from "fast-string-width";
+
+// packages/toolcraft-design/src/prompts/interactive/pagination.ts
+import { wrapAnsi as wrapAnsi3 } from "fast-wrap-ansi";
+
+// packages/toolcraft-design/src/static/spinner.ts
+var SPINNER_FRAMES = Object.freeze(["\u25D2", "\u25D0", "\u25D3", "\u25D1"]);
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+
+// packages/config-mutations/src/formats/object.ts
+function cloneConfigObject(value) {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    setConfigEntry(result, key, cloneConfigValue(entry));
+  }
+  return result;
+}
+function setConfigEntry(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+}
+function hasConfigEntry(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+function cloneConfigValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneConfigValue(entry));
+  }
+  if (value && typeof value === "object" && !(value instanceof Date)) {
+    return cloneConfigObject(value);
+  }
+  return value;
+}
+
+// packages/config-mutations/src/formats/json.ts
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectIndent(content) {
+  const match = content.match(/^[\t ]+/m);
+  if (match) {
+    return match[0];
+  }
+  return "  ";
+}
+function parse4(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 cloneConfigObject(parsed);
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge(base, patch) {
+  const result = cloneConfigObject(base);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = hasConfigEntry(result, key) ? result[key] : void 0;
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      setConfigEntry(result, key, merge(existing, value));
+      continue;
+    }
+    setConfigEntry(result, key, value);
+  }
+  return result;
+}
+function configValuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function prune(obj, shape) {
+  let changed = false;
+  const result = cloneConfigObject(obj);
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!hasConfigEntry(result, key)) {
+      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 } = prune(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        setConfigEntry(result, key, childResult);
+      }
+      continue;
+    }
+    if (isConfigObject(pattern) && Object.keys(pattern).length > 0) {
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+function modifyAtPath(content, path9, value) {
+  const indent = detectIndent(content);
+  const formattingOptions = {
+    tabSize: indent === "	" ? 1 : indent.length,
+    insertSpaces: indent !== "	",
+    eol: "\n"
+  };
+  const edits = jsonc.modify(content, path9, value, { formattingOptions });
+  let result = jsonc.applyEdits(content, edits);
+  if (!result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function removeAtPath(content, path9) {
+  return modifyAtPath(content, path9, void 0);
+}
+function serializeUpdate(content, current, next) {
+  let result = content || "{}";
+  result = applyObjectUpdate(result, [], current, next);
+  if (!result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function applyObjectUpdate(content, path9, current, next) {
+  let result = content;
+  for (const key of Object.keys(current)) {
+    if (!hasConfigEntry(next, key)) {
+      result = removeAtPath(result, [...path9, key]);
+    }
+  }
+  for (const [key, nextValue] of Object.entries(next)) {
+    const nextPath = [...path9, key];
+    const hasCurrent = hasConfigEntry(current, key);
+    const currentValue = hasCurrent ? current[key] : void 0;
+    if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
+      result = applyObjectUpdate(result, nextPath, currentValue, nextValue);
+      continue;
+    }
+    if (!hasCurrent || !configValuesEqual(currentValue, nextValue)) {
+      result = modifyAtPath(result, nextPath, nextValue);
+    }
+  }
+  return result;
+}
+var jsonFormat = {
+  parse: parse4,
+  serialize,
+  serializeUpdate,
+  merge,
+  prune
+};
+
+// 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 parse5(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return cloneConfigObject(parsed);
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge2(base, patch) {
+  const result = cloneConfigObject(base);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = hasConfigEntry(result, key) ? result[key] : void 0;
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      setConfigEntry(result, key, merge2(existing, value));
+      continue;
+    }
+    setConfigEntry(result, key, value);
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = cloneConfigObject(obj);
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!hasConfigEntry(result, key)) {
+      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 } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        setConfigEntry(result, key, childResult);
+      }
+      continue;
+    }
+    if (!isConfigObject2(pattern) || Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+    }
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse5,
+  serialize: serialize2,
+  merge: merge2,
+  prune: prune2
+};
+
+// 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 parse6(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 cloneConfigObject(parsed);
+}
+function serialize3(obj) {
+  const serialized = stringifyYaml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge3(base, patch) {
+  const result = cloneConfigObject(base);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = hasConfigEntry(result, key) ? result[key] : void 0;
+    if (isConfigObject3(existing) && isConfigObject3(value)) {
+      setConfigEntry(result, key, merge3(existing, value));
+      continue;
+    }
+    setConfigEntry(result, key, value);
+  }
+  return result;
+}
+function prune3(obj, shape) {
+  let changed = false;
+  const result = cloneConfigObject(obj);
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!hasConfigEntry(result, key)) {
+      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 } = prune3(current, pattern);
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        setConfigEntry(result, key, childResult);
+      }
+      continue;
+    }
+    if (!isConfigObject3(pattern) || Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+    }
+  }
+  return { changed, result };
+}
+var yamlFormat = {
+  parse: parse6,
+  serialize: serialize3,
+  merge: merge3,
+  prune: prune3
+};
+
+// 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 (Object.prototype.hasOwnProperty.call(formatRegistry, pathOrFormat)) {
+    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(path9) {
+  const ext = getExtension(path9);
+  return extensionMap[ext];
+}
+function getExtension(path9) {
+  const lastDot = path9.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path9.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path2 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 : path2.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);
+  const canonicalHome = path2.resolve(homeDir);
+  const canonicalExpanded = path2.resolve(expanded);
+  const relative = path2.relative(canonicalHome, canonicalExpanded);
+  if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+    throw new Error(`Target path resolves outside home directory: "${rawPath}"`);
+  }
+  if (!pathMapper) {
+    return canonicalExpanded;
+  }
+  const rawDirectory = path2.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path2.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path2.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/error-codes.ts
+function hasOwnErrorCode(error2, code) {
+  return typeof error2 === "object" && error2 !== null && Object.prototype.hasOwnProperty.call(error2, "code") && error2.code === code;
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error2) {
+  return hasOwnErrorCode(error2, "ENOENT");
+}
+async function readFileIfExists(fs5, target) {
+  try {
+    return await fs5.readFile(target, "utf8");
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return null;
+    }
+    throw error2;
+  }
+}
+async function pathExists(fs5, target) {
+  try {
+    await fs5.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(context, targetPath, content) {
+  const baseBackupPath = createInvalidDocumentBackupPath(targetPath);
+  let attempt = 0;
+  while (true) {
+    const backupPath = attempt === 0 ? baseBackupPath : `${baseBackupPath}-${attempt}`;
+    await assertRegularWriteTarget(context, backupPath);
+    try {
+      await context.fs.writeFile(backupPath, content, { encoding: "utf8", flag: "wx" });
+      return;
+    } catch (error2) {
+      if (!isAlreadyExists(error2)) {
+        await context.fs.unlink(backupPath).catch(() => void 0);
+        throw error2;
+      }
+      attempt += 1;
+    }
+  }
+}
+function isAlreadyExists(error2) {
+  return hasOwnErrorCode(error2, "EEXIST");
+}
+async function assertRegularWriteTarget(context, targetPath) {
+  const boundary = path3.dirname(path3.resolve(context.homeDir));
+  let currentPath = path3.resolve(targetPath);
+  while (currentPath !== boundary) {
+    try {
+      if ((await context.fs.lstat(currentPath)).isSymbolicLink()) {
+        throw new Error(`Refusing mutation write through symbolic link: ${currentPath}`);
+      }
+    } catch (error2) {
+      if (!isNotFound(error2)) {
+        throw error2;
+      }
+    }
+    const parentPath = path3.dirname(currentPath);
+    if (parentPath === currentPath) {
+      return;
+    }
+    currentPath = parentPath;
+  }
+}
+async function writeAtomically(context, targetPath, content) {
+  await assertRegularWriteTarget(context, targetPath);
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    const tempPath = `${targetPath}.mutation-tmp-${process.pid}-${randomUUID()}`;
+    let tempCreated = false;
+    try {
+      await assertRegularWriteTarget(context, tempPath);
+      await context.fs.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+      tempCreated = true;
+      await context.fs.rename(tempPath, targetPath);
+      tempCreated = false;
+      return;
+    } catch (error2) {
+      const alreadyExists = isAlreadyExists(error2);
+      if (tempCreated || !alreadyExists) {
+        try {
+          await context.fs.unlink(tempPath);
+        } catch (cleanupError) {
+          if (!isNotFound(cleanupError)) {
+            void cleanupError;
+          }
+        }
+      }
+      if (alreadyExists) {
+        continue;
+      }
+      throw error2;
+    }
+  }
+  throw new Error(`Unable to create temporary mutation file for ${targetPath}.`);
+}
+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 "restoreBackup":
+      return `Restore ${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 mutationTargetPath(mutation, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+    case "removeDirectory":
+      return resolveValue(mutation.path, options);
+    case "removeFile":
+    case "chmod":
+    case "backup":
+    case "restoreBackup":
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateWrite":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return resolveValue(mutation.target, options);
+    default:
+      return void 0;
+  }
+}
+function resolveMutationDetails(mutation, context, options) {
+  try {
+    const rawTarget = mutationTargetPath(mutation, options);
+    if (rawTarget === void 0) {
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind
+      };
+    }
+    try {
+      const targetPath = resolvePath(rawTarget, context.homeDir, context.pathMapper);
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+        targetPath
+      };
+    } catch {
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? describeMutation(mutation.kind, rawTarget),
+        targetPath: void 0
+      };
+    }
+  } catch {
+    return {
+      kind: mutation.kind,
+      label: mutation.label ?? mutation.kind
+    };
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      setConfigEntry(result, key, value);
+    }
+  }
+  return result;
+}
+function isConfigObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = cloneConfigObject(base);
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject4(current) && isConfigObject4(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        setConfigEntry(result, key, mergePrunedConfigObject(pruned, value));
+      } else {
+        setConfigEntry(result, key, mergeWithPruneByPrefix(current, value, prefixMap));
+      }
+      continue;
+    }
+    setConfigEntry(result, key, value);
+  }
+  return result;
+}
+function mergePrunedConfigObject(base, patch) {
+  const result = cloneConfigObject(base);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    setConfigEntry(result, key, value);
+  }
+  return result;
+}
+function serializeConfigUpdate(format, rawContent, current, next) {
+  if (rawContent !== null && format.serializeUpdate) {
+    return format.serializeUpdate(rawContent, current, next);
+  }
+  return format.serialize(next);
+}
+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 "restoreBackup":
+      return applyRestoreBackup(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
+  };
+  await assertRegularWriteTarget(context, 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.lastIndex = 0;
+    }
+    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 {
+    await assertRegularWriteTarget(context, targetPath);
+    const stat3 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat3.mode === "number" ? stat3.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
+  };
+  await assertRegularWriteTarget(context, targetPath);
+  if (mutation.once && await findLatestGeneratedBackup(context.fs, targetPath) !== null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null && !mutation.once) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const baseBackupPath = `${targetPath}.backup-${createTimestamp()}${content === null ? ".missing" : ""}`;
+    let attempt = 0;
+    while (true) {
+      const backupPath = attempt === 0 ? baseBackupPath : `${baseBackupPath}-${attempt}`;
+      try {
+        await assertRegularWriteTarget(context, backupPath);
+        await context.fs.writeFile(backupPath, content ?? "", { encoding: "utf8", flag: "wx" });
+        break;
+      } catch (error2) {
+        if (!isAlreadyExists(error2)) {
+          await context.fs.unlink(backupPath).catch(() => void 0);
+          throw error2;
+        }
+        attempt += 1;
+      }
+    }
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyRestoreBackup(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 backup2 = await findLatestGeneratedBackup(context.fs, targetPath);
+  if (backup2 === null) {
+    return { outcome: { changed: false, effect: "none", detail: "noop" }, details };
+  }
+  if (!context.dryRun) {
+    await assertRegularWriteTarget(context, backup2.path);
+    if (backup2.originallyMissing) {
+      try {
+        await context.fs.unlink(targetPath);
+      } catch (error2) {
+        if (!isNotFound(error2)) {
+          throw error2;
+        }
+      }
+    } else {
+      const content = await context.fs.readFile(backup2.path, "utf8");
+      await writeAtomically(context, targetPath, content);
+    }
+    await context.fs.unlink(backup2.path);
+  }
+  return { outcome: { changed: true, effect: "copy", detail: "restore" }, details };
+}
+async function findLatestGeneratedBackup(fs5, targetPath) {
+  const separatorIndex = targetPath.lastIndexOf("/");
+  const directoryPath = separatorIndex <= 0 ? "/" : targetPath.slice(0, separatorIndex);
+  const targetName = targetPath.slice(separatorIndex + 1);
+  let entries;
+  try {
+    entries = await fs5.readdir(directoryPath);
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return null;
+    }
+    throw error2;
+  }
+  const backupName = entries.filter((entry) => isGeneratedBackupName(entry, targetName)).sort().at(-1);
+  return backupName === void 0 ? null : {
+    path: `${directoryPath}/${backupName}`,
+    originallyMissing: backupName.endsWith(".missing")
+  };
+}
+function isGeneratedBackupName(entry, targetName) {
+  const prefix = `${targetName}.backup-`;
+  if (!entry.startsWith(prefix)) {
+    return false;
+  }
+  const suffix = entry.slice(prefix.length);
+  const timestamp = suffix.slice(0, 24);
+  if (timestamp.length !== 24 || timestamp[4] !== "-" || timestamp[7] !== "-" || timestamp[10] !== "T" || timestamp[13] !== "-" || timestamp[16] !== "-" || timestamp[19] !== "-" || timestamp[23] !== "Z") {
+    return false;
+  }
+  const parsedTimestamp = `${timestamp.slice(0, 13)}:${timestamp.slice(14, 16)}:${timestamp.slice(17, 19)}.${timestamp.slice(20)}`;
+  if (Number.isNaN(Date.parse(parsedTimestamp))) {
+    return false;
+  }
+  const collisionSuffix = suffix.slice(24);
+  if (collisionSuffix.length === 0) {
+    return true;
+  }
+  if (collisionSuffix === ".missing") {
+    return true;
+  }
+  return collisionSuffix[0] === "-" && collisionSuffix.slice(1).length > 0 && [...collisionSuffix.slice(1)].every((character) => character >= "0" && character <= "9");
+}
+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 preserveContent = rawContent;
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null && !context.dryRun) {
+      await backupInvalidDocument(context, targetPath, rawContent);
+    }
+    current = {};
+    preserveContent = null;
+  }
+  const value = resolveValue(mutation.value, options);
+  if (!isConfigObject4(value)) {
+    throw new Error(`configMerge value must be an object for "${rawPath}".`);
+  }
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = serializeConfigUpdate(format, preserveContent, current, merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await writeAtomically(context, targetPath, serialized);
+  }
+  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 {
-        readFile: ((filePath, encoding) => {
-            if (encoding) {
-                return fs.readFile(filePath, encoding);
-            }
-            return fs.readFile(filePath);
-        }),
-        symlink: (target, filePath) => fs.symlink(target, filePath),
-        readlink: (filePath) => fs.readlink(filePath, { encoding: "utf8" }),
-        realpath: (filePath) => fs.realpath(filePath),
-        writeFile: (filePath, data, options) => fs.writeFile(filePath, data, options),
-        mkdir: (filePath, options) => fs.mkdir(filePath, options).then(() => { }),
-        stat: (filePath) => fs.stat(filePath),
-        lstat: (filePath) => fs.lstat(filePath),
-        rename: (oldPath, newPath) => fs.rename(oldPath, newPath),
-        rm: (filePath, options) => fs.rm(filePath, options),
-        unlink: (filePath) => fs.unlink(filePath),
-        readdir: (filePath) => fs.readdir(filePath),
-        copyFile: (src, dest) => fs.copyFile(src, dest),
-        chmod: (filePath, mode) => fs.chmod(filePath, mode)
+      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 = serializeConfigUpdate(format, rawContent, current, result);
+  if (!context.dryRun) {
+    await writeAtomically(context, targetPath, serialized);
+  }
+  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 preserveContent = rawContent;
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null && !context.dryRun) {
+      await backupInvalidDocument(context, targetPath, rawContent);
+    }
+    current = {};
+    preserveContent = null;
+  }
+  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 = serializeConfigUpdate(format, preserveContent, current, transformed);
+  const serializedChanged = serialized !== rawContent;
+  if (!serializedChanged) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await writeAtomically(context, targetPath, serialized);
+  }
+  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 = renderTemplate(template, templateContext);
+  const current = await readFileIfExists(context.fs, targetPath);
+  const changed = current !== rendered;
+  if (changed && !context.dryRun) {
+    await writeAtomically(context, targetPath, rendered);
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? current === null ? "create" : "update" : "noop"
+    },
+    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 = renderTemplate(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 && !context.dryRun) {
+      await backupInvalidDocument(context, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await writeAtomically(context, targetPath, serialized);
+  }
+  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) {
+  const pendingDetails = resolveMutationDetails(mutation, context, options);
+  context.observers?.onStart?.(pendingDetails);
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error2) {
+    context.observers?.onError?.(pendingDetails, error2);
+    throw error2;
+  }
+}
+
+// packages/agent-skill-config/src/error-codes.ts
+function hasOwnErrorCode2(error2, code) {
+  return error2 instanceof Error && Object.prototype.hasOwnProperty.call(error2, "code") && error2.code === code;
+}
+
+// packages/agent-skill-config/src/templates.ts
+import { readFile, stat } from "node:fs/promises";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/agent-skill-config/src/apply.ts
+var UnsupportedAgentError = class extends Error {
+  constructor(agentId) {
+    super(`Unsupported agent: ${agentId}`);
+    this.name = "UnsupportedAgentError";
+  }
+};
+function toHomeRelative(localSkillDir) {
+  if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+    return localSkillDir;
+  }
+  const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
+  return `~/${normalized}`;
+}
+async function pathExists2(fs5, targetPath) {
+  try {
+    await fs5.stat(targetPath);
+    return true;
+  } catch (error2) {
+    if (hasOwnErrorCode2(error2, "ENOENT")) {
+      return false;
+    }
+    throw error2;
+  }
+}
+var SKILL_TEMPLATE_ID = "__skill_content__";
+async function installSkill(agentId, skill, options) {
+  const support = resolveAgentSupport(agentId);
+  if (support.status !== "supported") {
+    throw new UnsupportedAgentError(agentId);
+  }
+  const scope = options.scope ?? "local";
+  const config2 = support.config;
+  if (skill.name.length === 0 || skill.name !== skill.name.trim() || skill.name === "." || skill.name === ".." || skill.name.includes("/") || skill.name.includes("\\") || skill.name.includes("\n") || skill.name.includes("\r")) {
+    throw new Error(`Invalid skill name: ${skill.name}`);
+  }
+  const skillDir = scope === "global" ? config2.globalSkillDir : toHomeRelative(config2.localSkillDir);
+  const skillFolderPath = `${skillDir}/${skill.name}`;
+  const skillFilePath = `${skillFolderPath}/SKILL.md`;
+  const displayPath = `${scope === "global" ? config2.globalSkillDir : config2.localSkillDir}/${skill.name}/SKILL.md`;
+  const absoluteSkillPath = `${scope === "global" ? options.homeDir : options.cwd}/${skillFilePath.slice(2)}`;
+  if (await pathExists2(options.fs, absoluteSkillPath)) {
+    throw new Error(`Skill already exists: ${displayPath}`);
+  }
+  await runMutations(
+    [
+      fileMutation.ensureDirectory({
+        path: skillFolderPath,
+        label: `Ensure skill directory ${skill.name}`
+      }),
+      templateMutation.write({
+        target: skillFilePath,
+        templateId: SKILL_TEMPLATE_ID,
+        label: `Write skill ${skill.name}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: scope === "global" ? options.homeDir : options.cwd,
+      dryRun: options.dryRun,
+      observers: options.observers,
+      templates: async (templateId) => {
+        if (templateId === SKILL_TEMPLATE_ID) {
+          return skill.content;
+        }
+        throw new Error(`Unknown template: ${templateId}`);
+      }
+    }
+  );
+  return { skillPath: absoluteSkillPath, displayPath };
+}
+
+// packages/agent-skill-config/src/resolve-skill-reference.ts
+import * as fs from "node:fs";
+import path5 from "node:path";
+
+// packages/agent-skill-config/src/git-exclude.ts
+import { execFileSync } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fs2 from "node:fs";
+import path6 from "node:path";
+
+// packages/agent-skill-config/src/bridge-active-skills.ts
+import * as fs3 from "node:fs";
+import { createHash, randomUUID as randomUUID3 } from "node:crypto";
+import path7 from "node:path";
+
+// src/skills.ts
+function createNodeFileSystem() {
+  return {
+    readFile: ((filePath, encoding) => {
+      if (encoding) {
+        return fs4.readFile(filePath, encoding);
+      }
+      return fs4.readFile(filePath);
+    }),
+    symlink: (target, filePath) => fs4.symlink(target, filePath),
+    readlink: (filePath) => fs4.readlink(filePath, { encoding: "utf8" }),
+    realpath: (filePath) => fs4.realpath(filePath),
+    writeFile: (filePath, data, options) => fs4.writeFile(filePath, data, options),
+    mkdir: (filePath, options) => fs4.mkdir(filePath, options).then(() => {
+    }),
+    stat: (filePath) => fs4.stat(filePath),
+    lstat: (filePath) => fs4.lstat(filePath),
+    rename: (oldPath, newPath) => fs4.rename(oldPath, newPath),
+    rm: (filePath, options) => fs4.rm(filePath, options),
+    unlink: (filePath) => fs4.unlink(filePath),
+    readdir: (filePath) => fs4.readdir(filePath),
+    copyFile: (src, dest) => fs4.copyFile(src, dest),
+    chmod: (filePath, mode) => fs4.chmod(filePath, mode)
+  };
 }
 async function resolveSkillContent(source, options) {
-    if ("content" in source) {
-        return source.content;
-    }
-    const sourcePath = path.isAbsolute(source.file)
-        ? source.file
-        : path.resolve(options.cwd, source.file);
-    return options.fs.readFile(sourcePath, "utf8");
-}
-/**
- * Install arbitrary skill content into an agent's native skill directory.
- *
- * The actual mutation and validation are delegated to poe-code's agent skill
- * configuration machinery, so SDK and CLI installs share the same safety rules.
- */
-export async function installSkill(agentId, source, options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const homeDir = options.homeDir ?? os.homedir();
-    const fileSystem = options.fs ?? createNodeFileSystem();
-    const content = await resolveSkillContent(source, { cwd, fs: fileSystem });
-    return installAgentSkill(agentId, {
-        name: source.name,
-        content
-    }, {
-        fs: fileSystem,
-        cwd,
-        homeDir,
-        scope: options.scope ?? "local",
-        dryRun: options.dryRun
-    });
+  if ("content" in source) {
+    return source.content;
+  }
+  const sourcePath = path8.isAbsolute(source.file) ? source.file : path8.resolve(options.cwd, source.file);
+  return options.fs.readFile(sourcePath, "utf8");
+}
+async function installSkill2(agentId, source, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const homeDir = options.homeDir ?? os2.homedir();
+  const fileSystem = options.fs ?? createNodeFileSystem();
+  const content = await resolveSkillContent(source, { cwd, fs: fileSystem });
+  return installSkill(
+    agentId,
+    {
+      name: source.name,
+      content
+    },
+    {
+      fs: fileSystem,
+      cwd,
+      homeDir,
+      scope: options.scope ?? "local",
+      dryRun: options.dryRun
+    }
+  );
 }
-//# sourceMappingURL=skills.js.map
+export {
+  installSkill2 as installSkill
+};
+//# sourceMappingURL=skills.js.map