poe-code 3.0.121 → 3.0.123

package/dist/index.js

@@ -925,16 +925,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path33) {
-  const ext = getExtension(path33);
+function detectFormat(path39) {
+  const ext = getExtension(path39);
   return extensionMap[ext];
 }
-function getExtension(path33) {
-  const lastDot = path33.lastIndexOf(".");
+function getExtension(path39) {
+  const lastDot = path39.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path33.slice(lastDot).toLowerCase();
+  return path39.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -1989,38 +1989,38 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path33, encoding) {
+    async readFile(path39, encoding) {
       if (encoding) {
-        return base.readFile(path33, encoding);
+        return base.readFile(path39, encoding);
       }
-      return base.readFile(path33);
+      return base.readFile(path39);
     },
-    async writeFile(path33, data, options) {
-      const previousContent = await tryReadText(base, path33);
+    async writeFile(path39, data, options) {
+      const previousContent = await tryReadText(base, path39);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path33,
+        path: path39,
         nextContent,
         previousContent
       });
     },
-    async mkdir(path33, options) {
-      recorder.record({ type: "mkdir", path: path33, options });
+    async mkdir(path39, options) {
+      recorder.record({ type: "mkdir", path: path39, options });
     },
-    async stat(path33) {
-      return base.stat(path33);
+    async stat(path39) {
+      return base.stat(path39);
     },
-    async unlink(path33) {
-      recorder.record({ type: "unlink", path: path33 });
+    async unlink(path39) {
+      recorder.record({ type: "unlink", path: path39 });
     },
-    async readdir(path33) {
-      return base.readdir(path33);
+    async readdir(path39) {
+      return base.readdir(path39);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path33, options) => {
-      recorder.record({ type: "rm", path: path33, options });
+    proxy.rm = async (path39, options) => {
+      recorder.record({ type: "rm", path: path39, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -2110,8 +2110,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path33, change) {
-  const command = `cat > ${path33}`;
+function renderWriteCommand(path39, change) {
+  const command = `cat > ${path39}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -2273,9 +2273,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path33) {
+async function tryReadText(base, path39) {
   try {
-    return await base.readFile(path33, "utf8");
+    return await base.readFile(path39, "utf8");
   } catch (error) {
     if (isNotFound(error)) {
       return null;
@@ -4123,21 +4123,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path33;
+        let path39;
         if (typeof item.content === "string") {
-          path33 = item.content;
+          path39 = item.content;
         } else {
           try {
-            path33 = JSON.stringify(item.content);
+            path39 = JSON.stringify(item.content);
           } catch {
-            path33 = String(item.content);
+            path39 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path33
+          path: path39
         };
       }
     }
@@ -4259,10 +4259,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path33 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path39 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path33 };
+        yield { event: "tool_complete", id: item.id, kind, path: path39 };
       }
     }
   }
@@ -4711,7 +4711,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path33 = readString(event.path);
+  const path39 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -4726,8 +4726,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path33) {
-    toolCall.path = path33;
+  if (path39) {
+    toolCall.path = path39;
   }
 }
 var sessionCapture;
@@ -6729,21 +6729,21 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path33, encoding) => {
+    readFile: ((path39, encoding) => {
       if (encoding) {
-        return fs2.readFile(path33, encoding);
+        return fs2.readFile(path39, encoding);
       }
-      return fs2.readFile(path33);
+      return fs2.readFile(path39);
     }),
-    writeFile: (path33, data, opts) => fs2.writeFile(path33, data, opts),
-    mkdir: (path33, opts) => fs2.mkdir(path33, opts).then(() => {
+    writeFile: (path39, data, opts) => fs2.writeFile(path39, data, opts),
+    mkdir: (path39, opts) => fs2.mkdir(path39, opts).then(() => {
     }),
-    stat: (path33) => fs2.stat(path33),
-    rm: (path33, opts) => fs2.rm(path33, opts),
-    unlink: (path33) => fs2.unlink(path33),
-    readdir: (path33) => fs2.readdir(path33),
+    stat: (path39) => fs2.stat(path39),
+    rm: (path39, opts) => fs2.rm(path39, opts),
+    unlink: (path39) => fs2.unlink(path39),
+    readdir: (path39) => fs2.readdir(path39),
     copyFile: (src, dest) => fs2.copyFile(src, dest),
-    chmod: (path33, mode) => fs2.chmod(path33, mode)
+    chmod: (path39, mode) => fs2.chmod(path39, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -7510,8 +7510,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function backoff(attempt, min, max) {
-  const delay = Math.min(max, min * Math.pow(2, attempt));
-  return delay + Math.random() * delay * 0.1;
+  const delay2 = Math.min(max, min * Math.pow(2, attempt));
+  return delay2 + Math.random() * delay2 * 0.1;
 }
 function createDefaultFs2() {
   return {
@@ -7889,6 +7889,1503 @@ var init_pipeline2 = __esm({
   }
 });
 
+// packages/process-launcher/src/state/state-store.ts
+import path15 from "node:path";
+import * as nodeFs from "node:fs/promises";
+function isNotFoundError2(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function removeDirectory2(fs3, directoryPath) {
+  let entries;
+  try {
+    entries = await fs3.readdir(directoryPath);
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return;
+    }
+    throw error;
+  }
+  for (const entry of entries) {
+    const entryPath = path15.join(directoryPath, entry);
+    const stat11 = await fs3.stat(entryPath);
+    if (stat11.isFile()) {
+      await fs3.rm(entryPath, { force: true });
+      continue;
+    }
+    await removeDirectory2(fs3, entryPath);
+  }
+  const fsWithDirectoryRemoval = fs3;
+  if (typeof fsWithDirectoryRemoval.rmdir === "function") {
+    await fsWithDirectoryRemoval.rmdir(directoryPath);
+    return;
+  }
+  await fs3.rm(directoryPath, { force: true });
+}
+function createStateStore(stateDir, fs3 = nodeFs) {
+  async function read(id) {
+    const statePath = path15.join(stateDir, id, "state.json");
+    try {
+      const content = await fs3.readFile(statePath, "utf8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (isNotFoundError2(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async function write2(id, state) {
+    const processDir = path15.join(stateDir, id);
+    await fs3.mkdir(processDir, { recursive: true });
+    await fs3.writeFile(path15.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
+`);
+  }
+  async function list() {
+    let entries;
+    try {
+      entries = await fs3.readdir(stateDir);
+    } catch (error) {
+      if (isNotFoundError2(error)) {
+        return [];
+      }
+      throw error;
+    }
+    const states = [];
+    for (const entry of [...entries].sort()) {
+      const entryPath = path15.join(stateDir, entry);
+      try {
+        const stat11 = await fs3.stat(entryPath);
+        if (stat11.isFile()) {
+          continue;
+        }
+      } catch (error) {
+        if (isNotFoundError2(error)) {
+          continue;
+        }
+        throw error;
+      }
+      const state = await read(entry);
+      if (state !== null) {
+        states.push(state);
+      }
+    }
+    return states;
+  }
+  async function remove2(id) {
+    await removeDirectory2(fs3, path15.join(stateDir, id));
+  }
+  return { read, write: write2, list, remove: remove2 };
+}
+var init_state_store = __esm({
+  "packages/process-launcher/src/state/state-store.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-launcher/src/logs/log-writer.ts
+import path16 from "node:path";
+import * as nodeFs2 from "node:fs/promises";
+function isNotFoundError3(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function getCurrentLogPath(logDir, stream) {
+  return path16.join(logDir, `${stream}.log`);
+}
+function getRotatedLogPath(logDir, stream, index) {
+  return path16.join(logDir, `${stream}.${index}.log`);
+}
+async function isFile(fs3, filePath) {
+  try {
+    return (await fs3.stat(filePath)).isFile();
+  } catch (error) {
+    if (isNotFoundError3(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function removeIfExists(fs3, filePath) {
+  if (!await isFile(fs3, filePath)) {
+    return;
+  }
+  await fs3.rm(filePath, { force: true });
+}
+async function moveIfExists(fs3, sourcePath, destinationPath) {
+  if (!await isFile(fs3, sourcePath)) {
+    return;
+  }
+  const content = await fs3.readFile(sourcePath, "utf8");
+  await fs3.writeFile(destinationPath, content);
+  await fs3.rm(sourcePath, { force: true });
+}
+function getRotatedLogIndex(fileName, stream) {
+  const prefix = `${stream}.`;
+  const suffix = ".log";
+  if (!fileName.startsWith(prefix) || !fileName.endsWith(suffix)) {
+    return null;
+  }
+  const rawIndex = fileName.slice(prefix.length, -suffix.length);
+  const index = Number.parseInt(rawIndex, 10);
+  if (!Number.isInteger(index) || index < 1 || `${index}` !== rawIndex) {
+    return null;
+  }
+  return index;
+}
+async function removeAllStreamLogs(fs3, logDir, stream) {
+  await removeIfExists(fs3, getCurrentLogPath(logDir, stream));
+  try {
+    const fileNames = await fs3.readdir(logDir);
+    for (const fileName of fileNames) {
+      if (getRotatedLogIndex(fileName, stream) === null) {
+        continue;
+      }
+      await fs3.rm(path16.join(logDir, fileName), { force: true });
+    }
+  } catch (error) {
+    if (isNotFoundError3(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+function getLines(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines = content.split("\n");
+  if (content.endsWith("\n")) {
+    lines.pop();
+  }
+  return lines;
+}
+function createLogWriter(logDir, retainCount, fs3 = nodeFs2) {
+  const maxRetainedRuns = Math.max(0, Math.trunc(retainCount));
+  async function write2(line, stream) {
+    await fs3.mkdir(logDir, { recursive: true });
+    await fs3.appendFile(getCurrentLogPath(logDir, stream), `${line}
+`);
+  }
+  async function rotateStream(stream) {
+    const currentPath = getCurrentLogPath(logDir, stream);
+    if (maxRetainedRuns === 0) {
+      await removeAllStreamLogs(fs3, logDir, stream);
+      return;
+    }
+    await removeIfExists(fs3, getRotatedLogPath(logDir, stream, maxRetainedRuns));
+    for (let index = maxRetainedRuns - 1; index >= 1; index -= 1) {
+      await moveIfExists(
+        fs3,
+        getRotatedLogPath(logDir, stream, index),
+        getRotatedLogPath(logDir, stream, index + 1)
+      );
+    }
+    await moveIfExists(fs3, currentPath, getRotatedLogPath(logDir, stream, 1));
+  }
+  async function rotate() {
+    await rotateStream("stdout");
+    await rotateStream("stderr");
+  }
+  async function tail(stream, lines = 50) {
+    try {
+      const content = await fs3.readFile(getCurrentLogPath(logDir, stream), "utf8");
+      const allLines = getLines(content);
+      const lineCount = Math.max(0, Math.trunc(lines));
+      if (lineCount === 0) {
+        return [];
+      }
+      return allLines.slice(-lineCount);
+    } catch (error) {
+      if (isNotFoundError3(error)) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  function close() {
+  }
+  return { write: write2, rotate, tail, close };
+}
+var init_log_writer = __esm({
+  "packages/process-launcher/src/logs/log-writer.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-launcher/src/health/health-check.ts
+import net from "node:net";
+async function waitForReady(check, options) {
+  if (check.kind === "log-pattern") {
+    return waitForLogPattern(check.pattern, options);
+  }
+  return waitForTcp(check, options.signal);
+}
+function waitForLogPattern(pattern, options) {
+  if (options.signal?.aborted) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    let finished = false;
+    const timeout = setTimeout(() => {
+      finish(false);
+    }, options.timeoutMs ?? 3e4);
+    const logSource = options.onLog;
+    const unsubscribe = logSource?.subscribe?.((line) => {
+      if (line.includes(pattern)) {
+        finish(true);
+      }
+    }) ?? (() => {
+    });
+    const onAbort = () => {
+      finish(false);
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    function finish(result) {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onAbort);
+      unsubscribe();
+      resolve(result);
+    }
+  });
+}
+function waitForTcp(check, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve(false);
+  }
+  const timeoutMs = check.timeoutMs ?? 3e4;
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    let finished = false;
+    let activeSocket;
+    let retryTimer;
+    const onAbort = () => {
+      finish(false);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    attemptConnection();
+    function attemptConnection() {
+      if (finished) {
+        return;
+      }
+      if (signal?.aborted || Date.now() >= deadline) {
+        finish(false);
+        return;
+      }
+      const socket = net.connect({
+        host: check.host ?? "127.0.0.1",
+        port: check.port
+      });
+      activeSocket = socket;
+      const socketTimeoutMs = Math.max(1, Math.min(500, deadline - Date.now()));
+      socket.setTimeout(socketTimeoutMs);
+      socket.once("connect", () => {
+        clearActiveSocket(socket);
+        socket.end();
+        socket.destroy();
+        finish(true);
+      });
+      socket.once("error", () => {
+        failAttempt(socket);
+      });
+      socket.once("timeout", () => {
+        failAttempt(socket);
+      });
+    }
+    function failAttempt(socket) {
+      clearActiveSocket(socket);
+      socket.destroy();
+      if (finished) {
+        return;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        finish(false);
+        return;
+      }
+      retryTimer = setTimeout(attemptConnection, Math.min(500, remainingMs));
+    }
+    function clearActiveSocket(socket) {
+      if (activeSocket === socket) {
+        activeSocket = void 0;
+      }
+    }
+    function finish(result) {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+      }
+      activeSocket?.destroy();
+      activeSocket = void 0;
+      signal?.removeEventListener("abort", onAbort);
+      resolve(result);
+    }
+  });
+}
+var init_health_check = __esm({
+  "packages/process-launcher/src/health/health-check.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/docker/context.ts
+import { execSync } from "node:child_process";
+function detectContext() {
+  try {
+    const output = execSync("colima list --json", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const lines = output.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const profile = JSON.parse(line);
+      if (profile.status === "Running" && profile.runtime === "docker") {
+        const name = profile.name ?? profile.profile;
+        if (!name) {
+          continue;
+        }
+        return name === "default" ? "colima" : `colima-${name}`;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function buildContextArgs(engine, context) {
+  if (engine === "docker" && context) {
+    return ["--context", context];
+  }
+  return [];
+}
+var init_context2 = __esm({
+  "packages/process-runner/src/docker/context.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/docker/engine.ts
+import { execSync as execSync2 } from "node:child_process";
+function detectEngine() {
+  if (isEngineAvailable("docker")) {
+    return "docker";
+  }
+  if (isEngineAvailable("podman")) {
+    return "podman";
+  }
+  throw new Error(
+    "No container engine found. Please install Docker or Podman:\n  - Docker Desktop: https://www.docker.com/products/docker-desktop\n  - Colima (macOS): brew install colima && colima start\n  - Podman: https://podman.io/docs/installation"
+  );
+}
+function isEngineAvailable(engine) {
+  try {
+    execSync2(`${engine} --version`, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_engine = __esm({
+  "packages/process-runner/src/docker/engine.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/docker/args.ts
+import path17 from "node:path";
+function buildDockerRunArgs(input) {
+  const args = [input.engine];
+  if (input.engine === "docker" && input.context) {
+    args.push("--context", input.context);
+  }
+  args.push("run");
+  if (input.rm) {
+    args.push("--rm");
+  }
+  if (input.detached) {
+    args.push("-d");
+  }
+  if (input.interactive) {
+    args.push("-i");
+  }
+  if (input.tty) {
+    args.push("-t");
+  }
+  args.push("--name", input.containerName);
+  if (input.cwd !== void 0) {
+    args.push("-w", input.cwd);
+  }
+  for (const [key, value] of Object.entries(input.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  for (const mount of input.mounts) {
+    const volume = `${path17.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    args.push("-v", volume);
+  }
+  for (const port of input.ports) {
+    const mapping = `${port.host}:${port.container}${port.protocol === void 0 || port.protocol === "tcp" ? "" : `/${port.protocol}`}`;
+    args.push("-p", mapping);
+  }
+  if (input.network !== void 0) {
+    args.push("--network", input.network);
+  }
+  args.push(...input.extraArgs, input.image, input.command, ...input.args);
+  return args;
+}
+var init_args = __esm({
+  "packages/process-runner/src/docker/args.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/docker/docker-runner.ts
+import * as childProcess from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function createDockerRunner(options) {
+  const engine = options.engine ?? detectEngine();
+  const context = options.context ?? detectContext();
+  return {
+    name: "docker",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const interactiveMode = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" && spec.tty === true;
+      const containerName = buildContainerName(options.containerName ?? spec.command);
+      const runArgs = buildDockerRunArgs({
+        engine,
+        context,
+        image: options.image,
+        command: spec.command,
+        args: spec.args ?? [],
+        cwd: spec.cwd,
+        env: spec.env,
+        mounts: options.mounts ?? [],
+        ports: options.ports ?? [],
+        network: options.network,
+        containerName,
+        detached: false,
+        interactive: stdinMode === "pipe" || stdinMode === "inherit",
+        tty: spec.tty ?? false,
+        rm: true,
+        extraArgs: options.extraArgs ?? []
+      });
+      const [command, ...args] = runArgs;
+      const child = childProcess.spawn(command, args, {
+        stdio: interactiveMode ? "inherit" : [stdinMode, stdoutMode, stderrMode]
+      });
+      let isResultSettled = false;
+      let resolveResult = null;
+      const result = new Promise((resolve) => {
+        resolveResult = resolve;
+      });
+      const cleanupAbort = bindAbortSignal(spec.signal, () => {
+        spawnControlCommand(engine, context, ["stop", containerName]);
+      });
+      const settleResult = (exitCode) => {
+        if (isResultSettled) {
+          return;
+        }
+        isResultSettled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode });
+      };
+      child.once("error", () => {
+        settleResult(1);
+      });
+      child.once("close", (code) => {
+        settleResult(code ?? 1);
+      });
+      return {
+        pid: null,
+        stdin: interactiveMode ? null : child.stdin,
+        stdout: interactiveMode ? null : child.stdout,
+        stderr: interactiveMode ? null : child.stderr,
+        result,
+        kill(signal) {
+          if (signal === "SIGKILL") {
+            spawnControlCommand(engine, context, ["kill", containerName]);
+            return;
+          }
+          if (signal === void 0 || signal === "SIGTERM") {
+            spawnControlCommand(engine, context, ["stop", containerName]);
+            return;
+          }
+          spawnControlCommand(engine, context, ["kill", `--signal=${signal}`, containerName]);
+        }
+      };
+    }
+  };
+}
+function buildContainerName(name) {
+  const suffix = randomBytes2(3).toString("hex").slice(0, 6);
+  const sanitizedName = sanitizeContainerName(name);
+  return `poe-run-${sanitizedName}-${suffix}`;
+}
+function sanitizeContainerName(name) {
+  let sanitized = "";
+  for (const char of name) {
+    if (isContainerNameCharacter(char)) {
+      sanitized += char;
+      continue;
+    }
+    sanitized += "-";
+  }
+  return sanitized.length > 0 ? sanitized : "command";
+}
+function isContainerNameCharacter(char) {
+  const code = char.charCodeAt(0);
+  if (code >= 48 && code <= 57) {
+    return true;
+  }
+  if (code >= 65 && code <= 90) {
+    return true;
+  }
+  if (code >= 97 && code <= 122) {
+    return true;
+  }
+  return char === "." || char === "_" || char === "-";
+}
+function spawnControlCommand(engine, context, args) {
+  childProcess.spawn(engine, [...buildContextArgs(engine, context), ...args], {
+    stdio: "ignore"
+  });
+}
+function bindAbortSignal(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
+}
+var init_docker_runner = __esm({
+  "packages/process-runner/src/docker/docker-runner.ts"() {
+    "use strict";
+    init_args();
+    init_context2();
+    init_engine();
+  }
+});
+
+// packages/process-runner/src/host/host-runner.ts
+import * as childProcess2 from "node:child_process";
+function createHostRunner(options = {}) {
+  const detached = options.detached === true;
+  return {
+    name: "host",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const child = childProcess2.spawn(spec.command, spec.args ?? [], {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio: [stdinMode, stdoutMode, stderrMode],
+        ...detached ? { detached: true } : {}
+      });
+      if (detached) {
+        child.unref();
+      }
+      const kill = (signal) => {
+        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+          process.kill(-child.pid, signal);
+          return;
+        }
+        child.kill(signal);
+      };
+      let resolveResult = null;
+      const result = new Promise((resolve) => {
+        resolveResult = resolve;
+      });
+      const cleanupAbort = bindAbortSignal2(spec.signal, () => {
+        kill("SIGTERM");
+      });
+      child.once("close", (code) => {
+        cleanupAbort();
+        resolveResult?.({ exitCode: code ?? 1 });
+      });
+      return {
+        pid: child.pid ?? null,
+        stdin: child.stdin,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        result,
+        kill
+      };
+    }
+  };
+}
+function bindAbortSignal2(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
+}
+var init_host_runner = __esm({
+  "packages/process-runner/src/host/host-runner.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/testing/mock-runner.ts
+import { Readable, Writable } from "node:stream";
+var init_mock_runner = __esm({
+  "packages/process-runner/src/testing/mock-runner.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/testing/index.ts
+var init_testing = __esm({
+  "packages/process-runner/src/testing/index.ts"() {
+    "use strict";
+    init_mock_runner();
+  }
+});
+
+// packages/process-runner/src/index.ts
+var init_src9 = __esm({
+  "packages/process-runner/src/index.ts"() {
+    "use strict";
+    init_context2();
+    init_engine();
+    init_docker_runner();
+    init_host_runner();
+    init_testing();
+  }
+});
+
+// packages/process-launcher/src/supervisor/supervisor.ts
+import path18 from "node:path";
+function createSupervisor(options) {
+  const { spec } = options;
+  const runner = resolveRunner(options);
+  const stateStore = createStateStore(options.stateDir, options.fs);
+  const logWriter = createLogWriter(
+    path18.join(options.stateDir, spec.id, "logs"),
+    spec.logRetainCount ?? 5,
+    options.fs
+  );
+  const logSource = createLogSource(options.onLog);
+  let state = createInitialState(spec, runner);
+  let handle = null;
+  let runId = 0;
+  let startPromise = null;
+  let pendingRestart = null;
+  let activeReadyController = null;
+  let stableTimer = null;
+  let stopRequested = false;
+  const onAbort = () => {
+    void stop();
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  async function start() {
+    if (handle !== null || pendingRestart !== null) {
+      return;
+    }
+    if (startPromise !== null) {
+      await startPromise;
+      return;
+    }
+    stopRequested = false;
+    startPromise = launch(false);
+    try {
+      await startPromise;
+    } finally {
+      startPromise = null;
+    }
+  }
+  async function stop() {
+    stopRequested = true;
+    pendingRestart = null;
+    activeReadyController?.abort();
+    activeReadyController = null;
+    const activeHandle = handle;
+    if (activeHandle !== null) {
+      activeHandle.kill("SIGTERM");
+      const exited = await waitForExit(activeHandle, 5e3);
+      if (!exited) {
+        activeHandle.kill("SIGKILL");
+        await activeHandle.result;
+      }
+    }
+    clearStableTimer();
+    handle = null;
+    state.pid = null;
+    state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await transitionTo("stopped");
+  }
+  async function restart() {
+    await stop();
+    await start();
+  }
+  function getState() {
+    return {
+      ...state,
+      args: [...state.args]
+    };
+  }
+  async function launch(isRestart) {
+    const nextRunId = runId + 1;
+    runId = nextRunId;
+    const nextHandle = runner.exec(createRunSpec(spec));
+    handle = nextHandle;
+    state.pid = nextHandle.pid;
+    state.lastExitCode = null;
+    state.lastStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const stdoutPump = pipeOutput(nextHandle.stdout, "stdout", logWriter.write, logSource);
+    const stderrPump = pipeOutput(nextHandle.stderr, "stderr", logWriter.write, logSource);
+    const outputSettled = Promise.all([stdoutPump, stderrPump]).then(() => void 0);
+    scheduleStableReset(nextRunId, nextHandle);
+    void monitorExit(nextHandle, nextRunId, outputSettled);
+    if (spec.readyCheck !== void 0) {
+      await transitionTo("restarting");
+      activeReadyController = new AbortController();
+      const ready = await waitForReady(resolveReadyCheck(spec.readyCheck, spec), {
+        onLog: logSource,
+        signal: activeReadyController.signal
+      });
+      activeReadyController = null;
+      if (runId !== nextRunId || handle !== nextHandle) {
+        return;
+      }
+      if (!ready) {
+        nextHandle.kill("SIGTERM");
+        return;
+      }
+    }
+    if (isRestart || spec.readyCheck !== void 0) {
+      await transitionTo("running");
+      return;
+    }
+    await transitionTo("running");
+  }
+  async function monitorExit(finishedHandle, finishedRunId, outputSettled) {
+    const result = await finishedHandle.result;
+    await outputSettled;
+    if (runId !== finishedRunId) {
+      return;
+    }
+    clearStableTimer();
+    activeReadyController?.abort();
+    activeReadyController = null;
+    handle = null;
+    state.pid = null;
+    state.lastExitCode = result.exitCode;
+    state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (stopRequested || options.signal?.aborted) {
+      await transitionTo("stopped");
+      return;
+    }
+    if (!shouldRestart(result.exitCode, spec.restart)) {
+      await transitionTo("stopped");
+      return;
+    }
+    const maxRestarts = spec.maxRestarts ?? 5;
+    if (maxRestarts > 0 && state.restartCount >= maxRestarts) {
+      await transitionTo("crashed");
+      return;
+    }
+    const backoffMs = getBackoffDelay(
+      state.restartCount,
+      spec.backoffMs ?? 1e3,
+      spec.maxBackoffMs ?? 3e4
+    );
+    state.restartCount += 1;
+    await logWriter.rotate();
+    await transitionTo("restarting");
+    const restartToken = /* @__PURE__ */ Symbol("restart");
+    pendingRestart = restartToken;
+    await delay(backoffMs);
+    if (pendingRestart !== restartToken || stopRequested || options.signal?.aborted) {
+      return;
+    }
+    pendingRestart = null;
+    await launch(true);
+  }
+  async function transitionTo(status) {
+    if (state.status === status) {
+      return;
+    }
+    state = {
+      ...state,
+      args: [...state.args],
+      status
+    };
+    await stateStore.write(spec.id, state);
+    options.onStatusChange?.(getState());
+  }
+  function scheduleStableReset(activeRunId, activeHandle) {
+    clearStableTimer();
+    stableTimer = setTimeout(() => {
+      if (runId !== activeRunId || handle !== activeHandle || state.restartCount === 0) {
+        return;
+      }
+      state.restartCount = 0;
+      void stateStore.write(spec.id, getState());
+    }, 6e4);
+  }
+  function clearStableTimer() {
+    if (stableTimer !== null) {
+      clearTimeout(stableTimer);
+      stableTimer = null;
+    }
+  }
+  return {
+    start,
+    stop,
+    restart,
+    getState
+  };
+}
+function resolveRunner(options) {
+  if (options.runner !== void 0) {
+    return options.runner;
+  }
+  if (options.spec.docker !== void 0) {
+    return createDockerRunner(options.spec.docker);
+  }
+  return createHostRunner();
+}
+function createInitialState(spec, runner) {
+  return {
+    id: spec.id,
+    pid: null,
+    status: "stopped",
+    runtime: spec.docker !== void 0 || runner.name === "docker" ? "docker" : "host",
+    restartCount: 0,
+    lastExitCode: null,
+    lastStartedAt: null,
+    lastStoppedAt: null,
+    command: spec.command,
+    args: [...spec.args ?? []]
+  };
+}
+function createRunSpec(spec) {
+  return {
+    command: spec.command,
+    args: spec.args,
+    cwd: spec.cwd,
+    env: spec.env,
+    stderr: "pipe",
+    stdout: "pipe"
+  };
+}
+function shouldRestart(exitCode, policy) {
+  if (policy === "always") {
+    return true;
+  }
+  if (policy === "on-failure") {
+    return exitCode !== 0;
+  }
+  return false;
+}
+function getBackoffDelay(restartCount, backoffMs, maxBackoffMs) {
+  return Math.min(backoffMs * 2 ** restartCount, maxBackoffMs);
+}
+function delay(durationMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+  });
+}
+function waitForExit(activeHandle, timeoutMs) {
+  return new Promise((resolve) => {
+    let finished = false;
+    const timeout = setTimeout(() => {
+      finish(false);
+    }, timeoutMs);
+    void activeHandle.result.then(() => {
+      finish(true);
+    });
+    function finish(result) {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      clearTimeout(timeout);
+      resolve(result);
+    }
+  });
+}
+function createLogSource(onLog) {
+  const listeners = /* @__PURE__ */ new Set();
+  const log3 = ((line, stream) => {
+    onLog?.(line, stream);
+    for (const listener of listeners) {
+      listener(line, stream);
+    }
+  });
+  log3.subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  return log3;
+}
+function pipeOutput(stream, output, write2, onLog) {
+  if (stream === null) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    let remainder = "";
+    let writes = Promise.resolve();
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+      remainder += chunk;
+      while (true) {
+        const lineBreak = remainder.indexOf("\n");
+        if (lineBreak === -1) {
+          break;
+        }
+        const rawLine = remainder.slice(0, lineBreak);
+        remainder = remainder.slice(lineBreak + 1);
+        writes = writes.then(async () => {
+          const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+          onLog(line, output);
+          await write2(line, output);
+        });
+      }
+    });
+    stream.once("end", () => {
+      if (remainder.length > 0) {
+        const finalLine = remainder.endsWith("\r") ? remainder.slice(0, -1) : remainder;
+        writes = writes.then(async () => {
+          onLog(finalLine, output);
+          await write2(finalLine, output);
+        });
+      }
+      void writes.then(() => {
+        resolve();
+      }, reject);
+    });
+    stream.once("error", reject);
+  });
+}
+function resolveReadyCheck(check, spec) {
+  if (check.kind !== "tcp" || spec.docker === void 0) {
+    return check;
+  }
+  const portMapping = spec.docker.ports?.find((mapping) => {
+    if (mapping.container !== check.port) {
+      return false;
+    }
+    return mapping.protocol === void 0 || mapping.protocol === "tcp";
+  });
+  if (portMapping === void 0) {
+    return check;
+  }
+  return {
+    ...check,
+    port: portMapping.host
+  };
+}
+var init_supervisor = __esm({
+  "packages/process-launcher/src/supervisor/supervisor.ts"() {
+    "use strict";
+    init_src9();
+    init_health_check();
+    init_log_writer();
+    init_state_store();
+  }
+});
+
+// packages/process-launcher/src/launcher.ts
+import path19 from "node:path";
+import * as nodeFs3 from "node:fs/promises";
+async function startManagedProcess(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const spec = normalizeSpec(options.spec);
+  const existing = await readManagedProcess({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: spec.id,
+    isPidRunning: options.isPidRunning
+  });
+  if (isActiveRecord(existing)) {
+    throw new Error(`Managed process "${spec.id}" is already running.`);
+  }
+  await fs3.mkdir(resolveProcessDir(options.baseDir, spec.id), { recursive: true });
+  await writeSpec(fs3, options.baseDir, spec);
+  await writeState(fs3, options.baseDir, createBootstrapState(spec));
+  await writeMeta(fs3, options.baseDir, spec.id, { daemonPid: null });
+  const daemonPid = await options.spawnDaemon(spec.id);
+  await writeMeta(fs3, options.baseDir, spec.id, { daemonPid });
+  const started = await waitForRecord({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: spec.id,
+    isPidRunning: options.isPidRunning,
+    pollIntervalMs: options.pollIntervalMs,
+    timeoutMs: options.startupTimeoutMs,
+    ready: (record) => record.state !== null && record.state.status !== "restarting"
+  });
+  return started;
+}
+async function stopManagedProcess(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const record = await readManagedProcess({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: options.id,
+    isPidRunning: options.isPidRunning
+  });
+  if (record.spec === null && record.state === null && record.daemonPid === null) {
+    return null;
+  }
+  const signal = options.force ? "SIGKILL" : "SIGTERM";
+  const signalProcess = options.signalProcess ?? defaultSignalProcess;
+  const daemonPid = record.daemonPid;
+  if (daemonPid !== null && isProcessRunning(daemonPid, options.isPidRunning)) {
+    signalProcess(daemonPid, signal);
+  } else if (record.state?.runtime === "host" && record.state.pid !== null) {
+    if (isProcessRunning(record.state.pid, options.isPidRunning)) {
+      signalProcess(record.state.pid, signal);
+    }
+  }
+  if (record.spec?.docker && options.stopRuntimeArtifacts) {
+    await options.stopRuntimeArtifacts({ record, force: Boolean(options.force) });
+  }
+  const stopped = await waitForStop({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: options.id,
+    isPidRunning: options.isPidRunning,
+    pollIntervalMs: options.pollIntervalMs,
+    timeoutMs: options.stopTimeoutMs
+  });
+  if (isActiveRecord(stopped)) {
+    const persisted = createStoppedState(stopped);
+    await writeState(fs3, options.baseDir, persisted);
+    await writeMeta(fs3, options.baseDir, options.id, { daemonPid: null });
+    return {
+      ...stopped,
+      daemonPid: null,
+      state: persisted
+    };
+  }
+  if (record.state !== null && isActiveStatus(record.state.status) && stopped.state !== null && !isActiveStatus(stopped.state.status)) {
+    await writeState(fs3, options.baseDir, stopped.state);
+    await writeMeta(fs3, options.baseDir, options.id, { daemonPid: null });
+  }
+  return stopped;
+}
+async function restartManagedProcess(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const record = await readManagedProcess({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: options.id,
+    isPidRunning: options.isPidRunning
+  });
+  if (record.spec === null) {
+    throw new Error(`Managed process "${options.id}" was not found.`);
+  }
+  await stopManagedProcess({
+    baseDir: options.baseDir,
+    force: false,
+    fs: fs3,
+    id: options.id,
+    isPidRunning: options.isPidRunning,
+    pollIntervalMs: options.pollIntervalMs,
+    signalProcess: options.signalProcess,
+    stopRuntimeArtifacts: options.stopRuntimeArtifacts,
+    stopTimeoutMs: options.stopTimeoutMs
+  });
+  return await startManagedProcess({
+    baseDir: options.baseDir,
+    fs: fs3,
+    isPidRunning: options.isPidRunning,
+    pollIntervalMs: options.pollIntervalMs,
+    spawnDaemon: options.spawnDaemon,
+    spec: record.spec,
+    startupTimeoutMs: options.startupTimeoutMs
+  });
+}
+async function listManagedProcesses(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const ids = await listIds(fs3, options.baseDir);
+  const records = [];
+  for (const id of ids) {
+    records.push(
+      await readManagedProcess({
+        baseDir: options.baseDir,
+        fs: fs3,
+        id,
+        isPidRunning: options.isPidRunning
+      })
+    );
+  }
+  return records.sort((left, right) => {
+    const leftId = left.spec?.id ?? left.state?.id ?? "";
+    const rightId = right.spec?.id ?? right.state?.id ?? "";
+    return leftId.localeCompare(rightId);
+  });
+}
+async function readManagedLogs(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const logWriter = createLogWriter(
+    resolveLogDir2(options.baseDir, options.id),
+    5,
+    fs3
+  );
+  return await logWriter.tail(options.stream ?? "stdout", options.lines ?? 50);
+}
+async function* followManagedLogs(options) {
+  const stream = options.stream ?? "stdout";
+  let previous = await readManagedLogs(options);
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  while (!options.signal?.aborted) {
+    await sleep2(pollIntervalMs);
+    if (options.signal?.aborted) {
+      return;
+    }
+    const next = await readManagedLogs({
+      baseDir: options.baseDir,
+      fs: options.fs,
+      id: options.id,
+      lines: options.lines,
+      stream
+    });
+    const delta = next.slice(previous.length);
+    previous = next;
+    for (const line of delta) {
+      yield line;
+    }
+  }
+}
+async function removeManagedProcess(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const record = await readManagedProcess({
+    baseDir: options.baseDir,
+    fs: fs3,
+    id: options.id,
+    isPidRunning: options.isPidRunning
+  });
+  if (isActiveRecord(record)) {
+    throw new Error(`Managed process "${options.id}" must be stopped before removal.`);
+  }
+  if (record.spec !== null && options.removeRuntimeArtifacts) {
+    await options.removeRuntimeArtifacts({ record });
+  }
+  const stateStore = createStateStore(options.baseDir, fs3);
+  await stateStore.remove(options.id);
+}
+async function runManagedProcess(options) {
+  const fs3 = options.fs ?? defaultFs();
+  const spec = await readSpec(fs3, options.baseDir, options.id);
+  if (spec === null) {
+    throw new Error(`Managed process "${options.id}" was not found.`);
+  }
+  const controller = new AbortController();
+  const onExternalAbort = () => {
+    controller.abort();
+  };
+  options.signal?.addEventListener("abort", onExternalAbort, { once: true });
+  const onSignal = () => {
+    controller.abort();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    await writeMeta(fs3, options.baseDir, options.id, { daemonPid: process.pid });
+    const supervisor = createSupervisor({
+      fs: fs3,
+      signal: controller.signal,
+      spec,
+      stateDir: options.baseDir
+    });
+    await supervisor.start();
+    const pollIntervalMs = options.pollIntervalMs ?? 250;
+    while (!controller.signal.aborted) {
+      const state = supervisor.getState();
+      if (!isActiveStatus(state.status) && state.pid === null) {
+        return;
+      }
+      await sleep2(pollIntervalMs);
+    }
+    await supervisor.stop();
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    options.signal?.removeEventListener("abort", onExternalAbort);
+    await writeMeta(fs3, options.baseDir, options.id, { daemonPid: null });
+  }
+}
+async function waitForRecord(options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS);
+  while (Date.now() <= deadline) {
+    const record = await readManagedProcess(options);
+    if (options.ready(record)) {
+      return record;
+    }
+    await sleep2(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  }
+  throw new Error(`Timed out waiting for managed process "${options.id}".`);
+}
+async function waitForStop(options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_STOP_TIMEOUT_MS);
+  while (Date.now() <= deadline) {
+    const record = await readManagedProcess(options);
+    if (!isActiveRecord(record)) {
+      return record;
+    }
+    await sleep2(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  }
+  return await readManagedProcess(options);
+}
+async function readManagedProcess(options) {
+  const spec = await readSpec(options.fs, options.baseDir, options.id);
+  const state = await readState(options.fs, options.baseDir, options.id);
+  const meta = await readMeta(options.fs, options.baseDir, options.id);
+  return normalizeRecord(
+    { daemonPid: meta?.daemonPid ?? null, spec, state },
+    options.isPidRunning
+  );
+}
+function normalizeRecord(record, isPidRunningOverride) {
+  if (record.state === null || !isActiveStatus(record.state.status)) {
+    return {
+      ...record,
+      daemonPid: isProcessRunning(record.daemonPid, isPidRunningOverride) ? record.daemonPid : null
+    };
+  }
+  if (isProcessRunning(record.daemonPid, isPidRunningOverride)) {
+    return record;
+  }
+  return {
+    ...record,
+    daemonPid: null,
+    state: createStoppedState(record)
+  };
+}
+function createStoppedState(record) {
+  const spec = record.spec;
+  const state = record.state;
+  if (state !== null) {
+    return {
+      ...state,
+      pid: null,
+      status: state.lastExitCode != null && state.lastExitCode !== 0 ? "crashed" : "stopped",
+      lastStoppedAt: state.lastStoppedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (spec === null) {
+    throw new Error("Cannot create a stopped state without spec or state.");
+  }
+  return {
+    args: [...spec.args ?? []],
+    command: spec.command,
+    id: spec.id,
+    lastExitCode: null,
+    lastStartedAt: null,
+    lastStoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pid: null,
+    restartCount: 0,
+    runtime: spec.docker ? "docker" : "host",
+    status: "stopped"
+  };
+}
+function createBootstrapState(spec) {
+  return {
+    args: [...spec.args ?? []],
+    command: spec.command,
+    id: spec.id,
+    lastExitCode: null,
+    lastStartedAt: null,
+    lastStoppedAt: null,
+    pid: null,
+    restartCount: 0,
+    runtime: spec.docker ? "docker" : "host",
+    status: "restarting"
+  };
+}
+function normalizeSpec(spec) {
+  if (!spec.docker) {
+    return {
+      ...spec,
+      args: [...spec.args ?? []],
+      env: spec.env ? { ...spec.env } : void 0
+    };
+  }
+  return {
+    ...spec,
+    args: [...spec.args ?? []],
+    docker: {
+      ...spec.docker,
+      containerName: spec.docker.containerName ?? buildContainerName2(spec.id),
+      mounts: spec.docker.mounts ? [...spec.docker.mounts] : void 0,
+      ports: spec.docker.ports ? [...spec.docker.ports] : void 0
+    },
+    env: spec.env ? { ...spec.env } : void 0
+  };
+}
+function buildContainerName2(id) {
+  let output = "poe-launch-";
+  for (const char of id) {
+    const code = char.charCodeAt(0);
+    const isAlphaNumeric = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    output += isAlphaNumeric || char === "." || char === "_" || char === "-" ? char : "-";
+  }
+  return output;
+}
+function isActiveRecord(record) {
+  return record.state !== null && isActiveStatus(record.state.status);
+}
+function isActiveStatus(status) {
+  return status === "running" || status === "restarting";
+}
+async function listIds(fs3, baseDir) {
+  try {
+    const entries = await fs3.readdir(baseDir);
+    const ids = [];
+    for (const entry of entries) {
+      const entryPath = path19.join(baseDir, entry);
+      try {
+        const stat11 = await fs3.stat(entryPath);
+        if (!stat11.isFile()) {
+          ids.push(entry);
+        }
+      } catch (error) {
+        if (!isNotFoundError4(error)) {
+          throw error;
+        }
+      }
+    }
+    return ids.sort();
+  } catch (error) {
+    if (isNotFoundError4(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function readSpec(fs3, baseDir, id) {
+  return await readJsonFile(fs3, resolveSpecPath(baseDir, id));
+}
+async function writeSpec(fs3, baseDir, spec) {
+  await writeJsonFile(fs3, resolveSpecPath(baseDir, spec.id), spec);
+}
+async function readState(fs3, baseDir, id) {
+  return await readJsonFile(fs3, resolveStatePath(baseDir, id));
+}
+async function writeState(fs3, baseDir, state) {
+  await writeJsonFile(fs3, resolveStatePath(baseDir, state.id), state);
+}
+async function readMeta(fs3, baseDir, id) {
+  return await readJsonFile(fs3, resolveMetaPath(baseDir, id));
+}
+async function writeMeta(fs3, baseDir, id, meta) {
+  await writeJsonFile(fs3, resolveMetaPath(baseDir, id), meta);
+}
+async function readJsonFile(fs3, filePath) {
+  try {
+    const content = await fs3.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (isNotFoundError4(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(fs3, filePath, value) {
+  await fs3.mkdir(path19.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+function resolveProcessDir(baseDir, id) {
+  return path19.join(baseDir, id);
+}
+function resolveSpecPath(baseDir, id) {
+  return path19.join(resolveProcessDir(baseDir, id), "spec.json");
+}
+function resolveStatePath(baseDir, id) {
+  return path19.join(resolveProcessDir(baseDir, id), "state.json");
+}
+function resolveMetaPath(baseDir, id) {
+  return path19.join(resolveProcessDir(baseDir, id), "meta.json");
+}
+function resolveLogDir2(baseDir, id) {
+  return path19.join(resolveProcessDir(baseDir, id), "logs");
+}
+function isNotFoundError4(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function defaultFs() {
+  return nodeFs3;
+}
+function defaultSignalProcess(pid, signal) {
+  process.kill(pid, signal);
+}
+function isProcessRunning(pid, isPidRunningOverride) {
+  if (pid === null) {
+    return false;
+  }
+  if (isPidRunningOverride) {
+    return isPidRunningOverride(pid);
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleep2(durationMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+  });
+}
+var DEFAULT_POLL_INTERVAL_MS, DEFAULT_STARTUP_TIMEOUT_MS, DEFAULT_STOP_TIMEOUT_MS;
+var init_launcher = __esm({
+  "packages/process-launcher/src/launcher.ts"() {
+    "use strict";
+    init_log_writer();
+    init_state_store();
+    init_supervisor();
+    DEFAULT_POLL_INTERVAL_MS = 100;
+    DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
+    DEFAULT_STOP_TIMEOUT_MS = 5e3;
+  }
+});
+
+// packages/process-launcher/src/index.ts
+var init_src10 = __esm({
+  "packages/process-launcher/src/index.ts"() {
+    "use strict";
+    init_state_store();
+    init_log_writer();
+    init_health_check();
+    init_supervisor();
+    init_launcher();
+  }
+});
+
 // packages/ralph/src/frontmatter/frontmatter.ts
 import { parse as parse6, stringify } from "yaml";
 function parseFrontmatter(content) {
@@ -8017,7 +9514,7 @@ var init_frontmatter = __esm({
 });
 
 // packages/ralph/src/discovery/discovery.ts
-import path15 from "node:path";
+import path20 from "node:path";
 import * as fsPromises4 from "node:fs/promises";
 function createDefaultFs4() {
   return {
@@ -8052,12 +9549,12 @@ async function scanDir(fs3, absoluteDir, displayDir) {
     if (!isMarkdownFile(entry)) {
       continue;
     }
-    const absolutePath = path15.join(absoluteDir, entry);
+    const absolutePath = path20.join(absoluteDir, entry);
     const stat11 = await fs3.stat(absolutePath);
     if (!stat11.isFile()) {
       continue;
     }
-    const displayPath = path15.join(displayDir, entry);
+    const displayPath = path20.join(displayDir, entry);
     docs.push({
       path: displayPath,
       displayPath
@@ -8070,8 +9567,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 = path15.basename(left.displayPath).toLowerCase();
-    const rightName = path15.basename(right.displayPath).toLowerCase();
+    const leftName = path20.basename(left.displayPath).toLowerCase();
+    const rightName = path20.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -8084,12 +9581,12 @@ async function scanDefaultDirs(fs3, cwd, homeDir) {
   const [localDocs, globalDocs] = await Promise.all([
     scanDir(
       fs3,
-      path15.join(cwd, ".poe-code", "ralph", "plans"),
+      path20.join(cwd, ".poe-code", "ralph", "plans"),
       ".poe-code/ralph/plans"
     ),
     scanDir(
       fs3,
-      path15.join(homeDir, ".poe-code", "ralph", "plans"),
+      path20.join(homeDir, ".poe-code", "ralph", "plans"),
       "~/.poe-code/ralph/plans"
     )
   ]);
@@ -8097,9 +9594,9 @@ async function scanDefaultDirs(fs3, cwd, homeDir) {
 }
 function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path15.join(homeDir, dir.slice(2));
+    return path20.join(homeDir, dir.slice(2));
   }
-  return path15.isAbsolute(dir) ? dir : path15.resolve(cwd, dir);
+  return path20.isAbsolute(dir) ? dir : path20.resolve(cwd, dir);
 }
 var init_discovery2 = __esm({
   "packages/ralph/src/discovery/discovery.ts"() {
@@ -8108,7 +9605,7 @@ var init_discovery2 = __esm({
 });
 
 // packages/ralph/src/run/ralph.ts
-import path16 from "node:path";
+import path21 from "node:path";
 import * as fsPromises5 from "node:fs/promises";
 async function runRalph(options) {
   const fs3 = options.fs ?? createDefaultFs5();
@@ -8240,9 +9737,9 @@ function normalizeAgents(agent2) {
 }
 function resolveAbsoluteDocPath(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path16.join(homeDir, docPath.slice(2));
+    return path21.join(homeDir, docPath.slice(2));
   }
-  return path16.isAbsolute(docPath) ? docPath : path16.resolve(cwd, docPath);
+  return path21.isAbsolute(docPath) ? docPath : path21.resolve(cwd, docPath);
 }
 function assertNotAborted2(signal) {
   if (!signal?.aborted) {
@@ -8273,9 +9770,9 @@ async function updateFrontmatter(fs3, absoluteDocPath, body, frontmatter, state,
   await fs3.writeFile(absoluteDocPath, content);
 }
 async function archivePlan2(fs3, absoluteDocPath) {
-  const dir = path16.dirname(absoluteDocPath);
-  const archiveDir = path16.join(dir, "archive");
-  const archivePath = path16.join(archiveDir, path16.basename(absoluteDocPath));
+  const dir = path21.dirname(absoluteDocPath);
+  const archiveDir = path21.join(dir, "archive");
+  const archivePath = path21.join(archiveDir, path21.basename(absoluteDocPath));
   await fs3.mkdir(archiveDir, { recursive: true });
   await fs3.rename(absoluteDocPath, archivePath);
 }
@@ -8299,7 +9796,7 @@ var init_ralph = __esm({
 });
 
 // packages/ralph/src/index.ts
-var init_src9 = __esm({
+var init_src11 = __esm({
   "packages/ralph/src/index.ts"() {
     "use strict";
     init_frontmatter();
@@ -8328,7 +9825,7 @@ async function runRalph2(options) {
 var init_ralph2 = __esm({
   async "src/sdk/ralph.ts"() {
     "use strict";
-    init_src9();
+    init_src11();
     init_src6();
     await init_spawn3();
   }
@@ -8510,7 +10007,7 @@ var TSV_HEADER, ExperimentJournal;
 var init_journal = __esm({
   "packages/experiment-loop/src/journal/journal.ts"() {
     "use strict";
-    TSV_HEADER = ["commit", "status", "score", "durationMs", "timestamp", "output"].join("	");
+    TSV_HEADER = ["commit", "status", "score", "durationMs", "timestamp", "output", "agentOutput"].join("	");
     ExperimentJournal = class {
       constructor(journalPath, fs3) {
         this.journalPath = journalPath;
@@ -8555,7 +10052,8 @@ var init_journal = __esm({
               entry.score === null ? "null" : String(entry.score),
               String(entry.durationMs),
               entry.timestamp,
-              formatOutput(entry.output)
+              formatOutput(entry.output),
+              formatOutput(entry.agentOutput ?? "")
             ].join("	")
           )
         ].join("\n");
@@ -8668,7 +10166,7 @@ var init_git = __esm({
 });
 
 // packages/experiment-loop/src/config/loader.ts
-import path17 from "node:path";
+import path22 from "node:path";
 import { parse as parse7 } from "yaml";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8710,8 +10208,8 @@ function defaultRunConfig() {
   return { prompt: DEFAULT_PROMPT };
 }
 async function loadRunConfig(options) {
-  const projectPath = path17.join(options.cwd, ".poe-code", "experiments", "run.yaml");
-  const globalPath = path17.join(options.homeDir, ".poe-code", "experiments", "run.yaml");
+  const projectPath = path22.join(options.cwd, ".poe-code", "experiments", "run.yaml");
+  const globalPath = path22.join(options.homeDir, ".poe-code", "experiments", "run.yaml");
   const projectContent = await readOptionalFile2(options.fs, projectPath);
   if (projectContent != null) {
     const config = parseRunConfigDocument(projectPath, projectContent);
@@ -8752,7 +10250,7 @@ Do not write to the journal file or commit changes. Both are managed automatical
 // packages/experiment-loop/src/run/loop.ts
 import { exec as execCallback } from "node:child_process";
 import * as fsPromises6 from "node:fs/promises";
-import path18 from "node:path";
+import path23 from "node:path";
 function createDefaultFs6() {
   return {
     readFile: fsPromises6.readFile,
@@ -8796,14 +10294,14 @@ function createDefaultExec() {
 }
 function resolveAbsoluteDocPath2(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path18.join(homeDir, docPath.slice(2));
+    return path23.join(homeDir, docPath.slice(2));
   }
-  return path18.isAbsolute(docPath) ? docPath : path18.resolve(cwd, docPath);
+  return path23.isAbsolute(docPath) ? docPath : path23.resolve(cwd, docPath);
 }
 function resolveJournalPath(docPath) {
-  return path18.join(
-    path18.dirname(docPath),
-    `${path18.basename(docPath, path18.extname(docPath))}.journal.jsonl`
+  return path23.join(
+    path23.dirname(docPath),
+    `${path23.basename(docPath, path23.extname(docPath))}.journal.jsonl`
   );
 }
 function normalizeMetrics(metric) {
@@ -8939,6 +10437,7 @@ function createEntry(options) {
     status: options.status,
     score: options.score,
     output: options.output,
+    agentOutput: options.agentOutput,
     durationMs: options.durationMs,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -9058,12 +10557,14 @@ async function runExperimentLoop(options) {
         }
         throw error;
       }
+      const agentOutput = combineOutput(agentResult.stdout, agentResult.stderr);
       if (agentResult.exitCode !== 0) {
         const entry2 = createEntry({
           commit: preExperimentHash,
           status: "crash",
           score: null,
-          output: combineOutput(agentResult.stdout, agentResult.stderr),
+          output: agentOutput,
+          agentOutput,
           durationMs: Date.now() - experimentStart
         });
         experimentsCompleted += 1;
@@ -9081,7 +10582,7 @@ async function runExperimentLoop(options) {
         });
         continue;
       }
-      const commitMessage = `experiment-loop: ${path18.basename(absoluteDocPath, path18.extname(absoluteDocPath))} #${experimentIndex}`;
+      const commitMessage = `experiment-loop: ${path23.basename(absoluteDocPath, path23.extname(absoluteDocPath))} #${experimentIndex}`;
       let commitHash;
       try {
         commitHash = await git.commitAll(commitMessage, options.cwd);
@@ -9104,6 +10605,7 @@ ${errorMessage}`,
             status: "crash",
             score: null,
             output: errorMessage,
+            agentOutput,
             durationMs: Date.now() - experimentStart
           });
           experimentsCompleted += 1;
@@ -9131,6 +10633,7 @@ ${errorMessage}`,
         status: keep ? "keep" : "discard",
         score: selectJournalScore(metrics, evaluationResults),
         output: formatEvaluationOutput(metrics, evaluationResults),
+        agentOutput,
         durationMs: Date.now() - experimentStart
       });
       experimentsCompleted += 1;
@@ -9178,7 +10681,7 @@ var init_loop = __esm({
 });
 
 // packages/experiment-loop/src/index.ts
-var init_src10 = __esm({
+var init_src12 = __esm({
   "packages/experiment-loop/src/index.ts"() {
     "use strict";
     init_types2();
@@ -9192,7 +10695,7 @@ var init_src10 = __esm({
 });
 
 // src/sdk/experiment.ts
-import path19 from "node:path";
+import path24 from "node:path";
 import * as fsPromises7 from "node:fs/promises";
 function createDefaultFs7() {
   return {
@@ -9218,14 +10721,14 @@ function createDefaultFs7() {
 }
 function resolveAbsoluteDocPath3(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
-    return path19.join(homeDir, docPath.slice(2));
+    return path24.join(homeDir, docPath.slice(2));
   }
-  return path19.isAbsolute(docPath) ? docPath : path19.resolve(cwd, docPath);
+  return path24.isAbsolute(docPath) ? docPath : path24.resolve(cwd, docPath);
 }
 function resolveJournalPath2(docPath) {
-  return path19.join(
-    path19.dirname(docPath),
-    `${path19.basename(docPath, path19.extname(docPath))}.journal.jsonl`
+  return path24.join(
+    path24.dirname(docPath),
+    `${path24.basename(docPath, path24.extname(docPath))}.journal.jsonl`
   );
 }
 async function runExperiment(options) {
@@ -9253,7 +10756,7 @@ async function readExperimentJournal(options) {
 var init_experiment = __esm({
   async "src/sdk/experiment.ts"() {
     "use strict";
-    init_src10();
+    init_src12();
     init_src6();
     await init_spawn3();
   }
@@ -9322,99 +10825,393 @@ async function readErrorBody(response) {
     return void 0;
   }
 }
-function extractTextContent(data) {
-  if (!isRecord7(data)) return void 0;
-  const choices = data.choices;
-  if (!Array.isArray(choices) || choices.length === 0) return void 0;
-  const first = choices[0];
-  if (!isRecord7(first)) return void 0;
-  const message = first.message;
-  if (!isRecord7(message)) return void 0;
-  return typeof message.content === "string" ? message.content : void 0;
+function extractTextContent(data) {
+  if (!isRecord7(data)) return void 0;
+  const choices = data.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return void 0;
+  const first = choices[0];
+  if (!isRecord7(first)) return void 0;
+  const message = first.message;
+  if (!isRecord7(message)) return void 0;
+  return typeof message.content === "string" ? message.content : void 0;
+}
+function extractMediaFromCompletion(data) {
+  const content = extractTextContent(data);
+  if (!content) return {};
+  try {
+    const parsed = JSON.parse(content);
+    if (isRecord7(parsed) && typeof parsed.url === "string") {
+      return {
+        url: parsed.url,
+        mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0,
+        data: typeof parsed.data === "string" ? parsed.data : void 0
+      };
+    }
+    if (isRecord7(parsed) && typeof parsed.data === "string") {
+      return {
+        data: parsed.data,
+        mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0
+      };
+    }
+  } catch {
+  }
+  if (isValidUrl(content.trim())) {
+    return { url: content.trim() };
+  }
+  const markdownUrl = extractMarkdownUrl(content);
+  if (markdownUrl) {
+    return { url: markdownUrl };
+  }
+  return { content };
+}
+function extractMarkdownUrl(content) {
+  const start = content.indexOf("](");
+  if (start === -1) return void 0;
+  const urlStart = start + 2;
+  const end = content.indexOf(")", urlStart);
+  if (end === -1) return void 0;
+  const url = content.slice(urlStart, end);
+  return isValidUrl(url) ? url : void 0;
+}
+function isValidUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecord7(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+var init_llm_client = __esm({
+  "src/services/llm-client.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/services/client-instance.ts
+function setGlobalClient(client) {
+  globalClient = client;
+}
+function getGlobalClient() {
+  if (!globalClient) {
+    throw new Error("LLM client not initialized. Call setGlobalClient() first.");
+  }
+  return globalClient;
+}
+async function initializeClient(options) {
+  if (globalClient !== null) {
+    return;
+  }
+  const client = createPoeClient({
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    httpClient: options.httpClient
+  });
+  setGlobalClient(client);
+}
+var globalClient;
+var init_client_instance = __esm({
+  "src/services/client-instance.ts"() {
+    "use strict";
+    init_llm_client();
+    globalClient = null;
+  }
+});
+
+// src/utils/execution-context.ts
+import { basename as basename2, dirname as dirname3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function detectExecutionContext(input) {
+  const { argv, env, moduleUrl } = input;
+  if (isDevelopmentMode(argv, env)) {
+    return createDevelopmentContext(moduleUrl);
+  }
+  if (isNpxExecution(env)) {
+    const version = detectNpxVersion(env);
+    return createNpxContext(version);
+  }
+  const invoked = basename2(argv[1] ?? "");
+  const isPoeShort = invoked === "poe" || invoked === "poe.cmd" || invoked === "poe.exe";
+  return {
+    mode: "global",
+    command: {
+      command: isPoeShort ? "poe" : "poe-code",
+      args: []
+    }
+  };
+}
+function isDevelopmentMode(argv, env) {
+  const scriptPath = argv[1] ?? "";
+  if (scriptPath.endsWith(".ts") || scriptPath.includes("/src/")) {
+    return true;
+  }
+  if (env.npm_lifecycle_event === "dev") {
+    return true;
+  }
+  const nodeOptions = env.NODE_OPTIONS ?? "";
+  if (nodeOptions.includes("tsx") || nodeOptions.includes("ts-node")) {
+    return true;
+  }
+  return false;
+}
+function isNpxExecution(env) {
+  const execPath = env.npm_execpath ?? "";
+  if (execPath.includes("npx") || execPath.includes("npm")) {
+    const packagePath = env.npm_package_json ?? "";
+    if (packagePath.includes("_npx") || packagePath.includes(".npm/_cacache")) {
+      return true;
+    }
+  }
+  if (env.npm_command === "exec") {
+    return true;
+  }
+  return false;
+}
+function detectNpxVersion(env) {
+  const packageJson = env.npm_package_json ?? "";
+  const packageVersion = env.npm_package_version ?? "";
+  if (packageJson.includes("@beta") || packageVersion.includes("beta")) {
+    return "beta";
+  }
+  if (packageJson.includes("@latest")) {
+    return "latest";
+  }
+  return "default";
+}
+function createDevelopmentContext(moduleUrl) {
+  const modulePath = fileURLToPath2(moduleUrl);
+  const srcIndex = modulePath.lastIndexOf("/src/");
+  const projectRoot = srcIndex !== -1 ? modulePath.substring(0, srcIndex) : dirname3(dirname3(modulePath));
+  return {
+    mode: "development",
+    command: {
+      command: "npm",
+      args: ["--silent", "--prefix", projectRoot, "run", "dev", "--"]
+    }
+  };
+}
+function createNpxContext(version) {
+  const packageSpec = version === "default" ? "poe-code" : `poe-code@${version}`;
+  return {
+    mode: version === "default" ? "npx" : `npx-${version}`,
+    command: {
+      command: "npx",
+      args: ["--yes", packageSpec]
+    }
+  };
+}
+function toMcpServerCommand(execCommand, subcommand) {
+  return {
+    command: execCommand.command,
+    args: [...execCommand.args, subcommand]
+  };
+}
+function formatCliHelpCommand(context, args) {
+  const base = formatCliUsageCommand(context);
+  const trailing = args.join(" ");
+  if (trailing.length === 0) {
+    return base;
+  }
+  return `${base} ${trailing}`;
+}
+function formatCliUsageCommand(context) {
+  switch (context.mode) {
+    case "development":
+      return "npm run dev --";
+    case "npx":
+      return "npx poe-code";
+    case "npx-latest":
+      return "npx poe-code@latest";
+    case "npx-beta":
+      return "npx poe-code@beta";
+    case "global":
+    default:
+      return context.command.command;
+  }
+}
+function getCurrentExecutionContext(moduleUrl) {
+  return detectExecutionContext({
+    argv: process.argv,
+    env: process.env,
+    moduleUrl
+  });
+}
+var init_execution_context = __esm({
+  "src/utils/execution-context.ts"() {
+    "use strict";
+  }
+});
+
+// src/sdk/launch.ts
+import path25 from "node:path";
+import { spawnSync } 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 });
+  return await startManagedProcess({
+    baseDir: resolveLaunchBaseDir(homeDir),
+    spec: options.spec,
+    spawnDaemon: async (id) => {
+      const handle = runner.exec({
+        args: [...executionContext.command.args, "launch", "__run", id],
+        command: executionContext.command.command,
+        cwd,
+        env: objectToEnv(variables),
+        stderr: "inherit",
+        stdin: "ignore",
+        stdout: "inherit"
+      });
+      return handle.pid;
+    }
+  });
+}
+async function stopLaunch(options) {
+  const homeDir = resolveHomeDir(options.homeDir);
+  return await stopManagedProcess({
+    baseDir: resolveLaunchBaseDir(homeDir),
+    force: options.force,
+    id: options.id,
+    signalProcess: sendSignalToManagedProcess,
+    stopRuntimeArtifacts: async ({ record, force }) => {
+      await stopDockerArtifacts(record, force);
+    }
+  });
 }
-function extractMediaFromCompletion(data) {
-  const content = extractTextContent(data);
-  if (!content) return {};
-  try {
-    const parsed = JSON.parse(content);
-    if (isRecord7(parsed) && typeof parsed.url === "string") {
-      return {
-        url: parsed.url,
-        mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0,
-        data: typeof parsed.data === "string" ? parsed.data : void 0
-      };
+async function restartLaunch(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 });
+  return await restartManagedProcess({
+    baseDir: resolveLaunchBaseDir(homeDir),
+    id: options.id,
+    signalProcess: sendSignalToManagedProcess,
+    spawnDaemon: async (id) => {
+      const handle = runner.exec({
+        args: [...executionContext.command.args, "launch", "__run", id],
+        command: executionContext.command.command,
+        cwd,
+        env: objectToEnv(variables),
+        stderr: "inherit",
+        stdin: "ignore",
+        stdout: "inherit"
+      });
+      return handle.pid;
+    },
+    stopRuntimeArtifacts: async ({ record, force }) => {
+      await stopDockerArtifacts(record, force);
     }
-    if (isRecord7(parsed) && typeof parsed.data === "string") {
-      return {
-        data: parsed.data,
-        mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0
-      };
+  });
+}
+async function listLaunches(options = {}) {
+  return await listManagedProcesses({
+    baseDir: resolveLaunchBaseDir(resolveHomeDir(options.homeDir))
+  });
+}
+async function readLaunchLogs(options) {
+  return await readManagedLogs({
+    baseDir: resolveLaunchBaseDir(resolveHomeDir(options.homeDir)),
+    id: options.id,
+    lines: options.lines,
+    stream: options.stream
+  });
+}
+function followLaunchLogs(options) {
+  const forwarded = {
+    baseDir: resolveLaunchBaseDir(resolveHomeDir(options.homeDir)),
+    id: options.id,
+    lines: options.lines,
+    pollIntervalMs: options.pollIntervalMs,
+    signal: options.signal,
+    stream: options.stream
+  };
+  return followManagedLogs(forwarded);
+}
+async function removeLaunch(options) {
+  await removeManagedProcess({
+    baseDir: resolveLaunchBaseDir(resolveHomeDir(options.homeDir)),
+    id: options.id,
+    removeRuntimeArtifacts: async ({ record }) => {
+      await removeDockerArtifacts(record);
     }
-  } catch {
-  }
-  if (isValidUrl(content.trim())) {
-    return { url: content.trim() };
-  }
-  const markdownUrl = extractMarkdownUrl(content);
-  if (markdownUrl) {
-    return { url: markdownUrl };
-  }
-  return { content };
+  });
 }
-function extractMarkdownUrl(content) {
-  const start = content.indexOf("](");
-  if (start === -1) return void 0;
-  const urlStart = start + 2;
-  const end = content.indexOf(")", urlStart);
-  if (end === -1) return void 0;
-  const url = content.slice(urlStart, end);
-  return isValidUrl(url) ? url : void 0;
+async function runLaunchDaemon(options) {
+  await runManagedProcess({
+    baseDir: resolveLaunchBaseDir(resolveHomeDir(options.homeDir)),
+    id: options.id,
+    signal: options.signal
+  });
 }
-function isValidUrl(value) {
+function resolveLaunchBaseDir(homeDir) {
+  return path25.join(homeDir, ".poe-code", "launch");
+}
+function resolveHomeDir(homeDir) {
+  if (homeDir) {
+    return homeDir;
+  }
+  return process.env.HOME ?? process.cwd();
+}
+function sendSignalToManagedProcess(pid, signal) {
+  if (process.platform === "win32") {
+    process.kill(pid, signal);
+    return;
+  }
   try {
-    new URL(value);
-    return true;
-  } catch {
-    return false;
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (!isMissingProcessGroupError(error)) {
+      throw error;
+    }
+    process.kill(pid, signal);
   }
 }
-function isRecord7(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+function isMissingProcessGroupError(error) {
+  return error instanceof Error && "code" in error && error.code === "ESRCH";
 }
-var init_llm_client = __esm({
-  "src/services/llm-client.ts"() {
-    "use strict";
-    init_errors();
+function objectToEnv(variables) {
+  const env = {};
+  for (const [key, value] of Object.entries(variables)) {
+    if (value !== void 0) {
+      env[key] = value;
+    }
   }
-});
-
-// src/services/client-instance.ts
-function setGlobalClient(client) {
-  globalClient = client;
+  return env;
 }
-function getGlobalClient() {
-  if (!globalClient) {
-    throw new Error("LLM client not initialized. Call setGlobalClient() first.");
+async function stopDockerArtifacts(record, force) {
+  if (!record.spec?.docker?.containerName) {
+    return;
   }
-  return globalClient;
+  const engine = resolveEngine(record.spec.docker.engine);
+  const command = force ? "kill" : "stop";
+  spawnSync(engine, [command, record.spec.docker.containerName], { stdio: "ignore" });
 }
-async function initializeClient(options) {
-  if (globalClient !== null) {
+async function removeDockerArtifacts(record) {
+  if (!record.spec?.docker?.containerName) {
     return;
   }
-  const client = createPoeClient({
-    apiKey: options.apiKey,
-    baseUrl: options.baseUrl,
-    httpClient: options.httpClient
-  });
-  setGlobalClient(client);
+  const engine = resolveEngine(record.spec.docker.engine);
+  spawnSync(engine, ["rm", "-f", record.spec.docker.containerName], { stdio: "ignore" });
 }
-var globalClient;
-var init_client_instance = __esm({
-  "src/services/client-instance.ts"() {
+function resolveEngine(engine) {
+  if (engine) {
+    return engine;
+  }
+  return detectEngine();
+}
+var init_launch = __esm({
+  "src/sdk/launch.ts"() {
     "use strict";
-    init_llm_client();
-    globalClient = null;
+    init_src10();
+    init_src9();
+    init_execution_context();
   }
 });
 
@@ -9898,13 +11695,13 @@ var init_acp_transport = __esm({
           env,
           requestTimeoutMs,
           firstRequestId,
-          spawn: spawn7 = spawnChildProcess4
+          spawn: spawn9 = spawnChildProcess4
         } = options;
         this.command = command;
         this.closed = new Promise((resolve) => {
           this.resolveClosed = resolve;
         });
-        this.child = spawn7(command, [...args], {
+        this.child = spawn9(command, [...args], {
           cwd,
           env,
           stdio: ["pipe", "pipe", "pipe"]
@@ -10017,8 +11814,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path33) {
-  if (!isAbsolute(path33)) {
+function assertAbsolutePath(path39) {
+  if (!isAbsolute(path39)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -10752,7 +12549,7 @@ var init_run_report = __esm({
 });
 
 // packages/poe-acp-client/src/index.ts
-var init_src11 = __esm({
+var init_src13 = __esm({
   "packages/poe-acp-client/src/index.ts"() {
     "use strict";
     init_acp_client();
@@ -11779,7 +13576,7 @@ var init_acp_core = __esm({
 });
 
 // packages/poe-agent/src/plugins/plugin-args.ts
-import path20 from "node:path";
+import path26 from "node:path";
 function isObjectRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -11810,13 +13607,13 @@ function getOptionalString(args, key) {
   return value;
 }
 function resolveAllowedPath(cwd, allowedPaths, inputPath) {
-  const resolvedPath = path20.resolve(cwd, inputPath);
+  const resolvedPath = path26.resolve(cwd, inputPath);
   const isAllowed = allowedPaths.some((allowedPath) => {
     if (allowedPath === resolvedPath) {
       return true;
     }
-    const rel = path20.relative(allowedPath, resolvedPath);
-    return rel.length > 0 && !rel.startsWith("..") && !path20.isAbsolute(rel);
+    const rel = path26.relative(allowedPath, resolvedPath);
+    return rel.length > 0 && !rel.startsWith("..") && !path26.isAbsolute(rel);
   });
   if (!isAllowed) {
     throw new Error(`Path is outside allowed paths: ${inputPath}`);
@@ -11831,7 +13628,7 @@ var init_plugin_args = __esm({
 
 // packages/poe-agent/src/plugins/poe-agent-plugin-files.ts
 import fsPromises9 from "node:fs/promises";
-import path21 from "node:path";
+import path27 from "node:path";
 async function fileExists(fs3, filePath) {
   try {
     await fs3.readFile(filePath, "utf8");
@@ -11855,9 +13652,9 @@ var init_poe_agent_plugin_files = __esm({
     "use strict";
     init_plugin_args();
     filesPlugin = (options = {}) => {
-      const cwd = path21.resolve(options.cwd ?? process.cwd());
+      const cwd = path27.resolve(options.cwd ?? process.cwd());
       const allowedPaths = (options.allowedPaths ?? [cwd]).map(
-        (allowedPath) => path21.resolve(cwd, allowedPath)
+        (allowedPath) => path27.resolve(cwd, allowedPath)
       );
       const fs3 = options.fs ?? fsPromises9;
       const readFileTool = {
@@ -11911,7 +13708,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 = path21.relative(cwd, filePath) || path21.basename(filePath);
+          const displayedPath = path27.relative(cwd, filePath) || path27.basename(filePath);
           if (command === "str_replace") {
             const oldStr = getRequiredString(args, "old_str", true);
             const newStr = getRequiredString(args, "new_str", true);
@@ -11931,7 +13728,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(path21.dirname(filePath), { recursive: true });
+            await fs3.mkdir(path27.dirname(filePath), { recursive: true });
             await fs3.writeFile(filePath, fileText, "utf8");
             return `Created file: ${displayedPath}`;
           }
@@ -11972,7 +13769,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 path22 from "node:path";
+import path28 from "node:path";
 import { promisify } from "node:util";
 async function defaultRunCommand(command, cwd) {
   try {
@@ -12005,9 +13802,9 @@ var init_poe_agent_plugin_shell = __esm({
     init_plugin_args();
     exec = promisify(execCallback2);
     shellPlugin = (options = {}) => {
-      const cwd = path22.resolve(options.cwd ?? process.cwd());
+      const cwd = path28.resolve(options.cwd ?? process.cwd());
       const allowedPaths = (options.allowedPaths ?? [cwd]).map(
-        (allowedPath) => path22.resolve(cwd, allowedPath)
+        (allowedPath) => path28.resolve(cwd, allowedPath)
       );
       const runCommand2 = options.runCommand ?? defaultRunCommand;
       const runCommandTool = {
@@ -12046,7 +13843,7 @@ var init_poe_agent_plugin_shell = __esm({
 // packages/poe-agent/src/system-prompt.ts
 import { readFileSync } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function loadSystemPromptSync() {
   return readFileSync(SYSTEM_PROMPT_PATH, "utf8");
 }
@@ -12054,7 +13851,7 @@ var SYSTEM_PROMPT_PATH;
 var init_system_prompt = __esm({
   "packages/poe-agent/src/system-prompt.ts"() {
     "use strict";
-    SYSTEM_PROMPT_PATH = fileURLToPath2(new URL("./SYSTEM_PROMPT.md", import.meta.url));
+    SYSTEM_PROMPT_PATH = fileURLToPath3(new URL("./SYSTEM_PROMPT.md", import.meta.url));
   }
 });
 
@@ -12791,7 +14588,7 @@ var AgentHost;
 var init_agent_host = __esm({
   "packages/poe-agent/src/runtime/agent-host.ts"() {
     "use strict";
-    init_src11();
+    init_src13();
     init_agent_session();
     init_acp_core();
     init_run_context();
@@ -13158,10 +14955,10 @@ var init_config2 = __esm({
 });
 
 // packages/tiny-mcp-client/src/internal.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { PassThrough } from "node:stream";
 function defaultStdioSpawn(command, args, options) {
-  return spawn5(command, args, options);
+  return spawn7(command, args, options);
 }
 function serializeJsonRpcMessage2(message) {
   return `${JSON.stringify(message)}
@@ -14078,7 +15875,7 @@ var init_internal = __esm({
 });
 
 // packages/tiny-mcp-client/src/index.ts
-var init_src12 = __esm({
+var init_src14 = __esm({
   "packages/tiny-mcp-client/src/index.ts"() {
     "use strict";
     init_internal();
@@ -14127,7 +15924,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_src12();
+    init_src14();
     init_hooks();
     DEFAULT_MCP_CLIENT_INFO = {
       name: "poe-agent",
@@ -14694,7 +16491,7 @@ __export(src_exports, {
   agent: () => agent,
   createAgentSession: () => createAgentSession
 });
-var init_src13 = __esm({
+var init_src15 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent();
@@ -15032,7 +16829,7 @@ function createInMemoryAcpTransport2(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src13(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src15(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
           cwd: request.cwd || options.cwd,
@@ -15182,7 +16979,7 @@ var init_poe_agent = __esm({
   "src/providers/poe-agent.ts"() {
     "use strict";
     init_constants();
-    init_src11();
+    init_src13();
     init_create_provider();
     poeAgentService = createProvider({
       id: "poe-agent",
@@ -15376,7 +17173,7 @@ var init_container2 = __esm({
 });
 
 // src/services/config.ts
-import path24 from "node:path";
+import path30 from "node:path";
 async function deleteConfig(options) {
   const { fs: fs3, filePath } = options;
   try {
@@ -15457,7 +17254,7 @@ async function migrateLegacyCredentialsIfNeeded(fs3, filePath) {
   await migrateLegacyCredentialsFile(fs3, filePath);
 }
 async function migrateLegacyCredentialsFile(fs3, configPath) {
-  const legacyPath = path24.join(path24.dirname(configPath), "credentials.json");
+  const legacyPath = path30.join(path30.dirname(configPath), "credentials.json");
   const raw = await readFileIfExists(fs3, legacyPath);
   if (raw === null) {
     return;
@@ -15525,9 +17322,9 @@ async function recoverInvalidConfig(fs3, filePath, content) {
   await fs3.writeFile(filePath, EMPTY_DOCUMENT3, { encoding: "utf8" });
 }
 function createInvalidBackupPath2(filePath) {
-  const directory = path24.dirname(filePath);
-  const baseName = path24.basename(filePath);
-  return path24.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
+  const directory = path30.dirname(filePath);
+  const baseName = path30.basename(filePath);
+  return path30.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
 function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -15746,7 +17543,7 @@ function registerAgentCommand(program, container) {
     }
     let session;
     try {
-      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src13(), src_exports));
+      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src15(), src_exports));
       session = await createAgentSession2({
         model: options.model,
         apiKey: options.apiKey,
@@ -15805,7 +17602,7 @@ var init_agent2 = __esm({
 });
 
 // src/cli/commands/spawn.ts
-import path25 from "node:path";
+import path31 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 ?? [];
@@ -16007,10 +17804,10 @@ function resolveSpawnWorkingDirectory2(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path25.isAbsolute(candidate)) {
+  if (path31.isAbsolute(candidate)) {
     return candidate;
   }
-  return path25.resolve(baseDir, candidate);
+  return path31.resolve(baseDir, candidate);
 }
 function parseMcpSpawnConfig2(input) {
   if (!input) {
@@ -16128,7 +17925,7 @@ var init_spawn4 = __esm({
 });
 
 // src/sdk/research.ts
-import path26 from "node:path";
+import path32 from "node:path";
 async function research(container, options) {
   const logger2 = options.logger;
   const source = await resolveSource({
@@ -16163,7 +17960,7 @@ async function research(container, options) {
         markdown: markdownOutput
       });
       outputPath = buildOutputPath(container.env.homeDir, options.prompt);
-      await ensureDirectory2(container.fs, path26.dirname(outputPath));
+      await ensureDirectory2(container.fs, path32.dirname(outputPath));
       await container.fs.writeFile(outputPath, document, {
         encoding: "utf8"
       });
@@ -16238,7 +18035,7 @@ function buildResearchDocument(input) {
 }
 function buildClonePath(homeDir, github) {
   const slug = extractRepoSlug(github);
-  return path26.join(homeDir, ".poe-code", "repos", slug);
+  return path32.join(homeDir, ".poe-code", "repos", slug);
 }
 function extractRepoSlug(value) {
   const trimmed = value.trim();
@@ -16276,7 +18073,7 @@ function extractRepoSlug(value) {
 function buildOutputPath(homeDir, prompt, now = /* @__PURE__ */ new Date()) {
   const timestamp = formatTimestamp2(now);
   const slug = buildSlug(prompt);
-  return path26.join(
+  return path32.join(
     homeDir,
     ".poe-code",
     "research",
@@ -16297,7 +18094,7 @@ async function resolveSource(input) {
   if (options.github) {
     const cloneUrl = resolveGithubCloneUrl(options.github);
     const clonePath = buildClonePath(container.env.homeDir, options.github);
-    await ensureDirectory2(container.fs, path26.dirname(clonePath));
+    await ensureDirectory2(container.fs, path32.dirname(clonePath));
     const exists = await pathExists2(container.fs, clonePath);
     if (!exists) {
       const cloneResult = await container.commandRunner(
@@ -16395,10 +18192,10 @@ function formatYamlString(value) {
   return JSON.stringify(value);
 }
 function resolvePath2(baseDir, candidate) {
-  if (path26.isAbsolute(candidate)) {
+  if (path32.isAbsolute(candidate)) {
     return candidate;
   }
-  return path26.resolve(baseDir, candidate);
+  return path32.resolve(baseDir, candidate);
 }
 function teeAcpStream(events) {
   const chunks = [];
@@ -16458,7 +18255,7 @@ async function removePathFallback(fs3, target) {
   if (stats && typeof stats.isDirectory === "function" && stats.isDirectory()) {
     const entries = await fs3.readdir(target);
     for (const entry of entries) {
-      await removePathFallback(fs3, path26.join(target, entry));
+      await removePathFallback(fs3, path32.join(target, entry));
     }
   }
   try {
@@ -16624,7 +18421,7 @@ var init_research2 = __esm({
 });
 
 // src/cli/isolated-env-runner.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 async function isolatedEnvRunner(input) {
   const details = await resolveIsolatedEnvDetails(
     input.env,
@@ -16649,7 +18446,7 @@ async function isolatedEnvRunner(input) {
     );
     args = buildArgsWithMergedSettings(args, resolvedSettings);
   }
-  const child = spawn6(details.agentBinary, args, {
+  const child = spawn8(details.agentBinary, args, {
     stdio: "inherit",
     env: {
       ...process.env,
@@ -17020,7 +18817,7 @@ function registerAuthCommand(program, container) {
   const auth = program.command("auth").description("Authentication and account commands.").action(async () => {
     await executeStatus(program, container);
   });
-  auth.command("status").description("Show login, balance, and configuration status.").action(async () => {
+  auth.command("status").description("Show login status.").action(async () => {
     await executeStatus(program, container);
   });
   auth.command("api_key").description("Display stored API key.").action(async () => {
@@ -17099,7 +18896,7 @@ var init_auth = __esm({
 });
 
 // src/cli/commands/config.ts
-import { execSync } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 function registerConfigCommand(program, container) {
   const config = program.command("config").description("Inspect and manage poe-code config files.").action(async () => {
     await executeConfigInfo(program, container);
@@ -17188,7 +18985,7 @@ async function executeConfigEdit(program, container, options) {
   if (!await pathExists(container.fs, targetPath)) {
     await initProjectConfig(container.fs, targetPath);
   }
-  execSync(`${editor} ${shlexQuote(targetPath)}`, {
+  execSync3(`${editor} ${shlexQuote(targetPath)}`, {
     stdio: "inherit"
   });
 }
@@ -17238,7 +19035,7 @@ var init_utils3 = __esm({
 function registerInstallCommand(program, container) {
   const serviceNames = container.registry.list().filter((service) => typeof service.install === "function").map((service) => service.name);
   const serviceDescription = `Agent to install${formatServiceList(serviceNames)}`;
-  return program.command("install").alias("i").description("Install tooling for a configured agent.").argument(
+  return program.command("install").alias("i").description("Install agent binary for a configured agent.").argument(
     "[agent]",
     serviceDescription
   ).action(async (service) => {
@@ -17430,7 +19227,7 @@ var init_media_download = __esm({
 });
 
 // src/cli/commands/generate.ts
-import path27 from "node:path";
+import path33 from "node:path";
 function registerGenerateCommand(program, container) {
   const generate2 = program.command("generate").alias("g").description("Generate content via Poe API").option("--model <model>", `Model identifier (default: ${DEFAULT_TEXT_MODEL})`).option(
     "--param <key=value>",
@@ -17703,11 +19500,11 @@ function getDefaultMimeType(type) {
   return defaults[type];
 }
 function resolveOutputPath(filename, cwd) {
-  if (path27.isAbsolute(filename)) {
+  if (path33.isAbsolute(filename)) {
     return { path: filename, label: filename };
   }
   return {
-    path: path27.join(cwd, filename),
+    path: path33.join(cwd, filename),
     label: `./${filename}`
   };
 }
@@ -18435,7 +20232,7 @@ var init_content = __esm({
 });
 
 // packages/tiny-stdio-mcp-server/src/index.ts
-var init_src14 = __esm({
+var init_src16 = __esm({
   "packages/tiny-stdio-mcp-server/src/index.ts"() {
     "use strict";
     init_server();
@@ -18738,7 +20535,7 @@ var generateTextSchema, generateImageSchema, generateVideoSchema, generateAudioS
 var init_mcp_server = __esm({
   "src/cli/mcp-server.ts"() {
     "use strict";
-    init_src14();
+    init_src16();
     init_client_instance();
     init_constants();
     generateTextSchema = defineSchema({
@@ -18817,150 +20614,26 @@ function parseMcpOutputFormatPreferences(value) {
       );
     }
     if (normalized !== "url" && normalized !== "base64" && normalized !== "markdown" && normalized !== "markdown_instructions") {
-      throw new ValidationError(
-        `Invalid --output-format entry "${raw.trim()}". Expected "url", "base64", "markdown", or "markdown_instructions".`
-      );
-    }
-    preferences.push(normalized);
-  }
-  const standaloneFormats = ["markdown", "markdown_instructions"];
-  for (const standalone of standaloneFormats) {
-    if (preferences.includes(standalone) && preferences.length > 1) {
-      throw new ValidationError(
-        `${standalone} output format cannot be combined with other formats. Use ${standalone} alone or choose a different format combination.`
-      );
-    }
-  }
-  return preferences;
-}
-var init_mcp_output_format = __esm({
-  "src/cli/mcp-output-format.ts"() {
-    "use strict";
-    init_errors();
-  }
-});
-
-// src/utils/execution-context.ts
-import { basename as basename2, dirname as dirname3 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function detectExecutionContext(input) {
-  const { argv, env, moduleUrl } = input;
-  if (isDevelopmentMode(argv, env)) {
-    return createDevelopmentContext(moduleUrl);
-  }
-  if (isNpxExecution(env)) {
-    const version = detectNpxVersion(env);
-    return createNpxContext(version);
-  }
-  const invoked = basename2(argv[1] ?? "");
-  const isPoeShort = invoked === "poe" || invoked === "poe.cmd" || invoked === "poe.exe";
-  return {
-    mode: "global",
-    command: {
-      command: isPoeShort ? "poe" : "poe-code",
-      args: []
-    }
-  };
-}
-function isDevelopmentMode(argv, env) {
-  const scriptPath = argv[1] ?? "";
-  if (scriptPath.endsWith(".ts") || scriptPath.includes("/src/")) {
-    return true;
-  }
-  if (env.npm_lifecycle_event === "dev") {
-    return true;
-  }
-  const nodeOptions = env.NODE_OPTIONS ?? "";
-  if (nodeOptions.includes("tsx") || nodeOptions.includes("ts-node")) {
-    return true;
-  }
-  return false;
-}
-function isNpxExecution(env) {
-  const execPath = env.npm_execpath ?? "";
-  if (execPath.includes("npx") || execPath.includes("npm")) {
-    const packagePath = env.npm_package_json ?? "";
-    if (packagePath.includes("_npx") || packagePath.includes(".npm/_cacache")) {
-      return true;
-    }
-  }
-  if (env.npm_command === "exec") {
-    return true;
-  }
-  return false;
-}
-function detectNpxVersion(env) {
-  const packageJson = env.npm_package_json ?? "";
-  const packageVersion = env.npm_package_version ?? "";
-  if (packageJson.includes("@beta") || packageVersion.includes("beta")) {
-    return "beta";
-  }
-  if (packageJson.includes("@latest")) {
-    return "latest";
-  }
-  return "default";
-}
-function createDevelopmentContext(moduleUrl) {
-  const modulePath = fileURLToPath3(moduleUrl);
-  const srcIndex = modulePath.lastIndexOf("/src/");
-  const projectRoot = srcIndex !== -1 ? modulePath.substring(0, srcIndex) : dirname3(dirname3(modulePath));
-  return {
-    mode: "development",
-    command: {
-      command: "npm",
-      args: ["--silent", "--prefix", projectRoot, "run", "dev", "--"]
-    }
-  };
-}
-function createNpxContext(version) {
-  const packageSpec = version === "default" ? "poe-code" : `poe-code@${version}`;
-  return {
-    mode: version === "default" ? "npx" : `npx-${version}`,
-    command: {
-      command: "npx",
-      args: ["--yes", packageSpec]
-    }
-  };
-}
-function toMcpServerCommand(execCommand, subcommand) {
-  return {
-    command: execCommand.command,
-    args: [...execCommand.args, subcommand]
-  };
-}
-function formatCliHelpCommand(context, args) {
-  const base = formatCliUsageCommand(context);
-  const trailing = args.join(" ");
-  if (trailing.length === 0) {
-    return base;
+      throw new ValidationError(
+        `Invalid --output-format entry "${raw.trim()}". Expected "url", "base64", "markdown", or "markdown_instructions".`
+      );
+    }
+    preferences.push(normalized);
   }
-  return `${base} ${trailing}`;
-}
-function formatCliUsageCommand(context) {
-  switch (context.mode) {
-    case "development":
-      return "npm run dev --";
-    case "npx":
-      return "npx poe-code";
-    case "npx-latest":
-      return "npx poe-code@latest";
-    case "npx-beta":
-      return "npx poe-code@beta";
-    case "global":
-    default:
-      return context.command.command;
+  const standaloneFormats = ["markdown", "markdown_instructions"];
+  for (const standalone of standaloneFormats) {
+    if (preferences.includes(standalone) && preferences.length > 1) {
+      throw new ValidationError(
+        `${standalone} output format cannot be combined with other formats. Use ${standalone} alone or choose a different format combination.`
+      );
+    }
   }
+  return preferences;
 }
-function getCurrentExecutionContext(moduleUrl) {
-  return detectExecutionContext({
-    argv: process.argv,
-    env: process.env,
-    moduleUrl
-  });
-}
-var init_execution_context = __esm({
-  "src/utils/execution-context.ts"() {
+var init_mcp_output_format = __esm({
+  "src/cli/mcp-output-format.ts"() {
     "use strict";
+    init_errors();
   }
 });
 
@@ -19146,9 +20819,9 @@ var init_shapes = __esm({
 });
 
 // packages/agent-mcp-config/src/apply.ts
-import path28 from "node:path";
+import path34 from "node:path";
 function getConfigDirectory(configPath) {
-  return path28.dirname(configPath);
+  return path34.dirname(configPath);
 }
 function isConfigObject5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -19250,7 +20923,7 @@ var init_apply = __esm({
 });
 
 // packages/agent-mcp-config/src/index.ts
-var init_src15 = __esm({
+var init_src17 = __esm({
   "packages/agent-mcp-config/src/index.ts"() {
     "use strict";
     init_configs2();
@@ -19430,7 +21103,7 @@ var init_mcp2 = __esm({
     init_shared();
     init_mcp_output_format();
     init_command_not_found();
-    init_src15();
+    init_src17();
     init_execution_context();
     DEFAULT_MCP_AGENT = "claude-code";
   }
@@ -19438,7 +21111,7 @@ var init_mcp2 = __esm({
 
 // packages/agent-skill-config/src/configs.ts
 import os2 from "node:os";
-import path29 from "node:path";
+import path35 from "node:path";
 function resolveAgentSupport2(input, registry = agentSkillConfigs) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
@@ -19630,7 +21303,7 @@ var init_apply2 = __esm({
 });
 
 // packages/agent-skill-config/src/index.ts
-var init_src16 = __esm({
+var init_src18 = __esm({
   "packages/agent-skill-config/src/index.ts"() {
     "use strict";
     init_configs3();
@@ -19855,7 +21528,7 @@ var init_skill = __esm({
   "src/cli/commands/skill.ts"() {
     "use strict";
     init_src5();
-    init_src16();
+    init_src18();
     init_shared();
     init_command_not_found();
     DEFAULT_SKILL_AGENT = "claude-code";
@@ -20524,7 +22197,7 @@ var init_models2 = __esm({
 });
 
 // src/cli/commands/pipeline.ts
-import path30 from "node:path";
+import path36 from "node:path";
 import { readFile as readFile9, stat as stat9 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function resolvePipelinePlanDirectory(container) {
@@ -20572,11 +22245,11 @@ function resolveMaxRuns(value) {
   return parsed;
 }
 function resolvePipelinePaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path30.join(homeDir, ".poe-code", "pipeline") : path30.join(cwd, ".poe-code", "pipeline");
+  const rootPath = scope === "global" ? path36.join(homeDir, ".poe-code", "pipeline") : path36.join(cwd, ".poe-code", "pipeline");
   const displayRoot = scope === "global" ? "~/.poe-code/pipeline" : ".poe-code/pipeline";
   return {
-    plansPath: path30.join(rootPath, "plans"),
-    stepsPath: path30.join(rootPath, "steps.yaml"),
+    plansPath: path36.join(rootPath, "plans"),
+    stepsPath: path36.join(rootPath, "steps.yaml"),
     displayPlansPath: `${displayRoot}/plans`,
     displayStepsPath: `${displayRoot}/steps.yaml`
   };
@@ -20587,16 +22260,16 @@ async function loadPipelineTemplates() {
   }
   const packageRoot = await findPackageRoot(fileURLToPath4(import.meta.url));
   const templateRoots = [
-    path30.join(packageRoot, "src", "templates", "pipeline"),
-    path30.join(packageRoot, "dist", "templates", "pipeline")
+    path36.join(packageRoot, "src", "templates", "pipeline"),
+    path36.join(packageRoot, "dist", "templates", "pipeline")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk(templateRoot)) {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile9(path30.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile9(path30.join(templateRoot, "steps.yaml.hbs"), "utf8")
+      readFile9(path36.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile9(path36.join(templateRoot, "steps.yaml.hbs"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -20615,12 +22288,12 @@ async function pathExistsOnDisk(targetPath) {
   }
 }
 async function findPackageRoot(entryFilePath) {
-  let currentPath = path30.dirname(entryFilePath);
+  let currentPath = path36.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk(path30.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk(path36.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path30.dirname(currentPath);
+    const parentPath = path36.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Pipeline templates.");
     }
@@ -20911,7 +22584,7 @@ function registerPipelineCommand(program, container) {
           `Would ${stepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayStepsPath}`
         );
       } else {
-        await container.fs.mkdir(path30.dirname(pipelinePaths.stepsPath), {
+        await container.fs.mkdir(path36.dirname(pipelinePaths.stepsPath), {
           recursive: true
         });
         await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
@@ -20936,7 +22609,7 @@ var init_pipeline3 = __esm({
     "use strict";
     init_src5();
     init_src2();
-    init_src16();
+    init_src18();
     init_src4();
     init_config3();
     init_errors();
@@ -20950,7 +22623,7 @@ var init_pipeline3 = __esm({
 });
 
 // src/cli/commands/ralph.ts
-import path31 from "node:path";
+import path37 from "node:path";
 function formatDuration2(ms) {
   const totalSeconds = Math.round(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
@@ -20986,9 +22659,9 @@ function normalizeConfiguredIterations(value) {
 }
 function resolveAbsoluteDocPath4(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path31.join(container.env.homeDir, docPath.slice(2));
+    return path37.join(container.env.homeDir, docPath.slice(2));
   }
-  return path31.isAbsolute(docPath) ? docPath : path31.resolve(container.env.cwd, docPath);
+  return path37.isAbsolute(docPath) ? docPath : path37.resolve(container.env.cwd, docPath);
 }
 async function resolvePlanDirectory2(container) {
   const configDoc = await readMergedDocument(
@@ -21347,7 +23020,7 @@ var init_ralph3 = __esm({
     init_src5();
     init_src2();
     init_src6();
-    init_src9();
+    init_src11();
     init_src4();
     init_config3();
     init_errors();
@@ -21359,11 +23032,11 @@ var init_ralph3 = __esm({
 });
 
 // src/cli/commands/experiment.ts
-import path32 from "node:path";
+import path38 from "node:path";
 import { readFile as readFile10, stat as stat10 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path32.join(homeDir, ".poe-code", "experiments") : path32.join(cwd, ".poe-code", "experiments");
+  const rootPath = scope === "global" ? path38.join(homeDir, ".poe-code", "experiments") : path38.join(cwd, ".poe-code", "experiments");
   const displayRoot = scope === "global" ? "~/.poe-code/experiments" : ".poe-code/experiments";
   return {
     experimentsPath: rootPath,
@@ -21382,12 +23055,12 @@ async function pathExistsOnDisk2(targetPath) {
   }
 }
 async function findPackageRoot2(entryFilePath) {
-  let currentPath = path32.dirname(entryFilePath);
+  let currentPath = path38.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk2(path32.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk2(path38.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path32.dirname(currentPath);
+    const parentPath = path38.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Experiment templates.");
     }
@@ -21400,16 +23073,16 @@ async function loadExperimentTemplates() {
   }
   const packageRoot = await findPackageRoot2(fileURLToPath5(import.meta.url));
   const templateRoots = [
-    path32.join(packageRoot, "src", "templates", "experiment"),
-    path32.join(packageRoot, "dist", "templates", "experiment")
+    path38.join(packageRoot, "src", "templates", "experiment"),
+    path38.join(packageRoot, "dist", "templates", "experiment")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk2(templateRoot)) {
       continue;
     }
     const [skillPlan, runYaml] = await Promise.all([
-      readFile10(path32.join(templateRoot, "SKILL_experiment.md"), "utf8"),
-      readFile10(path32.join(templateRoot, "run.yaml.hbs"), "utf8")
+      readFile10(path38.join(templateRoot, "SKILL_experiment.md"), "utf8"),
+      readFile10(path38.join(templateRoot, "run.yaml.hbs"), "utf8")
     ]);
     experimentTemplatesCache = { skillPlan, runYaml };
     return experimentTemplatesCache;
@@ -21487,12 +23160,12 @@ function parseNonNegativeInt(value, fieldName) {
 }
 function resolveAbsoluteDocPath5(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path32.join(container.env.homeDir, docPath.slice(2));
+    return path38.join(container.env.homeDir, docPath.slice(2));
   }
-  return path32.isAbsolute(docPath) ? docPath : path32.resolve(container.env.cwd, docPath);
+  return path38.isAbsolute(docPath) ? docPath : path38.resolve(container.env.cwd, docPath);
 }
 async function discoverExperimentDocs(container) {
-  const directoryPath = path32.join(container.env.cwd, EXPERIMENTS_DIRECTORY);
+  const directoryPath = path38.join(container.env.cwd, EXPERIMENTS_DIRECTORY);
   let names;
   try {
     names = await container.fs.readdir(directoryPath);
@@ -21507,8 +23180,8 @@ async function discoverExperimentDocs(container) {
     if (!name.endsWith(".md")) {
       continue;
     }
-    const relativePath = path32.join(EXPERIMENTS_DIRECTORY, name);
-    const absolutePath = path32.join(directoryPath, name);
+    const relativePath = path38.join(EXPERIMENTS_DIRECTORY, name);
+    const absolutePath = path38.join(directoryPath, name);
     const stat11 = await container.fs.stat(absolutePath);
     if (!stat11.isFile()) {
       continue;
@@ -21872,8 +23545,8 @@ function registerExperimentCommand(program, container) {
           );
         }
       }
-      const runYamlPath = path32.join(experimentPaths.experimentsPath, "run.yaml");
-      const runYamlDisplayPath = path32.join(experimentPaths.displayExperimentsPath, "run.yaml");
+      const runYamlPath = path38.join(experimentPaths.experimentsPath, "run.yaml");
+      const runYamlDisplayPath = path38.join(experimentPaths.displayExperimentsPath, "run.yaml");
       if (!await pathExists4(container.fs, runYamlPath)) {
         if (flags.dryRun) {
           resources.logger.dryRun(`Would create: ${runYamlDisplayPath}`);
@@ -21898,25 +23571,446 @@ var init_experiment2 = __esm({
     init_src5();
     init_src2();
     init_src6();
-    init_src16();
-    init_src10();
+    init_src18();
+    init_src12();
     init_errors();
     init_shared();
     await init_experiment();
     DEFAULT_EXPERIMENT_AGENT = "claude-code";
     DEFAULT_EXPERIMENT_SCOPE = "local";
-    EXPERIMENTS_DIRECTORY = path32.join(".poe-code", "experiments");
+    EXPERIMENTS_DIRECTORY = path38.join(".poe-code", "experiments");
     experimentTemplatesCache = null;
   }
 });
 
+// src/cli/commands/launch.ts
+import { Option } from "commander";
+function registerLaunchCommand(program, container) {
+  const launch = program.command("launch").description("Manage long-running host and Docker processes.");
+  launch.command("start [id] [commandArgs...]").usage("<id> -- <command> [args...]").description("Start and supervise a managed process.").addOption(createChoiceOption("--restart <policy>", "Restart policy", ["never", "on-failure", "always"], "on-failure")).option("--max-restarts <n>", "Max consecutive restarts", "5").option("--ready-pattern <string>", "Log substring to wait for before reporting running").option("--ready-port <port>", "TCP port to probe for readiness").option("--cwd <dir>", "Working directory for the managed process").option("--env <entry>", "Environment variable (KEY=VALUE)", collectValues, []).option("--image <image>", "Docker image").option("--mount <src:target[:ro]>", "Docker bind mount", collectValues, []).option("--port <host:container>", "Docker port mapping", collectValues, []).option("--network <name>", "Docker network").addOption(createChoiceOption("--engine <engine>", "Container engine", ["docker", "podman"])).action(async function(id, commandArgs) {
+    const spec = await resolveStartSpec({
+      commandArgs,
+      id,
+      options: this.opts(),
+      program
+    });
+    if (spec === null) {
+      return;
+    }
+    await startLaunch({
+      cwd: container.env.cwd,
+      homeDir: container.env.homeDir,
+      spec
+    });
+  });
+  launch.command("stop <id>").description("Stop a managed process.").option("--force", "Stop immediately with SIGKILL / docker kill").action(async function(id) {
+    const result = await stopLaunch({
+      force: Boolean(this.opts().force),
+      homeDir: container.env.homeDir,
+      id
+    });
+    if (result === null) {
+      throw new ValidationError(`Managed process not found: ${id}`);
+    }
+  });
+  launch.command("restart <id>").description("Restart a managed process.").action(async function(id) {
+    await restartLaunch({ homeDir: container.env.homeDir, id });
+  });
+  launch.command("status").description("List managed processes.").action(async function() {
+    const records = await listLaunches({ homeDir: container.env.homeDir });
+    const flags = resolveCommandFlags(program);
+    const resources = createExecutionResources(container, flags, "launch:status");
+    if (records.length === 0) {
+      resources.logger.info("No managed processes.");
+      return;
+    }
+    resources.logger.info(renderTable({
+      columns: [
+        { name: "ID", title: "ID", alignment: "left", maxLen: 24 },
+        { name: "RUNTIME", title: "RUNTIME", alignment: "left", maxLen: 8 },
+        { name: "STATUS", title: "STATUS", alignment: "left", maxLen: 12 },
+        { name: "PID", title: "PID", alignment: "right", maxLen: 8 },
+        { name: "RESTARTS", title: "RESTARTS", alignment: "right", maxLen: 10 },
+        { name: "UPTIME", title: "UPTIME", alignment: "right", maxLen: 12 },
+        { name: "LAST EXIT", title: "LAST EXIT", alignment: "right", maxLen: 10 }
+      ],
+      rows: records.map(formatStatusRow),
+      theme: getTheme()
+    }));
+  });
+  launch.command("logs <id>").description("Show managed process logs.").option("--follow", "Follow log output").option("--lines <n>", "Number of lines to show", "50").option("--stderr", "Show stderr instead of stdout").action(async function(id) {
+    const options = this.opts();
+    const lines = parseNonNegativeInt2(options.lines, "lines") ?? 50;
+    const stream = options.stderr ? "stderr" : "stdout";
+    const flags = resolveCommandFlags(program);
+    const resources = createExecutionResources(container, flags, `launch:logs:${id}`);
+    const initial = await readLaunchLogs({
+      homeDir: container.env.homeDir,
+      id,
+      lines,
+      stream
+    });
+    if (initial.length > 0) {
+      resources.logger.info(initial.join("\n"));
+    }
+    if (!options.follow) {
+      return;
+    }
+    const controller = new AbortController();
+    const stop = () => {
+      controller.abort();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+      for await (const line of followLaunchLogs({
+        homeDir: container.env.homeDir,
+        id,
+        lines,
+        signal: controller.signal,
+        stream
+      })) {
+        resources.logger.info(line);
+      }
+    } finally {
+      process.removeListener("SIGINT", stop);
+      process.removeListener("SIGTERM", stop);
+    }
+  });
+  launch.command("rm <id>").description("Remove managed process state and logs.").action(async function(id) {
+    await removeLaunch({ homeDir: container.env.homeDir, id });
+  });
+  launch.command("__run <id>", { hidden: true }).action(async function(id) {
+    await runLaunchDaemon({ homeDir: container.env.homeDir, id });
+  });
+  return launch;
+}
+async function resolveStartSpec(options) {
+  const flags = resolveCommandFlags(options.program);
+  const id = await resolveProcessId(options.id);
+  if (id === null) {
+    return null;
+  }
+  const commandParts = await resolveCommandParts(options.commandArgs);
+  if (commandParts === null) {
+    return null;
+  }
+  if (commandParts.length === 0) {
+    throw new ValidationError("Command to run is required.");
+  }
+  const runtime = await resolveRuntime({
+    assumeYes: flags.assumeYes,
+    hasCommand: commandParts.length > 0,
+    image: options.options.image
+  });
+  if (runtime === null) {
+    return null;
+  }
+  const restart = await resolveRestart(options.options.restart, flags.assumeYes);
+  if (restart === null) {
+    return null;
+  }
+  const spec = {
+    args: commandParts.slice(1),
+    command: commandParts[0],
+    id,
+    restart
+  };
+  const maxRestarts = parseNonNegativeInt2(options.options.maxRestarts, "max-restarts");
+  if (maxRestarts !== void 0) {
+    spec.maxRestarts = maxRestarts;
+  }
+  if (options.options.cwd) {
+    spec.cwd = options.options.cwd;
+  }
+  const envEntries = options.options.env ?? [];
+  if (envEntries.length > 0) {
+    spec.env = parseEnvEntries(envEntries);
+  }
+  const readyCheck = resolveReadyCheck2(options.options);
+  if (readyCheck) {
+    spec.readyCheck = readyCheck;
+  }
+  if (runtime === "docker") {
+    const image = await resolveDockerImage(options.options.image);
+    if (image === null) {
+      return null;
+    }
+    spec.docker = {
+      image,
+      ...options.options.engine ? { engine: options.options.engine } : {},
+      ...options.options.mount?.length ? { mounts: options.options.mount.map(parseMount) } : {},
+      ...options.options.port?.length ? { ports: options.options.port.map(parsePort) } : {},
+      ...options.options.network ? { network: options.options.network } : {}
+    };
+  }
+  return spec;
+}
+async function resolveProcessId(value) {
+  if (value && value.trim().length > 0) {
+    return value.trim();
+  }
+  const entered = await text3({
+    message: "Process ID"
+  });
+  if (isCancel2(entered)) {
+    cancel2("Launch start cancelled.");
+    return null;
+  }
+  const id = typeof entered === "string" ? entered.trim() : "";
+  if (id.length === 0) {
+    throw new ValidationError("Process ID is required.");
+  }
+  return id;
+}
+async function resolveCommandParts(commandArgs) {
+  if (commandArgs.length > 0) {
+    return [...commandArgs];
+  }
+  const entered = await text3({
+    message: "Command to run"
+  });
+  if (isCancel2(entered)) {
+    cancel2("Launch start cancelled.");
+    return null;
+  }
+  const value = typeof entered === "string" ? entered.trim() : "";
+  if (value.length === 0) {
+    throw new ValidationError("Command to run is required.");
+  }
+  return splitCommandLine(value);
+}
+async function resolveRuntime(options) {
+  if (options.image) {
+    return "docker";
+  }
+  if (options.hasCommand || options.assumeYes) {
+    return "host";
+  }
+  const selected = await select2({
+    message: "Runtime",
+    options: [
+      { label: "host", value: "host" },
+      { label: "docker", value: "docker" }
+    ]
+  });
+  if (isCancel2(selected)) {
+    cancel2("Launch start cancelled.");
+    return null;
+  }
+  return selected;
+}
+async function resolveDockerImage(value) {
+  if (value && value.trim().length > 0) {
+    return value.trim();
+  }
+  const entered = await text3({
+    message: "Docker image"
+  });
+  if (isCancel2(entered)) {
+    cancel2("Launch start cancelled.");
+    return null;
+  }
+  const image = typeof entered === "string" ? entered.trim() : "";
+  if (image.length === 0) {
+    throw new ValidationError("Docker image is required when runtime is docker.");
+  }
+  return image;
+}
+async function resolveRestart(restart, assumeYes) {
+  if (restart) {
+    return restart;
+  }
+  if (assumeYes) {
+    return "on-failure";
+  }
+  const selected = await select2({
+    message: "Restart policy",
+    options: [
+      { label: "on-failure", value: "on-failure" },
+      { label: "never", value: "never" },
+      { label: "always", value: "always" }
+    ]
+  });
+  if (isCancel2(selected)) {
+    cancel2("Launch start cancelled.");
+    return null;
+  }
+  return selected;
+}
+function resolveReadyCheck2(options) {
+  if (options.readyPattern && options.readyPattern.trim().length > 0) {
+    return { kind: "log-pattern", pattern: options.readyPattern.trim() };
+  }
+  const readyPort = parsePositiveInt2(options.readyPort, "ready-port");
+  if (readyPort !== void 0) {
+    return { kind: "tcp", port: readyPort };
+  }
+  return void 0;
+}
+function parseEnvEntries(entries) {
+  const env = {};
+  for (const entry of entries) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) {
+      throw new ValidationError(`Invalid --env value "${entry}". Expected KEY=VALUE.`);
+    }
+    const key = entry.slice(0, separator).trim();
+    const value = entry.slice(separator + 1);
+    if (key.length === 0) {
+      throw new ValidationError(`Invalid --env value "${entry}". Expected KEY=VALUE.`);
+    }
+    env[key] = value;
+  }
+  return env;
+}
+function parseMount(value) {
+  const parts = value.split(":");
+  if (parts.length < 2 || parts.length > 3) {
+    throw new ValidationError(`Invalid --mount value "${value}". Expected src:target[:ro].`);
+  }
+  const mount = {
+    source: parts[0],
+    target: parts[1]
+  };
+  if (parts[2] === "ro") {
+    mount.readonly = true;
+  } else if (parts[2] !== void 0) {
+    throw new ValidationError(`Invalid --mount value "${value}". Only :ro is supported.`);
+  }
+  return mount;
+}
+function parsePort(value) {
+  const parts = value.split(":");
+  if (parts.length !== 2) {
+    throw new ValidationError(`Invalid --port value "${value}". Expected host:container.`);
+  }
+  return {
+    container: parseRequiredPositiveInt(parts[1], "port"),
+    host: parseRequiredPositiveInt(parts[0], "port")
+  };
+}
+function splitCommandLine(value) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (const char of value) {
+    if (quote !== null) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === " " || char === "	") {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote !== null) {
+    throw new ValidationError("Command contains an unterminated quote.");
+  }
+  if (current.length > 0) {
+    parts.push(current);
+  }
+  return parts;
+}
+function formatStatusRow(record) {
+  const state = record.state;
+  const id = record.spec?.id ?? state?.id ?? "-";
+  return {
+    ID: id,
+    "LAST EXIT": state?.lastExitCode == null ? "-" : String(state.lastExitCode),
+    PID: state?.pid == null ? "-" : String(state.pid),
+    RESTARTS: state ? String(state.restartCount) : "0",
+    RUNTIME: state?.runtime ?? (record.spec?.docker ? "docker" : "host"),
+    STATUS: state?.status ?? "stopped",
+    UPTIME: formatUptime(state)
+  };
+}
+function formatUptime(state) {
+  if (!state || state.status !== "running" && state.status !== "restarting" || !state.lastStartedAt) {
+    return "-";
+  }
+  const startedAt = Date.parse(state.lastStartedAt);
+  if (!Number.isFinite(startedAt)) {
+    return "-";
+  }
+  const totalSeconds = Math.max(0, Math.floor((Date.now() - startedAt) / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function createChoiceOption(flags, description, choices, defaultValue) {
+  const option = new Option(flags, description).choices(choices);
+  if (defaultValue !== void 0) {
+    option.default(defaultValue);
+  }
+  return option;
+}
+function parsePositiveInt2(value, fieldName) {
+  if (value == null) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new ValidationError(`Invalid ${fieldName} "${value}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function parseRequiredPositiveInt(value, fieldName) {
+  const parsed = parsePositiveInt2(value, fieldName);
+  if (parsed === void 0) {
+    throw new ValidationError(`Invalid ${fieldName} "${value}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function parseNonNegativeInt2(value, fieldName) {
+  if (value == null) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new ValidationError(`Invalid ${fieldName} "${value}". Expected a non-negative integer.`);
+  }
+  return parsed;
+}
+function collectValues(value, previous) {
+  return [...previous, value];
+}
+var init_launch2 = __esm({
+  "src/cli/commands/launch.ts"() {
+    "use strict";
+    init_src5();
+    init_shared();
+    init_errors();
+    init_launch();
+  }
+});
+
 // package.json
 var package_default;
 var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.121",
+      version: "3.0.123",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -22031,7 +24125,9 @@ var init_package = __esm({
         typescript: "^5.9.3",
         "typescript-eslint": "^8.54.0",
         vitest: "^4.0.18",
-        "@poe-code/experiment-loop": "*"
+        "@poe-code/experiment-loop": "*",
+        "@poe-code/process-launcher": "*",
+        "@poe-code/process-runner": "*"
       },
       repository: {
         type: "git",
@@ -22047,7 +24143,7 @@ __export(program_exports, {
   createProgram: () => createProgram
 });
 import { basename as basename3 } from "node:path";
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 function formatCommandHeader(cmd) {
   const parts = [];
   let current = cmd;
@@ -22069,7 +24165,7 @@ function formatHelpText(input) {
       name: "install",
       aliases: ["i"],
       args: "[agent]",
-      description: "Install tooling for a configured agent"
+      description: "Install agent binary for a configured agent"
     },
     {
       name: "configure",
@@ -22099,7 +24195,7 @@ function formatHelpText(input) {
       name: "auth status",
       aliases: [],
       args: "",
-      description: "Show login, balance, and configuration status"
+      description: "Show login status"
     },
     {
       name: "agent",
@@ -22144,10 +24240,10 @@ function formatHelpText(input) {
       description: "Remove Poe MCP configuration from your agent"
     },
     {
-      name: "mcp serve",
+      name: "experiment install",
       aliases: [],
-      args: "",
-      description: "Run the Poe MCP server on stdin/stdout"
+      args: "[agent]",
+      description: "Install the experiment skill into agent configuration"
     },
     {
       name: "skill configure",
@@ -22197,6 +24293,12 @@ function formatHelpText(input) {
       args: "[doc]",
       description: "Display an experiment journal as a formatted table"
     },
+    {
+      name: "launch",
+      aliases: [],
+      args: "",
+      description: "Manage long-running host and Docker processes"
+    },
     {
       name: "usage",
       aliases: ["u"],
@@ -22214,24 +24316,6 @@ function formatHelpText(input) {
       aliases: [],
       args: "",
       description: "Show config file paths and usage hints"
-    },
-    {
-      name: "utils config show",
-      aliases: [],
-      args: "",
-      description: "Show config inputs and resolved result"
-    },
-    {
-      name: "utils config init",
-      aliases: [],
-      args: "",
-      description: "Create a project config file"
-    },
-    {
-      name: "utils config edit",
-      aliases: [],
-      args: "",
-      description: "Open a config file in your editor"
     }
   ];
   const nameWidth = Math.max(
@@ -22335,7 +24419,7 @@ function createProgram(dependencies) {
   return program;
 }
 function bootstrapProgram(container) {
-  const program = new Command2();
+  const program = new Command3();
   const executionContext = detectExecutionContext({
     argv: process.argv,
     env: container.env.variables,
@@ -22371,6 +24455,7 @@ function bootstrapProgram(container) {
   registerPipelineCommand(program, container);
   registerRalphCommand(program, container);
   registerExperimentCommand(program, container);
+  registerLaunchCommand(program, container);
   registerUsageCommand(program, container);
   registerModelsCommand(program, container);
   program.allowExcessArguments().action(function() {
@@ -22431,6 +24516,7 @@ var init_program = __esm({
     await init_pipeline3();
     await init_ralph3();
     await init_experiment2();
+    init_launch2();
     init_package();
     init_command_not_found();
     init_execution_context();
@@ -22522,7 +24608,7 @@ __export(bootstrap_exports, {
   createCliMain: () => createCliMain,
   isCliInvocation: () => isCliInvocation
 });
-import * as nodeFs from "node:fs/promises";
+import * as nodeFs4 from "node:fs/promises";
 import * as nodeFsSync3 from "node:fs";
 import { realpathSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
@@ -22597,18 +24683,23 @@ var init_bootstrap = __esm({
     init_error_logger();
     init_errors();
     init_prompt_runner();
-    fsAdapter = nodeFs;
+    fsAdapter = nodeFs4;
   }
 });
 
 // src/index.ts
 await init_spawn3();
 await init_pipeline2();
-await init_ralph2();
-await init_experiment();
 import { realpathSync as realpathSync2 } from "node:fs";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
+// src/sdk/process-launcher.ts
+init_src10();
+
+// src/index.ts
+await init_ralph2();
+await init_experiment();
+
 // src/sdk/generate.ts
 init_constants();
 init_credentials();
@@ -22708,13 +24799,14 @@ function normalizeBaseUrl(value) {
 
 // src/index.ts
 init_credentials();
+init_launch();
 
 // src/cli/poe-agent-main.ts
 init_src6();
 init_src5();
 init_constants();
 init_errors();
-import path23 from "node:path";
+import path29 from "node:path";
 import { Command } from "commander";
 function parseMcpSpawnConfig(input) {
   if (!input) {
@@ -22785,10 +24877,10 @@ function resolveWorkingDirectory(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path23.isAbsolute(candidate)) {
+  if (path29.isAbsolute(candidate)) {
     return candidate;
   }
-  return path23.resolve(baseDir, candidate);
+  return path29.resolve(baseDir, candidate);
 }
 function createPoeAgentProgram() {
   const program = new Command();
@@ -22882,18 +24974,30 @@ if (isCliInvocation2(process.argv, import.meta.url)) {
   void main();
 }
 export {
+  createLogWriter,
+  createStateStore,
+  createSupervisor,
+  followLaunchLogs,
   generate,
   generateAudio,
   generateImage,
   generateVideo,
   getPoeApiKey,
   isCliInvocation2 as isCliInvocation,
+  listLaunches,
   main,
   poeAgentMain,
   readExperimentJournal,
+  readLaunchLogs,
+  removeLaunch,
+  restartLaunch,
   runExperiment,
+  runLaunchDaemon,
   runPipeline2 as runPipeline,
   runRalph2 as runRalph,
-  spawn4 as spawn
+  spawn4 as spawn,
+  startLaunch,
+  stopLaunch,
+  waitForReady
 };
 //# sourceMappingURL=index.js.map