poe-code 3.0.131 → 3.0.132

package/dist/index.js

@@ -1265,8 +1265,8 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
-    const stat11 = await context.fs.stat(targetPath);
-    const currentMode = typeof stat11.mode === "number" ? stat11.mode & 511 : null;
+    const stat13 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat13.mode === "number" ? stat13.mode & 511 : null;
     if (currentMode === mutation.mode) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
@@ -2756,7 +2756,7 @@ function toTomlInlineTable(values) {
   return `{${parts.join(", ")}}`;
 }
 function serializeJsonMcpArgs(servers) {
-  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
+  return ["--mcp-servers", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
 }
 function serializeOpenCodeMcpEnv(servers) {
   const mcp = {};
@@ -3925,10 +3925,10 @@ function renderTableTerminal(options) {
 }
 function renderTableMarkdown(options) {
   const { columns, rows } = options;
-  const header = `| ${columns.map((c) => c.title).join(" | ")} |`;
-  const separator = `| ${columns.map((c) => c.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
+  const header = `| ${columns.map((c2) => c2.title).join(" | ")} |`;
+  const separator = `| ${columns.map((c2) => c2.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
   const dataRows = rows.map(
-    (row) => `| ${columns.map((c) => stripAnsi2(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
+    (row) => `| ${columns.map((c2) => stripAnsi2(row[c2.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
   );
   return [header, separator, ...dataRows].join("\n");
 }
@@ -4105,6 +4105,42 @@ var init_acp = __esm({
   }
 });
 
+// node_modules/fast-string-truncated-width/dist/utils.js
+var init_utils = __esm({
+  "node_modules/fast-string-truncated-width/dist/utils.js"() {
+  }
+});
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var EMOJI_RE, MODIFIER_RE;
+var init_dist = __esm({
+  "node_modules/fast-string-truncated-width/dist/index.js"() {
+    init_utils();
+    EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+    MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+  }
+});
+
+// node_modules/fast-string-width/dist/index.js
+var init_dist2 = __esm({
+  "node_modules/fast-string-width/dist/index.js"() {
+    init_dist();
+  }
+});
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_ESCAPE_LINK, GROUP_REGEX;
+var init_main = __esm({
+  "node_modules/fast-wrap-ansi/lib/main.js"() {
+    init_dist2();
+    ANSI_ESCAPE_BELL = "\x07";
+    ANSI_CSI = "[";
+    ANSI_OSC = "]";
+    ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+    GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+  }
+});
+
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
   "node_modules/sisteransi/src/index.js"(exports, module) {
@@ -4113,16 +4149,16 @@ var require_src = __commonJS({
     var CSI = `${ESC}[`;
     var beep = "\x07";
     var cursor = {
-      to(x, y) {
-        if (!y) return `${CSI}${x + 1}G`;
-        return `${CSI}${y + 1};${x + 1}H`;
+      to(x, y2) {
+        if (!y2) return `${CSI}${x + 1}G`;
+        return `${CSI}${y2 + 1};${x + 1}H`;
       },
-      move(x, y) {
+      move(x, y2) {
         let ret = "";
         if (x < 0) ret += `${CSI}${-x}D`;
         else if (x > 0) ret += `${CSI}${x}C`;
-        if (y < 0) ret += `${CSI}${-y}A`;
-        else if (y > 0) ret += `${CSI}${y}B`;
+        if (y2 < 0) ret += `${CSI}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI}${y2}B`;
         return ret;
       },
       up: (count = 1) => `${CSI}${count}A`,
@@ -4162,30 +4198,24 @@ var require_src = __commonJS({
 });
 
 // node_modules/@clack/core/dist/index.mjs
-import { stdout as R, stdin as q } from "node:process";
-import * as k from "node:readline";
-import ot from "node:readline";
-import { ReadStream as J } from "node:tty";
-function Ct(t) {
-  return t === z;
-}
-var import_sisteransi, P, ct, pt, ft, j, Q, dt, U, et, At, _, bt, z;
-var init_dist = __esm({
+import { styleText as y } from "node:util";
+import { stdout as S, stdin as $ } from "node:process";
+import * as _ from "node:readline";
+import P from "node:readline";
+import { ReadStream as D } from "node:tty";
+function q(r) {
+  return r === C;
+}
+var import_sisteransi, E, G, u, Y, C;
+var init_dist3 = __esm({
   "node_modules/@clack/core/dist/index.mjs"() {
+    init_main();
     import_sisteransi = __toESM(require_src(), 1);
-    P = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
-    ct = new RegExp("\\p{M}+", "gu");
-    pt = { limit: 1 / 0, ellipsis: "" };
-    ft = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
-    j = "\x07";
-    Q = "[";
-    dt = "]";
-    U = `${dt}8;;`;
-    et = new RegExp(`(?:\\${Q}(?<code>\\d+)m|\\${U}(?<uri>.*)${j})`, "y");
-    At = ["up", "down", "left", "right", "space", "enter", "cancel"];
-    _ = { actions: new Set(At), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true };
-    bt = globalThis.process.platform.startsWith("win");
-    z = /* @__PURE__ */ Symbol("clack:cancel");
+    E = ["up", "down", "left", "right", "space", "enter", "cancel"];
+    G = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+    u = { actions: new Set(E), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...G], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+    Y = globalThis.process.platform.startsWith("win");
+    C = /* @__PURE__ */ Symbol("clack:cancel");
   }
 });
 
@@ -4202,7 +4232,7 @@ function cancel(msg = "") {
 var init_cancel = __esm({
   "packages/design-system/src/prompts/primitives/cancel.ts"() {
     "use strict";
-    init_dist();
+    init_dist3();
     init_output_format();
   }
 });
@@ -4688,7 +4718,7 @@ function extractThreadId(value) {
   const maybeThreadId = isNonEmptyString(obj.thread_id) && obj.thread_id || isNonEmptyString(obj.threadId) && obj.threadId || isNonEmptyString(obj.threadID) && obj.threadID || isNonEmptyString(obj.session_id) && obj.session_id || isNonEmptyString(obj.sessionId) && obj.sessionId || isNonEmptyString(obj.sessionID) && obj.sessionID;
   return maybeThreadId || void 0;
 }
-var init_utils = __esm({
+var init_utils2 = __esm({
   "packages/agent-spawn/src/adapters/utils.ts"() {
     "use strict";
   }
@@ -4805,7 +4835,7 @@ var TOOL_KIND_MAP, TITLE_KEYS;
 var init_claude = __esm({
   "packages/agent-spawn/src/adapters/claude.ts"() {
     "use strict";
-    init_utils();
+    init_utils2();
     TOOL_KIND_MAP = {
       Read: "read",
       Write: "edit",
@@ -4928,7 +4958,7 @@ async function* adaptCodex(lines) {
 var init_codex3 = __esm({
   "packages/agent-spawn/src/adapters/codex.ts"() {
     "use strict";
-    init_utils();
+    init_utils2();
   }
 });
 
@@ -4968,7 +4998,7 @@ async function* adaptKimi(lines) {
 var init_kimi3 = __esm({
   "packages/agent-spawn/src/adapters/kimi.ts"() {
     "use strict";
-    init_utils();
+    init_utils2();
   }
 });
 
@@ -5003,7 +5033,7 @@ async function* adaptNative(lines) {
 var init_native = __esm({
   "packages/agent-spawn/src/adapters/native.ts"() {
     "use strict";
-    init_utils();
+    init_utils2();
   }
 });
 
@@ -5119,7 +5149,7 @@ async function* adaptOpenCode(lines) {
 var init_opencode3 = __esm({
   "packages/agent-spawn/src/adapters/opencode.ts"() {
     "use strict";
-    init_utils();
+    init_utils2();
   }
 });
 
@@ -7415,8 +7445,357 @@ var init_shared = __esm({
   }
 });
 
-// src/sdk/spawn-core.ts
+// packages/workspace-resolver/src/parse.ts
+function parseLocator(input) {
+  const value = input.trim();
+  if (value.length === 0 || looksLikeWindowsDrivePath(value)) {
+    return { scheme: "local", path: value };
+  }
+  const schemeSeparator = value.indexOf("://");
+  if (schemeSeparator === -1) {
+    return { scheme: "local", path: value };
+  }
+  const scheme = value.slice(0, schemeSeparator).toLowerCase();
+  const rest = value.slice(schemeSeparator + 3);
+  if (scheme === "github") {
+    return parseGithubLocator(rest);
+  }
+  if (scheme === "ssh") {
+    return parseSshLocator(value);
+  }
+  if (scheme === "docker") {
+    return parseDockerLocator(rest);
+  }
+  throw new Error(`Unsupported workspace locator scheme "${scheme}".`);
+}
+function parseGithubLocator(input) {
+  const { head, tail } = splitOnce(input, "#");
+  const segments = splitPathSegments(head);
+  const owner = segments[0];
+  const repo = segments[1];
+  if (!owner || !repo) {
+    throw new Error(`Invalid github workspace locator "${input}".`);
+  }
+  const pathSubdir = joinPathSegments(segments.slice(2));
+  let ref;
+  let fragmentSubdir;
+  if (tail !== void 0 && tail.length > 0) {
+    const refParts = splitOnce(tail, ":");
+    ref = refParts.head || void 0;
+    fragmentSubdir = refParts.tail || void 0;
+  }
+  if (pathSubdir && fragmentSubdir) {
+    throw new Error(`Invalid github workspace locator "${input}".`);
+  }
+  return {
+    scheme: "github",
+    owner,
+    repo,
+    ...ref ? { ref } : {},
+    ...pathSubdir || fragmentSubdir ? { subdir: pathSubdir || fragmentSubdir } : {}
+  };
+}
+function parseSshLocator(input) {
+  const url = new URL(input);
+  const host = url.hostname;
+  const pathname = url.pathname;
+  if (!host || pathname.length === 0) {
+    throw new Error(`Invalid ssh workspace locator "${input}".`);
+  }
+  const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : void 0;
+  return {
+    scheme: "ssh",
+    ...url.username ? { user: decodeURIComponent(url.username) } : {},
+    host,
+    ...port !== void 0 ? { port } : {},
+    path: pathname
+  };
+}
+function parseDockerLocator(input) {
+  const slashIndex = input.indexOf("/");
+  if (slashIndex === -1) {
+    throw new Error(`Invalid docker workspace locator "${input}".`);
+  }
+  const container = input.slice(0, slashIndex);
+  const path42 = input.slice(slashIndex);
+  if (container.length === 0 || path42.length === 0) {
+    throw new Error(`Invalid docker workspace locator "${input}".`);
+  }
+  return {
+    scheme: "docker",
+    container,
+    path: path42
+  };
+}
+function splitOnce(input, separator) {
+  const index = input.indexOf(separator);
+  if (index === -1) {
+    return { head: input };
+  }
+  return {
+    head: input.slice(0, index),
+    tail: input.slice(index + separator.length)
+  };
+}
+function splitPathSegments(input) {
+  const segments = [];
+  let current = "";
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (char === "/") {
+      if (current.length > 0) {
+        segments.push(current);
+      }
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  return segments;
+}
+function joinPathSegments(segments) {
+  if (segments.length === 0) {
+    return void 0;
+  }
+  let output = segments[0] ?? "";
+  for (let index = 1; index < segments.length; index += 1) {
+    output += `/${segments[index]}`;
+  }
+  return output;
+}
+function looksLikeWindowsDrivePath(input) {
+  if (input.length < 3 || input[1] !== ":") {
+    return false;
+  }
+  const drive = input.charCodeAt(0);
+  const isLetter = drive >= 65 && drive <= 90 || drive >= 97 && drive <= 122;
+  if (!isLetter) {
+    return false;
+  }
+  const separator = input[2];
+  return separator === "\\" || separator === "/";
+}
+var init_parse = __esm({
+  "packages/workspace-resolver/src/parse.ts"() {
+    "use strict";
+  }
+});
+
+// packages/workspace-resolver/src/github/clone.ts
 import path8 from "node:path";
+function buildCachePath(homeDir, locator) {
+  return path8.join(
+    homeDir,
+    ".poe-code",
+    "workspaces",
+    "github",
+    `${locator.owner}-${locator.repo}`
+  );
+}
+function buildCloneUrl(locator) {
+  return `https://github.com/${locator.owner}/${locator.repo}.git`;
+}
+async function cloneOrUpdate(locator, options) {
+  const cacheDir = buildCachePath(options.homeDir, locator);
+  const exists = await pathExists2(options.fs, cacheDir);
+  if (!exists) {
+    await options.fs.mkdir(path8.dirname(cacheDir), { recursive: true });
+    await assertExecSuccess(
+      await options.exec("git", ["clone", "--depth", "1", buildCloneUrl(locator), cacheDir]),
+      "git clone failed"
+    );
+    await options.fs.mkdir(cacheDir, { recursive: true });
+  } else {
+    const statusResult = await options.exec("git", ["status", "--porcelain"], { cwd: cacheDir });
+    if (statusResult.exitCode === 0 && statusResult.stdout.trim().length === 0) {
+      await options.exec("git", ["pull", "--ff-only"], { cwd: cacheDir });
+    }
+  }
+  if (locator.ref) {
+    await assertExecSuccess(
+      await options.exec("git", ["fetch", "origin"], { cwd: cacheDir }),
+      "git fetch failed"
+    );
+    await assertExecSuccess(
+      await options.exec("git", ["checkout", locator.ref], { cwd: cacheDir }),
+      "git checkout failed"
+    );
+  }
+  return cacheDir;
+}
+async function pathExists2(fs3, target) {
+  try {
+    await fs3.stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertExecSuccess(result, fallback) {
+  if (result.exitCode === 0) {
+    return;
+  }
+  const detail = result.stderr.trim() || result.stdout.trim() || fallback;
+  throw new Error(detail);
+}
+var init_clone = __esm({
+  "packages/workspace-resolver/src/github/clone.ts"() {
+    "use strict";
+  }
+});
+
+// packages/workspace-resolver/src/github/isolation.ts
+import path9 from "node:path";
+async function createWritableCheckout(locator, sourceCwd, options) {
+  const cwd = path9.join(
+    options.homeDir,
+    ".poe-code",
+    "workspaces",
+    "checkouts",
+    `${locator.owner}-${locator.repo}`,
+    createCheckoutId()
+  );
+  const revision = locator.ref ?? "HEAD";
+  await options.fs.mkdir(path9.dirname(cwd), { recursive: true });
+  await assertExecSuccess2(
+    await options.exec("git", ["worktree", "add", "--detach", cwd, revision], {
+      cwd: sourceCwd
+    }),
+    "git worktree add failed"
+  );
+  await options.fs.mkdir(cwd, { recursive: true });
+  return {
+    cwd,
+    cleanup: async () => {
+      const result = await options.exec("git", ["worktree", "remove", "--force", cwd], {
+        cwd: sourceCwd
+      });
+      if (result.exitCode === 0) {
+        return;
+      }
+      if (options.fs.rm) {
+        await options.fs.rm(cwd, { recursive: true, force: true });
+      }
+    }
+  };
+}
+function createCheckoutId() {
+  return `${Date.now().toString(36)}-${process.pid.toString(36)}`;
+}
+function assertExecSuccess2(result, fallback) {
+  if (result.exitCode === 0) {
+    return;
+  }
+  const detail = result.stderr.trim() || result.stdout.trim() || fallback;
+  throw new Error(detail);
+}
+var init_isolation = __esm({
+  "packages/workspace-resolver/src/github/isolation.ts"() {
+    "use strict";
+  }
+});
+
+// packages/workspace-resolver/src/resolve.ts
+import path10 from "node:path";
+async function resolveWorkspace(input, options) {
+  const locator = parseLocator(input);
+  if (locator.scheme === "local") {
+    return {
+      cwd: path10.isAbsolute(locator.path) ? locator.path : path10.resolve(options.baseDir, locator.path),
+      locator
+    };
+  }
+  if (locator.scheme === "ssh" || locator.scheme === "docker") {
+    throw new Error(`Unsupported workspace locator scheme "${locator.scheme}".`);
+  }
+  const mode = options.mode ?? "read";
+  const cacheDir = await cloneOrUpdate(locator, options);
+  let writable;
+  try {
+    writable = mode === "read" ? void 0 : await createWritableCheckout(locator, cacheDir, options);
+    const workspaceRoot = writable?.cwd ?? cacheDir;
+    const cwd = locator.subdir ? path10.join(workspaceRoot, locator.subdir) : workspaceRoot;
+    await assertPathExists(options.fs, cwd, locator);
+    return {
+      cwd,
+      ...writable ? { cleanup: writable.cleanup } : {},
+      locator
+    };
+  } catch (error2) {
+    await writable?.cleanup?.();
+    throw error2;
+  }
+}
+async function assertPathExists(fs3, target, locator) {
+  try {
+    await fs3.stat(target);
+  } catch {
+    if (locator.scheme === "github" && locator.subdir) {
+      throw new Error(
+        `Workspace subdirectory "${locator.subdir}" does not exist in github://${locator.owner}/${locator.repo}.`
+      );
+    }
+    throw new Error(`Workspace path "${target}" does not exist.`);
+  }
+}
+var init_resolve2 = __esm({
+  "packages/workspace-resolver/src/resolve.ts"() {
+    "use strict";
+    init_clone();
+    init_isolation();
+    init_parse();
+  }
+});
+
+// packages/workspace-resolver/src/index.ts
+var init_src8 = __esm({
+  "packages/workspace-resolver/src/index.ts"() {
+    "use strict";
+    init_parse();
+    init_resolve2();
+    init_clone();
+    init_isolation();
+  }
+});
+
+// src/workspace/resolve-spawn-workspace.ts
+async function resolveSpawnWorkspace(candidate, options) {
+  if (!candidate || candidate.trim().length === 0) {
+    return {};
+  }
+  const locator = parseLocator(candidate);
+  if (locator.scheme !== "local" && options.resolveRemoteLocators === false) {
+    return {
+      cwd: candidate
+    };
+  }
+  const resolved = await resolveWorkspace(candidate, {
+    baseDir: options.baseDir,
+    homeDir: options.homeDir,
+    mode: options.mode,
+    fs: {
+      mkdir: options.fs.mkdir,
+      stat: options.fs.stat,
+      ...options.fs.rm ? { rm: options.fs.rm } : {}
+    },
+    exec: async (command, args, execOptions) => await options.exec(command, args, execOptions ? { cwd: execOptions.cwd } : void 0)
+  });
+  return {
+    cwd: resolved.cwd,
+    cleanup: resolved.cleanup
+  };
+}
+var init_resolve_spawn_workspace = __esm({
+  "src/workspace/resolve-spawn-workspace.ts"() {
+    "use strict";
+    init_src8();
+  }
+});
+
+// src/sdk/spawn-core.ts
 import chalk17 from "chalk";
 async function spawnCore(container, service, options, flags = { dryRun: false, verbose: false }) {
   const adapter = container.registry.get(service);
@@ -7424,66 +7803,75 @@ async function spawnCore(container, service, options, flags = { dryRun: false, v
     throw new Error(`Unknown service "${service}".`);
   }
   const model = await resolveConfiguredModel(container, service, options.model);
-  const cwdOverride = resolveSpawnWorkingDirectory(
-    container.env.cwd,
-    options.cwd
-  );
-  const spawnOptions = {
-    prompt: options.prompt,
-    args: options.args,
-    model,
+  const workspace = await resolveSpawnWorkspace(options.cwd, {
+    baseDir: container.env.cwd,
+    homeDir: container.env.homeDir,
     mode: options.mode,
-    mcpServers: options.mcpServers,
-    cwd: cwdOverride,
-    useStdin: options.useStdin ?? false
-  };
-  const commandFlags = { dryRun: flags.dryRun, assumeYes: true, verbose: flags.verbose };
-  const resources = createExecutionResources(
-    container,
-    commandFlags,
-    `spawn:${service}`
-  );
-  if (flags.dryRun) {
-    const summary = formatSpawnDryRunMessage(adapter.label, spawnOptions);
-    resources.logger.dryRun(summary);
-    return {
-      stdout: "",
-      stderr: "",
-      exitCode: 0
+    resolveRemoteLocators: !flags.dryRun,
+    fs: container.fs,
+    exec: container.commandRunner
+  });
+  const cwdOverride = workspace.cwd;
+  try {
+    const spawnOptions = {
+      prompt: options.prompt,
+      args: options.args,
+      model,
+      mode: options.mode,
+      mcpServers: options.mcpServers,
+      cwd: cwdOverride,
+      useStdin: options.useStdin ?? false
     };
-  }
-  if (typeof adapter.spawn !== "function") {
-    throw new Error(`${adapter.label} does not support spawn.`);
-  }
-  if (spawnOptions.useStdin && !adapter.supportsStdinPrompt) {
-    throw new Error(
-      `${adapter.label} does not support stdin prompts. Use a different service (e.g. "codex") or pass the prompt as an argument.`
+    const commandFlags = { dryRun: flags.dryRun, assumeYes: true, verbose: flags.verbose };
+    const resources = createExecutionResources(
+      container,
+      commandFlags,
+      `spawn:${service}`
     );
-  }
-  const providerContext = buildProviderContext(container, adapter, resources);
-  const result = await container.registry.invoke(
-    adapter.name,
-    "spawn",
-    async (entry) => {
-      if (!entry.spawn) {
-        throw new Error(`${adapter.label} does not support spawn.`);
+    if (flags.dryRun) {
+      const summary = formatSpawnDryRunMessage(adapter.label, spawnOptions);
+      resources.logger.dryRun(summary);
+      return {
+        stdout: "",
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    if (typeof adapter.spawn !== "function") {
+      throw new Error(`${adapter.label} does not support spawn.`);
+    }
+    if (spawnOptions.useStdin && !adapter.supportsStdinPrompt) {
+      throw new Error(
+        `${adapter.label} does not support stdin prompts. Use a different service (e.g. "codex") or pass the prompt as an argument.`
+      );
+    }
+    const providerContext = buildProviderContext(container, adapter, resources);
+    const result = await container.registry.invoke(
+      adapter.name,
+      "spawn",
+      async (entry) => {
+        if (!entry.spawn) {
+          throw new Error(`${adapter.label} does not support spawn.`);
+        }
+        const output = await entry.spawn(providerContext, spawnOptions);
+        return output;
       }
-      const output = await entry.spawn(providerContext, spawnOptions);
-      return output;
+    );
+    if (!result) {
+      return {
+        stdout: "",
+        stderr: "",
+        exitCode: 0
+      };
     }
-  );
-  if (!result) {
     return {
-      stdout: "",
-      stderr: "",
-      exitCode: 0
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
     };
+  } finally {
+    await workspace.cleanup?.();
   }
-  return {
-    stdout: result.stdout,
-    stderr: result.stderr,
-    exitCode: result.exitCode
-  };
 }
 async function resolveConfiguredModel(container, service, model) {
   if (model != null) {
@@ -7531,26 +7919,18 @@ function formatSpawnArg(arg) {
 function formatQuoted(value) {
   return JSON.stringify(value);
 }
-function resolveSpawnWorkingDirectory(baseDir, candidate) {
-  if (!candidate || candidate.trim().length === 0) {
-    return void 0;
-  }
-  if (path8.isAbsolute(candidate)) {
-    return candidate;
-  }
-  return path8.resolve(baseDir, candidate);
-}
 var init_spawn_core = __esm({
   "src/sdk/spawn-core.ts"() {
     "use strict";
     init_src2();
     init_src4();
     init_shared();
+    init_resolve_spawn_workspace();
   }
 });
 
 // src/cli/environment.ts
-import path9 from "node:path";
+import path11 from "node:path";
 function createCliEnvironment(init) {
   const platform = init.platform ?? process.platform;
   const variables = init.variables ?? process.env;
@@ -7558,7 +7938,7 @@ function createCliEnvironment(init) {
   const projectConfigPath = resolveProjectConfigPath(init.cwd);
   const logDir = resolveLogDir(init.homeDir);
   const { poeApiBaseUrl, poeBaseUrl } = resolvePoeBaseUrls(variables);
-  const resolveHomePath = (...segments) => path9.join(init.homeDir, ...segments);
+  const resolveHomePath = (...segments) => path11.join(init.homeDir, ...segments);
   const getVariable = (name) => variables[name];
   return {
     cwd: init.cwd,
@@ -7575,7 +7955,7 @@ function createCliEnvironment(init) {
   };
 }
 function resolveLogDir(homeDir) {
-  return path9.join(homeDir, ".poe-code", "logs");
+  return path11.join(homeDir, ".poe-code", "logs");
 }
 function resolvePoeBaseUrls(variables) {
   const raw = variables.POE_BASE_URL;
@@ -8031,7 +8411,7 @@ var init_oauth_client = __esm({
 });
 
 // packages/poe-oauth/src/index.ts
-var init_src8 = __esm({
+var init_src9 = __esm({
   "packages/poe-oauth/src/index.ts"() {
     "use strict";
     init_check_auth();
@@ -8471,7 +8851,7 @@ var init_logger2 = __esm({
 });
 
 // src/cli/error-logger.ts
-import path10 from "node:path";
+import path12 from "node:path";
 var DEFAULT_MAX_SIZE, DEFAULT_MAX_BACKUPS, ErrorLogger;
 var init_error_logger = __esm({
   "src/cli/error-logger.ts"() {
@@ -8488,7 +8868,7 @@ var init_error_logger = __esm({
       fileLoggingAvailable;
       constructor(options) {
         this.fs = options.fs;
-        this.logFilePath = path10.join(options.logDir, "errors.log");
+        this.logFilePath = path12.join(options.logDir, "errors.log");
         this.logToStderr = options.logToStderr ?? true;
         this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
         this.maxBackups = options.maxBackups ?? DEFAULT_MAX_BACKUPS;
@@ -8609,7 +8989,7 @@ ${entry.stack}`);
         return `${this.logFilePath}.${index}`;
       }
       ensureLogDirectory() {
-        const directory = path10.dirname(this.logFilePath);
+        const directory = path12.dirname(this.logFilePath);
         try {
           if (!this.fs.existsSync(directory)) {
             this.fs.mkdirSync(directory, { recursive: true });
@@ -8627,7 +9007,7 @@ ${entry.stack}`);
 });
 
 // src/providers/index.ts
-import path11 from "node:path";
+import path13 from "node:path";
 import { readdir } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 function isProviderModule(filename) {
@@ -8654,7 +9034,7 @@ async function loadProviders() {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!isProviderModule(entry.name)) continue;
-    const moduleUrl = pathToFileURL(path11.join(currentDir, entry.name)).href;
+    const moduleUrl = pathToFileURL(path13.join(currentDir, entry.name)).href;
     const moduleExports = await import(moduleUrl);
     if (!moduleExports.provider) {
       throw new Error(`Provider module "${entry.name}" must export "provider".`);
@@ -8670,8 +9050,8 @@ var moduleDir, currentDir, defaultProviders;
 var init_providers = __esm({
   async "src/providers/index.ts"() {
     "use strict";
-    moduleDir = path11.dirname(fileURLToPath(import.meta.url));
-    currentDir = path11.basename(moduleDir) === "providers" ? moduleDir : path11.join(moduleDir, "providers");
+    moduleDir = path13.dirname(fileURLToPath(import.meta.url));
+    currentDir = path13.basename(moduleDir) === "providers" ? moduleDir : path13.join(moduleDir, "providers");
     defaultProviders = await loadProviders();
   }
 });
@@ -9129,7 +9509,7 @@ var init_container = __esm({
     init_service_registry();
     init_context();
     init_prompts2();
-    init_src8();
+    init_src9();
     init_options();
     init_logger2();
     init_error_logger();
@@ -9141,9 +9521,11 @@ var init_container = __esm({
 });
 
 // src/sdk/spawn.ts
+import * as nodeFs from "node:fs/promises";
+import os2 from "node:os";
 function spawn4(service, promptOrOptions, maybeOptions) {
   const options = typeof promptOrOptions === "string" ? { ...maybeOptions, prompt: promptOrOptions } : promptOrOptions;
-  const mcpConfig = options.mcpConfig ?? options.mcpServers;
+  const resolvedMcpServers = options.mcpServers ?? options.mcpConfig;
   const emptyEvents = (async function* () {
   })();
   let resolveEvents;
@@ -9162,11 +9544,24 @@ function spawn4(service, promptOrOptions, maybeOptions) {
     }
   })();
   const result = (async () => {
+    let workspace;
     try {
+      workspace = await resolveSpawnWorkspace(options.cwd, {
+        baseDir: process.cwd(),
+        homeDir: os2.homedir(),
+        mode: options.mode,
+        fs: {
+          mkdir: async (target, resolveOptions) => await nodeFs.mkdir(target, resolveOptions).then(() => void 0),
+          stat: async (target) => await nodeFs.stat(target),
+          rm: async (target, resolveOptions) => await nodeFs.rm(target, resolveOptions)
+        },
+        exec: runCommand
+      });
+      const cwd = workspace.cwd;
       await getPoeApiKey();
       let container;
       const getContainer = () => {
-        container ??= createSdkContainer({ cwd: options.cwd });
+        container ??= createSdkContainer({ cwd });
         return container;
       };
       const resolveModel3 = async () => options.model ?? await resolveConfiguredModel(getContainer(), service);
@@ -9175,12 +9570,12 @@ function spawn4(service, promptOrOptions, maybeOptions) {
         const model2 = await resolveModel3();
         const interactiveResult = await spawnInteractive(service, {
           prompt: options.prompt,
-          cwd: options.cwd,
+          cwd,
           model: model2,
           mode: options.mode,
           signal: options.signal,
           args: options.args,
-          ...mcpConfig ? { mcpServers: mcpConfig } : {}
+          ...resolvedMcpServers ? { mcpServers: resolvedMcpServers } : {}
         });
         return {
           stdout: interactiveResult.stdout,
@@ -9238,12 +9633,12 @@ function spawn4(service, promptOrOptions, maybeOptions) {
         const { events: rawEvents, done } = spawnStreaming({
           agentId: service,
           prompt: options.prompt,
-          cwd: options.cwd,
+          cwd,
           model: model2,
           mode: options.mode,
           args: options.args,
           signal: options.signal,
-          ...mcpConfig ? { mcpServers: mcpConfig } : {},
+          ...resolvedMcpServers ? { mcpServers: resolvedMcpServers } : {},
           ...options.activityTimeoutMs !== void 0 ? { activityTimeoutMs: options.activityTimeoutMs } : {},
           useStdin: false
         });
@@ -9260,7 +9655,7 @@ function spawn4(service, promptOrOptions, maybeOptions) {
           prompt: options.prompt,
           model: model2,
           mode: options.mode,
-          cwd: options.cwd,
+          cwd,
           startedAt: /* @__PURE__ */ new Date()
         };
         await applyMiddlewares([sessionCapture, usageCapture, spawnLog], middlewareContext);
@@ -9283,12 +9678,12 @@ function spawn4(service, promptOrOptions, maybeOptions) {
         const model2 = await resolveModel3();
         return spawn3(service, {
           prompt: options.prompt,
-          cwd: options.cwd,
+          cwd,
           model: model2,
           mode: options.mode,
           args: options.args,
           signal: options.signal,
-          ...mcpConfig ? { mcpServers: mcpConfig } : {},
+          ...resolvedMcpServers ? { mcpServers: resolvedMcpServers } : {},
           ...options.activityTimeoutMs !== void 0 ? { activityTimeoutMs: options.activityTimeoutMs } : {},
           useStdin: false
         });
@@ -9297,16 +9692,18 @@ function spawn4(service, promptOrOptions, maybeOptions) {
       const model = await resolveModel3();
       return spawnCore(getContainer(), service, {
         prompt: options.prompt,
-        cwd: options.cwd,
+        cwd,
         model,
         mode: options.mode,
         args: options.args,
-        ...mcpConfig ? { mcpServers: mcpConfig } : {},
+        ...resolvedMcpServers ? { mcpServers: resolvedMcpServers } : {},
         useStdin: false
       });
     } catch (error2) {
       resolveEventsOnce(emptyEvents);
       throw error2;
+    } finally {
+      await workspace?.cleanup?.();
     }
   })();
   return { events, result };
@@ -9330,6 +9727,7 @@ var init_spawn3 = __esm({
     init_spawn_core();
     await init_container();
     init_src7();
+    init_resolve_spawn_workspace();
     spawn4.pretty = async function pretty(service, promptOrOptions, maybeOptions) {
       const { events, result } = spawn4(service, promptOrOptions, maybeOptions);
       await renderAcpStream(events);
@@ -9366,14 +9764,14 @@ function createAbortError4() {
   error2.name = "AbortError";
   return error2;
 }
-var init_utils2 = __esm({
+var init_utils3 = __esm({
   "packages/pipeline/src/utils.ts"() {
     "use strict";
   }
 });
 
 // packages/pipeline/src/config/loader.ts
-import path12 from "node:path";
+import path14 from "node:path";
 import { parse as parse4 } from "yaml";
 function asStepMode(value) {
   if (value === void 0 || value === null) {
@@ -9465,8 +9863,8 @@ async function loadStepsFile(fs3, filePath) {
   return parseStepConfigDocument(filePath, content);
 }
 async function loadPipelineConfig(options) {
-  const globalPath = path12.join(options.homeDir, ".poe-code", "pipeline", "config.yaml");
-  const projectPath = path12.join(options.cwd, ".poe-code", "pipeline", "config.yaml");
+  const globalPath = path14.join(options.homeDir, ".poe-code", "pipeline", "config.yaml");
+  const projectPath = path14.join(options.cwd, ".poe-code", "pipeline", "config.yaml");
   const [globalConfig, projectConfig] = await Promise.all([
     loadConfigFile(options.fs, globalPath),
     loadConfigFile(options.fs, projectPath)
@@ -9477,8 +9875,8 @@ async function loadPipelineConfig(options) {
   };
 }
 async function loadResolvedSteps(options) {
-  const globalPath = path12.join(options.homeDir, ".poe-code", "pipeline", "steps.yaml");
-  const projectPath = path12.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
+  const globalPath = path14.join(options.homeDir, ".poe-code", "pipeline", "steps.yaml");
+  const projectPath = path14.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
   const [globalConfig, projectConfig] = await Promise.all([
     loadStepsFile(options.fs, globalPath),
     loadStepsFile(options.fs, projectPath)
@@ -9492,7 +9890,7 @@ async function loadResolvedSteps(options) {
 var init_loader = __esm({
   "packages/pipeline/src/config/loader.ts"() {
     "use strict";
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -9638,23 +10036,23 @@ function parsePlan(yamlContent, options = {}) {
 var init_parser = __esm({
   "packages/pipeline/src/plan/parser.ts"() {
     "use strict";
-    init_utils2();
+    init_utils3();
   }
 });
 
 // packages/pipeline/src/plan/discovery.ts
-import path13 from "node:path";
+import path15 from "node:path";
 import * as fsPromises2 from "node:fs/promises";
 function createDefaultFs() {
   return {
     readFile: fsPromises2.readFile,
     readdir: fsPromises2.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises2.stat(filePath);
+      const stat13 = await fsPromises2.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        isDirectory: () => stat11.isDirectory(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        isDirectory: () => stat13.isDirectory(),
+        mtimeMs: stat13.mtimeMs
       };
     }
   };
@@ -9679,10 +10077,10 @@ function countCompletedTasks(planPath, content) {
   };
 }
 async function ensurePlanExists(fs3, cwd, planPath) {
-  const absolutePath = path13.isAbsolute(planPath) ? planPath : path13.resolve(cwd, planPath);
+  const absolutePath = path15.isAbsolute(planPath) ? planPath : path15.resolve(cwd, planPath);
   try {
-    const stat11 = await fs3.stat(absolutePath);
-    if (!stat11.isFile()) {
+    const stat13 = await fs3.stat(absolutePath);
+    if (!stat13.isFile()) {
       throw new Error(`Plan not found at "${planPath}".`);
     }
   } catch (error2) {
@@ -9707,12 +10105,12 @@ async function scanPlansDir(fs3, plansDir, displayPrefix) {
     if (!isPlanCandidateFile(entry)) {
       continue;
     }
-    const absolutePath = path13.join(plansDir, entry);
-    const stat11 = await fs3.stat(absolutePath);
-    if (!stat11.isFile()) {
+    const absolutePath = path15.join(plansDir, entry);
+    const stat13 = await fs3.stat(absolutePath);
+    if (!stat13.isFile()) {
       continue;
     }
-    const displayPath = path13.join(displayPrefix, entry);
+    const displayPath = path15.join(displayPrefix, entry);
     const content = await fs3.readFile(absolutePath, "utf8");
     candidates.push(countCompletedTasks(displayPath, content));
   }
@@ -9729,8 +10127,8 @@ async function scanCustomPlanDir(fs3, planDirectory, cwd, homeDir) {
   return scanPlansDir(fs3, absoluteDir, planDirectory);
 }
 async function scanDefaultPlanDirs(fs3, cwd, homeDir) {
-  const projectDir = path13.join(cwd, ".poe-code", "pipeline", "plans");
-  const globalDir = path13.join(homeDir, ".poe-code", "pipeline", "plans");
+  const projectDir = path15.join(cwd, ".poe-code", "pipeline", "plans");
+  const globalDir = path15.join(homeDir, ".poe-code", "pipeline", "plans");
   const [projectCandidates, globalCandidates] = await Promise.all([
     scanPlansDir(fs3, projectDir, ".poe-code/pipeline/plans"),
     scanPlansDir(fs3, globalDir, "~/.poe-code/pipeline/plans")
@@ -9739,9 +10137,9 @@ async function scanDefaultPlanDirs(fs3, cwd, homeDir) {
 }
 function resolveAbsoluteDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path13.join(homeDir, dir.slice(2));
+    return path15.join(homeDir, dir.slice(2));
   }
-  return path13.isAbsolute(dir) ? dir : path13.resolve(cwd, dir);
+  return path15.isAbsolute(dir) ? dir : path15.resolve(cwd, dir);
 }
 async function resolvePlanDirectory(options) {
   const customDir = options.planDirectory?.trim();
@@ -9749,21 +10147,21 @@ async function resolvePlanDirectory(options) {
     return resolveAbsoluteDirectory(customDir, options.cwd, options.homeDir);
   }
   const fs3 = options.fs ?? createDefaultFs();
-  const projectDir = path13.join(options.cwd, ".poe-code");
+  const projectDir = path15.join(options.cwd, ".poe-code");
   try {
-    const stat11 = await fs3.stat(projectDir);
-    if (stat11.isDirectory()) {
-      return path13.join(options.cwd, ".poe-code", "pipeline", "plans");
+    const stat13 = await fs3.stat(projectDir);
+    if (stat13.isDirectory()) {
+      return path15.join(options.cwd, ".poe-code", "pipeline", "plans");
     }
   } catch {
   }
-  return path13.join(options.homeDir, ".poe-code", "pipeline", "plans");
+  return path15.join(options.homeDir, ".poe-code", "pipeline", "plans");
 }
 function resolveAbsolutePlanPath(planPath, cwd, homeDir) {
   if (planPath.startsWith("~/")) {
-    return path13.join(homeDir, planPath.slice(2));
+    return path15.join(homeDir, planPath.slice(2));
   }
-  return path13.isAbsolute(planPath) ? planPath : path13.resolve(cwd, planPath);
+  return path15.isAbsolute(planPath) ? planPath : path15.resolve(cwd, planPath);
 }
 async function resolvePlanPath(options) {
   const fs3 = options.fs ?? createDefaultFs();
@@ -9815,7 +10213,7 @@ var init_discovery = __esm({
     "use strict";
     init_loader();
     init_parser();
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -9867,7 +10265,7 @@ var init_writer = __esm({
 });
 
 // packages/pipeline/src/run/runner.ts
-import path14 from "node:path";
+import path16 from "node:path";
 function getFailedStepName(status) {
   return Object.entries(status).find(([, value]) => value === "failed")?.[0];
 }
@@ -9921,7 +10319,7 @@ async function resolveFileIncludes(template, cwd, readFile15) {
   }
   let result = template;
   for (const match of matches) {
-    const absolutePath = path14.resolve(cwd, match[1]);
+    const absolutePath = path16.resolve(cwd, match[1]);
     const content = await readFile15(absolutePath, "utf8");
     result = result.replace(match[0], content);
   }
@@ -9967,11 +10365,11 @@ function createDefaultFs2() {
     },
     rmdir: fsPromises3.rmdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises3.stat(filePath);
+      const stat13 = await fsPromises3.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        isDirectory: () => stat11.isDirectory(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        isDirectory: () => stat13.isDirectory(),
+        mtimeMs: stat13.mtimeMs
       };
     }
   };
@@ -10004,8 +10402,8 @@ async function lockFile(filePath, options = {}) {
       if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "EEXIST") {
         throw error2;
       }
-      const stat11 = await fs3.stat(lockPath);
-      if (Date.now() - stat11.mtimeMs > staleMs) {
+      const stat13 = await fs3.stat(lockPath);
+      if (Date.now() - stat13.mtimeMs > staleMs) {
         await fs3.rmdir(lockPath);
         continue;
       }
@@ -10023,7 +10421,7 @@ var init_lock = __esm({
 });
 
 // packages/pipeline/src/run/pipeline.ts
-import path15 from "node:path";
+import path17 from "node:path";
 import * as fsPromises4 from "node:fs/promises";
 function createDefaultFs3() {
   return {
@@ -10031,11 +10429,11 @@ function createDefaultFs3() {
     writeFile: fsPromises4.writeFile,
     readdir: fsPromises4.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises4.stat(filePath);
+      const stat13 = await fsPromises4.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        isDirectory: () => stat11.isDirectory(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        isDirectory: () => stat13.isDirectory(),
+        mtimeMs: stat13.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -10066,9 +10464,9 @@ function resolveMode(stepName, steps) {
   return step.mode;
 }
 async function archivePlan(fs3, absolutePlanPath) {
-  const dir = path15.dirname(absolutePlanPath);
-  const archiveDir = path15.join(dir, "archive");
-  const archivePath = path15.join(archiveDir, path15.basename(absolutePlanPath));
+  const dir = path17.dirname(absolutePlanPath);
+  const archiveDir = path17.join(dir, "archive");
+  const archivePath = path17.join(archiveDir, path17.basename(absolutePlanPath));
   await fs3.mkdir(archiveDir, { recursive: true });
   await fs3.rename(absolutePlanPath, archivePath);
 }
@@ -10396,12 +10794,12 @@ var init_pipeline = __esm({
     init_parser();
     init_writer();
     init_runner();
-    init_utils2();
+    init_utils3();
   }
 });
 
 // packages/pipeline/src/index.ts
-var init_src9 = __esm({
+var init_src10 = __esm({
   "packages/pipeline/src/index.ts"() {
     "use strict";
     init_loader();
@@ -10446,18 +10844,18 @@ var AUTONOMOUS_ACTIVITY_TIMEOUT_MS, MAX_TIMEOUT_RETRIES;
 var init_pipeline2 = __esm({
   async "src/sdk/pipeline.ts"() {
     "use strict";
-    init_src9();
+    init_src10();
     init_src7();
     await init_spawn3();
-    init_src9();
+    init_src10();
     AUTONOMOUS_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
     MAX_TIMEOUT_RETRIES = 3;
   }
 });
 
 // packages/process-launcher/src/state/state-store.ts
-import path16 from "node:path";
-import * as nodeFs from "node:fs/promises";
+import path18 from "node:path";
+import * as nodeFs2 from "node:fs/promises";
 function isNotFoundError2(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
@@ -10472,9 +10870,9 @@ async function removeDirectory2(fs3, directoryPath) {
     throw error2;
   }
   for (const entry of entries) {
-    const entryPath = path16.join(directoryPath, entry);
-    const stat11 = await fs3.stat(entryPath);
-    if (stat11.isFile()) {
+    const entryPath = path18.join(directoryPath, entry);
+    const stat13 = await fs3.stat(entryPath);
+    if (stat13.isFile()) {
       await fs3.rm(entryPath, { force: true });
       continue;
     }
@@ -10487,9 +10885,9 @@ async function removeDirectory2(fs3, directoryPath) {
   }
   await fs3.rm(directoryPath, { force: true });
 }
-function createStateStore(stateDir, fs3 = nodeFs) {
+function createStateStore(stateDir, fs3 = nodeFs2) {
   async function read(id) {
-    const statePath = path16.join(stateDir, id, "state.json");
+    const statePath = path18.join(stateDir, id, "state.json");
     try {
       const content = await fs3.readFile(statePath, "utf8");
       return JSON.parse(content);
@@ -10501,9 +10899,9 @@ function createStateStore(stateDir, fs3 = nodeFs) {
     }
   }
   async function write2(id, state) {
-    const processDir = path16.join(stateDir, id);
+    const processDir = path18.join(stateDir, id);
     await fs3.mkdir(processDir, { recursive: true });
-    await fs3.writeFile(path16.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
+    await fs3.writeFile(path18.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
 `);
   }
   async function list() {
@@ -10518,10 +10916,10 @@ function createStateStore(stateDir, fs3 = nodeFs) {
     }
     const states = [];
     for (const entry of [...entries].sort()) {
-      const entryPath = path16.join(stateDir, entry);
+      const entryPath = path18.join(stateDir, entry);
       try {
-        const stat11 = await fs3.stat(entryPath);
-        if (stat11.isFile()) {
+        const stat13 = await fs3.stat(entryPath);
+        if (stat13.isFile()) {
           continue;
         }
       } catch (error2) {
@@ -10538,7 +10936,7 @@ function createStateStore(stateDir, fs3 = nodeFs) {
     return states;
   }
   async function remove2(id) {
-    await removeDirectory2(fs3, path16.join(stateDir, id));
+    await removeDirectory2(fs3, path18.join(stateDir, id));
   }
   return { read, write: write2, list, remove: remove2 };
 }
@@ -10549,16 +10947,16 @@ var init_state_store = __esm({
 });
 
 // packages/process-launcher/src/logs/log-writer.ts
-import path17 from "node:path";
-import * as nodeFs2 from "node:fs/promises";
+import path19 from "node:path";
+import * as nodeFs3 from "node:fs/promises";
 function isNotFoundError3(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
 function getCurrentLogPath(logDir, stream) {
-  return path17.join(logDir, `${stream}.log`);
+  return path19.join(logDir, `${stream}.log`);
 }
 function getRotatedLogPath(logDir, stream, index) {
-  return path17.join(logDir, `${stream}.${index}.log`);
+  return path19.join(logDir, `${stream}.${index}.log`);
 }
 async function isFile(fs3, filePath) {
   try {
@@ -10605,7 +11003,7 @@ async function removeAllStreamLogs(fs3, logDir, stream) {
       if (getRotatedLogIndex(fileName, stream) === null) {
         continue;
       }
-      await fs3.rm(path17.join(logDir, fileName), { force: true });
+      await fs3.rm(path19.join(logDir, fileName), { force: true });
     }
   } catch (error2) {
     if (isNotFoundError3(error2)) {
@@ -10624,7 +11022,7 @@ function getLines(content) {
   }
   return lines;
 }
-function createLogWriter(logDir, retainCount, fs3 = nodeFs2) {
+function createLogWriter(logDir, retainCount, fs3 = nodeFs3) {
   const maxRetainedRuns = Math.max(0, Math.trunc(retainCount));
   async function write2(line, stream) {
     await fs3.mkdir(logDir, { recursive: true });
@@ -10865,7 +11263,7 @@ var init_engine = __esm({
 });
 
 // packages/process-runner/src/docker/args.ts
-import path18 from "node:path";
+import path20 from "node:path";
 function buildDockerRunArgs(input) {
   const args = [input.engine];
   if (input.engine === "docker" && input.context) {
@@ -10892,7 +11290,7 @@ function buildDockerRunArgs(input) {
     args.push("-e", `${key}=${value}`);
   }
   for (const mount of input.mounts) {
-    const volume = `${path18.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    const volume = `${path20.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
     args.push("-v", volume);
   }
   for (const port of input.ports) {
@@ -11134,7 +11532,7 @@ var init_testing = __esm({
 });
 
 // packages/process-runner/src/index.ts
-var init_src10 = __esm({
+var init_src11 = __esm({
   "packages/process-runner/src/index.ts"() {
     "use strict";
     init_context2();
@@ -11146,13 +11544,16 @@ var init_src10 = __esm({
 });
 
 // packages/process-launcher/src/supervisor/supervisor.ts
-import path19 from "node:path";
+import { spawnSync } from "node:child_process";
+import * as nodeFs4 from "node:fs/promises";
+import os3 from "node:os";
+import path21 from "node:path";
 function createSupervisor(options) {
   const { spec } = options;
   const runner = resolveRunner(options);
   const stateStore = createStateStore(options.stateDir, options.fs);
   const logWriter = createLogWriter(
-    path19.join(options.stateDir, spec.id, "logs"),
+    path21.join(options.stateDir, spec.id, "logs"),
     spec.logRetainCount ?? 5,
     options.fs
   );
@@ -11165,6 +11566,8 @@ function createSupervisor(options) {
   let activeReadyController = null;
   let stableTimer = null;
   let stopRequested = false;
+  let workspacePromise = null;
+  let workspaceCleanupPromise = null;
   const onAbort = () => {
     void stop();
   };
@@ -11204,6 +11607,7 @@ function createSupervisor(options) {
     state.pid = null;
     state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
     await transitionTo("stopped");
+    await cleanupWorkspace();
   }
   async function restart() {
     await stop();
@@ -11218,7 +11622,14 @@ function createSupervisor(options) {
   async function launch(isRestart) {
     const nextRunId = runId + 1;
     runId = nextRunId;
-    const nextHandle = runner.exec(createRunSpec(spec));
+    const workspace = await ensureWorkspace();
+    let nextHandle;
+    try {
+      nextHandle = runner.exec(createRunSpec(spec, workspace.cwd));
+    } catch (error2) {
+      await cleanupWorkspace();
+      throw error2;
+    }
     handle = nextHandle;
     state.pid = nextHandle.pid;
     state.lastExitCode = null;
@@ -11265,15 +11676,18 @@ function createSupervisor(options) {
     state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (stopRequested || options.signal?.aborted) {
       await transitionTo("stopped");
+      await cleanupWorkspace();
       return;
     }
     if (!shouldRestart(result.exitCode, spec.restart)) {
       await transitionTo("stopped");
+      await cleanupWorkspace();
       return;
     }
     const maxRestarts = spec.maxRestarts ?? 5;
     if (maxRestarts > 0 && state.restartCount >= maxRestarts) {
       await transitionTo("crashed");
+      await cleanupWorkspace();
       return;
     }
     const backoffMs = getBackoffDelay(
@@ -11321,6 +11735,36 @@ function createSupervisor(options) {
       stableTimer = null;
     }
   }
+  async function ensureWorkspace() {
+    if (workspacePromise !== null) {
+      return await workspacePromise;
+    }
+    workspacePromise = resolveProcessWorkspace(spec.cwd, options.stateDir);
+    try {
+      return await workspacePromise;
+    } catch (error2) {
+      workspacePromise = null;
+      throw error2;
+    }
+  }
+  async function cleanupWorkspace() {
+    if (workspacePromise === null) {
+      return;
+    }
+    const workspace = await workspacePromise;
+    if (!workspace.cleanup) {
+      return;
+    }
+    if (workspaceCleanupPromise !== null) {
+      await workspaceCleanupPromise;
+      return;
+    }
+    workspaceCleanupPromise = workspace.cleanup().finally(() => {
+      workspaceCleanupPromise = null;
+      workspacePromise = null;
+    });
+    await workspaceCleanupPromise;
+  }
   return {
     start,
     stop,
@@ -11351,11 +11795,11 @@ function createInitialState(spec, runner) {
     args: [...spec.args ?? []]
   };
 }
-function createRunSpec(spec) {
+function createRunSpec(spec, cwdOverride) {
   return {
     command: spec.command,
     args: spec.args,
-    cwd: spec.cwd,
+    cwd: cwdOverride ?? spec.cwd,
     env: spec.env,
     stderr: "pipe",
     stdout: "pipe"
@@ -11452,6 +11896,54 @@ function pipeOutput(stream, output, write2, onLog) {
     stream.once("error", reject);
   });
 }
+async function resolveProcessWorkspace(cwd, stateDir) {
+  if (!cwd) {
+    return {};
+  }
+  const resolved = await resolveWorkspace(cwd, {
+    baseDir: process.cwd(),
+    homeDir: resolveWorkspaceHomeDir(stateDir),
+    mode: "edit",
+    exec: async (command, args, options) => execWorkspaceCommand(command, args, options?.cwd),
+    fs: {
+      mkdir: async (target, options) => {
+        await nodeFs4.mkdir(target, options);
+      },
+      stat: async (target) => await nodeFs4.stat(target),
+      rm: async (target, options) => {
+        await nodeFs4.rm(target, options);
+      }
+    }
+  });
+  return {
+    cwd: resolved.cwd,
+    cleanup: resolved.cleanup
+  };
+}
+function resolveWorkspaceHomeDir(stateDir) {
+  if (path21.basename(stateDir) === "launch" && path21.basename(path21.dirname(stateDir)) === ".poe-code") {
+    return path21.dirname(path21.dirname(stateDir));
+  }
+  return os3.homedir();
+}
+function execWorkspaceCommand(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: "utf8"
+  });
+  if (result.error) {
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.error.message,
+      exitCode: typeof result.status === "number" ? result.status : 1
+    };
+  }
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.status ?? 0
+  };
+}
 function resolveReadyCheck(check, spec) {
   if (check.kind !== "tcp" || spec.docker === void 0) {
     return check;
@@ -11473,7 +11965,8 @@ function resolveReadyCheck(check, spec) {
 var init_supervisor = __esm({
   "packages/process-launcher/src/supervisor/supervisor.ts"() {
     "use strict";
-    init_src10();
+    init_src11();
+    init_src8();
     init_health_check();
     init_log_writer();
     init_state_store();
@@ -11481,8 +11974,8 @@ var init_supervisor = __esm({
 });
 
 // packages/process-launcher/src/launcher.ts
-import path20 from "node:path";
-import * as nodeFs3 from "node:fs/promises";
+import path22 from "node:path";
+import * as nodeFs5 from "node:fs/promises";
 async function startManagedProcess(options) {
   const fs3 = options.fs ?? defaultFs();
   const spec = normalizeSpec(options.spec);
@@ -11830,10 +12323,10 @@ async function listIds(fs3, baseDir) {
     const entries = await fs3.readdir(baseDir);
     const ids = [];
     for (const entry of entries) {
-      const entryPath = path20.join(baseDir, entry);
+      const entryPath = path22.join(baseDir, entry);
       try {
-        const stat11 = await fs3.stat(entryPath);
-        if (!stat11.isFile()) {
+        const stat13 = await fs3.stat(entryPath);
+        if (!stat13.isFile()) {
           ids.push(entry);
         }
       } catch (error2) {
@@ -11880,30 +12373,30 @@ async function readJsonFile(fs3, filePath) {
   }
 }
 async function writeJsonFile(fs3, filePath, value) {
-  await fs3.mkdir(path20.dirname(filePath), { recursive: true });
+  await fs3.mkdir(path22.dirname(filePath), { recursive: true });
   await fs3.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function resolveProcessDir(baseDir, id) {
-  return path20.join(baseDir, id);
+  return path22.join(baseDir, id);
 }
 function resolveSpecPath(baseDir, id) {
-  return path20.join(resolveProcessDir(baseDir, id), "spec.json");
+  return path22.join(resolveProcessDir(baseDir, id), "spec.json");
 }
 function resolveStatePath(baseDir, id) {
-  return path20.join(resolveProcessDir(baseDir, id), "state.json");
+  return path22.join(resolveProcessDir(baseDir, id), "state.json");
 }
 function resolveMetaPath(baseDir, id) {
-  return path20.join(resolveProcessDir(baseDir, id), "meta.json");
+  return path22.join(resolveProcessDir(baseDir, id), "meta.json");
 }
 function resolveLogDir2(baseDir, id) {
-  return path20.join(resolveProcessDir(baseDir, id), "logs");
+  return path22.join(resolveProcessDir(baseDir, id), "logs");
 }
 function isNotFoundError4(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
 function defaultFs() {
-  return nodeFs3;
+  return nodeFs5;
 }
 function defaultSignalProcess(pid, signal) {
   process.kill(pid, signal);
@@ -11941,7 +12434,7 @@ var init_launcher = __esm({
 });
 
 // packages/process-launcher/src/index.ts
-var init_src11 = __esm({
+var init_src12 = __esm({
   "packages/process-launcher/src/index.ts"() {
     "use strict";
     init_state_store();
@@ -12080,16 +12573,16 @@ var init_frontmatter = __esm({
 });
 
 // packages/ralph/src/discovery/discovery.ts
-import path21 from "node:path";
+import path23 from "node:path";
 import * as fsPromises5 from "node:fs/promises";
 function createDefaultFs4() {
   return {
     readdir: fsPromises5.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises5.stat(filePath);
+      const stat13 = await fsPromises5.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        mtimeMs: stat13.mtimeMs
       };
     }
   };
@@ -12115,12 +12608,12 @@ async function scanDir(fs3, absoluteDir, displayDir) {
     if (!isMarkdownFile(entry)) {
       continue;
     }
-    const absolutePath = path21.join(absoluteDir, entry);
-    const stat11 = await fs3.stat(absolutePath);
-    if (!stat11.isFile()) {
+    const absolutePath = path23.join(absoluteDir, entry);
+    const stat13 = await fs3.stat(absolutePath);
+    if (!stat13.isFile()) {
       continue;
     }
-    const displayPath = path21.join(displayDir, entry);
+    const displayPath = path23.join(displayDir, entry);
     docs.push({
       path: displayPath,
       displayPath
@@ -12133,8 +12626,8 @@ async function discoverDocs(options) {
   const customDir = options.planDirectory?.trim();
   const docs = customDir ? await scanCustomDir(fs3, customDir, options.cwd, options.homeDir) : await scanDefaultDirs(fs3, options.cwd, options.homeDir);
   return docs.sort((left, right) => {
-    const leftName = path21.basename(left.displayPath).toLowerCase();
-    const rightName = path21.basename(right.displayPath).toLowerCase();
+    const leftName = path23.basename(left.displayPath).toLowerCase();
+    const rightName = path23.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -12147,12 +12640,12 @@ async function scanDefaultDirs(fs3, cwd, homeDir) {
   const [localDocs, globalDocs] = await Promise.all([
     scanDir(
       fs3,
-      path21.join(cwd, ".poe-code", "ralph", "plans"),
+      path23.join(cwd, ".poe-code", "ralph", "plans"),
       ".poe-code/ralph/plans"
     ),
     scanDir(
       fs3,
-      path21.join(homeDir, ".poe-code", "ralph", "plans"),
+      path23.join(homeDir, ".poe-code", "ralph", "plans"),
       "~/.poe-code/ralph/plans"
     )
   ]);
@@ -12160,9 +12653,9 @@ async function scanDefaultDirs(fs3, cwd, homeDir) {
 }
 function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path21.join(homeDir, dir.slice(2));
+    return path23.join(homeDir, dir.slice(2));
   }
-  return path21.isAbsolute(dir) ? dir : path21.resolve(cwd, dir);
+  return path23.isAbsolute(dir) ? dir : path23.resolve(cwd, dir);
 }
 var init_discovery2 = __esm({
   "packages/ralph/src/discovery/discovery.ts"() {
@@ -12171,7 +12664,7 @@ var init_discovery2 = __esm({
 });
 
 // packages/ralph/src/run/ralph.ts
-import path22 from "node:path";
+import path24 from "node:path";
 import * as fsPromises6 from "node:fs/promises";
 async function runRalph(options) {
   const fs3 = options.fs ?? createDefaultFs5();
@@ -12275,10 +12768,10 @@ function createDefaultFs5() {
     writeFile: (filePath, content) => fsPromises6.writeFile(filePath, content, "utf8"),
     readdir: fsPromises6.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises6.stat(filePath);
+      const stat13 = await fsPromises6.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        mtimeMs: stat13.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -12303,9 +12796,9 @@ function normalizeAgents(agent2) {
 }
 function resolveAbsoluteDocPath(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path22.join(homeDir, docPath.slice(2));
+    return path24.join(homeDir, docPath.slice(2));
   }
-  return path22.isAbsolute(docPath) ? docPath : path22.resolve(cwd, docPath);
+  return path24.isAbsolute(docPath) ? docPath : path24.resolve(cwd, docPath);
 }
 function assertNotAborted2(signal) {
   if (!signal?.aborted) {
@@ -12336,9 +12829,9 @@ async function updateFrontmatter(fs3, absoluteDocPath, body, frontmatter, state,
   await fs3.writeFile(absoluteDocPath, content);
 }
 async function archivePlan2(fs3, absoluteDocPath) {
-  const dir = path22.dirname(absoluteDocPath);
-  const archiveDir = path22.join(dir, "archive");
-  const archivePath = path22.join(archiveDir, path22.basename(absoluteDocPath));
+  const dir = path24.dirname(absoluteDocPath);
+  const archiveDir = path24.join(dir, "archive");
+  const archivePath = path24.join(archiveDir, path24.basename(absoluteDocPath));
   await fs3.mkdir(archiveDir, { recursive: true });
   await fs3.rename(absoluteDocPath, archivePath);
 }
@@ -12362,7 +12855,7 @@ var init_ralph = __esm({
 });
 
 // packages/ralph/src/index.ts
-var init_src12 = __esm({
+var init_src13 = __esm({
   "packages/ralph/src/index.ts"() {
     "use strict";
     init_frontmatter();
@@ -12402,7 +12895,7 @@ var AUTONOMOUS_ACTIVITY_TIMEOUT_MS2, MAX_TIMEOUT_RETRIES2;
 var init_ralph2 = __esm({
   async "src/sdk/ralph.ts"() {
     "use strict";
-    init_src12();
+    init_src13();
     init_src7();
     await init_spawn3();
     AUTONOMOUS_ACTIVITY_TIMEOUT_MS2 = 10 * 60 * 1e3;
@@ -12566,6 +13059,8 @@ var init_journal = __esm({
         this.journalPath = journalPath;
         this.fs = fs3;
       }
+      journalPath;
+      fs;
       async init() {
         await this.fs.mkdir(dirname2(this.journalPath), { recursive: true });
         try {
@@ -12719,7 +13214,7 @@ var init_git = __esm({
 });
 
 // packages/experiment-loop/src/config/loader.ts
-import path23 from "node:path";
+import path25 from "node:path";
 import { readFile as readFile5 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { parse as parse7 } from "yaml";
@@ -12775,8 +13270,8 @@ async function loadInstructions() {
   return readBundledFile("default-instructions.md");
 }
 async function loadRunConfig(options) {
-  const projectPath = path23.join(options.cwd, ".poe-code", "experiments", "run.yaml");
-  const globalPath = path23.join(options.homeDir, ".poe-code", "experiments", "run.yaml");
+  const projectPath = path25.join(options.cwd, ".poe-code", "experiments", "run.yaml");
+  const globalPath = path25.join(options.homeDir, ".poe-code", "experiments", "run.yaml");
   const projectContent = await readOptionalFile2(options.fs, projectPath);
   if (projectContent != null) {
     const config = parseRunConfigDocument(projectPath, projectContent);
@@ -12802,17 +13297,17 @@ var init_loader2 = __esm({
 // packages/experiment-loop/src/run/loop.ts
 import { exec as execCallback } from "node:child_process";
 import * as fsPromises7 from "node:fs/promises";
-import path24 from "node:path";
+import path26 from "node:path";
 function createDefaultFs6() {
   return {
     readFile: fsPromises7.readFile,
     writeFile: (filePath, content) => fsPromises7.writeFile(filePath, content, "utf8"),
     readdir: fsPromises7.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises7.stat(filePath);
+      const stat13 = await fsPromises7.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        mtimeMs: stat13.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -12846,14 +13341,14 @@ function createDefaultExec() {
 }
 function resolveAbsoluteDocPath2(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path24.join(homeDir, docPath.slice(2));
+    return path26.join(homeDir, docPath.slice(2));
   }
-  return path24.isAbsolute(docPath) ? docPath : path24.resolve(cwd, docPath);
+  return path26.isAbsolute(docPath) ? docPath : path26.resolve(cwd, docPath);
 }
 function resolveJournalPath(docPath) {
-  return path24.join(
-    path24.dirname(docPath),
-    `${path24.basename(docPath, path24.extname(docPath))}.journal.jsonl`
+  return path26.join(
+    path26.dirname(docPath),
+    `${path26.basename(docPath, path26.extname(docPath))}.journal.jsonl`
   );
 }
 function normalizeMetrics(metric) {
@@ -13033,7 +13528,7 @@ async function runExperimentLoop(options) {
         experimentIndex,
         baseline,
         docPath: options.docPath,
-        docName: path24.basename(absoluteDocPath, path24.extname(absoluteDocPath))
+        docName: path26.basename(absoluteDocPath, path26.extname(absoluteDocPath))
       });
       const currentSpecifier = agents[(experimentIndex - 1) % agents.length];
       const model = currentSpecifier.model;
@@ -13108,7 +13603,7 @@ var init_loop = __esm({
 });
 
 // packages/experiment-loop/src/index.ts
-var init_src13 = __esm({
+var init_src14 = __esm({
   "packages/experiment-loop/src/index.ts"() {
     "use strict";
     init_types3();
@@ -13122,7 +13617,7 @@ var init_src13 = __esm({
 });
 
 // src/sdk/experiment.ts
-import path25 from "node:path";
+import path27 from "node:path";
 import * as fsPromises8 from "node:fs/promises";
 function createDefaultFs7() {
   return {
@@ -13132,10 +13627,10 @@ function createDefaultFs7() {
     },
     readdir: fsPromises8.readdir,
     stat: async (filePath) => {
-      const stat11 = await fsPromises8.stat(filePath);
+      const stat13 = await fsPromises8.stat(filePath);
       return {
-        isFile: () => stat11.isFile(),
-        mtimeMs: stat11.mtimeMs
+        isFile: () => stat13.isFile(),
+        mtimeMs: stat13.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -13148,14 +13643,14 @@ function createDefaultFs7() {
 }
 function resolveAbsoluteDocPath3(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path25.join(homeDir, docPath.slice(2));
+    return path27.join(homeDir, docPath.slice(2));
   }
-  return path25.isAbsolute(docPath) ? docPath : path25.resolve(cwd, docPath);
+  return path27.isAbsolute(docPath) ? docPath : path27.resolve(cwd, docPath);
 }
 function resolveJournalPath2(docPath) {
-  return path25.join(
-    path25.dirname(docPath),
-    `${path25.basename(docPath, path25.extname(docPath))}.journal.jsonl`
+  return path27.join(
+    path27.dirname(docPath),
+    `${path27.basename(docPath, path27.extname(docPath))}.journal.jsonl`
   );
 }
 async function runExperiment(options) {
@@ -13201,7 +13696,7 @@ var AUTONOMOUS_ACTIVITY_TIMEOUT_MS3, MAX_TIMEOUT_RETRIES3;
 var init_experiment = __esm({
   async "src/sdk/experiment.ts"() {
     "use strict";
-    init_src13();
+    init_src14();
     init_src7();
     await init_spawn3();
     AUTONOMOUS_ACTIVITY_TIMEOUT_MS3 = 10 * 60 * 1e3;
@@ -13642,11 +14137,11 @@ function assertValidEnumValues(values) {
     throw new Error("Enum schema values must be unique");
   }
 }
-var S;
-var init_src14 = __esm({
+var S2;
+var init_src15 = __esm({
   "packages/cmdkit-schema/src/index.ts"() {
     "use strict";
-    S = {
+    S2 = {
       String(options = {}) {
         return {
           kind: "string",
@@ -14061,10 +14556,10 @@ function getCommandSourcePath(command) {
   return command[commandSourcePathSymbol];
 }
 var commandConfigSymbol, groupConfigSymbol, commandSourcePathSymbol, UserError;
-var init_src15 = __esm({
+var init_src16 = __esm({
   "packages/cmdkit/src/index.ts"() {
     "use strict";
-    init_src14();
+    init_src15();
     commandConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.command.config");
     groupConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.group.config");
     commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
@@ -14097,7 +14592,7 @@ function checkUserAllow(automation, commentAuthorAssociation) {
 var init_check_user_allow = __esm({
   "packages/github-workflows/src/exec/check-user-allow.ts"() {
     "use strict";
-    init_src15();
+    init_src16();
   }
 });
 
@@ -14121,13 +14616,13 @@ function requireCommentPrefix(automation, commentBody) {
 var init_require_comment_prefix = __esm({
   "packages/github-workflows/src/exec/require-comment-prefix.ts"() {
     "use strict";
-    init_src15();
+    init_src16();
   }
 });
 
 // packages/github-workflows/src/commands.ts
-import { access, mkdir as mkdir8, readFile as readFile9, unlink as unlink2, writeFile as writeFile6 } from "node:fs/promises";
-import path26 from "node:path";
+import { access, mkdir as mkdir10, readFile as readFile9, unlink as unlink2, writeFile as writeFile6 } from "node:fs/promises";
+import path28 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import Mustache3 from "mustache";
 function formatLabel(name) {
@@ -14146,7 +14641,7 @@ async function loadNamedAutomation(name, cwd) {
 }
 async function readBuiltInPromptFile(name) {
   try {
-    return await readFile9(path26.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
+    return await readFile9(path28.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
   } catch (error2) {
     if (isMissingPathError2(error2)) {
       throw new UserError(`Automation "${name}" was not found.`);
@@ -14155,7 +14650,7 @@ async function readBuiltInPromptFile(name) {
   }
 }
 async function readBuiltInWorkflowTemplate(name, variant) {
-  const templatePath = path26.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
+  const templatePath = path28.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
   try {
     const content = await readFile9(templatePath, "utf8");
     const header = variant === "ejected" ? `# Auto-generated by: poe-code github-workflows install ${name}
@@ -14185,7 +14680,7 @@ async function resolveBuiltInWorkflowTemplatesDir() {
   return builtInWorkflowTemplatesDirCandidates[0];
 }
 function projectPromptsDir(cwd) {
-  return path26.join(cwd, ".poe-code", "github-workflows");
+  return path28.join(cwd, ".poe-code", "github-workflows");
 }
 async function resolveBuiltInPromptsDir() {
   for (const candidate of builtInPromptsDirCandidates) {
@@ -14355,7 +14850,7 @@ async function selectAutomationName(message2, automations) {
     message: message2,
     options: automations.map((a) => ({ label: a.label ?? formatLabel(a.name), value: a.name }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -14366,8 +14861,8 @@ var init_commands = __esm({
   "packages/github-workflows/src/commands.ts"() {
     "use strict";
     init_src7();
-    init_src14();
     init_src15();
+    init_src16();
     init_src5();
     init_discover();
     init_check_user_allow();
@@ -14395,12 +14890,12 @@ var init_commands = __esm({
       name: "run",
       description: "Run a GitHub automation.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Optional(S.String()),
-        agent: S.Optional(S.String()),
-        model: S.Optional(S.String()),
-        mode: S.Optional(S.Enum(["yolo", "edit", "read"])),
-        cwd: S.Optional(S.String())
+      params: S2.Object({
+        name: S2.Optional(S2.String()),
+        agent: S2.Optional(S2.String()),
+        model: S2.Optional(S2.String()),
+        mode: S2.Optional(S2.Enum(["yolo", "edit", "read"])),
+        cwd: S2.Optional(S2.String())
       }),
       secrets: {
         poeApiKey: { env: "POE_API_KEY" },
@@ -14480,7 +14975,7 @@ var init_commands = __esm({
     listCommand = defineCommand({
       name: "list",
       description: "List available automations.",
-      params: S.Object({}),
+      params: S2.Object({}),
       scope: ["cli", "sdk"],
       handler: async () => discoverAutomations(await resolveBuiltInPromptsDir(), projectPromptsDir(resolveCwd())),
       render: {
@@ -14508,15 +15003,15 @@ var init_commands = __esm({
       name: "install",
       description: "Install an automation workflow into the current repo.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Enum(installableAutomations, {
+      params: S2.Object({
+        name: S2.Enum(installableAutomations, {
           description: "Pick a GitHub workflow to install",
           loadOptions: async () => {
             const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
             return automations.map((a) => ({ label: a.label ?? formatLabel(a.name), value: a.name }));
           }
         }),
-        eject: S.Optional(S.Boolean())
+        eject: S2.Optional(S2.Boolean())
       }),
       scope: ["cli"],
       handler: async ({ params }) => {
@@ -14528,13 +15023,13 @@ var init_commands = __esm({
           readBuiltInPromptFile(name)
         ]);
         const cwd = resolveCwd();
-        const workflowPath = path26.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
-        await mkdir8(path26.dirname(workflowPath), { recursive: true });
+        const workflowPath = path28.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
+        await mkdir10(path28.dirname(workflowPath), { recursive: true });
         await writeFile6(workflowPath, workflowTemplate, "utf8");
         let promptPath;
         if (isEject) {
-          promptPath = path26.join(projectPromptsDir(cwd), `poe-code-${name}.md`);
-          await mkdir8(path26.dirname(promptPath), { recursive: true });
+          promptPath = path28.join(projectPromptsDir(cwd), `poe-code-${name}.md`);
+          await mkdir10(path28.dirname(promptPath), { recursive: true });
           await writeFile6(promptPath, addPromptHeader(rawPrompt, name), "utf8");
         }
         return {
@@ -14563,8 +15058,8 @@ var init_commands = __esm({
       name: "uninstall",
       description: "Remove an installed automation workflow from the current repo.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Enum(installableAutomations, {
+      params: S2.Object({
+        name: S2.Enum(installableAutomations, {
           description: "Pick a GitHub workflow to uninstall",
           loadOptions: async () => {
             const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
@@ -14575,7 +15070,7 @@ var init_commands = __esm({
       scope: ["cli"],
       handler: async ({ params }) => {
         const name = params.name;
-        const workflowPath = path26.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
+        const workflowPath = path28.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
         try {
           await unlink2(workflowPath);
         } catch (error2) {
@@ -14598,8 +15093,8 @@ var init_commands = __esm({
       name: "check-user-allow",
       description: "Fail when COMMENT_AUTHOR_ASSOCIATION is not allowed by the automation frontmatter.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -14612,8 +15107,8 @@ var init_commands = __esm({
       name: "require-comment-prefix",
       description: "Fail when COMMENT_BODY does not start with the automation prefix frontmatter.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -14626,8 +15121,8 @@ var init_commands = __esm({
       name: "prompt-preview",
       description: "Preview the resolved prompt for an automation.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli", "sdk"],
       handler: async ({ params }) => {
@@ -14658,7 +15153,7 @@ var init_commands = __esm({
 });
 
 // packages/github-workflows/src/index.ts
-var init_src16 = __esm({
+var init_src17 = __esm({
   "packages/github-workflows/src/index.ts"() {
     "use strict";
     init_frontmatter3();
@@ -14794,17 +15289,18 @@ var init_execution_context = __esm({
 });
 
 // src/sdk/launch.ts
-import path27 from "node:path";
-import { spawnSync } from "node:child_process";
+import path29 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
 async function startLaunch(options) {
   const homeDir = resolveHomeDir(options.homeDir);
   const cwd = options.cwd ?? process.cwd();
   const variables = options.variables ?? process.env;
   const executionContext = getCurrentExecutionContext(import.meta.url);
   const runner = createHostRunner({ detached: true });
+  const spec = normalizeLaunchSpec(options.spec, cwd);
   return await startManagedProcess({
     baseDir: resolveLaunchBaseDir(homeDir),
-    spec: options.spec,
+    spec,
     spawnDaemon: async (id) => {
       const handle = runner.exec({
         args: [...executionContext.command.args, "launch", "__run", id],
@@ -14899,7 +15395,7 @@ async function runLaunchDaemon(options) {
   });
 }
 function resolveLaunchBaseDir(homeDir) {
-  return path27.join(homeDir, ".poe-code", "launch");
+  return path29.join(homeDir, ".poe-code", "launch");
 }
 function resolveHomeDir(homeDir) {
   if (homeDir) {
@@ -14907,6 +15403,20 @@ function resolveHomeDir(homeDir) {
   }
   return process.env.HOME ?? process.cwd();
 }
+function normalizeLaunchSpec(spec, baseDir) {
+  if (!spec.cwd) {
+    return spec;
+  }
+  const locator = parseLocator(spec.cwd);
+  if (locator.scheme !== "local") {
+    return spec;
+  }
+  const cwd = path29.isAbsolute(locator.path) ? locator.path : path29.resolve(baseDir, locator.path);
+  return {
+    ...spec,
+    cwd
+  };
+}
 function sendSignalToManagedProcess(pid, signal) {
   if (process.platform === "win32") {
     process.kill(pid, signal);
@@ -14939,14 +15449,14 @@ async function stopDockerArtifacts(record, force) {
   }
   const engine = resolveEngine(record.spec.docker.engine);
   const command = force ? "kill" : "stop";
-  spawnSync(engine, [command, record.spec.docker.containerName], { stdio: "ignore" });
+  spawnSync2(engine, [command, record.spec.docker.containerName], { stdio: "ignore" });
 }
 async function removeDockerArtifacts(record) {
   if (!record.spec?.docker?.containerName) {
     return;
   }
   const engine = resolveEngine(record.spec.docker.engine);
-  spawnSync(engine, ["rm", "-f", record.spec.docker.containerName], { stdio: "ignore" });
+  spawnSync2(engine, ["rm", "-f", record.spec.docker.containerName], { stdio: "ignore" });
 }
 function resolveEngine(engine) {
   if (engine) {
@@ -14957,8 +15467,9 @@ function resolveEngine(engine) {
 var init_launch = __esm({
   "src/sdk/launch.ts"() {
     "use strict";
+    init_src8();
+    init_src12();
     init_src11();
-    init_src10();
     init_execution_context();
   }
 });
@@ -15977,7 +16488,7 @@ var init_acp_core = __esm({
 });
 
 // packages/poe-agent/src/plugins/plugin-args.ts
-import path28 from "node:path";
+import path30 from "node:path";
 function isObjectRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -16008,13 +16519,13 @@ function getOptionalString(args, key) {
   return value;
 }
 function resolveAllowedPath(cwd, allowedPaths, inputPath) {
-  const resolvedPath = path28.resolve(cwd, inputPath);
+  const resolvedPath = path30.resolve(cwd, inputPath);
   const isAllowed = allowedPaths.some((allowedPath) => {
     if (allowedPath === resolvedPath) {
       return true;
     }
-    const rel = path28.relative(allowedPath, resolvedPath);
-    return rel.length > 0 && !rel.startsWith("..") && !path28.isAbsolute(rel);
+    const rel = path30.relative(allowedPath, resolvedPath);
+    return rel.length > 0 && !rel.startsWith("..") && !path30.isAbsolute(rel);
   });
   if (!isAllowed) {
     throw new Error(`Path is outside allowed paths: ${inputPath}`);
@@ -16029,7 +16540,7 @@ var init_plugin_args = __esm({
 
 // packages/poe-agent/src/plugins/poe-agent-plugin-files.ts
 import fsPromises9 from "node:fs/promises";
-import path29 from "node:path";
+import path31 from "node:path";
 async function fileExists(fs3, filePath) {
   try {
     await fs3.readFile(filePath, "utf8");
@@ -16053,9 +16564,9 @@ var init_poe_agent_plugin_files = __esm({
     "use strict";
     init_plugin_args();
     filesPlugin = (options = {}) => {
-      const cwd = path29.resolve(options.cwd ?? process.cwd());
+      const cwd = path31.resolve(options.cwd ?? process.cwd());
       const allowedPaths = (options.allowedPaths ?? [cwd]).map(
-        (allowedPath) => path29.resolve(cwd, allowedPath)
+        (allowedPath) => path31.resolve(cwd, allowedPath)
       );
       const fs3 = options.fs ?? fsPromises9;
       const readFileTool = {
@@ -16109,7 +16620,7 @@ var init_poe_agent_plugin_files = __esm({
         async call(args) {
           const command = getRequiredString(args, "command");
           const filePath = resolveAllowedPath(cwd, allowedPaths, getRequiredString(args, "path"));
-          const displayedPath = path29.relative(cwd, filePath) || path29.basename(filePath);
+          const displayedPath = path31.relative(cwd, filePath) || path31.basename(filePath);
           if (command === "str_replace") {
             const oldStr = getRequiredString(args, "old_str", true);
             const newStr = getRequiredString(args, "new_str", true);
@@ -16129,7 +16640,7 @@ var init_poe_agent_plugin_files = __esm({
             if (await fileExists(fs3, filePath)) {
               throw new Error("File already exists \u2014 use str_replace to edit");
             }
-            await fs3.mkdir(path29.dirname(filePath), { recursive: true });
+            await fs3.mkdir(path31.dirname(filePath), { recursive: true });
             await fs3.writeFile(filePath, fileText, "utf8");
             return `Created file: ${displayedPath}`;
           }
@@ -16170,7 +16681,7 @@ var init_poe_agent_plugin_files = __esm({
 
 // packages/poe-agent/src/plugins/poe-agent-plugin-shell.ts
 import { exec as execCallback2 } from "node:child_process";
-import path30 from "node:path";
+import path32 from "node:path";
 import { promisify } from "node:util";
 async function defaultRunCommand(command, cwd) {
   try {
@@ -16203,9 +16714,9 @@ var init_poe_agent_plugin_shell = __esm({
     init_plugin_args();
     exec = promisify(execCallback2);
     shellPlugin = (options = {}) => {
-      const cwd = path30.resolve(options.cwd ?? process.cwd());
+      const cwd = path32.resolve(options.cwd ?? process.cwd());
       const allowedPaths = (options.allowedPaths ?? [cwd]).map(
-        (allowedPath) => path30.resolve(cwd, allowedPath)
+        (allowedPath) => path32.resolve(cwd, allowedPath)
       );
       const runCommand2 = options.runCommand ?? defaultRunCommand;
       const runCommandTool = {
@@ -18276,7 +18787,7 @@ var init_internal = __esm({
 });
 
 // packages/tiny-mcp-client/src/index.ts
-var init_src17 = __esm({
+var init_src18 = __esm({
   "packages/tiny-mcp-client/src/index.ts"() {
     "use strict";
     init_internal();
@@ -18325,7 +18836,7 @@ var DEFAULT_MCP_CLIENT_INFO, PluginApiImpl;
 var init_plugin_api_impl = __esm({
   "packages/poe-agent/src/runtime/plugin-api-impl.ts"() {
     "use strict";
-    init_src17();
+    init_src18();
     init_hooks();
     DEFAULT_MCP_CLIENT_INFO = {
       name: "poe-agent",
@@ -18892,7 +19403,7 @@ __export(src_exports, {
   agent: () => agent,
   createAgentSession: () => createAgentSession
 });
-var init_src18 = __esm({
+var init_src19 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent();
@@ -19230,7 +19741,7 @@ function createInMemoryAcpTransport2(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src18(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src19(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
           cwd: request.cwd || options.cwd,
@@ -19565,14 +20076,14 @@ var init_renderer2 = __esm({
 
 // packages/cmdkit/src/cli.ts
 import { access as access2, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
-import path32 from "node:path";
+import path34 from "node:path";
 import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
 function inferProgramName(argv) {
   const entrypoint = argv[1];
   if (typeof entrypoint !== "string" || entrypoint.length === 0) {
     return "cmdkit";
   }
-  const parsed = path32.parse(entrypoint);
+  const parsed = path34.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "cmdkit";
 }
 function normalizeRoots(roots, argv) {
@@ -20148,7 +20659,7 @@ async function promptForField(field) {
       options,
       initialValue: field.hasDefault ? field.defaultValue : void 0
     });
-    if (Ct(selected)) {
+    if (q(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -20159,7 +20670,7 @@ async function promptForField(field) {
       message: field.displayPath,
       initialValue: field.hasDefault ? Boolean(field.defaultValue) : void 0
     });
-    if (Ct(selected)) {
+    if (q(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -20169,7 +20680,7 @@ async function promptForField(field) {
     message: field.displayPath,
     initialValue: field.hasDefault && field.defaultValue !== void 0 ? formatResolvedValue(field.defaultValue) : void 0
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -20525,8 +21036,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path32.parse(commandPath);
-  return path32.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path34.parse(commandPath);
+  return path34.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector) {
   if (isNumericFixtureSelector(selector)) {
@@ -20732,7 +21243,7 @@ async function executeCommand(state, services, requirementOptions) {
         message: "Proceed?",
         initialValue: true
       });
-      if (Ct(proceed)) {
+      if (q(proceed)) {
         cancel("Operation cancelled.");
         throw new UserError("Operation cancelled.");
       }
@@ -20816,7 +21327,7 @@ var init_cli = __esm({
   "packages/cmdkit/src/cli.ts"() {
     "use strict";
     init_src5();
-    init_src15();
+    init_src16();
     init_renderer2();
     RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
     HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
@@ -20868,7 +21379,7 @@ function openInBrowser(url) {
 var init_oauth_login = __esm({
   "src/cli/oauth-login.ts"() {
     "use strict";
-    init_src8();
+    init_src9();
     init_src5();
   }
 });
@@ -20941,7 +21452,7 @@ function createCliContainer(dependencies) {
     checkAuth: async (apiKey) => await checkAuth({ apiKey }) !== null,
     confirm: async (message2) => {
       const result = await confirm2({ message: message2 });
-      if (Ct(result)) {
+      if (q(result)) {
         cancel("Operation cancelled.");
         throw new OperationCancelledError();
       }
@@ -20987,7 +21498,7 @@ var init_container2 = __esm({
     init_service_registry();
     init_context();
     init_prompts2();
-    init_src8();
+    init_src9();
     init_options();
     init_logger2();
     init_error_logger();
@@ -21001,7 +21512,7 @@ var init_container2 = __esm({
 });
 
 // src/services/config.ts
-import path33 from "node:path";
+import path35 from "node:path";
 async function deleteConfig(options) {
   const { fs: fs3, filePath } = options;
   try {
@@ -21082,7 +21593,7 @@ async function migrateLegacyCredentialsIfNeeded(fs3, filePath) {
   await migrateLegacyCredentialsFile(fs3, filePath);
 }
 async function migrateLegacyCredentialsFile(fs3, configPath) {
-  const legacyPath = path33.join(path33.dirname(configPath), "credentials.json");
+  const legacyPath = path35.join(path35.dirname(configPath), "credentials.json");
   const raw = await readFileIfExists(fs3, legacyPath);
   if (raw === null) {
     return;
@@ -21150,9 +21661,9 @@ async function recoverInvalidConfig(fs3, filePath, content) {
   await fs3.writeFile(filePath, EMPTY_DOCUMENT3, { encoding: "utf8" });
 }
 function createInvalidBackupPath2(filePath) {
-  const directory = path33.dirname(filePath);
-  const baseName = path33.basename(filePath);
-  return path33.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
+  const directory = path35.dirname(filePath);
+  const baseName = path35.basename(filePath);
+  return path35.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
 function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -21371,7 +21882,7 @@ function registerAgentCommand(program, container) {
     }
     let session;
     try {
-      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src18(), src_exports));
+      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src19(), src_exports));
       session = await createAgentSession2({
         model: options.model,
         apiKey: options.apiKey,
@@ -21430,13 +21941,12 @@ var init_agent2 = __esm({
 });
 
 // src/cli/commands/spawn.ts
-import path34 from "node:path";
 function registerSpawnCommand(program, container, options = {}) {
   const spawnServices = container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name)).map((service) => service.name);
   const extraServices = options.extraServices ?? [];
   const serviceList = [...spawnServices, ...extraServices];
   const serviceDescription = `Agent to spawn${formatServiceList(serviceList)}`;
-  program.command("spawn").alias("s").description("Run a single prompt through a configured agent CLI.").option("--model <model>", "Model identifier override passed to the agent CLI").option("-C, --cwd <path>", "Working directory for the agent CLI").option("--stdin", "Read the prompt from stdin").option("-i, --interactive", "Launch the agent in interactive TUI mode").option("--mode <mode>", "Permission mode: yolo | edit | read (default: yolo)").option("--mcp-config <json>", "MCP server config JSON: {name: {command, args?, env?}}").option("--log-dir <path>", "Directory override for ACP JSONL spawn logs").option(
+  program.command("spawn").alias("s").description("Run a single prompt through a configured agent CLI.").option("--model <model>", "Model identifier override passed to the agent CLI").option("-C, --cwd <path>", "Working directory or workspace locator for the agent CLI").option("--stdin", "Read the prompt from stdin").option("-i, --interactive", "Launch the agent in interactive TUI mode").option("--mode <mode>", "Permission mode: yolo | edit | read (default: yolo)").option("--mcp-servers <json>", "MCP server config JSON: {name: {command, args?, env?}}").option("--mcp-config <json>", "[deprecated: use --mcp-servers]").option("--log-dir <path>", "Directory override for ACP JSONL spawn logs").option(
     "--activity-timeout-ms <ms>",
     "Kill the agent after N ms of inactivity",
     (value) => parsePositiveInt(value, "--activity-timeout-ms")
@@ -21444,8 +21954,7 @@ function registerSpawnCommand(program, container, options = {}) {
     const flags = resolveCommandFlags(program);
     const commandOptions = this.opts();
     const shouldEmitUiOutput = resolveOutputFormat() !== "json";
-    const mcpServers = parseMcpSpawnConfig2(commandOptions.mcpConfig);
-    const cwdOverride = resolveSpawnWorkingDirectory2(container.env.cwd, commandOptions.cwd);
+    const mcpServers = parseMcpSpawnConfig2(commandOptions.mcpServers ?? commandOptions.mcpConfig);
     const wantsStdinFlag = commandOptions.stdin === true;
     const shouldReadFromStdin = wantsStdinFlag || promptText === "-" || !promptText && !process.stdin.isTTY;
     const forwardedArgs = wantsStdinFlag ? [...promptText ? [promptText] : [], ...agentArgs] : agentArgs;
@@ -21455,35 +21964,6 @@ function registerSpawnCommand(program, container, options = {}) {
     if (promptText === "-") {
       promptText = void 0;
     }
-    if (commandOptions.interactive) {
-      const adapter2 = resolveServiceAdapter(container, service);
-      const canonicalService2 = adapter2.name;
-      assertInteractiveSupport(adapter2.label, canonicalService2);
-      const proceed = await confirmUnconfiguredService(
-        container,
-        canonicalService2,
-        adapter2.label,
-        flags
-      );
-      if (!proceed) {
-        return;
-      }
-      const model2 = await resolveConfiguredModel(
-        container,
-        canonicalService2,
-        commandOptions.model
-      );
-      const result = await spawnInteractive(canonicalService2, {
-        prompt: promptText ?? "",
-        args: forwardedArgs,
-        model: model2,
-        mode: commandOptions.mode,
-        ...mcpServers ? { mcpServers } : {},
-        cwd: cwdOverride
-      });
-      process.exitCode = result.exitCode;
-      return;
-    }
     if (!promptText && shouldReadFromStdin) {
       const chunks = [];
       for await (const chunk of process.stdin) {
@@ -21491,154 +21971,197 @@ function registerSpawnCommand(program, container, options = {}) {
       }
       promptText = Buffer.concat(chunks).toString("utf8").trim();
     }
-    if (!promptText) {
+    if (!promptText && !commandOptions.interactive) {
       throw new Error("No prompt provided via argument or stdin");
     }
-    const directSpawnOptions = {
-      prompt: promptText,
-      args: forwardedArgs,
-      model: commandOptions.model,
+    const prompt = promptText ?? "";
+    const workspace = await resolveSpawnWorkspace(commandOptions.cwd, {
+      baseDir: container.env.cwd,
+      homeDir: container.env.homeDir,
       mode: commandOptions.mode,
-      mcpServers,
-      cwd: cwdOverride,
-      logDir: commandOptions.logDir,
-      activityTimeoutMs: commandOptions.activityTimeoutMs,
-      useStdin: shouldReadFromStdin
-    };
-    const directHandler = options.handlers?.[service];
-    if (directHandler) {
-      const resources2 = createExecutionResources(container, flags, `spawn:${service}`);
-      if (shouldEmitUiOutput) {
-        resources2.logger.intro(`spawn ${service}`);
-      }
-      await directHandler({
-        container,
-        service,
-        options: directSpawnOptions,
-        flags,
-        resources: resources2
-      });
-      if (shouldEmitUiOutput) {
-        resources2.context.finalize();
-      }
-      return;
-    }
-    const adapter = resolveServiceAdapter(container, service);
-    const canonicalService = adapter.name;
-    const model = await resolveConfiguredModel(
-      container,
-      canonicalService,
-      commandOptions.model
-    );
-    const spawnOptions = {
-      ...directSpawnOptions,
-      model
-    };
-    const resources = createExecutionResources(container, flags, `spawn:${canonicalService}`);
-    if (shouldEmitUiOutput) {
-      resources.logger.intro(`spawn ${canonicalService}`);
-    }
-    const canonicalHandler = options.handlers?.[canonicalService];
-    if (canonicalHandler) {
-      try {
-        await canonicalHandler({
+      resolveRemoteLocators: !flags.dryRun,
+      fs: container.fs,
+      exec: container.commandRunner
+    });
+    const cwdOverride = workspace.cwd;
+    try {
+      if (commandOptions.interactive) {
+        const adapter2 = resolveServiceAdapter(container, service);
+        const canonicalService2 = adapter2.name;
+        assertInteractiveSupport(adapter2.label, canonicalService2);
+        const proceed = await confirmUnconfiguredService(
           container,
-          service: canonicalService,
-          options: spawnOptions,
-          flags,
-          resources
+          canonicalService2,
+          adapter2.label,
+          flags
+        );
+        if (!proceed) {
+          return;
+        }
+        const model2 = await resolveConfiguredModel(
+          container,
+          canonicalService2,
+          commandOptions.model
+        );
+        const result = await spawnInteractive(canonicalService2, {
+          prompt,
+          args: forwardedArgs,
+          model: model2,
+          mode: commandOptions.mode,
+          ...mcpServers ? { mcpServers } : {},
+          cwd: cwdOverride
         });
+        process.exitCode = result.exitCode;
         return;
-      } finally {
+      }
+      const directSpawnOptions = {
+        prompt,
+        args: forwardedArgs,
+        model: commandOptions.model,
+        mode: commandOptions.mode,
+        mcpServers,
+        cwd: cwdOverride,
+        logDir: commandOptions.logDir,
+        activityTimeoutMs: commandOptions.activityTimeoutMs,
+        useStdin: shouldReadFromStdin
+      };
+      const directHandler = options.handlers?.[service];
+      if (directHandler) {
+        const resources2 = createExecutionResources(container, flags, `spawn:${service}`);
         if (shouldEmitUiOutput) {
-          resources.context.finalize();
+          resources2.logger.intro(`spawn ${service}`);
         }
-      }
-    }
-    try {
-      assertSpawnSupport(adapter.label, canonicalService, typeof adapter.spawn === "function");
-      assertMcpSpawnSupport(
-        adapter.label,
-        canonicalService,
-        adapter.supportsMcpSpawn === true,
-        mcpServers
-      );
-      if (flags.dryRun) {
-        await spawnCore(container, canonicalService, spawnOptions, {
-          dryRun: true,
-          verbose: flags.verbose
+        await directHandler({
+          container,
+          service,
+          options: directSpawnOptions,
+          flags,
+          resources: resources2
         });
+        if (shouldEmitUiOutput) {
+          resources2.context.finalize();
+        }
         return;
       }
-      const proceed = await confirmUnconfiguredService(
+      const adapter = resolveServiceAdapter(container, service);
+      const canonicalService = adapter.name;
+      const model = await resolveConfiguredModel(
         container,
         canonicalService,
-        adapter.label,
-        flags
+        commandOptions.model
       );
-      if (!proceed) {
-        return;
+      const spawnOptions = {
+        ...directSpawnOptions,
+        model
+      };
+      const resources = createExecutionResources(container, flags, `spawn:${canonicalService}`);
+      if (shouldEmitUiOutput) {
+        resources.logger.intro(`spawn ${canonicalService}`);
       }
-      const { events, result } = spawn4(canonicalService, {
-        prompt: spawnOptions.prompt,
-        args: spawnOptions.args,
-        model: spawnOptions.model,
-        mode: spawnOptions.mode,
-        cwd: spawnOptions.cwd,
-        ...spawnOptions.mcpServers ? { mcpConfig: spawnOptions.mcpServers } : {},
-        ...spawnOptions.logDir !== void 0 ? { logDir: spawnOptions.logDir } : {},
-        ...spawnOptions.activityTimeoutMs !== void 0 ? { activityTimeoutMs: spawnOptions.activityTimeoutMs } : {}
-      });
-      await renderAcpStream(events);
-      const final = await result;
-      process.exitCode = final.exitCode;
-      if (!shouldEmitUiOutput) {
-        renderAcpEvent({
-          event: "spawn_result",
-          exitCode: final.exitCode,
-          ...final.threadId ? { threadId: final.threadId } : {},
-          ...final.usage ? { usage: final.usage } : {},
-          protocolVersion: 1
-        });
+      const canonicalHandler = options.handlers?.[canonicalService];
+      if (canonicalHandler) {
+        try {
+          await canonicalHandler({
+            container,
+            service: canonicalService,
+            options: spawnOptions,
+            flags,
+            resources
+          });
+          return;
+        } finally {
+          if (shouldEmitUiOutput) {
+            resources.context.finalize();
+          }
+        }
       }
-      if (final.exitCode !== 0) {
-        if (!shouldEmitUiOutput) {
+      try {
+        assertSpawnSupport(adapter.label, canonicalService, typeof adapter.spawn === "function");
+        assertMcpSpawnSupport(
+          adapter.label,
+          canonicalService,
+          adapter.supportsMcpSpawn === true,
+          mcpServers
+        );
+        if (flags.dryRun) {
+          await spawnCore(container, canonicalService, spawnOptions, {
+            dryRun: true,
+            verbose: flags.verbose
+          });
           return;
         }
-        const detail = final.stderr.trim() || final.stdout.trim();
-        const suffix = detail ? `: ${detail}` : "";
-        throw new Error(
-          `${adapter.label} spawn failed with exit code ${final.exitCode}${suffix}`
+        const proceed = await confirmUnconfiguredService(
+          container,
+          canonicalService,
+          adapter.label,
+          flags
         );
-      }
-      if (shouldEmitUiOutput) {
-        const trimmedStdout = final.stdout.trim();
-        if (trimmedStdout) {
-          resources.logger.info(trimmedStdout);
-        } else {
-          const trimmedStderr = final.stderr.trim();
-          if (trimmedStderr) {
-            resources.logger.info(trimmedStderr);
+        if (!proceed) {
+          return;
+        }
+        const { events, result } = spawn4(canonicalService, {
+          prompt: spawnOptions.prompt,
+          args: spawnOptions.args,
+          model: spawnOptions.model,
+          mode: spawnOptions.mode,
+          cwd: spawnOptions.cwd,
+          ...spawnOptions.mcpServers ? { mcpServers: spawnOptions.mcpServers } : {},
+          ...spawnOptions.logDir !== void 0 ? { logDir: spawnOptions.logDir } : {},
+          ...spawnOptions.activityTimeoutMs !== void 0 ? { activityTimeoutMs: spawnOptions.activityTimeoutMs } : {}
+        });
+        await renderAcpStream(events);
+        const final = await result;
+        process.exitCode = final.exitCode;
+        if (!shouldEmitUiOutput) {
+          renderAcpEvent({
+            event: "spawn_result",
+            exitCode: final.exitCode,
+            ...final.threadId ? { threadId: final.threadId } : {},
+            ...final.usage ? { usage: final.usage } : {},
+            protocolVersion: 1
+          });
+        }
+        if (final.exitCode !== 0) {
+          if (!shouldEmitUiOutput) {
+            return;
+          }
+          const detail = final.stderr.trim() || final.stdout.trim();
+          const suffix = detail ? `: ${detail}` : "";
+          throw new Error(
+            `${adapter.label} spawn failed with exit code ${final.exitCode}${suffix}`
+          );
+        }
+        if (shouldEmitUiOutput) {
+          const trimmedStdout = final.stdout.trim();
+          if (trimmedStdout) {
+            resources.logger.info(trimmedStdout);
           } else {
-            resources.logger.info(`${adapter.label} spawn completed.`);
+            const trimmedStderr = final.stderr.trim();
+            if (trimmedStderr) {
+              resources.logger.info(trimmedStderr);
+            } else {
+              resources.logger.info(`${adapter.label} spawn completed.`);
+            }
           }
         }
-      }
-      if (shouldEmitUiOutput && final.threadId) {
-        const resumeCommand = buildResumeCommand(
-          canonicalService,
-          final.threadId,
-          spawnOptions.cwd ?? process.cwd()
-        );
-        if (resumeCommand) {
-          resources.logger.info(text.muted(`
+        if (shouldEmitUiOutput && final.threadId) {
+          const resumeCommand = buildResumeCommand(
+            canonicalService,
+            final.threadId,
+            spawnOptions.cwd ?? process.cwd()
+          );
+          if (resumeCommand) {
+            resources.logger.info(text.muted(`
 Resume: ${resumeCommand}`));
+          }
+        }
+      } finally {
+        if (shouldEmitUiOutput) {
+          resources.context.finalize();
         }
       }
     } finally {
-      if (shouldEmitUiOutput) {
-        resources.context.finalize();
-      }
+      await workspace.cleanup?.();
     }
   });
 }
@@ -21654,22 +22177,13 @@ async function confirmUnconfiguredService(container, service, label, flags) {
   if (flags.assumeYes) {
     return true;
   }
-  const shouldProceed = await confirm2({
-    message: `${label} is not configured via poe. Do you want to proceed?`
-  });
-  if (Ct(shouldProceed)) {
-    throw new OperationCancelledError();
-  }
-  return shouldProceed === true;
-}
-function resolveSpawnWorkingDirectory2(baseDir, candidate) {
-  if (!candidate || candidate.trim().length === 0) {
-    return void 0;
-  }
-  if (path34.isAbsolute(candidate)) {
-    return candidate;
+  const shouldProceed = await confirm2({
+    message: `${label} is not configured via poe. Do you want to proceed?`
+  });
+  if (q(shouldProceed)) {
+    throw new OperationCancelledError();
   }
-  return path34.resolve(baseDir, candidate);
+  return shouldProceed === true;
 }
 function parseMcpSpawnConfig2(input) {
   if (!input) {
@@ -21680,37 +22194,37 @@ function parseMcpSpawnConfig2(input) {
     parsed = JSON.parse(input);
   } catch {
     throw new ValidationError(
-      "--mcp-config must be valid JSON in this shape: {name: {command, args?, env?}}"
+      "--mcp-servers must be valid JSON in this shape: {name: {command, args?, env?}}"
     );
   }
   if (!isObjectRecord5(parsed)) {
     throw new ValidationError(
-      "--mcp-config must be an object in this shape: {name: {command, args?, env?}}"
+      "--mcp-servers must be an object in this shape: {name: {command, args?, env?}}"
     );
   }
   const servers = {};
   for (const [name, value] of Object.entries(parsed)) {
     if (!isObjectRecord5(value)) {
       throw new ValidationError(
-        `--mcp-config entry "${name}" must be an object: {command, args?, env?}`
+        `--mcp-servers entry "${name}" must be an object: {command, args?, env?}`
       );
     }
     const command = value.command;
     if (typeof command !== "string" || command.trim().length === 0) {
       throw new ValidationError(
-        `--mcp-config entry "${name}" must include a non-empty string "command"`
+        `--mcp-servers entry "${name}" must include a non-empty string "command"`
       );
     }
     let args;
     if ("args" in value && value.args !== void 0) {
       if (!Array.isArray(value.args)) {
-        throw new ValidationError(`--mcp-config entry "${name}".args must be an array of strings`);
+        throw new ValidationError(`--mcp-servers entry "${name}".args must be an array of strings`);
       }
       args = [];
       for (const arg of value.args) {
         if (typeof arg !== "string") {
           throw new ValidationError(
-            `--mcp-config entry "${name}".args must be an array of strings`
+            `--mcp-servers entry "${name}".args must be an array of strings`
           );
         }
         args.push(arg);
@@ -21720,14 +22234,14 @@ function parseMcpSpawnConfig2(input) {
     if ("env" in value && value.env !== void 0) {
       if (!isObjectRecord5(value.env)) {
         throw new ValidationError(
-          `--mcp-config entry "${name}".env must be an object of string values`
+          `--mcp-servers entry "${name}".env must be an object of string values`
         );
       }
       env = {};
       for (const [envKey, envValue] of Object.entries(value.env)) {
         if (typeof envValue !== "string") {
           throw new ValidationError(
-            `--mcp-config entry "${name}".env must be an object of string values`
+            `--mcp-servers entry "${name}".env must be an object of string values`
           );
         }
         env[envKey] = envValue;
@@ -21790,502 +22304,7 @@ var init_spawn4 = __esm({
     init_spawn_core();
     await init_spawn3();
     init_errors();
-  }
-});
-
-// src/sdk/research.ts
-import path35 from "node:path";
-async function research(container, options) {
-  const logger2 = options.logger;
-  const source = await resolveSource({
-    container,
-    options,
-    logger: logger2
-  });
-  const researchPrompt = buildResearchPrompt(options.prompt);
-  const mode = options.mode ?? "read";
-  const { events, result } = spawn4(options.agent, {
-    prompt: researchPrompt,
-    args: options.args ?? [],
-    model: options.model,
-    mode,
-    cwd: source.cwd
-  });
-  const { teed, getOutput, done } = teeAcpStream(events);
-  const resultPromise = (async () => {
-    let outputPath;
-    let markdownOutput = "";
-    try {
-      const final = await result;
-      await done;
-      markdownOutput = getOutput();
-      const resumeCommand = final.threadId && options.resolveResumeCommand ? options.resolveResumeCommand(final.threadId, source.cwd) : void 0;
-      const document = buildResearchDocument({
-        prompt: options.prompt,
-        agent: options.agent,
-        path: source.cwd,
-        github: source.github,
-        resumeCommand,
-        markdown: markdownOutput
-      });
-      outputPath = buildOutputPath(container.env.homeDir, options.prompt);
-      await ensureDirectory2(container.fs, path35.dirname(outputPath));
-      await container.fs.writeFile(outputPath, document, {
-        encoding: "utf8"
-      });
-      if (final.exitCode !== 0) {
-        const detail = final.stderr.trim() || final.stdout.trim();
-        const suffix = detail ? `: ${detail}` : "";
-        const label = options.agentLabel ?? options.agent;
-        throw new Error(
-          `${label} research failed with exit code ${final.exitCode}${suffix}`
-        );
-      }
-      if (outputPath) {
-        logger2?.info?.(`Saved research to ${outputPath}`);
-      }
-      return {
-        ...final,
-        markdownOutput,
-        outputPath,
-        cwd: source.cwd,
-        github: source.github
-      };
-    } finally {
-      if (source.shouldCleanup && source.clonePath) {
-        await removePath(container.fs, source.clonePath);
-      }
-    }
-  })();
-  return { events: teed, result: resultPromise };
-}
-function buildSlug(value) {
-  const trimmed = value.trim().toLowerCase();
-  const maxLength = 48;
-  let output = "";
-  let pendingSeparator = false;
-  for (let index = 0; index < trimmed.length; index += 1) {
-    const char = trimmed[index] ?? "";
-    const code = char.charCodeAt(0);
-    if (isSlugChar(code)) {
-      if (pendingSeparator && output.length > 0) {
-        output += "-";
-      }
-      pendingSeparator = false;
-      output += char;
-    } else {
-      pendingSeparator = true;
-    }
-    if (output.length >= maxLength) {
-      break;
-    }
-  }
-  output = trimTrailingDashes(output.slice(0, maxLength));
-  return output.length > 0 ? output : "research";
-}
-function buildResearchPrompt(prompt) {
-  return `${RESEARCH_SYSTEM_PROMPT}
-
-${prompt}`;
-}
-function buildResearchDocument(input) {
-  const lines = ["---"];
-  lines.push(`research_prompt: ${formatYamlString(input.prompt)}`);
-  lines.push(`agent: ${formatYamlString(input.agent)}`);
-  lines.push(`path: ${formatYamlString(input.path)}`);
-  if (input.github) {
-    lines.push(`github: ${formatYamlString(input.github)}`);
-  }
-  if (input.resumeCommand) {
-    lines.push(`resume_session_cmd: ${formatYamlString(input.resumeCommand)}`);
-  }
-  lines.push("---", "", input.markdown);
-  return lines.join("\n");
-}
-function buildClonePath(homeDir, github) {
-  const slug = extractRepoSlug(github);
-  return path35.join(homeDir, ".poe-code", "repos", slug);
-}
-function extractRepoSlug(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return "repo";
-  }
-  let pathPart = trimmed;
-  const schemeIndex = trimmed.indexOf("://");
-  if (schemeIndex !== -1) {
-    try {
-      const url = new URL(trimmed);
-      pathPart = url.pathname;
-    } catch {
-      pathPart = trimmed.slice(schemeIndex + 3);
-    }
-  } else if (trimmed.startsWith("git@")) {
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex !== -1) {
-      pathPart = trimmed.slice(colonIndex + 1);
-    }
-  }
-  if (pathPart.startsWith("/")) {
-    pathPart = pathPart.slice(1);
-  }
-  if (pathPart.endsWith(".git")) {
-    pathPart = pathPart.slice(0, -4);
-  }
-  const parts = pathPart.split("/");
-  const owner = parts[0] ?? "";
-  const repo = parts[1] ?? "";
-  const combined = repo.length > 0 ? `${owner}-${repo}` : owner;
-  const slug = buildSlug(combined);
-  return slug.length > 0 ? slug : buildSlug(trimmed);
-}
-function buildOutputPath(homeDir, prompt, now = /* @__PURE__ */ new Date()) {
-  const timestamp = formatTimestamp2(now);
-  const slug = buildSlug(prompt);
-  return path35.join(
-    homeDir,
-    ".poe-code",
-    "research",
-    `${timestamp}-${slug}.md`
-  );
-}
-function resolveGithubCloneUrl(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith("git@") || trimmed.includes("://")) {
-    return trimmed;
-  }
-  const suffix = trimmed.endsWith(".git") ? trimmed : `${trimmed}.git`;
-  return `https://github.com/${suffix}`;
-}
-async function resolveSource(input) {
-  const { container, options } = input;
-  const logger2 = input.logger;
-  if (options.github) {
-    const cloneUrl = resolveGithubCloneUrl(options.github);
-    const clonePath = buildClonePath(container.env.homeDir, options.github);
-    await ensureDirectory2(container.fs, path35.dirname(clonePath));
-    const exists = await pathExists2(container.fs, clonePath);
-    if (!exists) {
-      const cloneResult = await container.commandRunner(
-        "git",
-        ["clone", "--depth", "1", cloneUrl, clonePath]
-      );
-      if (cloneResult.exitCode !== 0) {
-        throw new Error(
-          `git clone failed with exit code ${cloneResult.exitCode}: ${cloneResult.stderr.trim()}`
-        );
-      }
-      return {
-        cwd: clonePath,
-        github: options.github,
-        clonePath,
-        shouldCleanup: !options.keep
-      };
-    }
-    const statusResult = await container.commandRunner(
-      "git",
-      ["status", "--porcelain"],
-      { cwd: clonePath }
-    );
-    if (statusResult.exitCode !== 0) {
-      logger2?.warn?.("Unable to check git status; using existing clone.");
-    } else if (statusResult.stdout.trim().length > 0) {
-      logger2?.warn?.("Repo has uncommitted changes; skipping update.");
-    } else {
-      const pullResult = await container.commandRunner(
-        "git",
-        ["pull", "--ff-only"],
-        { cwd: clonePath }
-      );
-      if (pullResult.exitCode !== 0) {
-        logger2?.warn?.("Git pull failed; using existing clone.");
-      }
-    }
-    return {
-      cwd: clonePath,
-      github: options.github,
-      clonePath,
-      shouldCleanup: false
-    };
-  }
-  if (options.path) {
-    return {
-      cwd: resolvePath2(container.env.cwd, options.path),
-      shouldCleanup: false
-    };
-  }
-  if (options.cwd) {
-    return {
-      cwd: resolvePath2(container.env.cwd, options.cwd),
-      shouldCleanup: false
-    };
-  }
-  return {
-    cwd: container.env.cwd,
-    shouldCleanup: false
-  };
-}
-function isSlugChar(code) {
-  if (code >= 48 && code <= 57) {
-    return true;
-  }
-  if (code >= 97 && code <= 122) {
-    return true;
-  }
-  return false;
-}
-function trimTrailingDashes(value) {
-  let output = value;
-  while (output.endsWith("-")) {
-    output = output.slice(0, -1);
-  }
-  return output;
-}
-function formatTimestamp2(now) {
-  const year = now.getUTCFullYear();
-  const month = padNumber(now.getUTCMonth() + 1, 2);
-  const day = padNumber(now.getUTCDate(), 2);
-  const hours = padNumber(now.getUTCHours(), 2);
-  const minutes = padNumber(now.getUTCMinutes(), 2);
-  const seconds = padNumber(now.getUTCSeconds(), 2);
-  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
-}
-function padNumber(value, length) {
-  let output = String(value);
-  while (output.length < length) {
-    output = `0${output}`;
-  }
-  return output;
-}
-function formatYamlString(value) {
-  return JSON.stringify(value);
-}
-function resolvePath2(baseDir, candidate) {
-  if (path35.isAbsolute(candidate)) {
-    return candidate;
-  }
-  return path35.resolve(baseDir, candidate);
-}
-function teeAcpStream(events) {
-  const chunks = [];
-  let resolveDone;
-  const done = new Promise((resolve) => {
-    resolveDone = resolve;
-  });
-  const teed = (async function* () {
-    try {
-      for await (const event of events) {
-        if (event.event === "agent_message") {
-          chunks.push(event.text);
-        }
-        yield event;
-      }
-    } finally {
-      resolveDone?.();
-    }
-  })();
-  return {
-    teed,
-    getOutput: () => chunks.join(""),
-    done
-  };
-}
-async function ensureDirectory2(fs3, target) {
-  await fs3.mkdir(target, { recursive: true });
-}
-async function pathExists2(fs3, target) {
-  try {
-    await fs3.stat(target);
-    return true;
-  } catch (error2) {
-    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
-      return false;
-    }
-    throw error2;
-  }
-}
-async function removePath(fs3, target) {
-  if (typeof fs3.rm === "function") {
-    await fs3.rm(target, { recursive: true, force: true });
-    return;
-  }
-  await removePathFallback(fs3, target);
-}
-async function removePathFallback(fs3, target) {
-  let stats;
-  try {
-    stats = await fs3.stat(target);
-  } catch (error2) {
-    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
-      return;
-    }
-    throw error2;
-  }
-  if (stats && typeof stats.isDirectory === "function" && stats.isDirectory()) {
-    const entries = await fs3.readdir(target);
-    for (const entry of entries) {
-      await removePathFallback(fs3, path35.join(target, entry));
-    }
-  }
-  try {
-    await fs3.unlink(target);
-  } catch {
-  }
-}
-var RESEARCH_SYSTEM_PROMPT;
-var init_research = __esm({
-  async "src/sdk/research.ts"() {
-    "use strict";
-    await init_spawn3();
-    RESEARCH_SYSTEM_PROMPT = [
-      "You are a codebase research assistant.",
-      "Read files and answer the user's question about the codebase.",
-      "Do not modify files or suggest edits.",
-      "Respond in Markdown."
-    ].join("\n");
-  }
-});
-
-// src/cli/commands/research.ts
-function registerResearchCommand(program, container) {
-  const spawnServices = container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name)).map((service) => service.name);
-  const serviceDescription = `Agent to research with${formatServiceList(spawnServices)}`;
-  program.command("research").description("Research a codebase using a coding agent.").option("--agent <agent>", serviceDescription).option("--model <model>", "Model identifier override passed to the agent CLI").option("--mode <mode>", "Permission mode: yolo | edit | read (default: read)").option("-C, --cwd <path>", "Working directory override").option("--path <path>", "Local directory to research").option("--github <repo>", "Clone and research a GitHub repo").option("--stdin", "Read the prompt from stdin").option("--keep", "Keep the cloned repo when using --github").argument("[prompt]", "Prompt text to send (or '-' / stdin)").argument("[agentArgs...]", "Additional arguments forwarded to the agent CLI").action(async function(promptText, agentArgs = []) {
-    const flags = resolveCommandFlags(program);
-    const commandOptions = this.opts();
-    const wantsStdinFlag = commandOptions.stdin === true;
-    const shouldReadFromStdin = wantsStdinFlag || promptText === "-" || !promptText && !process.stdin.isTTY;
-    const forwardedArgs = wantsStdinFlag ? [...promptText ? [promptText] : [], ...agentArgs] : agentArgs;
-    if (wantsStdinFlag) {
-      promptText = void 0;
-    }
-    if (promptText === "-") {
-      promptText = void 0;
-    }
-    if (!promptText && shouldReadFromStdin) {
-      const chunks = [];
-      for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-      }
-      promptText = Buffer.concat(chunks).toString("utf8").trim();
-    }
-    if (!promptText) {
-      throw new Error("No prompt provided via argument or stdin");
-    }
-    const resolvedAgent = await resolveResearchAgent({
-      container,
-      flags,
-      agent: commandOptions.agent
-    });
-    const adapter = resolveServiceAdapter(container, resolvedAgent);
-    const canonicalService = adapter.name;
-    const resources = createExecutionResources(container, flags, `research:${canonicalService}`);
-    resources.logger.intro(`research ${canonicalService}`);
-    const model = await resolveResearchModel({
-      container,
-      flags,
-      adapter,
-      value: commandOptions.model
-    });
-    try {
-      const { events, result } = await research(container, {
-        prompt: promptText,
-        agent: canonicalService,
-        agentLabel: adapter.label,
-        model,
-        mode: commandOptions.mode,
-        args: forwardedArgs,
-        cwd: commandOptions.cwd,
-        path: commandOptions.path,
-        github: commandOptions.github,
-        keep: commandOptions.keep,
-        logger: resources.logger,
-        resolveResumeCommand: (threadId, cwdValue) => buildResumeCommand(canonicalService, threadId, cwdValue)
-      });
-      await renderAcpStream(events);
-      await result;
-    } finally {
-      resources.context.finalize();
-    }
-  });
-}
-async function resolveResearchAgent(input) {
-  if (input.agent) {
-    return input.agent;
-  }
-  const spawnable = input.container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name));
-  if (spawnable.length === 0) {
-    throw new Error("No spawn-capable agents available.");
-  }
-  if (input.flags.assumeYes) {
-    const configured = await loadConfiguredServices({
-      fs: input.container.fs,
-      filePath: input.container.env.configPath,
-      projectFilePath: input.container.env.projectConfigPath
-    });
-    const configuredService = spawnable.find((service) => service.name in configured);
-    return configuredService?.name ?? spawnable[0].name;
-  }
-  const choices = spawnable.map((service) => ({
-    title: service.label,
-    value: service.name
-  }));
-  const descriptor = input.container.promptLibrary.serviceSelection({
-    message: "Pick an agent to research with:",
-    choices
-  });
-  const response = await input.container.prompts(descriptor);
-  const selectionValue = response[descriptor.name];
-  if (typeof selectionValue !== "string") {
-    throw new OperationCancelledError();
-  }
-  const resolved = spawnable.find((service) => service.name === selectionValue);
-  if (!resolved) {
-    throw new Error("Invalid agent selection.");
-  }
-  return resolved.name;
-}
-async function resolveResearchModel(input) {
-  if (input.value) {
-    return input.value;
-  }
-  const modelPrompt = input.adapter.configurePrompts?.model;
-  if (modelPrompt) {
-    return await input.container.options.resolveModel({
-      value: input.value,
-      assumeDefault: input.flags.assumeYes,
-      defaultValue: modelPrompt.defaultValue,
-      choices: modelPrompt.choices,
-      label: modelPrompt.label
-    });
-  }
-  if (input.flags.assumeYes) {
-    return void 0;
-  }
-  const descriptor = {
-    name: "model",
-    message: "Model identifier",
-    type: "text"
-  };
-  const response = await input.container.prompts(descriptor);
-  const result = response[descriptor.name];
-  if (typeof result !== "string") {
-    throw new OperationCancelledError();
-  }
-  const trimmed = result.trim();
-  if (trimmed.length === 0) {
-    throw new Error("Model identifier is required.");
-  }
-  return trimmed;
-}
-var init_research2 = __esm({
-  async "src/cli/commands/research.ts"() {
-    "use strict";
-    init_src7();
-    init_config3();
-    await init_research();
-    init_errors();
-    init_shared();
+    init_resolve_spawn_workspace();
   }
 });
 
@@ -22893,7 +22912,7 @@ function registerUtilsCommand(program, container) {
   const utils = program.command("utils").description("Utility commands for inspecting and managing poe-code.");
   registerConfigCommand(utils, container);
 }
-var init_utils3 = __esm({
+var init_utils4 = __esm({
   "src/cli/commands/utils.ts"() {
     "use strict";
     init_config4();
@@ -23589,6 +23608,8 @@ var init_image = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
+      base64Data;
+      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -23663,6 +23684,8 @@ var init_audio = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
+      base64Data;
+      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -23733,6 +23756,10 @@ var init_file = __esm({
         this.isText = isText;
         this.name = name;
       }
+      data;
+      mimeType;
+      isText;
+      name;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -24114,7 +24141,7 @@ var init_content = __esm({
 });
 
 // packages/tiny-stdio-mcp-server/src/index.ts
-var init_src19 = __esm({
+var init_src20 = __esm({
   "packages/tiny-stdio-mcp-server/src/index.ts"() {
     "use strict";
     init_server();
@@ -24417,7 +24444,7 @@ var generateTextSchema, generateImageSchema, generateVideoSchema, generateAudioS
 var init_mcp_server = __esm({
   "src/cli/mcp-server.ts"() {
     "use strict";
-    init_src19();
+    init_src20();
     init_client_instance();
     init_constants();
     generateTextSchema = defineSchema({
@@ -24805,7 +24832,7 @@ var init_apply = __esm({
 });
 
 // packages/agent-mcp-config/src/index.ts
-var init_src20 = __esm({
+var init_src21 = __esm({
   "packages/agent-mcp-config/src/index.ts"() {
     "use strict";
     init_configs2();
@@ -24878,7 +24905,7 @@ function registerMcpCommand(program, container) {
           message: "Select agent to configure:",
           options: supportedAgents.map((a) => ({ value: a, label: a }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -24985,14 +25012,14 @@ var init_mcp2 = __esm({
     init_shared();
     init_mcp_output_format();
     init_command_not_found();
-    init_src20();
+    init_src21();
     init_execution_context();
     DEFAULT_MCP_AGENT = "claude-code";
   }
 });
 
 // packages/agent-skill-config/src/configs.ts
-import os2 from "node:os";
+import os4 from "node:os";
 import path38 from "node:path";
 function resolveAgentSupport2(input, registry = agentSkillConfigs) {
   const resolvedId = resolveAgentId(input);
@@ -25185,7 +25212,7 @@ var init_apply2 = __esm({
 });
 
 // packages/agent-skill-config/src/index.ts
-var init_src21 = __esm({
+var init_src22 = __esm({
   "packages/agent-skill-config/src/index.ts"() {
     "use strict";
     init_configs3();
@@ -25231,7 +25258,7 @@ function registerSkillCommand(program, container) {
           message: "Select agent to configure:",
           options: supportedAgents2.map((a) => ({ value: a, label: a }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -25264,7 +25291,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25310,7 +25337,7 @@ function registerSkillCommand(program, container) {
         message: "Select agent to unconfigure:",
         options: supportedAgents2.map((a) => ({ value: a, label: a }))
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25340,7 +25367,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25410,7 +25437,7 @@ var init_skill = __esm({
   "src/cli/commands/skill.ts"() {
     "use strict";
     init_src5();
-    init_src21();
+    init_src22();
     init_shared();
     init_command_not_found();
     DEFAULT_SKILL_AGENT = "claude-code";
@@ -25703,7 +25730,7 @@ function registerUsageCommand(program, container) {
         startingAfter = result.data[result.data.length - 1].query_id;
         if (maxPages === void 0) {
           const shouldContinue = await confirm2({ message: "Load more?" });
-          if (Ct(shouldContinue)) {
+          if (q(shouldContinue)) {
             throw new OperationCancelledError();
           }
           if (!shouldContinue) {
@@ -26080,7 +26107,7 @@ var init_models2 = __esm({
 
 // src/cli/commands/pipeline.ts
 import path39 from "node:path";
-import { readFile as readFile13, stat as stat9 } from "node:fs/promises";
+import { readFile as readFile13, stat as stat11 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 async function resolvePipelinePlanDirectory(container) {
   const configDoc = await readMergedDocument(
@@ -26160,7 +26187,7 @@ async function loadPipelineTemplates() {
 }
 async function pathExistsOnDisk(targetPath) {
   try {
-    await stat9(targetPath);
+    await stat11(targetPath);
     return true;
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
@@ -26218,7 +26245,7 @@ function registerPipelineCommand(program, container) {
             label: value
           }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Pipeline run cancelled.");
           return;
         }
@@ -26250,7 +26277,7 @@ function registerPipelineCommand(program, container) {
         },
         selectPlan: async (input) => {
           const selected = await select2(input);
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -26258,7 +26285,7 @@ function registerPipelineCommand(program, container) {
         },
         promptForPath: async (input) => {
           const value = await text3(input);
-          if (Ct(value)) {
+          if (q(value)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -26438,7 +26465,7 @@ function registerPipelineCommand(program, container) {
               label: value
             }))
           });
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Pipeline install cancelled.");
             return;
           }
@@ -26464,7 +26491,7 @@ function registerPipelineCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Pipeline install cancelled.");
           return;
         }
@@ -26539,13 +26566,13 @@ var init_pipeline3 = __esm({
     "use strict";
     init_src5();
     init_src2();
-    init_src21();
+    init_src22();
     init_src4();
     init_config3();
     init_errors();
     init_shared();
     await init_pipeline2();
-    init_src9();
+    init_src10();
     DEFAULT_PIPELINE_AGENT = "claude-code";
     DEFAULT_PIPELINE_SCOPE = "local";
     pipelineTemplatesCache = null;
@@ -26662,7 +26689,7 @@ async function resolveDocPath(options) {
       value: doc.path
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26706,7 +26733,7 @@ async function promptForAgent(program) {
       value: config.agentId
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26743,7 +26770,7 @@ async function resolveRunIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26773,7 +26800,7 @@ async function resolveInitIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Ralph init cancelled.");
     return null;
   }
@@ -26950,7 +26977,7 @@ var init_ralph3 = __esm({
     init_src5();
     init_src2();
     init_src7();
-    init_src12();
+    init_src13();
     init_src4();
     init_config3();
     init_errors();
@@ -26963,7 +26990,7 @@ var init_ralph3 = __esm({
 
 // src/cli/commands/experiment.ts
 import path41 from "node:path";
-import { readFile as readFile14, stat as stat10 } from "node:fs/promises";
+import { readFile as readFile14, stat as stat12 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
   const rootPath = scope === "global" ? path41.join(homeDir, ".poe-code", "experiments") : path41.join(cwd, ".poe-code", "experiments");
@@ -26975,7 +27002,7 @@ function resolveExperimentPaths(scope, cwd, homeDir) {
 }
 async function pathExistsOnDisk2(targetPath) {
   try {
-    await stat10(targetPath);
+    await stat12(targetPath);
     return true;
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
@@ -27107,8 +27134,8 @@ async function discoverExperimentDocs(container) {
     }
     const relativePath = path41.join(EXPERIMENTS_DIRECTORY, name);
     const absolutePath = path41.join(directoryPath, name);
-    const stat11 = await container.fs.stat(absolutePath);
-    if (!stat11.isFile()) {
+    const stat13 = await container.fs.stat(absolutePath);
+    if (!stat13.isFile()) {
       continue;
     }
     docs.push({
@@ -27139,7 +27166,7 @@ async function resolveDocPath2(options) {
       value: doc.path
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel(options.cancelMessage);
     return null;
   }
@@ -27169,7 +27196,7 @@ async function promptForAgent2(program) {
       value: config.agentId
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Experiment run cancelled.");
     return null;
   }
@@ -27452,7 +27479,7 @@ function registerExperimentCommand(program, container) {
               label: value
             }))
           });
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Experiment install cancelled.");
             return;
           }
@@ -27478,7 +27505,7 @@ function registerExperimentCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Experiment install cancelled.");
           return;
         }
@@ -27550,8 +27577,8 @@ var init_experiment2 = __esm({
     init_src5();
     init_src2();
     init_src7();
-    init_src21();
-    init_src13();
+    init_src22();
+    init_src14();
     init_errors();
     init_shared();
     await init_experiment();
@@ -27732,7 +27759,7 @@ async function resolveProcessId(value) {
   const entered = await text3({
     message: "Process ID"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27749,7 +27776,7 @@ async function resolveCommandParts(commandArgs) {
   const entered = await text3({
     message: "Command to run"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27773,7 +27800,7 @@ async function resolveRuntime(options) {
       { label: "docker", value: "docker" }
     ]
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27786,7 +27813,7 @@ async function resolveDockerImage(value) {
   const entered = await text3({
     message: "Docker image"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27811,7 +27838,7 @@ async function resolveRestart(restart, assumeYes) {
       { label: "always", value: "always" }
     ]
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27989,7 +28016,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.131",
+      version: "3.0.132",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -28105,6 +28132,7 @@ var init_package = __esm({
         "@poe-code/process-runner": "*",
         "@poe-code/ralph": "*",
         "@poe-code/worktree": "*",
+        "@poe-code/workspace-resolver": "*",
         "@types/mustache": "^4.2.6",
         "@types/node": "^25.2.2",
         "@types/semver": "^7.7.1",
@@ -28466,7 +28494,6 @@ function bootstrapProgram(container) {
   registerConfigureCommand(program, container);
   registerAgentCommand(program, container);
   registerSpawnCommand(program, container);
-  registerResearchCommand(program, container);
   registerWrapCommand(program, container);
   registerGenerateCommand(program, container);
   registerTestCommand(program, container);
@@ -28529,18 +28556,17 @@ var init_program = __esm({
   async "src/cli/program.ts"() {
     "use strict";
     init_cli();
-    init_src16();
+    init_src17();
     await init_container2();
     init_src5();
     init_configure();
     init_agent2();
     await init_spawn4();
-    await init_research2();
     init_wrap();
     init_login();
     init_logout();
     init_auth();
-    init_utils3();
+    init_utils4();
     init_install();
     init_unconfigure();
     init_test();
@@ -28581,7 +28607,7 @@ function createPromptRunner(adapter = {
   text: text3,
   password: password2,
   select: select2,
-  isCancel: Ct,
+  isCancel: q,
   cancel
 }) {
   const runPrompt = async (descriptor) => {
@@ -28646,7 +28672,7 @@ __export(bootstrap_exports, {
   createCliMain: () => createCliMain,
   isCliInvocation: () => isCliInvocation
 });
-import * as nodeFs4 from "node:fs/promises";
+import * as nodeFs6 from "node:fs/promises";
 import * as nodeFsSync3 from "node:fs";
 import { realpathSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
@@ -28721,7 +28747,7 @@ var init_bootstrap = __esm({
     init_error_logger();
     init_errors();
     init_prompt_runner();
-    fsAdapter = nodeFs4;
+    fsAdapter = nodeFs6;
   }
 });
 
@@ -28732,7 +28758,7 @@ import { realpathSync as realpathSync2 } from "node:fs";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/sdk/process-launcher.ts
-init_src11();
+init_src12();
 
 // src/index.ts
 await init_ralph2();
@@ -28837,7 +28863,7 @@ function normalizeBaseUrl(value) {
 
 // src/index.ts
 init_credentials();
-init_src16();
+init_src17();
 init_launch();
 
 // src/cli/poe-agent-main.ts
@@ -28845,7 +28871,7 @@ init_src7();
 init_src5();
 init_constants();
 init_errors();
-import path31 from "node:path";
+import path33 from "node:path";
 import { Command } from "commander";
 function parseMcpSpawnConfig(input) {
   if (!input) {
@@ -28856,33 +28882,33 @@ function parseMcpSpawnConfig(input) {
     parsed = JSON.parse(input);
   } catch {
     throw new ValidationError(
-      "--mcp-config must be valid JSON in this shape: {name: {command, args?, env?}}"
+      "--mcp-servers must be valid JSON in this shape: {name: {command, args?, env?}}"
     );
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new ValidationError(
-      "--mcp-config must be an object in this shape: {name: {command, args?, env?}}"
+      "--mcp-servers must be an object in this shape: {name: {command, args?, env?}}"
     );
   }
   const servers = {};
   for (const [name, value] of Object.entries(parsed)) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       throw new ValidationError(
-        `--mcp-config entry "${name}" must be an object: {command, args?, env?}`
+        `--mcp-servers entry "${name}" must be an object: {command, args?, env?}`
       );
     }
     const entry = value;
     const command = entry.command;
     if (typeof command !== "string" || command.trim().length === 0) {
       throw new ValidationError(
-        `--mcp-config entry "${name}" must include a non-empty string "command"`
+        `--mcp-servers entry "${name}" must include a non-empty string "command"`
       );
     }
     let args;
     if ("args" in entry && entry.args !== void 0) {
       if (!Array.isArray(entry.args) || entry.args.some((a) => typeof a !== "string")) {
         throw new ValidationError(
-          `--mcp-config entry "${name}".args must be an array of strings`
+          `--mcp-servers entry "${name}".args must be an array of strings`
         );
       }
       args = entry.args;
@@ -28891,14 +28917,14 @@ function parseMcpSpawnConfig(input) {
     if ("env" in entry && entry.env !== void 0) {
       if (typeof entry.env !== "object" || entry.env === null || Array.isArray(entry.env)) {
         throw new ValidationError(
-          `--mcp-config entry "${name}".env must be an object of string values`
+          `--mcp-servers entry "${name}".env must be an object of string values`
         );
       }
       env = {};
       for (const [envKey, envValue] of Object.entries(entry.env)) {
         if (typeof envValue !== "string") {
           throw new ValidationError(
-            `--mcp-config entry "${name}".env must be an object of string values`
+            `--mcp-servers entry "${name}".env must be an object of string values`
           );
         }
         env[envKey] = envValue;
@@ -28916,19 +28942,19 @@ function resolveWorkingDirectory(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path31.isAbsolute(candidate)) {
+  if (path33.isAbsolute(candidate)) {
     return candidate;
   }
-  return path31.resolve(baseDir, candidate);
+  return path33.resolve(baseDir, candidate);
 }
 function createPoeAgentProgram() {
   const program = new Command();
   program.name("poe-agent").description("Run a single prompt through the Poe agent runtime.").version("0.0.0").option("--model <model>", "Model identifier override").option("-C, --cwd <path>", "Working directory for the agent").option("--stdin", "Read the prompt from stdin").option(
-    "--mcp-config <json>",
+    "--mcp-servers <json>",
     "MCP server config JSON: {name: {command, args?, env?}}"
-  ).argument("[prompt]", "Prompt text to send (or '-' / stdin)").argument("[args...]", "Additional arguments forwarded to the agent").action(async function(promptText, _args = []) {
+  ).option("--mcp-config <json>", "[deprecated: use --mcp-servers]").argument("[prompt]", "Prompt text to send (or '-' / stdin)").argument("[args...]", "Additional arguments forwarded to the agent").action(async function(promptText, _args = []) {
     const commandOptions = this.opts();
-    const mcpServers = parseMcpSpawnConfig(commandOptions.mcpConfig);
+    const mcpServers = parseMcpSpawnConfig(commandOptions.mcpServers ?? commandOptions.mcpConfig);
     const cwdOverride = resolveWorkingDirectory(
       process.cwd(),
       commandOptions.cwd