poe-code 3.0.202 → 3.0.203

package/dist/providers/kimi.js

@@ -52,19 +52,11 @@ var require_config_toml = __commonJS({
   }
 });
 
-// packages/agent-spawn/src/run-command.ts
-import { spawn } from "node:child_process";
+// packages/agent-spawn/src/register-factories.ts
+import { spawn as spawnChildProcess2 } from "node:child_process";
 
-// packages/agent-spawn/src/types.ts
-function resolveModeConfig(modeConfig) {
-  if (Array.isArray(modeConfig)) {
-    return { args: modeConfig };
-  }
-  return {
-    args: modeConfig.args ?? [],
-    env: modeConfig.env && Object.keys(modeConfig.env).length > 0 ? modeConfig.env : void 0
-  };
-}
+// packages/agent-harness-tools/src/paths.ts
+import path from "node:path";
 
 // packages/agent-defs/src/agents/claude-code.ts
 var claudeCodeAgent = {
@@ -205,1925 +197,2968 @@ function resolveAgentId(input) {
   return lookup.get(input.toLowerCase());
 }
 
-// packages/agent-spawn/src/configs/mcp.ts
-function toJsonMcpServers(servers) {
-  const out = {};
-  for (const [name, server] of Object.entries(servers)) {
-    const mapped = { command: server.command };
-    if (server.args && server.args.length > 0) {
-      mapped.args = server.args;
-    }
-    if (server.env && Object.keys(server.env).length > 0) {
-      mapped.env = server.env;
-    }
-    if (server.timeout !== void 0) {
-      mapped.timeout = server.timeout;
+// packages/agent-harness-tools/src/select-agent.ts
+var loopAgents = allAgents.filter(
+  (agent) => agent.binaryName !== void 0 || agent.id === "poe-agent"
+);
+var supportedAgents = loopAgents.map((agent) => agent.id).join(", ");
+
+// packages/file-lock/src/lock.ts
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+
+// packages/agent-harness-tools/src/run-logs.ts
+import path2 from "node:path";
+
+// packages/agent-harness-tools/src/log-stream.ts
+import nodeFs from "node:fs";
+
+// packages/agent-harness-tools/src/run-poe-command.ts
+import { randomBytes } from "node:crypto";
+
+// packages/agent-harness-tools/src/poe-command-execution.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import os3 from "node:os";
+
+// packages/poe-code-config/src/runtime.ts
+import { existsSync } from "node:fs";
+import path3 from "node:path";
+var defaultWorkspaceExclude = [
+  ".git",
+  "node_modules",
+  "dist",
+  ".turbo",
+  ".next",
+  ".poe-code/state.json"
+];
+var runtimeConfigScope = {
+  scope: "runtime",
+  schema: {
+    type: {
+      type: "string",
+      default: "host",
+      doc: "Runtime backend: host, docker, or e2b"
+    },
+    build_args: {
+      type: "json",
+      default: {},
+      parse: parseBuildArgs,
+      doc: "Build arguments passed to the runtime image build"
+    },
+    mounts: {
+      type: "json",
+      default: [],
+      parse: parseMounts,
+      doc: "Additional runtime mounts"
+    },
+    runner: {
+      type: "json",
+      default: createDefaultRunnerScope(),
+      parse: parseRunner,
+      doc: "Runner process and workspace transfer settings"
+    },
+    link: {
+      type: "string",
+      default: "",
+      doc: "Informational link for the runtime definition"
+    },
+    image: {
+      type: "string",
+      default: "",
+      doc: "Prebuilt Docker image"
+    },
+    dockerfile: {
+      type: "string",
+      default: "",
+      doc: "Path to the Dockerfile used for docker or e2b builds"
+    },
+    build_context: {
+      type: "string",
+      default: "",
+      doc: "Path to the Docker build context"
+    },
+    engine: {
+      type: "string",
+      default: "",
+      doc: "Container engine for Docker runtime"
+    },
+    network: {
+      type: "string",
+      default: "",
+      doc: "Docker network"
+    },
+    extra_args: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalStringArray,
+      doc: "Extra Docker runtime arguments"
+    },
+    template_id: {
+      type: "string",
+      default: "",
+      doc: "Prebuilt E2B template id"
+    },
+    cpu: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B CPU count"
+    },
+    memory_mb: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B memory in megabytes"
+    },
+    timeout_minutes: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B timeout in minutes"
+    },
+    preserve_after_exit_hours: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "Hours to keep an E2B sandbox alive after job exit"
+    },
+    api_key_env: {
+      type: "string",
+      default: "",
+      doc: "Environment variable name containing the E2B API key"
     }
-    out[name] = mapped;
   }
-  return out;
-}
-function toTomlString(value) {
-  return JSON.stringify(value);
+};
+function parseRunner(raw) {
+  if (raw === void 0) {
+    return createDefaultRunnerScope();
+  }
+  const record = asRecord(raw);
+  if (record === void 0) {
+    throw new Error("runner: expected an object.");
+  }
+  const uploadMaxFileMb = parseOptionalNumber(record.upload_max_file_mb, "runner.upload_max_file_mb") ?? 100;
+  if (uploadMaxFileMb <= 0) {
+    throw new Error("runner.upload_max_file_mb: expected a positive finite number.");
+  }
+  return omitUndefined({
+    detach: parseOptionalBoolean(record.detach, "runner.detach") ?? false,
+    upload_max_file_mb: uploadMaxFileMb,
+    download_conflict: parseDownloadConflict(record.download_conflict),
+    workspace: parseRunnerWorkspace(record.workspace)
+  });
 }
-function toTomlArray(values) {
-  const serialized = values.map((value) => toTomlString(value));
-  return `[${serialized.join(", ")}]`;
+function createDefaultRunnerScope() {
+  return {
+    detach: false,
+    upload_max_file_mb: 100,
+    download_conflict: "refuse",
+    workspace: {
+      exclude: [...defaultWorkspaceExclude]
+    }
+  };
 }
-function toTomlInlineTable(values) {
-  const parts = [];
-  for (const [key, value] of Object.entries(values)) {
-    parts.push(`${JSON.stringify(key)}=${toTomlString(value)}`);
+function parseRunnerWorkspace(value) {
+  if (value === void 0) {
+    return {
+      exclude: [...defaultWorkspaceExclude]
+    };
   }
-  return `{${parts.join(", ")}}`;
+  const record = asRecord(value);
+  if (record === void 0) {
+    throw new Error("runner.workspace: expected an object.");
+  }
+  return {
+    exclude: parseOptionalStringArray(record.exclude, "runner.workspace.exclude") ?? [
+      ...defaultWorkspaceExclude
+    ]
+  };
 }
-function serializeJsonMcpArgs(servers) {
-  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
+function parseDownloadConflict(value) {
+  if (value === void 0) {
+    return "refuse";
+  }
+  if (value === "refuse" || value === "overwrite") {
+    return value;
+  }
+  throw new Error('runner.download_conflict: expected "refuse" or "overwrite".');
 }
-function serializeOpenCodeMcpEnv(servers) {
-  const mcp = {};
-  for (const [name, server] of Object.entries(servers)) {
-    const entry = { type: "local", command: [server.command, ...server.args ?? []] };
-    if (server.env && Object.keys(server.env).length > 0) {
-      entry.environment = server.env;
+function parseBuildArgs(value) {
+  if (value === void 0) {
+    return {};
+  }
+  const record = asRecord(value);
+  if (record === void 0) {
+    throw new Error("build_args: expected an object.");
+  }
+  const parsed = {};
+  for (const [key, entry] of Object.entries(record)) {
+    if (typeof entry !== "string") {
+      throw new Error(`build_args.${key}: expected a string.`);
     }
-    mcp[name] = entry;
+    parsed[key] = entry;
   }
-  return { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp }) };
+  return parsed;
 }
-function serializeCodexMcpArgs(servers) {
-  const args = [];
-  for (const [name, server] of Object.entries(servers)) {
-    const prefix = `mcp_servers.${name}`;
-    args.push("-c", `${prefix}.command=${toTomlString(server.command)}`);
-    if (server.args && server.args.length > 0) {
-      args.push("-c", `${prefix}.args=${toTomlArray(server.args)}`);
+function parseMounts(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("mounts: expected an array.");
+  }
+  return value.map((entry, index) => {
+    const record = asRecord(entry);
+    if (record === void 0) {
+      throw new Error(`mounts[${index}]: expected an object.`);
     }
-    if (server.env && Object.keys(server.env).length > 0) {
-      args.push("-c", `${prefix}.env=${toTomlInlineTable(server.env)}`);
+    const source = record.source;
+    const target = record.target;
+    if (typeof source !== "string") {
+      throw new Error(`mounts[${index}].source: expected a string.`);
     }
-    if (server.timeout !== void 0) {
-      args.push("-c", `${prefix}.timeout=${server.timeout}`);
+    if (typeof target !== "string") {
+      throw new Error(`mounts[${index}].target: expected a string.`);
     }
+    return omitUndefined({
+      source,
+      target,
+      readonly: parseOptionalBoolean(record.readonly, `mounts[${index}].readonly`)
+    });
+  });
+}
+function parseOptionalStringArray(value, key = "") {
+  if (value === void 0) {
+    return void 0;
   }
-  return args;
+  if (!Array.isArray(value)) {
+    throw new Error(`${key ? `${key}: ` : ""}expected an array.`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw new Error(`${key}[${index}]: expected a string.`);
+    }
+    return entry;
+  });
 }
-function serializeGooseMcpArgs(servers) {
-  return Object.values(servers).flatMap((server) => [
-    "--with-extension",
-    [server.command, ...server.args ?? []].join(" ")
-  ]);
+function parseOptionalNumber(value, key = "") {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${key ? `${key}: ` : ""}expected a finite number.`);
+  }
+  return value;
+}
+function parseOptionalBoolean(value, key) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`${key}: expected a boolean.`);
+  }
+  return value;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function omitUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 
-// packages/agent-spawn/src/configs/claude-code.ts
-var claudeCodeSpawnConfig = {
-  kind: "cli",
-  agentId: "claude-code",
-  // ACP adapter support: yes (adapter: "claude")
-  adapter: "claude",
-  promptFlag: "-p",
-  modelFlag: "--model",
-  modelStripProviderPrefix: true,
-  modelTransform: (model) => model.replaceAll(".", "-"),
-  defaultArgs: [
-    "--output-format",
-    "stream-json",
-    "--verbose"
-  ],
-  mcpArgs: serializeJsonMcpArgs,
-  modes: {
-    yolo: ["--dangerously-skip-permissions"],
-    edit: ["--permission-mode", "acceptEdits", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,NotebookEdit"],
-    read: ["--permission-mode", "plan"]
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--input-format", "text"]
-  },
-  interactive: {
-    defaultArgs: []
-  },
-  resumeCommand: (threadId) => ["--resume", threadId]
-};
+// packages/poe-code-config/src/schema.ts
+function defineScope(scope, schema) {
+  return {
+    scope,
+    schema
+  };
+}
 
-// packages/agent-spawn/src/configs/codex.ts
-var codexSpawnConfig = {
-  kind: "cli",
-  agentId: "codex",
-  // ACP adapter support: yes (adapter: "codex")
-  adapter: "codex",
-  promptFlag: "exec",
-  modelFlag: "--model",
-  modelStripProviderPrefix: true,
-  defaultArgs: ["--skip-git-repo-check", "--json"],
-  mcpArgs: serializeCodexMcpArgs,
-  mcpArgsBeforeCommand: true,
-  modes: {
-    yolo: ["-s", "danger-full-access"],
-    edit: ["-s", "workspace-write"],
-    read: ["-s", "read-only"]
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["-"]
-  },
-  interactive: {
-    defaultArgs: ["-a", "never"]
-  },
-  resumeCommand: (threadId, cwd) => ["resume", "-C", cwd, threadId]
-};
+// packages/poe-code-config/src/plan-scope.ts
+var planConfigScope = defineScope("plan", {
+  plan_directory: {
+    type: "string",
+    default: "docs/plans",
+    env: "POE_PLAN_DIRECTORY",
+    doc: "Directory where planning documents are stored"
+  }
+});
 
-// packages/agent-spawn/src/configs/opencode.ts
-var openCodeSpawnConfig = {
-  kind: "cli",
-  agentId: "opencode",
-  // ACP adapter support: yes (adapter: "opencode").
-  // OpenCode's `--format json` emits NDJSON events with `{ type, sessionID, part }`
-  // (no `{ event, ... }` field), so it needs the OpenCode adapter (not "native").
-  adapter: "opencode",
-  promptFlag: "run",
-  modelFlag: "--model",
-  modelStripProviderPrefix: false,
-  modelTransform: (model) => {
-    return model.startsWith("poe/") ? model : `poe/${model}`;
-  },
-  defaultArgs: ["--format", "json"],
-  modes: {
-    yolo: [],
-    edit: [],
-    read: ["--agent", "plan"]
-  },
-  interactive: {
-    defaultArgs: [],
-    promptFlag: "--prompt"
-  },
-  resumeCommand: (threadId, cwd) => [cwd, "--session", threadId],
-  mcpEnv: serializeOpenCodeMcpEnv
-};
-var openCodeAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "opencode",
-  acpArgs: ["acp"],
-  skipAuth: true,
-  mcpEnv: serializeOpenCodeMcpEnv
-};
+// packages/poe-code-config/src/store.ts
+import path8 from "node:path";
 
-// packages/agent-spawn/src/configs/kimi.ts
-var kimiSpawnConfig = {
-  kind: "cli",
-  agentId: "kimi",
-  // ACP adapter support: yes (adapter: "kimi").
-  // Kimi's `--output-format stream-json` emits OpenAI-style `{ role, content }` JSON
-  // (no `{ event, ... }` field), so it needs the Kimi adapter (not "native").
-  adapter: "kimi",
-  promptFlag: "-p",
-  modelStripProviderPrefix: true,
-  defaultArgs: ["--print", "--output-format", "stream-json"],
-  mcpArgs: serializeJsonMcpArgs,
-  modes: {
-    yolo: ["--yolo"],
-    edit: [],
-    read: []
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--input-format", "stream-json"]
-  },
-  interactive: {
-    defaultArgs: [],
-    promptFlag: "-p"
-  },
-  resumeCommand: (threadId, cwd) => ["--session", threadId, "--work-dir", cwd]
-};
-var kimiAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "kimi",
-  acpArgs: ["acp"]
-};
+// packages/config-extends/src/discover.ts
+import path4 from "node:path";
 
-// packages/agent-spawn/src/configs/goose.ts
-var gooseFileSecretsEnv = { GOOSE_DISABLE_KEYRING: "1" };
-var gooseSpawnConfig = {
-  kind: "cli",
-  agentId: "goose",
-  adapter: "native",
-  promptFlag: "--text",
-  modelFlag: "--model",
-  modelStripProviderPrefix: false,
-  defaultArgs: ["run", "--output-format", "stream-json"],
-  defaultArgsPosition: "beforePrompt",
-  mcpArgs: serializeGooseMcpArgs,
-  mcpArgsPosition: "beforePrompt",
-  modes: {
-    yolo: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "auto" } },
-    edit: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "smart_approve" } },
-    read: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "chat" } }
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--instructions", "-"]
-  },
-  interactive: {
-    defaultArgs: ["session"],
-    defaultArgsPosition: "beforePrompt"
-  },
-  resumeCommand: () => ["run", "--resume", "--text", "continue"]
-};
-var gooseAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "goose",
-  acpArgs: ["acp"],
-  env: gooseFileSecretsEnv,
-  skipAuth: true
-};
+// packages/config-extends/src/parse.ts
+import path5 from "node:path";
+import matter from "gray-matter";
+import { parse as parseYaml } from "yaml";
 
-// packages/agent-spawn/src/configs/index.ts
-var allSpawnConfigs = [
-  claudeCodeSpawnConfig,
-  codexSpawnConfig,
-  openCodeSpawnConfig,
-  kimiSpawnConfig,
-  gooseSpawnConfig
-];
-var lookup2 = /* @__PURE__ */ new Map();
-for (const config of allSpawnConfigs) {
-  lookup2.set(config.agentId, config);
+// packages/config-extends/src/resolve.ts
+import path6 from "node:path";
+
+// packages/config-mutations/src/mutations/config-mutation.ts
+function merge(options) {
+  return {
+    kind: "configMerge",
+    target: options.target,
+    value: options.value,
+    format: options.format,
+    pruneByPrefix: options.pruneByPrefix,
+    label: options.label
+  };
 }
-var acpLookup = /* @__PURE__ */ new Map();
-acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
-acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
-acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
-function getSpawnConfig(input) {
-  const resolvedId = resolveAgentId(input);
-  if (!resolvedId) {
-    return void 0;
-  }
-  return lookup2.get(resolvedId);
+function prune(options) {
+  return {
+    kind: "configPrune",
+    target: options.target,
+    shape: options.shape,
+    format: options.format,
+    onlyIf: options.onlyIf,
+    label: options.label
+  };
 }
-function listMcpSupportedAgents() {
-  const supported = [];
-  for (const config of allSpawnConfigs) {
-    if (config.kind !== "cli" || typeof config.mcpArgs !== "function" && typeof config.mcpEnv !== "function") {
-      continue;
-    }
-    supported.push(config.agentId);
-  }
-  return supported;
+function transform(options) {
+  return {
+    kind: "configTransform",
+    target: options.target,
+    format: options.format,
+    transform: options.transform,
+    label: options.label
+  };
 }
+var configMutation = {
+  merge,
+  prune,
+  transform
+};
 
-// packages/agent-spawn/src/spawn.ts
-import { spawn as spawnChildProcess } from "node:child_process";
-import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path from "node:path";
-
-// packages/agent-spawn/src/configs/resolve-config.ts
-function resolveConfig(agentId) {
-  const resolvedAgentId = resolveAgentId(agentId);
-  if (!resolvedAgentId) {
-    throw new Error(`Unknown agent "${agentId}".`);
-  }
-  const agentDefinition = allAgents.find((agent) => agent.id === resolvedAgentId);
-  if (!agentDefinition) {
-    throw new Error(`Unknown agent "${agentId}".`);
-  }
-  const spawnConfig = getSpawnConfig(resolvedAgentId);
-  const binaryName = agentDefinition.binaryName;
-  return { agentId: resolvedAgentId, binaryName, spawnConfig };
+// packages/config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
 }
-
-// packages/agent-spawn/src/mcp-args.ts
-function hasMcpServers(servers) {
-  if (!servers) {
-    return false;
-  }
-  return Object.keys(servers).length > 0;
+function remove(options) {
+  return {
+    kind: "removeFile",
+    target: options.target,
+    whenEmpty: options.whenEmpty,
+    whenContentMatches: options.whenContentMatches,
+    label: options.label
+  };
 }
-function getMcpArgs(config, servers) {
-  if (!hasMcpServers(servers)) {
-    return [];
-  }
-  if (!config.mcpArgs && !config.mcpEnv) {
-    throw new Error(formatUnsupportedMcpSpawnMessage(config.agentId));
-  }
-  if (!config.mcpArgs) {
-    return [];
-  }
-  return config.mcpArgs(servers);
+function removeDirectory(options) {
+  return {
+    kind: "removeDirectory",
+    path: options.path,
+    force: options.force,
+    label: options.label
+  };
 }
-function formatUnsupportedMcpSpawnMessage(agentId) {
-  const supported = listMcpSupportedAgents();
-  const supportedText = supported.length > 0 ? supported.join(", ") : "(none)";
-  return `Agent "${agentId}" does not support MCP servers at spawn time.
-Agents with spawn-time MCP support: ${supportedText}`;
+function chmod(options) {
+  return {
+    kind: "chmod",
+    target: options.target,
+    mode: options.mode,
+    label: options.label
+  };
 }
-
-// packages/agent-spawn/src/model-utils.ts
-function stripModelNamespace(model) {
-  const slashIndex = model.indexOf("/");
-  return slashIndex === -1 ? model : model.slice(slashIndex + 1);
+function backup(options) {
+  return {
+    kind: "backup",
+    target: options.target,
+    label: options.label
+  };
 }
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup
+};
 
-// packages/agent-spawn/src/spawn.ts
-function resolveCliConfig(agentId) {
-  const resolved = resolveConfig(agentId);
-  if (!resolved.spawnConfig) {
-    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
+// packages/config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse2(content) {
+  if (!content || content.trim() === "") {
+    return {};
   }
-  if (resolved.spawnConfig.kind !== "cli") {
-    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  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 (!resolved.binaryName) {
-    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
+  if (parsed === null || parsed === void 0) {
+    return {};
   }
-  return {
-    agentId: resolved.agentId,
-    binaryName: resolved.binaryName,
-    spawnConfig: resolved.spawnConfig
-  };
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
 }
-function getDefaultArgsPosition(config) {
-  return config.defaultArgsPosition ?? "afterPrompt";
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
 }
-function getMcpArgsPosition(config) {
-  if (config.mcpArgsPosition) {
-    return config.mcpArgsPosition;
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
   }
-  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+  return result;
 }
-function buildCliArgs(config, options, stdinMode) {
-  const mcpArgs = getMcpArgs(config, options.mcpServers);
-  const defaultArgsPosition = getDefaultArgsPosition(config);
-  const mcpArgsPosition = getMcpArgsPosition(config);
-  const args = [];
-  if (mcpArgsPosition === "beforeCommand") {
-    args.push(...mcpArgs);
-  }
-  if (defaultArgsPosition === "beforePrompt") {
-    args.push(...config.defaultArgs);
-  }
-  if (mcpArgsPosition === "beforePrompt") {
-    args.push(...mcpArgs);
-  }
-  if (stdinMode) {
-    args.push(
-      config.promptFlag,
-      ...stdinMode.omitPrompt ? [] : [options.prompt],
-      ...stdinMode.extraArgs
-    );
-  } else {
-    args.push(config.promptFlag, options.prompt);
-  }
-  if (options.model && config.modelFlag) {
-    let model = config.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
-    if (config.modelTransform) model = config.modelTransform(model);
-    args.push(config.modelFlag, model);
-  }
-  if (defaultArgsPosition === "afterPrompt") {
-    args.push(...config.defaultArgs);
-  }
-  if (mcpArgsPosition === "afterCommand") {
-    args.push(...mcpArgs);
-  }
-  const mode = resolveModeConfig(config.modes[options.mode ?? "yolo"]);
-  args.push(...mode.args);
-  if (options.args && options.args.length > 0) {
-    args.push(...options.args);
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
   }
-  return { args, env: mode.env };
-}
-function buildSpawnArgs(agentId, options) {
-  const { binaryName, spawnConfig } = resolveCliConfig(agentId);
-  const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
-  const result = buildCliArgs(spawnConfig, options, stdinMode);
-  return { binaryName, args: result.args, env: result.env };
+  return { changed, result };
 }
-
-// packages/agent-spawn/src/spawn-interactive.ts
-import { spawn as spawnChildProcess2 } from "node:child_process";
-
-// packages/design-system/src/tokens/colors.ts
-import chalk from "chalk";
-var dark = {
-  header: (text4) => chalk.magentaBright.bold(text4),
-  divider: (text4) => chalk.dim(text4),
-  prompt: (text4) => chalk.cyan(text4),
-  number: (text4) => chalk.cyanBright(text4),
-  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
-  resolvedSymbol: chalk.magenta("\u25C7"),
-  errorSymbol: chalk.red("\u25A0"),
-  accent: (text4) => chalk.cyan(text4),
-  muted: (text4) => chalk.dim(text4),
-  success: (text4) => chalk.green(text4),
-  warning: (text4) => chalk.yellow(text4),
-  error: (text4) => chalk.red(text4),
-  info: (text4) => chalk.magenta(text4),
-  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
-};
-var light = {
-  header: (text4) => chalk.hex("#a200ff").bold(text4),
-  divider: (text4) => chalk.hex("#666666")(text4),
-  prompt: (text4) => chalk.hex("#006699").bold(text4),
-  number: (text4) => chalk.hex("#0077cc").bold(text4),
-  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
-  resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
-  errorSymbol: chalk.hex("#cc0000")("\u25A0"),
-  accent: (text4) => chalk.hex("#006699").bold(text4),
-  muted: (text4) => chalk.hex("#666666")(text4),
-  success: (text4) => chalk.hex("#008800")(text4),
-  warning: (text4) => chalk.hex("#cc6600")(text4),
-  error: (text4) => chalk.hex("#cc0000")(text4),
-  info: (text4) => chalk.hex("#a200ff")(text4),
-  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+var jsonFormat = {
+  parse: parse2,
+  serialize,
+  merge: merge2,
+  prune: prune2
 };
 
-// packages/design-system/src/tokens/typography.ts
-import chalk2 from "chalk";
-
-// packages/design-system/src/components/text.ts
-import chalk3 from "chalk";
-
-// packages/design-system/src/internal/output-format.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
-var formatStorage = new AsyncLocalStorage();
-var cached;
-function resolveOutputFormat(env = process.env) {
-  const scoped = formatStorage.getStore();
-  if (scoped) {
-    return scoped;
+// packages/config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
   }
-  if (cached) {
-    return cached;
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
   }
-  const raw = env.OUTPUT_FORMAT?.toLowerCase();
-  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
-  return cached;
+  return parsed;
 }
-
-// packages/design-system/src/internal/theme-detect.ts
-function detectThemeFromEnv(env) {
-  const apple = env.APPLE_INTERFACE_STYLE;
-  if (typeof apple === "string") {
-    return apple.toLowerCase() === "dark" ? "dark" : "light";
-  }
-  const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
-  if (typeof vscodeKind === "string") {
-    const normalized = vscodeKind.toLowerCase();
-    if (normalized.includes("light")) {
-      return "light";
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge3(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
     }
-    if (normalized.includes("dark")) {
-      return "dark";
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge3(existing, value);
+      continue;
     }
+    result[key] = value;
   }
-  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 result;
+}
+function prune3(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune3(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
     }
+    delete result[key];
+    changed = true;
   }
-  return void 0;
+  return { changed, result };
 }
-function resolveThemeName(env = process.env) {
-  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
-  if (raw === "light" || raw === "dark") {
-    return raw;
+var tomlFormat = {
+  parse: parse3,
+  serialize: serialize2,
+  merge: merge3,
+  prune: prune3
+};
+
+// packages/config-mutations/src/formats/yaml.ts
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse4(content) {
+  if (!content || content.trim() === "") {
+    return {};
   }
-  const detected = detectThemeFromEnv(env);
-  if (detected) {
-    return detected;
+  const parsed = parseYaml2(content);
+  if (parsed === null || parsed === void 0) {
+    return {};
   }
-  return "dark";
-}
-var cachedTheme;
-function getTheme(env) {
-  if (cachedTheme) {
-    return cachedTheme;
+  if (!isConfigObject3(parsed)) {
+    throw new Error("Expected YAML object.");
   }
-  const themeName = resolveThemeName(env);
-  cachedTheme = themeName === "light" ? light : dark;
-  return cachedTheme;
+  return parsed;
 }
-
-// packages/design-system/src/components/symbols.ts
-import chalk4 from "chalk";
-var symbols = {
-  get info() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "info";
-    if (format === "markdown") return "(i)";
-    return chalk4.magenta("\u25CF");
-  },
-  get success() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "success";
-    if (format === "markdown") return "[ok]";
-    return chalk4.magenta("\u25C6");
-  },
-  get resolved() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "resolved";
-    if (format === "markdown") return ">";
-    return getTheme().resolvedSymbol;
-  },
-  get errorResolved() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "error";
-    if (format === "markdown") return "[!]";
-    return getTheme().errorSymbol;
-  },
-  get bar() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "";
-    if (format === "markdown") return "|";
-    return "\u2502";
-  },
-  cornerTopRight: "\u256E",
-  cornerBottomRight: "\u256F",
-  get warning() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "warning";
-    if (format === "markdown") return "[!]";
-    return "\u25B2";
-  },
-  get active() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "active";
-    if (format === "markdown") return "[x]";
-    return "\u25C6";
-  },
-  get inactive() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "inactive";
-    if (format === "markdown") return "[ ]";
-    return "\u25CB";
-  }
-};
-
-// packages/design-system/src/components/logger.ts
-import chalk6 from "chalk";
-
-// packages/design-system/src/prompts/primitives/log.ts
-import chalk5 from "chalk";
-
-// packages/design-system/src/internal/strip-ansi.ts
-function stripAnsi(value) {
-  return value.replace(/\u001b\[[0-9;]*m/g, "");
+function serialize3(obj) {
+  const serialized = stringifyYaml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
 }
-
-// packages/design-system/src/prompts/primitives/log.ts
-function writeTerminalMessage(msg, {
-  symbol = chalk5.gray("\u2502"),
-  secondarySymbol = chalk5.gray("\u2502"),
-  spacing: spacing2 = 1,
-  withGuide = true
-} = {}) {
-  const lines = [];
-  const showGuide = withGuide !== false;
-  const contentLines = msg.split("\n");
-  const prefix = showGuide ? `${symbol}  ` : "";
-  const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
-  const emptyGuide = showGuide ? secondarySymbol : "";
-  for (let index = 0; index < spacing2; index += 1) {
-    lines.push(emptyGuide);
-  }
-  if (contentLines.length === 0) {
-    process.stdout.write("\n");
-    return;
-  }
-  const [firstLine = "", ...continuationLines] = contentLines;
-  if (firstLine.length > 0) {
-    lines.push(`${prefix}${firstLine}`);
-  } else {
-    lines.push(showGuide ? symbol : "");
-  }
-  for (const line of continuationLines) {
-    if (line.length > 0) {
-      lines.push(`${continuationPrefix}${line}`);
+function merge4(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
       continue;
     }
-    lines.push(emptyGuide);
+    const existing = result[key];
+    if (isConfigObject3(existing) && isConfigObject3(value)) {
+      result[key] = merge4(existing, value);
+      continue;
+    }
+    result[key] = value;
   }
-  process.stdout.write(`${lines.join("\n")}
-`);
+  return result;
 }
-function message(msg, options) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "message", message: stripAnsi(msg) })}
-`
-    );
-    return;
+function prune4(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject3(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject3(pattern) && isConfigObject3(current)) {
+      const { changed: childChanged, result: childResult } = prune4(current, pattern);
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
   }
-  writeTerminalMessage(msg, options);
+  return { changed, result };
 }
-function info(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **info:** ${stripAnsi(msg)}
-`);
-    return;
+var yamlFormat = {
+  parse: parse4,
+  serialize: serialize3,
+  merge: merge4,
+  prune: prune4
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat,
+  yaml: yamlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
   }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "info", message: stripAnsi(msg) })}
-`
+  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;
   }
-  message(msg, { symbol: symbols.info });
+  return formatRegistry[formatName];
 }
-function success(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **success:** ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "success", message: stripAnsi(msg) })}
-`
-    );
-    return;
+function detectFormat(path18) {
+  const ext = getExtension(path18);
+  return extensionMap[ext];
+}
+function getExtension(path18) {
+  const lastDot = path18.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
   }
-  message(msg, { symbol: symbols.success });
+  return path18.slice(lastDot).toLowerCase();
 }
-function warn(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **warning:** ${stripAnsi(msg)}
-`);
-    return;
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path7 from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
   }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
-`
-    );
-    return;
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
   }
-  message(msg, { symbol: chalk5.yellow("\u25B2") });
+  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 : path7.join(homeDir, remainder);
 }
-function error(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **error:** ${stripAnsi(msg)}
-`);
-    return;
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
   }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
-`
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
     );
-    return;
   }
-  message(msg, { symbol: chalk5.red("\u25A0") });
 }
-var log = {
-  info,
-  success,
-  message,
-  warn,
-  error
-};
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path7.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path7.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path7.join(mappedDirectory, filename);
+}
 
-// packages/design-system/src/components/logger.ts
-function createLogger(emitter) {
-  const emit = (level, message2) => {
-    if (emitter) {
-      emitter(message2);
-      return;
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+}
+async function readFileIfExists(fs, target) {
+  try {
+    return await fs.readFile(target, "utf8");
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return null;
     }
-    if (level === "success") {
-      log.success(message2);
-      return;
+    throw error2;
+  }
+}
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return false;
     }
-    if (level === "warn") {
-      log.warn(message2);
-      return;
+    throw error2;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
     }
-    if (level === "error") {
-      log.error(message2);
-      return;
+  }
+  return result;
+}
+function isConfigObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject4(current) && isConfigObject4(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
     }
-    log.info(message2);
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
   };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
   return {
-    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 });
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
     },
-    message(message2, symbol) {
-      if (emitter) {
-        emitter(message2);
-        return;
-      }
-      log.message(message2, { symbol: symbol ?? chalk6.gray("\u2502") });
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
     }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error2;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat2 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat2.mode === "number" ? stat2.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error2;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error2) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error2}`,
+      { cause: error2 }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
   };
 }
-var logger = createLogger();
-
-// packages/design-system/src/components/table.ts
-import { Table } from "console-table-printer";
-
-// packages/design-system/src/acp/components.ts
-import chalk7 from "chalk";
-
-// packages/design-system/src/acp/writer.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var storage = new AsyncLocalStorage2();
-
-// packages/design-system/src/acp/components.ts
-var AGENT_PREFIX = `${chalk7.green.bold("\u2713")} agent: `;
-
-// packages/design-system/src/dashboard/buffer.ts
-import chalk8 from "chalk";
-
-// packages/design-system/src/dashboard/terminal.ts
-import readline from "node:readline";
-import { PassThrough } from "node:stream";
-
-// packages/design-system/src/prompts/index.ts
-import chalk15 from "chalk";
-import * as clack from "@clack/prompts";
-
-// packages/design-system/src/prompts/primitives/cancel.ts
-import chalk9 from "chalk";
-import { isCancel } from "@clack/prompts";
-
-// packages/design-system/src/prompts/primitives/intro.ts
-import chalk10 from "chalk";
-
-// packages/design-system/src/prompts/primitives/note.ts
-import chalk11 from "chalk";
-
-// packages/design-system/src/prompts/primitives/outro.ts
-import chalk12 from "chalk";
 
-// packages/design-system/src/prompts/primitives/spinner.ts
-import chalk14 from "chalk";
+// packages/config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error2) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error2
+    );
+    throw error2;
+  }
+}
 
-// packages/design-system/src/static/spinner.ts
-import chalk13 from "chalk";
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
 
-// packages/design-system/src/static/menu.ts
-import chalk16 from "chalk";
+// packages/poe-code-config/src/store.ts
+var EMPTY_DOCUMENT = `${JSON.stringify({}, null, 2)}
+`;
 
-// packages/agent-spawn/src/autonomous.ts
-var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
+// packages/poe-code-config/src/inspect.ts
+import path9 from "node:path";
+var EMPTY_DOCUMENT2 = `${JSON.stringify({}, null, 2)}
+`;
 
-// packages/agent-spawn/src/acp/replay.ts
-import path2 from "node:path";
-import { homedir as homedir2 } from "node:os";
-import { open, readdir } from "node:fs/promises";
-import { createInterface } from "node:readline";
+// packages/poe-code-config/src/state/index.ts
+import os2 from "node:os";
 
-// packages/poe-acp-client/src/acp-client.ts
-import { isAbsolute } from "node:path";
+// packages/poe-code-config/src/state/jobs.ts
+import path10 from "node:path";
 
-// packages/poe-acp-client/src/acp-transport.ts
-import {
-  spawn as spawnChildProcess3
-} from "node:child_process";
+// packages/poe-code-config/src/state/fs.ts
+import * as nodeFs2 from "node:fs/promises";
 
-// packages/poe-acp-client/src/run-report.ts
-import * as fsPromises from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
+// packages/poe-code-config/src/state/templates.ts
+import path11 from "node:path";
 
-// packages/agent-spawn/src/acp/spawn.ts
-import { spawn as spawnChildProcess4 } from "node:child_process";
+// packages/agent-harness-tools/src/execution-env.ts
+var executionEnvFactories = /* @__PURE__ */ new Map();
+function registerExecutionEnvFactory(factory) {
+  executionEnvFactories.set(factory.type, factory);
+}
 
-// packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path3 from "node:path";
-import { homedir as homedir3 } from "node:os";
-import { mkdir, open as open2 } from "node:fs/promises";
+// packages/agent-harness-tools/src/workspace-transfer.ts
+import { createHash } from "node:crypto";
+import { promises as nodeFs3 } from "node:fs";
+import path12 from "node:path";
 
-// src/utils/command-checks.ts
-function formatCommandRunnerResult(result) {
-  const stdout = result.stdout.length > 0 ? result.stdout : "<empty>";
-  const stderr = result.stderr.length > 0 ? result.stderr : "<empty>";
-  return `stdout:
-${stdout}
-stderr:
-${stderr}`;
-}
-function createSpawnHealthCheck(agentId, options) {
-  const prompt = `Output exactly: ${options.expectedOutput}`;
-  const { binaryName, args, env: modeEnv } = buildSpawnArgs(agentId, {
-    prompt,
-    model: options.model,
-    mode: "yolo"
-  });
-  return {
-    id: `${agentId}-cli-health`,
-    description: `spawn ${agentId} (expecting "${options.expectedOutput}")`,
-    async run(context) {
-      if (context.isDryRun) {
-        context.logDryRun?.(
-          `Dry run: ${[binaryName, ...args].join(" ")} (expecting "${options.expectedOutput}")`
-        );
-        return;
-      }
-      const result = modeEnv ? await context.runCommand(binaryName, args, { env: modeEnv }) : await context.runCommand(binaryName, args);
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `spawn ${agentId} failed with exit code ${result.exitCode}.
-${formatCommandRunnerResult(result)}`
-        );
-      }
-      if (!result.stdout.includes(options.expectedOutput)) {
-        throw new Error(
-          `spawn ${agentId}: expected "${options.expectedOutput}" in stdout.
-${formatCommandRunnerResult(result)}`
-        );
-      }
-    }
-  };
-}
-function createBinaryExistsCheck(binaryName, id, description) {
-  return {
-    id,
-    description,
-    async run({ runCommand: runCommand2 }) {
-      const commonPaths = [
-        `/usr/local/bin/${binaryName}`,
-        `/usr/bin/${binaryName}`,
-        `$HOME/.local/bin/${binaryName}`,
-        `$HOME/.claude/local/bin/${binaryName}`
-      ];
-      const detectors = [
-        {
-          command: "which",
-          args: [binaryName],
-          validate: (result) => result.exitCode === 0
-        },
-        {
-          command: "where",
-          args: [binaryName],
-          validate: (result) => result.exitCode === 0 && result.stdout.trim().length > 0
-        },
-        // Check common installation paths using shell expansion for $HOME
-        {
-          command: "sh",
-          args: [
-            "-c",
-            commonPaths.map((p) => `test -f "${p}"`).join(" || ")
-          ],
-          validate: (result) => result.exitCode === 0
-        }
-      ];
-      for (const detector of detectors) {
-        const result = await runCommand2(detector.command, detector.args);
-        if (detector.validate(result)) {
-          return;
+// packages/process-runner/src/docker/context.ts
+import { execSync } from "node:child_process";
+function detectContext() {
+  try {
+    const output = execSync("colima list --json", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const lines = output.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const profile = JSON.parse(line);
+      if (profile.status === "Running" && profile.runtime === "docker") {
+        const name = profile.name ?? profile.profile;
+        if (!name) {
+          continue;
         }
+        return name === "default" ? "colima" : `colima-${name}`;
       }
-      throw new Error(`${binaryName} CLI binary not found on PATH.`);
     }
-  };
-}
-
-// packages/config-mutations/src/mutations/config-mutation.ts
-function merge(options) {
-  return {
-    kind: "configMerge",
-    target: options.target,
-    value: options.value,
-    format: options.format,
-    pruneByPrefix: options.pruneByPrefix,
-    label: options.label
-  };
-}
-function prune(options) {
-  return {
-    kind: "configPrune",
-    target: options.target,
-    shape: options.shape,
-    format: options.format,
-    onlyIf: options.onlyIf,
-    label: options.label
-  };
-}
-function transform(options) {
-  return {
-    kind: "configTransform",
-    target: options.target,
-    format: options.format,
-    transform: options.transform,
-    label: options.label
-  };
+  } catch {
+    return null;
+  }
+  return null;
+}
+function buildContextArgs(engine, context) {
+  if (engine === "docker" && context) {
+    return ["--context", context];
+  }
+  return [];
 }
-var configMutation = {
-  merge,
-  prune,
-  transform
-};
 
-// packages/config-mutations/src/mutations/file-mutation.ts
-function ensureDirectory(options) {
-  return {
-    kind: "ensureDirectory",
-    path: options.path,
-    label: options.label
-  };
+// packages/process-runner/src/docker/engine.ts
+import { execSync as execSync2 } from "node:child_process";
+function detectEngine() {
+  if (isEngineAvailable("docker")) {
+    return "docker";
+  }
+  if (isEngineAvailable("podman")) {
+    return "podman";
+  }
+  throw new Error(
+    "No container engine found. Please install Docker or Podman:\n  - Docker Desktop: https://www.docker.com/products/docker-desktop\n  - Colima (macOS): brew install colima && colima start\n  - Podman: https://podman.io/docs/installation"
+  );
 }
-function remove(options) {
-  return {
-    kind: "removeFile",
-    target: options.target,
-    whenEmpty: options.whenEmpty,
-    whenContentMatches: options.whenContentMatches,
-    label: options.label
-  };
+function isEngineAvailable(engine) {
+  try {
+    execSync2(`${engine} --version`, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
 }
-function removeDirectory(options) {
-  return {
-    kind: "removeDirectory",
-    path: options.path,
-    force: options.force,
-    label: options.label
-  };
+
+// packages/process-runner/src/docker/docker-runner.ts
+import * as childProcess from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// packages/process-runner/src/docker/args.ts
+import path13 from "node:path";
+function buildDockerRunArgs(input) {
+  const args = [input.engine];
+  if (input.engine === "docker" && input.context) {
+    args.push("--context", input.context);
+  }
+  args.push("run");
+  if (input.rm) {
+    args.push("--rm");
+  }
+  if (input.detached) {
+    args.push("-d");
+  }
+  if (input.interactive) {
+    args.push("-i");
+  }
+  if (input.tty) {
+    args.push("-t");
+  }
+  args.push("--name", input.containerName);
+  if (input.cwd !== void 0) {
+    args.push("-w", input.cwd);
+  }
+  for (const [key, value] of Object.entries(input.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  for (const mount of input.mounts) {
+    const volume = `${path13.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    args.push("-v", volume);
+  }
+  for (const port of input.ports) {
+    const mapping = `${port.host}:${port.container}${port.protocol === void 0 || port.protocol === "tcp" ? "" : `/${port.protocol}`}`;
+    args.push("-p", mapping);
+  }
+  if (input.network !== void 0) {
+    args.push("--network", input.network);
+  }
+  args.push(...input.extraArgs, input.image, input.command, ...input.args);
+  return args;
 }
-function chmod(options) {
+
+// packages/process-runner/src/docker/docker-execution-env.ts
+import { createHash as createHash2, randomBytes as randomBytes3 } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path14 from "node:path";
+
+// packages/process-runner/src/host/host-runner.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+function createHostRunner(options = {}) {
+  const detached = options.detached === true;
   return {
-    kind: "chmod",
-    target: options.target,
-    mode: options.mode,
-    label: options.label
+    name: "host",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" ? "inherit" : [stdinMode, stdoutMode, stderrMode];
+      const child = spawnChildProcess(spec.command, spec.args ?? [], {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio,
+        ...detached ? { detached: true } : {}
+      });
+      if (detached) {
+        child.unref();
+      }
+      const kill = (signal) => {
+        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+          process.kill(-child.pid, signal);
+          return;
+        }
+        child.kill(signal);
+      };
+      let settled = false;
+      let resolveResult = null;
+      const result = new Promise((resolve2) => {
+        resolveResult = resolve2;
+      });
+      const cleanupAbort = bindAbortSignal(spec.signal, () => {
+        kill("SIGTERM");
+      });
+      child.once("close", (code) => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: code ?? 1 });
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: 1 });
+      });
+      return {
+        pid: child.pid ?? null,
+        stdin: child.stdin,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        result,
+        kill
+      };
+    }
   };
 }
-function backup(options) {
-  return {
-    kind: "backup",
-    target: options.target,
-    label: options.label
+function bindAbortSignal(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
   };
 }
-var fileMutation = {
-  ensureDirectory,
-  remove,
-  removeDirectory,
-  chmod,
-  backup
-};
-
-// packages/config-mutations/src/execution/apply-mutation.ts
-import Mustache from "mustache";
 
-// packages/config-mutations/src/formats/json.ts
-import * as jsonc from "jsonc-parser";
-function isConfigObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// packages/process-runner/src/docker/docker-execution-env.ts
+var containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
+var dockerExecutionEnvFactory = {
+  type: "docker",
+  supportsDetach: true,
+  async open(spec) {
+    const runtime = parseDockerRuntime(spec.runtime);
+    const runner = spec.hostRunner ?? createHostRunner();
+    const engine = runtime.engine ?? detectEngine();
+    const context = detectContext();
+    const image = await resolveImage({
+      spec,
+      runtime,
+      runner,
+      engine,
+      context
+    });
+    const containerName = createContainerName();
+    const runArgs = buildDockerRunArgs({
+      engine,
+      context,
+      image,
+      command: containerCommand[0],
+      args: containerCommand.slice(1),
+      cwd: void 0,
+      env: void 0,
+      mounts: runtime.mounts ?? [],
+      ports: [],
+      network: runtime.network,
+      containerName,
+      detached: true,
+      interactive: true,
+      tty: false,
+      rm: false,
+      extraArgs: runtime.extra_args ?? []
+    });
+    const [command, ...args] = runArgs;
+    const id = (await runAndRead(runner, { command, args, stdout: "pipe", stderr: "pipe" })).trim();
+    return createDockerEnv({
+      id,
+      spec,
+      runner,
+      engine,
+      context
+    });
+  },
+  async attach(envId) {
+    const engine = detectEngine();
+    return createDockerEnv({
+      id: envId,
+      spec: createAttachedSpec(),
+      runner: createHostRunner(),
+      engine,
+      context: detectContext()
+    });
+  }
+};
+function createDockerEnv(input) {
+  const containerRef = input.id;
+  return {
+    id: containerRef,
+    job: null,
+    async uploadWorkspace() {
+      const tempDir = mkdtempSync(path14.join(tmpdir(), "poe-docker-upload-"));
+      const archivePath = path14.join(tempDir, "workspace.tar");
+      try {
+        const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
+          "--exclude",
+          ignored
+        ]);
+        const tarArgs = [...excludeArgs, "-cf", archivePath, "-C", input.spec.cwd, "."];
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: tarArgs,
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            archivePath,
+            `${containerRef}:/tmp/poe-workspace-upload.tar`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `mkdir -p ${shellQuote(input.spec.cwd)} && tar -xf /tmp/poe-workspace-upload.tar -C ${shellQuote(input.spec.cwd)}`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, skipped: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    async downloadWorkspace(opts) {
+      const tempDir = mkdtempSync(path14.join(tmpdir(), "poe-docker-download-"));
+      const archivePath = path14.join(tempDir, "workspace.tar");
+      try {
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote(input.spec.cwd)} .`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            `${containerRef}:/tmp/poe-workspace-download.tar`,
+            archivePath
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const extractMode = opts.conflictPolicy === "refuse" ? "-xkf" : "-xf";
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: [extractMode, archivePath, "-C", input.spec.cwd],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, conflicts: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    exec(spec) {
+      return input.runner.exec({
+        command: input.engine,
+        args: [
+          ...buildContextArgs(input.engine, input.context),
+          "exec",
+          ...spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : [],
+          ...spec.tty === true ? ["-t"] : [],
+          ...spec.cwd !== void 0 ? ["-w", spec.cwd] : [],
+          ...buildEnvArgs(spec.env),
+          containerRef,
+          spec.command,
+          ...spec.args ?? []
+        ],
+        stdin: spec.stdin,
+        stdout: spec.stdout,
+        stderr: spec.stderr,
+        tty: spec.tty
+      });
+    },
+    async detach() {
+      return createContainerJob(containerRef, input.runner, input.engine, input.context);
+    },
+    shell() {
+      const shellSpec = input.spec.shellSpec;
+      return this.exec({
+        command: shellSpec?.command ?? input.spec.env.SHELL ?? "sh",
+        ...shellSpec?.args ? { args: shellSpec.args } : {},
+        cwd: input.spec.cwd,
+        env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        tty: true
+      });
+    },
+    async close() {
+      await runOrThrow(input.runner, {
+        command: input.engine,
+        args: [...buildContextArgs(input.engine, input.context), "rm", "-f", containerRef],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    }
+  };
 }
-function parse3(content) {
-  if (!content || content.trim() === "") {
-    return {};
+async function resolveImage(input) {
+  if (input.runtime.image !== void 0) {
+    return input.runtime.image;
   }
-  const errors = [];
-  const parsed = jsonc.parse(content, errors, {
-    allowTrailingComma: true,
-    disallowComments: false
+  const dockerfilePath = path14.resolve(
+    input.spec.cwd,
+    input.runtime.dockerfile ?? path14.join(".poe-code", "Dockerfile")
+  );
+  const buildContext = path14.resolve(input.spec.cwd, input.runtime.build_context ?? ".");
+  const dockerfileBytes = await readFile2(dockerfilePath);
+  const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
+  const cached2 = await input.spec.state?.templates.get("docker", hash);
+  if (cached2?.image !== void 0) {
+    return cached2.image;
+  }
+  const image = `poe-code/local:${hash}`;
+  await buildImage({
+    runner: input.runner,
+    engine: input.engine,
+    context: input.context,
+    image,
+    dockerfilePath,
+    buildContext,
+    buildArgs: input.runtime.build_args ?? {}
   });
-  if (errors.length > 0) {
-    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  await input.spec.state?.templates.put("docker", {
+    hash,
+    image,
+    runtime_type: "docker",
+    dockerfile_path: dockerfilePath,
+    built_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return image;
+}
+function hashDockerTemplate(dockerfileBytes, buildArgs) {
+  const hash = createHash2("sha256");
+  hash.update(dockerfileBytes);
+  hash.update("\0");
+  for (const [key, value] of sortedBuildArgs(buildArgs)) {
+    hash.update(key);
+    hash.update("=");
+    hash.update(value);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function buildImage(input) {
+  await runOrThrow(input.runner, {
+    command: input.engine,
+    args: [
+      ...buildContextArgs(input.engine, input.context),
+      "build",
+      "--tag",
+      input.image,
+      "-f",
+      input.dockerfilePath,
+      ...sortedBuildArgs(input.buildArgs).flatMap(([key, value]) => [
+        "--build-arg",
+        `${key}=${value}`
+      ]),
+      input.buildContext
+    ],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+}
+function parseDockerRuntime(runtime) {
+  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+    throw new Error("docker runtime must be an object");
   }
-  if (parsed === null || parsed === void 0) {
-    return {};
+  const record = runtime;
+  if (record.type !== "docker") {
+    throw new Error('docker runtime type must be "docker"');
   }
-  if (!isConfigObject(parsed)) {
-    throw new Error("Expected JSON object.");
+  return record;
+}
+async function runAndRead(runner, spec) {
+  const handle = runner.exec(spec);
+  const stdout = readStream(handle.stdout);
+  const stderr = readStream(handle.stderr);
+  const result = await handle.result;
+  const output = await stdout;
+  if (result.exitCode !== 0) {
+    const errorOutput = await stderr;
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}${errorOutput ? `
+${errorOutput}` : ""}`
+    );
   }
-  return parsed;
+  return output;
 }
-function serialize(obj) {
-  return `${JSON.stringify(obj, null, 2)}
-`;
+async function runOrThrow(runner, spec) {
+  await runAndRead(runner, spec);
 }
-function merge2(base, patch) {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) {
-      continue;
-    }
-    const existing = result[key];
-    if (isConfigObject(existing) && isConfigObject(value)) {
-      result[key] = merge2(existing, value);
-      continue;
-    }
-    result[key] = value;
+async function readStream(stream) {
+  if (stream === null) {
+    return "";
   }
-  return result;
+  stream.setEncoding("utf8");
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
 }
-function prune2(obj, shape) {
-  let changed = false;
-  const result = { ...obj };
-  for (const [key, pattern] of Object.entries(shape)) {
-    if (!(key in result)) {
-      continue;
+function sortedBuildArgs(buildArgs) {
+  return Object.entries(buildArgs).sort(([left], [right]) => left.localeCompare(right));
+}
+function buildEnvArgs(env) {
+  if (env === void 0) {
+    return [];
+  }
+  return Object.entries(env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
+}
+function createContainerName() {
+  return `poe-env-${randomBytes3(6).toString("hex")}`;
+}
+async function createContainerJob(containerId, runner, engine, context) {
+  return {
+    id: containerId,
+    envId: containerId,
+    tool: "docker",
+    argv: ["attach", containerId],
+    async status() {
+      const handle = runner.exec({
+        command: engine,
+        args: [
+          ...buildContextArgs(engine, context),
+          "inspect",
+          "-f",
+          "{{.State.Status}}",
+          containerId
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      if (result.exitCode !== 0) {
+        return "lost";
+      }
+      return stdout.trim() === "running" ? "running" : "exited";
+    },
+    async *stream() {
+    },
+    async wait() {
+      const handle = runner.exec({
+        command: engine,
+        args: [...buildContextArgs(engine, context), "wait", containerId],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
+    },
+    async kill(signal) {
+      const args = signal === void 0 || signal === "SIGTERM" ? ["stop", containerId] : ["kill", ...signal === "SIGKILL" ? [] : [`--signal=${signal}`], containerId];
+      await runOrThrow(runner, {
+        command: engine,
+        args: [...buildContextArgs(engine, context), ...args],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
     }
-    const current = result[key];
-    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
-      delete result[key];
-      changed = true;
-      continue;
+  };
+}
+function createAttachedSpec() {
+  return {
+    cwd: "/workspace",
+    runtime: {
+      type: "docker",
+      image: "attached",
+      build_args: {},
+      mounts: []
+    },
+    env: {},
+    uploadIgnoreFiles: [],
+    jobLabel: {
+      tool: "docker",
+      argv: []
     }
-    if (isConfigObject(pattern) && isConfigObject(current)) {
-      const { changed: childChanged, result: childResult } = prune2(
-        current,
-        pattern
-      );
-      if (childChanged) {
-        changed = true;
-      }
-      if (Object.keys(childResult).length === 0) {
-        delete result[key];
-      } else {
-        result[key] = childResult;
+  };
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// packages/process-runner/src/host/host-execution-env.ts
+var hostExecutionEnvFactory = {
+  type: "host",
+  supportsDetach: false,
+  async open(openSpec) {
+    return {
+      id: "host",
+      job: null,
+      async uploadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          skipped: []
+        };
+      },
+      async downloadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          conflicts: []
+        };
+      },
+      exec(spec) {
+        return createHostRunner().exec(spec);
+      },
+      async detach() {
+        throw new Error("host runtime does not support detach because host has no addressable env");
+      },
+      shell() {
+        const shellSpec = openSpec.shellSpec;
+        return createHostRunner().exec({
+          command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+          ...shellSpec?.args ? { args: shellSpec.args } : {},
+          cwd: openSpec.cwd,
+          env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+          tty: true
+        });
+      },
+      async close() {
       }
-      continue;
-    }
-    delete result[key];
-    changed = true;
+    };
+  },
+  async attach() {
+    throw new Error("host runtime does not support reattach");
   }
-  return { changed, result };
-}
-var jsonFormat = {
-  parse: parse3,
-  serialize,
-  merge: merge2,
-  prune: prune2
 };
 
-// packages/config-mutations/src/formats/toml.ts
-import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-function isConfigObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// packages/process-runner/src/testing/mock-runner.ts
+import { Readable, Writable } from "node:stream";
+
+// packages/agent-spawn/src/register-factories.ts
+registerExecutionEnvFactory(hostExecutionEnvFactory);
+registerExecutionEnvFactory(dockerExecutionEnvFactory);
+if (process.env.VITEST === "true") {
+  registerExecutionEnvFactory(createTestHostExecutionEnvFactory());
 }
-function parse4(content) {
-  if (!content || content.trim() === "") {
-    return {};
-  }
-  const parsed = parseToml(content);
-  if (!isConfigObject2(parsed)) {
-    throw new Error("Expected TOML document to be a table.");
+function createTestHostExecutionEnvFactory() {
+  return {
+    type: "host",
+    supportsDetach: false,
+    open: ((openSpec) => {
+      return {
+        id: "host",
+        job: null,
+        async uploadWorkspace() {
+          return { files: 0, bytes: 0, skipped: [] };
+        },
+        async downloadWorkspace() {
+          return { files: 0, bytes: 0, conflicts: [] };
+        },
+        exec(spec) {
+          return runHost(spawnChildProcess2, spec);
+        },
+        async detach() {
+          throw new Error(
+            "host runtime does not support detach because host has no addressable env"
+          );
+        },
+        shell() {
+          return runHost(spawnChildProcess2, {
+            command: openSpec.shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+            args: openSpec.shellSpec?.args,
+            cwd: openSpec.cwd,
+            env: openSpec.shellSpec && "env" in openSpec.shellSpec ? openSpec.shellSpec.env : openSpec.env,
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+            tty: true
+          });
+        },
+        async close() {
+        }
+      };
+    }),
+    async attach() {
+      throw new Error("host runtime does not support reattach");
+    }
+  };
+}
+function runHost(spawnProcess, spec) {
+  const stdin = spec.stdin ?? "ignore";
+  const stdout = spec.stdout ?? "pipe";
+  const stderr = spec.stderr ?? "pipe";
+  const stdio = stdin === "inherit" && stdout === "inherit" && stderr === "inherit" ? "inherit" : [stdin, stdout, stderr];
+  const child = spawnProcess(spec.command, spec.args ?? [], {
+    cwd: spec.cwd,
+    env: spec.env,
+    stdio
+  });
+  const result = new Promise((resolve2) => {
+    child.once("close", (code) => {
+      resolve2({ exitCode: code ?? 1 });
+    });
+    child.once("error", () => {
+      resolve2({ exitCode: 1 });
+    });
+  });
+  const kill = (signal) => {
+    child.kill(signal);
+  };
+  if (spec.signal?.aborted) {
+    kill("SIGTERM");
+  } else {
+    spec.signal?.addEventListener("abort", () => kill("SIGTERM"), { once: true });
   }
-  return parsed;
-}
-function serialize2(obj) {
-  const serialized = stringifyToml(obj);
-  return serialized.endsWith("\n") ? serialized : `${serialized}
-`;
+  return {
+    pid: child.pid ?? null,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    result,
+    kill
+  };
 }
-function merge3(base, patch) {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) {
-      continue;
-    }
-    const existing = result[key];
-    if (isConfigObject2(existing) && isConfigObject2(value)) {
-      result[key] = merge3(existing, value);
-      continue;
-    }
-    result[key] = value;
+
+// packages/agent-spawn/src/run-command.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// packages/agent-spawn/src/types.ts
+function resolveModeConfig(modeConfig) {
+  if (Array.isArray(modeConfig)) {
+    return { args: modeConfig };
   }
-  return result;
+  return {
+    args: modeConfig.args ?? [],
+    env: modeConfig.env && Object.keys(modeConfig.env).length > 0 ? modeConfig.env : void 0
+  };
 }
-function prune3(obj, shape) {
-  let changed = false;
-  const result = { ...obj };
-  for (const [key, pattern] of Object.entries(shape)) {
-    if (!(key in result)) {
-      continue;
+
+// packages/agent-spawn/src/configs/mcp.ts
+function toJsonMcpServers(servers) {
+  const out = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const mapped = { command: server.command };
+    if (server.args && server.args.length > 0) {
+      mapped.args = server.args;
     }
-    const current = result[key];
-    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
-      delete result[key];
-      changed = true;
-      continue;
+    if (server.env && Object.keys(server.env).length > 0) {
+      mapped.env = server.env;
     }
-    if (isConfigObject2(pattern) && isConfigObject2(current)) {
-      const { changed: childChanged, result: childResult } = prune3(
-        current,
-        pattern
-      );
-      if (childChanged) {
-        changed = true;
-      }
-      if (Object.keys(childResult).length === 0) {
-        delete result[key];
-      } else {
-        result[key] = childResult;
-      }
-      continue;
+    if (server.timeout !== void 0) {
+      mapped.timeout = server.timeout;
     }
-    delete result[key];
-    changed = true;
+    out[name] = mapped;
   }
-  return { changed, result };
+  return out;
 }
-var tomlFormat = {
-  parse: parse4,
-  serialize: serialize2,
-  merge: merge3,
-  prune: prune3
-};
-
-// packages/config-mutations/src/formats/yaml.ts
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-function isConfigObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function toTomlString(value) {
+  return JSON.stringify(value);
 }
-function parse5(content) {
-  if (!content || content.trim() === "") {
-    return {};
-  }
-  const parsed = parseYaml(content);
-  if (parsed === null || parsed === void 0) {
-    return {};
-  }
-  if (!isConfigObject3(parsed)) {
-    throw new Error("Expected YAML object.");
+function toTomlArray(values) {
+  const serialized = values.map((value) => toTomlString(value));
+  return `[${serialized.join(", ")}]`;
+}
+function toTomlInlineTable(values) {
+  const parts = [];
+  for (const [key, value] of Object.entries(values)) {
+    parts.push(`${JSON.stringify(key)}=${toTomlString(value)}`);
   }
-  return parsed;
+  return `{${parts.join(", ")}}`;
 }
-function serialize3(obj) {
-  const serialized = stringifyYaml(obj);
-  return serialized.endsWith("\n") ? serialized : `${serialized}
-`;
+function serializeJsonMcpArgs(servers) {
+  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
 }
-function merge4(base, patch) {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) {
-      continue;
-    }
-    const existing = result[key];
-    if (isConfigObject3(existing) && isConfigObject3(value)) {
-      result[key] = merge4(existing, value);
-      continue;
+function serializeOpenCodeMcpEnv(servers) {
+  const mcp = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const entry = { type: "local", command: [server.command, ...server.args ?? []] };
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.environment = server.env;
     }
-    result[key] = value;
+    mcp[name] = entry;
   }
-  return result;
+  return { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp }) };
 }
-function prune4(obj, shape) {
-  let changed = false;
-  const result = { ...obj };
-  for (const [key, pattern] of Object.entries(shape)) {
-    if (!(key in result)) {
-      continue;
+function serializeCodexMcpArgs(servers) {
+  const args = [];
+  for (const [name, server] of Object.entries(servers)) {
+    const prefix = `mcp_servers.${name}`;
+    args.push("-c", `${prefix}.command=${toTomlString(server.command)}`);
+    if (server.args && server.args.length > 0) {
+      args.push("-c", `${prefix}.args=${toTomlArray(server.args)}`);
     }
-    const current = result[key];
-    if (isConfigObject3(pattern) && Object.keys(pattern).length === 0) {
-      delete result[key];
-      changed = true;
-      continue;
+    if (server.env && Object.keys(server.env).length > 0) {
+      args.push("-c", `${prefix}.env=${toTomlInlineTable(server.env)}`);
     }
-    if (isConfigObject3(pattern) && isConfigObject3(current)) {
-      const { changed: childChanged, result: childResult } = prune4(current, pattern);
-      if (childChanged) {
-        changed = true;
-      }
-      if (Object.keys(childResult).length === 0) {
-        delete result[key];
-      } else {
-        result[key] = childResult;
-      }
-      continue;
+    if (server.timeout !== void 0) {
+      args.push("-c", `${prefix}.timeout=${server.timeout}`);
     }
-    delete result[key];
-    changed = true;
   }
-  return { changed, result };
+  return args;
 }
-var yamlFormat = {
-  parse: parse5,
-  serialize: serialize3,
-  merge: merge4,
-  prune: prune4
+function serializeGooseMcpArgs(servers) {
+  return Object.values(servers).flatMap((server) => [
+    "--with-extension",
+    [server.command, ...server.args ?? []].join(" ")
+  ]);
+}
+
+// packages/agent-spawn/src/configs/claude-code.ts
+var claudeCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "claude-code",
+  // ACP adapter support: yes (adapter: "claude")
+  adapter: "claude",
+  promptFlag: "-p",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  modelTransform: (model) => model.replaceAll(".", "-"),
+  defaultArgs: [
+    "--output-format",
+    "stream-json",
+    "--verbose"
+  ],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--dangerously-skip-permissions"],
+    edit: ["--permission-mode", "acceptEdits", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,NotebookEdit"],
+    read: ["--permission-mode", "plan"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "text"]
+  },
+  interactive: {
+    defaultArgs: []
+  },
+  resumeCommand: (threadId) => ["--resume", threadId]
+};
+
+// packages/agent-spawn/src/configs/codex.ts
+var codexSpawnConfig = {
+  kind: "cli",
+  agentId: "codex",
+  // ACP adapter support: yes (adapter: "codex")
+  adapter: "codex",
+  promptFlag: "exec",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--skip-git-repo-check", "--json"],
+  mcpArgs: serializeCodexMcpArgs,
+  mcpArgsBeforeCommand: true,
+  modes: {
+    yolo: ["-s", "danger-full-access"],
+    edit: ["-s", "workspace-write"],
+    read: ["-s", "read-only"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["-"]
+  },
+  interactive: {
+    defaultArgs: ["-a", "never"]
+  },
+  resumeCommand: (threadId, cwd) => ["resume", "-C", cwd, threadId]
+};
+
+// packages/agent-spawn/src/configs/opencode.ts
+var openCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "opencode",
+  // ACP adapter support: yes (adapter: "opencode").
+  // OpenCode's `--format json` emits NDJSON events with `{ type, sessionID, part }`
+  // (no `{ event, ... }` field), so it needs the OpenCode adapter (not "native").
+  adapter: "opencode",
+  promptFlag: "run",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  modelTransform: (model) => {
+    return model.startsWith("poe/") ? model : `poe/${model}`;
+  },
+  defaultArgs: ["--format", "json"],
+  modes: {
+    yolo: [],
+    edit: [],
+    read: ["--agent", "plan"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "--prompt"
+  },
+  resumeCommand: (threadId, cwd) => [cwd, "--session", threadId],
+  mcpEnv: serializeOpenCodeMcpEnv
+};
+var openCodeAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "opencode",
+  acpArgs: ["acp"],
+  skipAuth: true,
+  mcpEnv: serializeOpenCodeMcpEnv
 };
 
-// packages/config-mutations/src/formats/index.ts
-var formatRegistry = {
-  json: jsonFormat,
-  toml: tomlFormat,
-  yaml: yamlFormat
+// packages/agent-spawn/src/configs/kimi.ts
+var kimiSpawnConfig = {
+  kind: "cli",
+  agentId: "kimi",
+  // ACP adapter support: yes (adapter: "kimi").
+  // Kimi's `--output-format stream-json` emits OpenAI-style `{ role, content }` JSON
+  // (no `{ event, ... }` field), so it needs the Kimi adapter (not "native").
+  adapter: "kimi",
+  promptFlag: "-p",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--print", "--output-format", "stream-json"],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--yolo"],
+    edit: [],
+    read: []
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "stream-json"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "-p"
+  },
+  resumeCommand: (threadId, cwd) => ["--session", threadId, "--work-dir", cwd]
 };
-var extensionMap = {
-  ".json": "json",
-  ".toml": "toml",
-  ".yaml": "yaml",
-  ".yml": "yaml"
+var kimiAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "kimi",
+  acpArgs: ["acp"]
 };
-function getConfigFormat(pathOrFormat) {
-  if (pathOrFormat in formatRegistry) {
-    return formatRegistry[pathOrFormat];
-  }
-  const ext = getExtension(pathOrFormat);
-  const formatName = extensionMap[ext];
-  if (!formatName) {
-    throw new Error(
-      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
-    );
-  }
-  return formatRegistry[formatName];
-}
-function detectFormat(path5) {
-  const ext = getExtension(path5);
-  return extensionMap[ext];
-}
-function getExtension(path5) {
-  const lastDot = path5.lastIndexOf(".");
-  if (lastDot === -1) {
-    return "";
-  }
-  return path5.slice(lastDot).toLowerCase();
-}
 
-// packages/config-mutations/src/execution/path-utils.ts
-import path4 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 : path4.join(homeDir, remainder);
-}
-function validateHomePath(targetPath) {
-  if (typeof targetPath !== "string" || targetPath.length === 0) {
-    throw new Error("Target path must be a non-empty string.");
-  }
-  if (!targetPath.startsWith("~")) {
-    throw new Error(
-      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
-    );
-  }
-}
-function resolvePath(rawPath, homeDir, pathMapper) {
-  validateHomePath(rawPath);
-  const expanded = expandHome(rawPath, homeDir);
-  if (!pathMapper) {
-    return expanded;
-  }
-  const rawDirectory = path4.dirname(expanded);
-  const mappedDirectory = pathMapper.mapTargetDirectory({
-    targetDirectory: rawDirectory
-  });
-  const filename = path4.basename(expanded);
-  return filename.length === 0 ? mappedDirectory : path4.join(mappedDirectory, filename);
-}
+// packages/agent-spawn/src/configs/goose.ts
+var gooseFileSecretsEnv = { GOOSE_DISABLE_KEYRING: "1" };
+var gooseSpawnConfig = {
+  kind: "cli",
+  agentId: "goose",
+  adapter: "native",
+  promptFlag: "--text",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  defaultArgs: ["run", "--output-format", "stream-json"],
+  defaultArgsPosition: "beforePrompt",
+  mcpArgs: serializeGooseMcpArgs,
+  mcpArgsPosition: "beforePrompt",
+  modes: {
+    yolo: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "auto" } },
+    edit: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "smart_approve" } },
+    read: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "chat" } }
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--instructions", "-"]
+  },
+  interactive: {
+    defaultArgs: ["session"],
+    defaultArgsPosition: "beforePrompt"
+  },
+  resumeCommand: () => ["run", "--resume", "--text", "continue"]
+};
+var gooseAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "goose",
+  acpArgs: ["acp"],
+  env: gooseFileSecretsEnv,
+  skipAuth: true
+};
 
-// packages/config-mutations/src/fs-utils.ts
-function isNotFound(error2) {
-  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+// packages/agent-spawn/src/configs/index.ts
+var allSpawnConfigs = [
+  claudeCodeSpawnConfig,
+  codexSpawnConfig,
+  openCodeSpawnConfig,
+  kimiSpawnConfig,
+  gooseSpawnConfig
+];
+var lookup2 = /* @__PURE__ */ new Map();
+for (const config of allSpawnConfigs) {
+  lookup2.set(config.agentId, config);
 }
-async function readFileIfExists(fs, target) {
-  try {
-    return await fs.readFile(target, "utf8");
-  } catch (error2) {
-    if (isNotFound(error2)) {
-      return null;
-    }
-    throw error2;
+var acpLookup = /* @__PURE__ */ new Map();
+acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
+acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
+acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
+function getSpawnConfig(input) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return void 0;
   }
+  return lookup2.get(resolvedId);
 }
-async function pathExists(fs, target) {
-  try {
-    await fs.stat(target);
-    return true;
-  } catch (error2) {
-    if (isNotFound(error2)) {
-      return false;
+function listMcpSupportedAgents() {
+  const supported = [];
+  for (const config of allSpawnConfigs) {
+    if (config.kind !== "cli" || typeof config.mcpArgs !== "function" && typeof config.mcpEnv !== "function") {
+      continue;
     }
-    throw error2;
+    supported.push(config.agentId);
   }
-}
-function createTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+  return supported;
 }
 
-// packages/config-mutations/src/execution/apply-mutation.ts
-function resolveValue(resolver, options) {
-  if (typeof resolver === "function") {
-    return resolver(options);
+// packages/agent-spawn/src/spawn.ts
+import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
+import path15 from "node:path";
+
+// packages/agent-spawn/src/configs/resolve-config.ts
+function resolveConfig(agentId) {
+  const resolvedAgentId = resolveAgentId(agentId);
+  if (!resolvedAgentId) {
+    throw new Error(`Unknown agent "${agentId}".`);
   }
-  return resolver;
-}
-function createInvalidDocumentBackupPath(targetPath) {
-  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
-  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
-}
-async function backupInvalidDocument(fs, targetPath, content) {
-  const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs.writeFile(backupPath, content, { encoding: "utf8" });
+  const agentDefinition = allAgents.find((agent) => agent.id === resolvedAgentId);
+  if (!agentDefinition) {
+    throw new Error(`Unknown agent "${agentId}".`);
+  }
+  const spawnConfig = getSpawnConfig(resolvedAgentId);
+  const binaryName = agentDefinition.binaryName;
+  return { agentId: resolvedAgentId, binaryName, spawnConfig };
 }
-function describeMutation(kind, targetPath) {
-  const displayPath = targetPath ?? "target";
-  switch (kind) {
-    case "ensureDirectory":
-      return `Create ${displayPath}`;
-    case "removeDirectory":
-      return `Remove directory ${displayPath}`;
-    case "backup":
-      return `Backup ${displayPath}`;
-    case "templateWrite":
-      return `Write ${displayPath}`;
-    case "chmod":
-      return `Set permissions on ${displayPath}`;
-    case "removeFile":
-      return `Remove ${displayPath}`;
-    case "configMerge":
-    case "configPrune":
-    case "configTransform":
-    case "templateMergeToml":
-    case "templateMergeJson":
-      return `Update ${displayPath}`;
-    default:
-      return "Operation";
+
+// packages/agent-spawn/src/mcp-args.ts
+function hasMcpServers(servers) {
+  if (!servers) {
+    return false;
   }
+  return Object.keys(servers).length > 0;
 }
-function pruneKeysByPrefix(table, prefix) {
-  const result = {};
-  for (const [key, value] of Object.entries(table)) {
-    if (!key.startsWith(prefix)) {
-      result[key] = value;
-    }
+function getMcpArgs(config, servers) {
+  if (!hasMcpServers(servers)) {
+    return [];
   }
-  return result;
+  if (!config.mcpArgs && !config.mcpEnv) {
+    throw new Error(formatUnsupportedMcpSpawnMessage(config.agentId));
+  }
+  if (!config.mcpArgs) {
+    return [];
+  }
+  return config.mcpArgs(servers);
 }
-function isConfigObject4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function formatUnsupportedMcpSpawnMessage(agentId) {
+  const supported = listMcpSupportedAgents();
+  const supportedText = supported.length > 0 ? supported.join(", ") : "(none)";
+  return `Agent "${agentId}" does not support MCP servers at spawn time.
+Agents with spawn-time MCP support: ${supportedText}`;
 }
-function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
-  const result = { ...base };
-  const prefixMap = pruneByPrefix ?? {};
-  for (const [key, value] of Object.entries(patch)) {
-    const current = result[key];
-    const prefix = prefixMap[key];
-    if (isConfigObject4(current) && isConfigObject4(value)) {
-      if (prefix) {
-        const pruned = pruneKeysByPrefix(current, prefix);
-        result[key] = { ...pruned, ...value };
-      } else {
-        result[key] = mergeWithPruneByPrefix(
-          current,
-          value,
-          prefixMap
-        );
-      }
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
+
+// packages/agent-spawn/src/model-utils.ts
+function stripModelNamespace(model) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex === -1 ? model : model.slice(slashIndex + 1);
 }
-async function applyMutation(mutation, context, options) {
-  switch (mutation.kind) {
-    case "ensureDirectory":
-      return applyEnsureDirectory(mutation, context, options);
-    case "removeDirectory":
-      return applyRemoveDirectory(mutation, context, options);
-    case "removeFile":
-      return applyRemoveFile(mutation, context, options);
-    case "chmod":
-      return applyChmod(mutation, context, options);
-    case "backup":
-      return applyBackup(mutation, context, options);
-    case "configMerge":
-      return applyConfigMerge(mutation, context, options);
-    case "configPrune":
-      return applyConfigPrune(mutation, context, options);
-    case "configTransform":
-      return applyConfigTransform(mutation, context, options);
-    case "templateWrite":
-      return applyTemplateWrite(mutation, context, options);
-    case "templateMergeToml":
-      return applyTemplateMerge(mutation, context, options, "toml");
-    case "templateMergeJson":
-      return applyTemplateMerge(mutation, context, options, "json");
-    default: {
-      const never = mutation;
-      throw new Error(`Unknown mutation kind: ${never.kind}`);
-    }
+
+// packages/agent-spawn/src/spawn.ts
+function resolveCliConfig(agentId) {
+  const resolved = resolveConfig(agentId);
+  if (!resolved.spawnConfig) {
+    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
   }
-}
-async function applyEnsureDirectory(mutation, context, options) {
-  const rawPath = resolveValue(mutation.path, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const existed = await pathExists(context.fs, targetPath);
-  if (!context.dryRun) {
-    await context.fs.mkdir(targetPath, { recursive: true });
+  if (resolved.spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  }
+  if (!resolved.binaryName) {
+    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
   }
   return {
-    outcome: {
-      changed: !existed,
-      effect: "mkdir",
-      detail: existed ? "noop" : "create"
-    },
-    details
+    agentId: resolved.agentId,
+    binaryName: resolved.binaryName,
+    spawnConfig: resolved.spawnConfig
   };
 }
-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
-    };
+function getDefaultArgsPosition(config) {
+  return config.defaultArgsPosition ?? "afterPrompt";
+}
+function getMcpArgsPosition(config) {
+  if (config.mcpArgsPosition) {
+    return config.mcpArgsPosition;
   }
-  if (typeof context.fs.rm !== "function") {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+}
+function buildCliArgs(config, options, stdinMode) {
+  const mcpArgs = getMcpArgs(config, options.mcpServers);
+  const defaultArgsPosition = getDefaultArgsPosition(config);
+  const mcpArgsPosition = getMcpArgsPosition(config);
+  const args = [];
+  if (mcpArgsPosition === "beforeCommand") {
+    args.push(...mcpArgs);
   }
-  if (mutation.force) {
-    if (!context.dryRun) {
-      await context.fs.rm(targetPath, { recursive: true, force: true });
-    }
-    return {
-      outcome: { changed: true, effect: "delete", detail: "delete" },
-      details
-    };
+  if (defaultArgsPosition === "beforePrompt") {
+    args.push(...config.defaultArgs);
   }
-  const entries = await context.fs.readdir(targetPath);
-  if (entries.length > 0) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+  if (mcpArgsPosition === "beforePrompt") {
+    args.push(...mcpArgs);
   }
-  if (!context.dryRun) {
-    await context.fs.rm(targetPath, { recursive: true, force: true });
+  if (stdinMode) {
+    args.push(
+      config.promptFlag,
+      ...stdinMode.omitPrompt ? [] : [options.prompt],
+      ...stdinMode.extraArgs
+    );
+  } else {
+    args.push(config.promptFlag, options.prompt);
   }
-  return {
-    outcome: { changed: true, effect: "delete", detail: "delete" },
-    details
-  };
+  if (options.model && config.modelFlag) {
+    let model = config.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
+    if (config.modelTransform) model = config.modelTransform(model);
+    args.push(config.modelFlag, model);
+  }
+  if (defaultArgsPosition === "afterPrompt") {
+    args.push(...config.defaultArgs);
+  }
+  if (mcpArgsPosition === "afterCommand") {
+    args.push(...mcpArgs);
+  }
+  const mode = resolveModeConfig(config.modes[options.mode ?? "yolo"]);
+  args.push(...mode.args);
+  if (options.args && options.args.length > 0) {
+    args.push(...options.args);
+  }
+  return { args, env: mode.env };
 }
-async function applyRemoveFile(mutation, context, options) {
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  try {
-    const content = await context.fs.readFile(targetPath, "utf8");
-    const trimmed = content.trim();
-    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
-      return {
-        outcome: { changed: false, effect: "none", detail: "noop" },
-        details
-      };
-    }
-    if (mutation.whenEmpty && trimmed.length > 0) {
-      return {
-        outcome: { changed: false, effect: "none", detail: "noop" },
-        details
-      };
-    }
-    if (!context.dryRun) {
-      await context.fs.unlink(targetPath);
-    }
-    return {
-      outcome: { changed: true, effect: "delete", detail: "delete" },
-      details
-    };
-  } catch (error2) {
-    if (isNotFound(error2)) {
-      return {
-        outcome: { changed: false, effect: "none", detail: "noop" },
-        details
-      };
-    }
-    throw error2;
+function buildSpawnArgs(agentId, options) {
+  const { binaryName, spawnConfig } = resolveCliConfig(agentId);
+  const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
+  const result = buildCliArgs(spawnConfig, options, stdinMode);
+  return { binaryName, args: result.args, env: result.env };
+}
+
+// packages/design-system/src/tokens/colors.ts
+import chalk from "chalk";
+var dark = {
+  header: (text4) => chalk.magentaBright.bold(text4),
+  divider: (text4) => chalk.dim(text4),
+  prompt: (text4) => chalk.cyan(text4),
+  number: (text4) => chalk.cyanBright(text4),
+  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.magenta("\u25C7"),
+  errorSymbol: chalk.red("\u25A0"),
+  accent: (text4) => chalk.cyan(text4),
+  muted: (text4) => chalk.dim(text4),
+  success: (text4) => chalk.green(text4),
+  warning: (text4) => chalk.yellow(text4),
+  error: (text4) => chalk.red(text4),
+  info: (text4) => chalk.magenta(text4),
+  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
+};
+var light = {
+  header: (text4) => chalk.hex("#a200ff").bold(text4),
+  divider: (text4) => chalk.hex("#666666")(text4),
+  prompt: (text4) => chalk.hex("#006699").bold(text4),
+  number: (text4) => chalk.hex("#0077cc").bold(text4),
+  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
+  errorSymbol: chalk.hex("#cc0000")("\u25A0"),
+  accent: (text4) => chalk.hex("#006699").bold(text4),
+  muted: (text4) => chalk.hex("#666666")(text4),
+  success: (text4) => chalk.hex("#008800")(text4),
+  warning: (text4) => chalk.hex("#cc6600")(text4),
+  error: (text4) => chalk.hex("#cc0000")(text4),
+  info: (text4) => chalk.hex("#a200ff")(text4),
+  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+};
+
+// packages/design-system/src/tokens/typography.ts
+import chalk2 from "chalk";
+
+// packages/design-system/src/components/text.ts
+import chalk3 from "chalk";
+
+// packages/design-system/src/internal/output-format.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
+var formatStorage = new AsyncLocalStorage();
+var cached;
+function resolveOutputFormat(env = process.env) {
+  const scoped = formatStorage.getStore();
+  if (scoped) {
+    return scoped;
+  }
+  if (cached) {
+    return cached;
   }
+  const raw = env.OUTPUT_FORMAT?.toLowerCase();
+  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
+  return cached;
 }
-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
-    };
+
+// packages/design-system/src/internal/theme-detect.ts
+function detectThemeFromEnv(env) {
+  const apple = env.APPLE_INTERFACE_STYLE;
+  if (typeof apple === "string") {
+    return apple.toLowerCase() === "dark" ? "dark" : "light";
   }
-  try {
-    const stat = await context.fs.stat(targetPath);
-    const currentMode = typeof stat.mode === "number" ? stat.mode & 511 : null;
-    if (currentMode === mutation.mode) {
-      return {
-        outcome: { changed: false, effect: "none", detail: "noop" },
-        details
-      };
+  const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
+  if (typeof vscodeKind === "string") {
+    const normalized = vscodeKind.toLowerCase();
+    if (normalized.includes("light")) {
+      return "light";
     }
-    if (!context.dryRun) {
-      await context.fs.chmod(targetPath, mutation.mode);
+    if (normalized.includes("dark")) {
+      return "dark";
     }
-    return {
-      outcome: { changed: true, effect: "chmod", detail: "update" },
-      details
-    };
-  } catch (error2) {
-    if (isNotFound(error2)) {
-      return {
-        outcome: { changed: false, effect: "none", detail: "noop" },
-        details
-      };
+  }
+  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";
     }
-    throw error2;
   }
+  return void 0;
 }
-async function applyBackup(mutation, context, options) {
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const content = await readFileIfExists(context.fs, targetPath);
-  if (content === null) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+function resolveThemeName(env = process.env) {
+  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
+  if (raw === "light" || raw === "dark") {
+    return raw;
   }
-  if (!context.dryRun) {
-    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
-    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  const detected = detectThemeFromEnv(env);
+  if (detected) {
+    return detected;
   }
-  return {
-    outcome: { changed: true, effect: "copy", detail: "backup" },
-    details
-  };
+  return "dark";
 }
-async function applyConfigMerge(mutation, context, options) {
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const formatName = mutation.format ?? detectFormat(rawPath);
-  if (!formatName) {
-    throw new Error(
-      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
-    );
-  }
-  const format = getConfigFormat(formatName);
-  const rawContent = await readFileIfExists(context.fs, targetPath);
-  let current;
-  try {
-    current = rawContent === null ? {} : format.parse(rawContent);
-  } catch {
-    if (rawContent !== null) {
-      await backupInvalidDocument(context.fs, targetPath, rawContent);
-    }
-    current = {};
-  }
-  const value = resolveValue(mutation.value, options);
-  let merged;
-  if (mutation.pruneByPrefix) {
-    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
-  } else {
-    merged = format.merge(current, value);
-  }
-  const serialized = format.serialize(merged);
-  const changed = serialized !== rawContent;
-  if (changed && !context.dryRun) {
-    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+var cachedTheme;
+function getTheme(env) {
+  if (cachedTheme) {
+    return cachedTheme;
   }
-  return {
-    outcome: {
-      changed,
-      effect: changed ? "write" : "none",
-      detail: changed ? rawContent === null ? "create" : "update" : "noop"
-    },
-    details
-  };
+  const themeName = resolveThemeName(env);
+  cachedTheme = themeName === "light" ? light : dark;
+  return cachedTheme;
 }
-async function applyConfigPrune(mutation, context, options) {
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const rawContent = await readFileIfExists(context.fs, targetPath);
-  if (rawContent === null) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
-  }
-  const formatName = mutation.format ?? detectFormat(rawPath);
-  if (!formatName) {
-    throw new Error(
-      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
-    );
+
+// packages/design-system/src/components/symbols.ts
+import chalk4 from "chalk";
+var symbols = {
+  get info() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "info";
+    if (format === "markdown") return "(i)";
+    return chalk4.magenta("\u25CF");
+  },
+  get success() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "success";
+    if (format === "markdown") return "[ok]";
+    return chalk4.magenta("\u25C6");
+  },
+  get resolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "resolved";
+    if (format === "markdown") return ">";
+    return getTheme().resolvedSymbol;
+  },
+  get errorResolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "error";
+    if (format === "markdown") return "[!]";
+    return getTheme().errorSymbol;
+  },
+  get bar() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "";
+    if (format === "markdown") return "|";
+    return "\u2502";
+  },
+  cornerTopRight: "\u256E",
+  cornerBottomRight: "\u256F",
+  get warning() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "warning";
+    if (format === "markdown") return "[!]";
+    return "\u25B2";
+  },
+  get active() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "active";
+    if (format === "markdown") return "[x]";
+    return "\u25C6";
+  },
+  get inactive() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "inactive";
+    if (format === "markdown") return "[ ]";
+    return "\u25CB";
   }
-  const format = getConfigFormat(formatName);
-  let current;
-  try {
-    current = format.parse(rawContent);
-  } catch {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+};
+
+// packages/design-system/src/components/logger.ts
+import chalk6 from "chalk";
+
+// packages/design-system/src/prompts/primitives/log.ts
+import chalk5 from "chalk";
+
+// packages/design-system/src/internal/strip-ansi.ts
+function stripAnsi(value) {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+// packages/design-system/src/prompts/primitives/log.ts
+function writeTerminalMessage(msg, {
+  symbol = chalk5.gray("\u2502"),
+  secondarySymbol = chalk5.gray("\u2502"),
+  spacing: spacing2 = 1,
+  withGuide = true
+} = {}) {
+  const lines = [];
+  const showGuide = withGuide !== false;
+  const contentLines = msg.split("\n");
+  const prefix = showGuide ? `${symbol}  ` : "";
+  const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
+  const emptyGuide = showGuide ? secondarySymbol : "";
+  for (let index = 0; index < spacing2; index += 1) {
+    lines.push(emptyGuide);
   }
-  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+  if (contentLines.length === 0) {
+    process.stdout.write("\n");
+    return;
   }
-  const shape = resolveValue(mutation.shape, options);
-  const { changed, result } = format.prune(current, shape);
-  if (!changed) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+  const [firstLine = "", ...continuationLines] = contentLines;
+  if (firstLine.length > 0) {
+    lines.push(`${prefix}${firstLine}`);
+  } else {
+    lines.push(showGuide ? symbol : "");
   }
-  if (Object.keys(result).length === 0) {
-    if (!context.dryRun) {
-      await context.fs.unlink(targetPath);
+  for (const line of continuationLines) {
+    if (line.length > 0) {
+      lines.push(`${continuationPrefix}${line}`);
+      continue;
     }
-    return {
-      outcome: { changed: true, effect: "delete", detail: "delete" },
-      details
-    };
-  }
-  const serialized = format.serialize(result);
-  if (!context.dryRun) {
-    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+    lines.push(emptyGuide);
   }
-  return {
-    outcome: { changed: true, effect: "write", detail: "update" },
-    details
-  };
+  process.stdout.write(`${lines.join("\n")}
+`);
 }
-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.`
+function message(msg, options) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "message", message: stripAnsi(msg) })}
+`
     );
+    return;
   }
-  const format = getConfigFormat(formatName);
-  const rawContent = await readFileIfExists(context.fs, targetPath);
-  let current;
-  try {
-    current = rawContent === null ? {} : format.parse(rawContent);
-  } catch {
-    if (rawContent !== null) {
-      await backupInvalidDocument(context.fs, targetPath, rawContent);
-    }
-    current = {};
+  writeTerminalMessage(msg, options);
+}
+function info(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **info:** ${stripAnsi(msg)}
+`);
+    return;
   }
-  const { content: transformed, changed } = mutation.transform(current, options);
-  if (!changed) {
-    return {
-      outcome: { changed: false, effect: "none", detail: "noop" },
-      details
-    };
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "info", message: stripAnsi(msg) })}
+`
+    );
+    return;
   }
-  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
-    };
+  message(msg, { symbol: symbols.info });
+}
+function success(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **success:** ${stripAnsi(msg)}
+`);
+    return;
   }
-  const serialized = format.serialize(transformed);
-  if (!context.dryRun) {
-    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "success", message: stripAnsi(msg) })}
+`
+    );
+    return;
   }
-  return {
-    outcome: {
-      changed: true,
-      effect: "write",
-      detail: rawContent === null ? "create" : "update"
-    },
-    details
-  };
+  message(msg, { symbol: symbols.success });
 }
-async function applyTemplateWrite(mutation, context, options) {
-  if (!context.templates) {
-    throw new Error(
-      "Template mutations require a templates loader. Provide templates function to runMutations context."
-    );
+function warn(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **warning:** ${stripAnsi(msg)}
+`);
+    return;
   }
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const template = await context.templates(mutation.templateId);
-  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
-  const rendered = Mustache.render(template, templateContext);
-  const existed = await pathExists(context.fs, targetPath);
-  if (!context.dryRun) {
-    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
+`
+    );
+    return;
   }
-  return {
-    outcome: {
-      changed: true,
-      effect: "write",
-      detail: existed ? "update" : "create"
-    },
-    details
-  };
+  message(msg, { symbol: chalk5.yellow("\u25B2") });
 }
-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."
-    );
+function error(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **error:** ${stripAnsi(msg)}
+`);
+    return;
   }
-  const rawPath = resolveValue(mutation.target, options);
-  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
-  const details = {
-    kind: mutation.kind,
-    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
-    targetPath
-  };
-  const format = getConfigFormat(formatName);
-  const template = await context.templates(mutation.templateId);
-  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
-  const rendered = Mustache.render(template, templateContext);
-  let templateDoc;
-  try {
-    templateDoc = format.parse(rendered);
-  } catch (error2) {
-    throw new Error(
-      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error2}`,
-      { cause: error2 }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
+`
     );
+    return;
   }
-  const rawContent = await readFileIfExists(context.fs, targetPath);
-  let current;
-  try {
-    current = rawContent === null ? {} : format.parse(rawContent);
-  } catch {
-    if (rawContent !== null) {
-      await backupInvalidDocument(context.fs, targetPath, rawContent);
+  message(msg, { symbol: chalk5.red("\u25A0") });
+}
+var log = {
+  info,
+  success,
+  message,
+  warn,
+  error
+};
+
+// packages/design-system/src/components/logger.ts
+function createLogger(emitter) {
+  const emit = (level, message2) => {
+    if (emitter) {
+      emitter(message2);
+      return;
     }
-    current = {};
-  }
-  const merged = format.merge(current, templateDoc);
-  const serialized = format.serialize(merged);
-  const changed = serialized !== rawContent;
-  if (changed && !context.dryRun) {
-    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
-  }
+    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 {
-    outcome: {
-      changed,
-      effect: changed ? "write" : "none",
-      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    info(message2) {
+      emit("info", message2);
     },
-    details
+    success(message2) {
+      emit("success", message2);
+    },
+    warn(message2) {
+      emit("warn", message2);
+    },
+    error(message2) {
+      emit("error", message2);
+    },
+    resolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.resolved });
+    },
+    errorResolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.errorResolved });
+    },
+    message(message2, symbol) {
+      if (emitter) {
+        emitter(message2);
+        return;
+      }
+      log.message(message2, { symbol: symbol ?? chalk6.gray("\u2502") });
+    }
   };
 }
+var logger = createLogger();
 
-// packages/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;
-    }
-  }
+// packages/design-system/src/components/table.ts
+import { Table } from "console-table-printer";
+
+// packages/design-system/src/acp/components.ts
+import chalk7 from "chalk";
+
+// packages/design-system/src/acp/writer.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var storage = new AsyncLocalStorage2();
+
+// packages/design-system/src/acp/components.ts
+var AGENT_PREFIX = `${chalk7.green.bold("\u2713")} agent: `;
+
+// packages/design-system/src/dashboard/buffer.ts
+import chalk8 from "chalk";
+
+// packages/design-system/src/dashboard/terminal.ts
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+
+// packages/design-system/src/prompts/index.ts
+import chalk15 from "chalk";
+import * as clack from "@clack/prompts";
+
+// packages/design-system/src/prompts/primitives/cancel.ts
+import chalk9 from "chalk";
+import { isCancel } from "@clack/prompts";
+
+// packages/design-system/src/prompts/primitives/intro.ts
+import chalk10 from "chalk";
+
+// packages/design-system/src/prompts/primitives/note.ts
+import chalk11 from "chalk";
+
+// packages/design-system/src/prompts/primitives/outro.ts
+import chalk12 from "chalk";
+
+// packages/design-system/src/prompts/primitives/spinner.ts
+import chalk14 from "chalk";
+
+// packages/design-system/src/static/spinner.ts
+import chalk13 from "chalk";
+
+// packages/design-system/src/static/menu.ts
+import chalk16 from "chalk";
+
+// packages/agent-spawn/src/autonomous.ts
+var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
+
+// packages/agent-spawn/src/acp/replay.ts
+import path16 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { open as open2, readdir } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+// packages/poe-acp-client/src/acp-client.ts
+import { isAbsolute } from "node:path";
+
+// packages/poe-acp-client/src/acp-transport.ts
+import {
+  spawn as spawnChildProcess3
+} from "node:child_process";
+
+// packages/poe-acp-client/src/run-report.ts
+import * as fsPromises2 from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// packages/agent-spawn/src/acp/middlewares/spawn-log.ts
+import path17 from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { mkdir, open as open3 } from "node:fs/promises";
+
+// src/utils/command-checks.ts
+function formatCommandRunnerResult(result) {
+  const stdout = result.stdout.length > 0 ? result.stdout : "<empty>";
+  const stderr = result.stderr.length > 0 ? result.stderr : "<empty>";
+  return `stdout:
+${stdout}
+stderr:
+${stderr}`;
+}
+function createSpawnHealthCheck(agentId, options) {
+  const prompt = `Output exactly: ${options.expectedOutput}`;
+  const { binaryName, args, env: modeEnv } = buildSpawnArgs(agentId, {
+    prompt,
+    model: options.model,
+    mode: "yolo"
+  });
   return {
-    changed: anyChanged,
-    effects
+    id: `${agentId}-cli-health`,
+    description: `spawn ${agentId} (expecting "${options.expectedOutput}")`,
+    async run(context) {
+      if (context.isDryRun) {
+        context.logDryRun?.(
+          `Dry run: ${[binaryName, ...args].join(" ")} (expecting "${options.expectedOutput}")`
+        );
+        return;
+      }
+      const result = modeEnv ? await context.runCommand(binaryName, args, { env: modeEnv }) : await context.runCommand(binaryName, args);
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `spawn ${agentId} failed with exit code ${result.exitCode}.
+${formatCommandRunnerResult(result)}`
+        );
+      }
+      if (!result.stdout.includes(options.expectedOutput)) {
+        throw new Error(
+          `spawn ${agentId}: expected "${options.expectedOutput}" in stdout.
+${formatCommandRunnerResult(result)}`
+        );
+      }
+    }
   };
 }
-async function executeMutation(mutation, context, options) {
-  context.observers?.onStart?.({
-    kind: mutation.kind,
-    label: mutation.label ?? mutation.kind,
-    targetPath: void 0
-    // Will be resolved during apply
-  });
-  try {
-    const { outcome, details } = await applyMutation(mutation, context, options);
-    context.observers?.onComplete?.(details, outcome);
-    return { outcome, details };
-  } catch (error2) {
-    context.observers?.onError?.(
-      {
-        kind: mutation.kind,
-        label: mutation.label ?? mutation.kind,
-        targetPath: void 0
-      },
-      error2
-    );
-    throw error2;
-  }
+function createBinaryExistsCheck(binaryName, id, description) {
+  return {
+    id,
+    description,
+    async run({ runCommand: runCommand2 }) {
+      const commonPaths = [
+        `/usr/local/bin/${binaryName}`,
+        `/usr/bin/${binaryName}`,
+        `$HOME/.local/bin/${binaryName}`,
+        `$HOME/.claude/local/bin/${binaryName}`
+      ];
+      const detectors = [
+        {
+          command: "which",
+          args: [binaryName],
+          validate: (result) => result.exitCode === 0
+        },
+        {
+          command: "where",
+          args: [binaryName],
+          validate: (result) => result.exitCode === 0 && result.stdout.trim().length > 0
+        },
+        // Check common installation paths using shell expansion for $HOME
+        {
+          command: "sh",
+          args: [
+            "-c",
+            commonPaths.map((p) => `test -f "${p}"`).join(" || ")
+          ],
+          validate: (result) => result.exitCode === 0
+        }
+      ];
+      for (const detector of detectors) {
+        const result = await runCommand2(detector.command, detector.args);
+        if (detector.validate(result)) {
+          return;
+        }
+      }
+      throw new Error(`${binaryName} CLI binary not found on PATH.`);
+    }
+  };
 }
 
-// packages/config-mutations/src/template/render.ts
-import Mustache2 from "mustache";
-var originalEscape = Mustache2.escape;
-
 // src/cli/constants.ts
 var CLAUDE_CODE_VARIANTS = {
   haiku: "anthropic/claude-haiku-4.5",