poe-code 3.0.214 → 3.0.216

package/packages/memory/dist/index.js

@@ -611,11 +611,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path42) {
+function mergeObjectLayers(layers, path45) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path42);
+    const resolved = resolveKey(layers, key, path45);
     if (resolved === void 0) {
       continue;
     }
@@ -633,7 +633,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path42) {
+function resolveKey(layers, key, path45) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -663,9 +663,9 @@ function resolveKey(layers, key, path42) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path42, key);
+  const fullPath = buildPath(path45, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path42, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path45, key]);
     return {
       value: merged.data,
       sources: {
@@ -690,8 +690,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path42, key) {
-  return [...path42, key].join(".");
+function buildPath(path45, key) {
+  return [...path45, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1325,16 +1325,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path42) {
-  const ext = getExtension(path42);
+function detectFormat2(path45) {
+  const ext = getExtension(path45);
   return extensionMap[ext];
 }
-function getExtension(path42) {
-  const lastDot = path42.lastIndexOf(".");
+function getExtension(path45) {
+  const lastDot = path45.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path42.slice(lastDot).toLowerCase();
+  return path45.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -2204,7 +2204,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path42 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path45 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key of keys) {
@@ -2216,20 +2216,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path42 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path42, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path45, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord3(baseValue) && isRecord3(overrideValue)) {
-      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path42, key]);
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path45, key]);
       continue;
     }
     merged[key] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path42) {
-  return path42.join(".") === "mounts" || path42.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path45) {
+  return path45.join(".") === "mounts" || path45.join(".") === "runner.workspace.exclude";
 }
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -2350,8 +2350,8 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path42, flags) => fsPromises.open(path42, flags),
-    readFile: (path42, encoding) => fsPromises.readFile(path42, encoding),
+    open: (path45, flags) => fsPromises.open(path45, flags),
+    readFile: (path45, encoding) => fsPromises.readFile(path45, encoding),
     stat: fsPromises.stat,
     unlink: fsPromises.unlink
   };
@@ -2977,10 +2977,10 @@ function parseSources(value) {
     if (!isRecord6(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path42 = readRequiredString(item.path, "sources[].path");
+    const path45 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path42, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path45, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -4036,7 +4036,7 @@ function parseOlderThan(value) {
 
 // packages/memory/src/ingest.ts
 import * as fs11 from "node:fs/promises";
-import path35 from "node:path";
+import path38 from "node:path";
 
 // packages/agent-spawn/src/register-factories.ts
 import { spawn as spawnChildProcess2 } from "node:child_process";
@@ -4044,1533 +4044,1676 @@ import { spawn as spawnChildProcess2 } from "node:child_process";
 // packages/agent-harness-tools/src/paths.ts
 import path22 from "node:path";
 
-// packages/agent-defs/src/agents/claude-code.ts
-var claudeCodeAgent = {
-  id: "claude-code",
-  name: "claude-code",
-  label: "Claude Code",
-  summary: "Configure Claude Code to route through Poe.",
-  aliases: ["claude"],
-  binaryName: "claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#C15F3C",
-      light: "#C15F3C"
-    }
-  }
-};
+// packages/agent-harness-tools/src/plans.ts
+import * as fsPromises4 from "node:fs/promises";
+import path27 from "node:path";
 
-// packages/agent-defs/src/agents/claude-desktop.ts
-var claudeDesktopAgent = {
-  id: "claude-desktop",
-  name: "claude-desktop",
-  label: "Claude Desktop",
-  summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#D97757",
-      light: "#D97757"
-    }
-  }
-};
+// packages/task-list/src/open.ts
+import * as fsPromises3 from "node:fs/promises";
 
-// packages/agent-defs/src/agents/codex.ts
-var codexAgent = {
-  id: "codex",
-  name: "codex",
-  label: "Codex",
-  summary: "Configure Codex to use Poe as the model provider.",
-  binaryName: "codex",
-  configPath: "~/.codex/config.toml",
-  branding: {
-    colors: {
-      dark: "#D5D9DF",
-      light: "#7A7F86"
-    }
+// packages/task-list/src/state-machine.ts
+function canFireFromState(event, fromState) {
+  if (event.from === "*") {
+    return event.to !== fromState;
   }
-};
-
-// packages/agent-defs/src/agents/opencode.ts
-var openCodeAgent = {
-  id: "opencode",
-  name: "opencode",
-  label: "OpenCode CLI",
-  summary: "Configure OpenCode CLI to use the Poe API.",
-  binaryName: "opencode",
-  configPath: "~/.config/opencode/config.json",
-  branding: {
-    colors: {
-      dark: "#4A4F55",
-      light: "#2F3338"
-    }
+  return event.from.includes(fromState);
+}
+function findEvent(machine, fromState, eventName) {
+  const event = machine.events[eventName];
+  if (event === void 0) {
+    return void 0;
   }
-};
+  return canFireFromState(event, fromState) ? event : void 0;
+}
 
-// packages/agent-defs/src/agents/kimi.ts
-var kimiAgent = {
-  id: "kimi",
-  name: "kimi",
-  label: "Kimi",
-  summary: "Configure Kimi CLI to use Poe API",
-  aliases: ["kimi-cli"],
-  binaryName: "kimi",
-  configPath: "~/.kimi/config.toml",
-  branding: {
-    colors: {
-      dark: "#7B68EE",
-      light: "#6A5ACD"
-    }
-  }
-};
+// packages/task-list/src/backends/gh-issues-client.ts
+import { text } from "node:stream/consumers";
 
-// packages/agent-defs/src/agents/goose.ts
-var gooseAgent = {
-  id: "goose",
-  name: "goose",
-  label: "Goose",
-  summary: "Block's open-source AI agent with ACP support.",
-  binaryName: "goose",
-  configPath: "~/.config/goose/config.yaml",
-  branding: {
-    colors: {
-      dark: "#FF6B35",
-      light: "#E85D26"
+// 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;
   }
-};
-
-// packages/agent-defs/src/agents/poe-agent.ts
-var poeAgentAgent = {
-  id: "poe-agent",
-  name: "poe-agent",
-  label: "Poe Agent",
-  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
-  configPath: "~/.poe-code/config.json",
-  branding: {
-    colors: {
-      dark: "#A465F7",
-      light: "#7A3FD3"
-    }
+  return null;
+}
+function buildContextArgs(engine, context) {
+  if (engine === "docker" && context) {
+    return ["--context", context];
   }
-};
+  return [];
+}
 
-// packages/agent-defs/src/registry.ts
-var allAgents = [
-  claudeCodeAgent,
-  claudeDesktopAgent,
-  codexAgent,
-  openCodeAgent,
-  kimiAgent,
-  gooseAgent,
-  poeAgentAgent
-];
-var lookup = /* @__PURE__ */ new Map();
-for (const agent of allAgents) {
-  const values = [agent.id, agent.name, ...agent.aliases ?? []];
-  for (const value of values) {
-    const normalized = value.toLowerCase();
-    if (!lookup.has(normalized)) {
-      lookup.set(normalized, agent.id);
-    }
+// 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 resolveAgentId(input) {
-  if (!input) {
-    return void 0;
+function isEngineAvailable(engine) {
+  try {
+    execSync2(`${engine} --version`, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
   }
-  return lookup.get(input.toLowerCase());
 }
 
-// packages/agent-harness-tools/src/select-agent.ts
-var loopAgents = allAgents.filter(
-  (agent) => agent.binaryName !== void 0 || agent.id === "poe-agent"
-);
-var supportedAgents = loopAgents.map((agent) => agent.id).join(", ");
+// packages/process-runner/src/docker/docker-runner.ts
+import * as childProcess from "node:child_process";
+import { randomBytes } from "node:crypto";
 
-// packages/agent-harness-tools/src/run-logs.ts
+// packages/process-runner/src/docker/args.ts
 import path23 from "node:path";
-
-// packages/agent-harness-tools/src/log-stream.ts
-import nodeFs2 from "node:fs";
-var JOB_DIR = "/tmp/poe-jobs";
-var POLL_INTERVAL_MS = 250;
-function wrapForLogTee(argv, jobId) {
-  if (argv.length === 0) {
-    throw new Error("wrapForLogTee requires argv to contain at least one argument");
+function buildDockerRunArgs(input) {
+  const args = [input.engine];
+  if (input.engine === "docker" && input.context) {
+    args.push("--context", input.context);
   }
-  const command = argv.map(shellQuote).join(" ");
-  const logFile = shellQuote(jobLogPath(jobId));
-  const exitFile = shellQuote(jobExitPath(jobId));
-  const exitTmpFile = shellQuote(`${jobExitPath(jobId)}.tmp`);
-  const script = [
-    `mkdir -p ${shellQuote(JOB_DIR)}`,
-    `({ (${command}); echo $? > ${exitTmpFile}; } 2>&1 | tee ${logFile}; mv ${exitTmpFile} ${exitFile})`
-  ].join(" && ");
-  return ["sh", "-c", script];
-}
-async function* streamLogFile(env, jobId, opts) {
-  const fs14 = env.fs ?? nodeFs2;
-  const file = jobLogPath(jobId);
-  let byteOffset = opts.sinceByte ?? 0;
-  while (true) {
-    if (opts.since !== void 0 && !await wasModifiedSince(fs14, file, opts.since)) {
-      await waitForLogChange(fs14, file);
-      continue;
-    }
-    const result = await readLogChunk(fs14, file, byteOffset);
-    if (result !== null) {
-      byteOffset = result.nextByteOffset;
-      yield result.chunk;
-      continue;
-    }
-    await waitForLogChange(fs14, file);
+  args.push("run");
+  if (input.rm) {
+    args.push("--rm");
   }
-}
-async function wasModifiedSince(fs14, file, since) {
-  if (fs14.promises.stat === void 0) {
-    return true;
+  if (input.detached) {
+    args.push("-d");
   }
-  try {
-    const stat7 = await fs14.promises.stat(file);
-    return stat7.mtimeMs >= since.getTime();
-  } catch (error2) {
-    if (isNodeError(error2) && error2.code === "ENOENT") {
-      return false;
-    }
-    throw error2;
+  if (input.interactive) {
+    args.push("-i");
   }
-}
-async function waitForExit(env, jobId, opts = {}) {
-  const fs14 = env.fs ?? nodeFs2;
-  const file = jobExitPath(jobId);
-  while (true) {
-    throwIfAborted2(opts.signal);
-    const contents = await readTextFileIfExists(fs14, file);
-    if (contents !== null) {
-      const text4 = contents.trim();
-      const exitCode = Number(text4);
-      if (text4.length === 0 || !Number.isInteger(exitCode)) {
-        throw new Error(`Invalid exit code in ${file}: ${contents}`);
-      }
-      return { exitCode };
-    }
-    await sleep3(POLL_INTERVAL_MS, opts.signal);
+  if (input.tty) {
+    args.push("-t");
   }
-}
-function jobLogPath(jobId) {
-  return `${JOB_DIR}/${jobId}.log`;
-}
-function jobExitPath(jobId) {
-  return `${JOB_DIR}/${jobId}.exit`;
-}
-async function readLogChunk(fs14, file, byteOffset) {
-  const contents = await readFileIfExists2(fs14, file);
-  if (contents === null || byteOffset >= contents.byteLength) {
-    return null;
+  args.push("--name", input.containerName);
+  if (input.cwd !== void 0) {
+    args.push("-w", input.cwd);
   }
-  return {
-    chunk: {
-      byteOffset,
-      data: contents.subarray(byteOffset).toString("utf8")
-    },
-    nextByteOffset: contents.byteLength
-  };
-}
-async function readTextFileIfExists(fs14, file) {
-  const contents = await readFileIfExists2(fs14, file);
-  return contents?.toString("utf8") ?? null;
-}
-async function readFileIfExists2(fs14, file) {
-  try {
-    const contents = await fs14.promises.readFile(file);
-    return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
-  } catch (error2) {
-    if (isNodeError(error2) && error2.code === "ENOENT") {
-      return null;
-    }
-    throw error2;
+  for (const [key, value] of Object.entries(input.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
   }
-}
-async function waitForLogChange(fs14, file) {
-  const watch = fs14.watch;
-  if (typeof watch !== "function") {
-    await sleep3(POLL_INTERVAL_MS);
-    return;
+  for (const mount of input.mounts) {
+    const volume = `${path23.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    args.push("-v", volume);
   }
-  await new Promise((resolve2) => {
-    let watcher = null;
-    const timer = setTimeout(done, POLL_INTERVAL_MS);
-    function done() {
-      clearTimeout(timer);
-      watcher?.close();
-      resolve2();
-    }
-    try {
-      watcher = watch(file, done);
-    } catch {
-      done();
-    }
-  });
-}
-function sleep3(ms, signal) {
-  return new Promise((resolve2, reject) => {
-    let timer = null;
-    const abort = () => {
-      if (timer !== null) {
-        clearTimeout(timer);
-      }
-      reject(new Error("waitForExit aborted."));
-    };
-    if (signal?.aborted) {
-      abort();
-      return;
-    }
-    timer = setTimeout(() => {
-      signal?.removeEventListener("abort", abort);
-      resolve2();
-    }, ms);
-    signal?.addEventListener("abort", abort, { once: true });
-  });
-}
-function throwIfAborted2(signal) {
-  if (signal?.aborted) {
-    throw new Error("waitForExit aborted.");
+  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);
   }
-}
-function shellQuote(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function isNodeError(error2) {
-  return error2 instanceof Error && "code" in error2;
+  if (input.network !== void 0) {
+    args.push("--network", input.network);
+  }
+  args.push(...input.extraArgs, input.image, input.command, ...input.args);
+  return args;
 }
 
-// packages/agent-harness-tools/src/run-poe-command.ts
-import { randomBytes } from "node:crypto";
+// packages/process-runner/src/docker/docker-execution-env.ts
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path24 from "node:path";
 
-// packages/agent-harness-tools/src/binary-exists.ts
-function createBinaryExistsDetectors(binaryName) {
-  const commonPaths = [
-    `/usr/local/bin/${binaryName}`,
-    `/usr/bin/${binaryName}`,
-    `$HOME/.local/bin/${binaryName}`,
-    `$HOME/.claude/local/bin/${binaryName}`
-  ];
-  return [
-    {
-      command: "which",
-      args: [binaryName],
-      validate: (result) => result.exitCode === 0
-    },
-    {
-      command: "where",
-      args: [binaryName],
-      validate: (result) => result.exitCode === 0 && result.stdout.trim().length > 0
-    },
-    {
-      command: "sh",
-      args: ["-c", commonPaths.map((p) => `test -f "${p}"`).join(" || ")],
-      validate: (result) => result.exitCode === 0
+// packages/process-runner/src/host/host-runner.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+function createHostRunner(options = {}) {
+  const detached = options.detached === true;
+  return {
+    name: "host",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" ? "inherit" : [stdinMode, stdoutMode, stderrMode];
+      const child = spawnChildProcess(spec.command, spec.args ?? [], {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio,
+        ...detached ? { detached: true } : {}
+      });
+      if (detached) {
+        child.unref();
+      }
+      const kill = (signal) => {
+        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+          process.kill(-child.pid, signal);
+          return;
+        }
+        child.kill(signal);
+      };
+      let settled = false;
+      let resolveResult = null;
+      const result = new Promise((resolve2) => {
+        resolveResult = resolve2;
+      });
+      const cleanupAbort = bindAbortSignal(spec.signal, () => {
+        kill("SIGTERM");
+      });
+      child.once("close", (code) => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: code ?? 1 });
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: 1 });
+      });
+      return {
+        pid: child.pid ?? null,
+        stdin: child.stdin,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        result,
+        kill
+      };
     }
-  ];
+  };
+}
+function bindAbortSignal(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
 }
 
-// packages/agent-harness-tools/src/run-poe-command.ts
-var ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-async function runPoeCommand(opts) {
-  const jobId = createUlid();
-  const execution = opts.openSpec.execution;
-  const wrapCommand = execution?.wrapForLogTee !== false;
-  const pendingJob = opts.state.jobs.put({
-    id: jobId,
-    env_id: "",
-    env_kind: opts.factory.type,
-    tool: opts.openSpec.jobLabel.tool,
-    argv: opts.openSpec.jobLabel.argv,
-    cwd: opts.openSpec.cwd,
-    started_at: "",
-    status: "pending"
-  });
-  const opened = opts.factory.open(opts.openSpec);
-  const env = isPromiseLike(opened) ? await opened : opened;
-  let shouldClose = true;
-  try {
-    const upload = env.uploadWorkspace();
-    await Promise.all([pendingJob, upload]);
-    await configureE2bSpawnAgentIfAvailable({
-      env,
-      openSpec: opts.openSpec,
-      factoryType: opts.factory.type
-    });
-    const argv = wrapCommand ? wrapForLogTee(opts.openSpec.jobLabel.argv, jobId) : opts.openSpec.jobLabel.argv;
-    const handle = execution?.tty ? env.shell() : env.exec({
-      command: argv[0],
-      args: argv.slice(1),
-      cwd: opts.openSpec.cwd,
-      env: resolveExecutionEnv(opts.openSpec),
-      stdin: execution?.stdin ?? "inherit",
-      stdout: execution?.stdout ?? "pipe",
-      stderr: execution?.stderr ?? "pipe",
-      signal: opts.signal
+// packages/process-runner/src/docker/docker-execution-env.ts
+var containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
+var dockerExecutionEnvFactory = {
+  type: "docker",
+  supportsDetach: true,
+  async open(spec) {
+    const runtime = parseDockerRuntime(spec.runtime);
+    const runner = spec.hostRunner ?? createHostRunner();
+    const engine = runtime.engine ?? detectEngine();
+    const context = detectContext();
+    const image = await resolveImage({
+      spec,
+      runtime,
+      runner,
+      engine,
+      context
     });
-    if (execution?.input !== void 0) {
-      handle.stdin?.setDefaultEncoding("utf8");
-      handle.stdin?.end(execution.input);
-    }
-    const runningJob = opts.state.jobs.update(jobId, {
-      status: "running",
-      env_id: env.id,
-      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    const containerName = createContainerName();
+    const runArgs = buildDockerRunArgs({
+      engine,
+      context,
+      image,
+      command: containerCommand[0],
+      args: containerCommand.slice(1),
+      cwd: void 0,
+      env: void 0,
+      mounts: runtime.mounts ?? [],
+      ports: [],
+      network: runtime.network,
+      containerName,
+      detached: true,
+      interactive: true,
+      tty: false,
+      rm: false,
+      extraArgs: runtime.extra_args ?? []
     });
-    if (opts.detach) {
-      await runningJob;
-      setDetachedJobContext(env, {
-        id: jobId,
-        tool: opts.openSpec.jobLabel.tool,
-        argv: opts.openSpec.jobLabel.argv
-      });
-      await env.detach();
-      shouldClose = false;
-      return { kind: "detached", jobId, envId: env.id };
-    }
-    const result = await runSync({
-      env,
-      handle,
-      jobId,
-      openSpec: opts.openSpec,
-      signal: opts.signal,
-      wrapCommand
+    const [command, ...args] = runArgs;
+    const id = (await runAndRead(runner, { command, args, stdout: "pipe", stderr: "pipe" })).trim();
+    return createDockerEnv({
+      id,
+      spec,
+      runner,
+      engine,
+      context
     });
-    await runningJob;
-    shouldClose = false;
-    await opts.state.jobs.update(jobId, {
-      status: "exited",
-      exit_code: result.exitCode,
-      exited_at: (/* @__PURE__ */ new Date()).toISOString()
+  },
+  async attach(envId, context) {
+    const engine = detectEngine();
+    return createDockerEnv({
+      id: envId,
+      spec: createAttachedSpec(context?.cwd),
+      runner: createHostRunner(),
+      engine,
+      context: detectContext(),
+      attachedJobId: context?.jobId
     });
-    return {
-      kind: "sync",
-      exitCode: result.exitCode,
-      download: result.download,
-      ...result.stdout !== void 0 ? { stdout: result.stdout } : {},
-      ...result.stderr !== void 0 ? { stderr: result.stderr } : {}
-    };
-  } finally {
-    if (shouldClose) {
-      await env.close();
-    }
   }
+};
+function createDockerEnv(input) {
+  const containerRef = input.id;
+  return {
+    id: containerRef,
+    job: input.attachedJobId === void 0 ? null : createContainerJob(containerRef, input.runner, input.engine, input.context, input.attachedJobId),
+    async uploadWorkspace() {
+      const tempDir = mkdtempSync(path24.join(tmpdir(), "poe-docker-upload-"));
+      const archivePath = path24.join(tempDir, "workspace.tar");
+      try {
+        const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
+          "--exclude",
+          ignored
+        ]);
+        const tarArgs = [...excludeArgs, "-cf", archivePath, "-C", input.spec.cwd, "."];
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: tarArgs,
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            archivePath,
+            `${containerRef}:/tmp/poe-workspace-upload.tar`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `mkdir -p ${shellQuote(input.spec.cwd)} && tar -xf /tmp/poe-workspace-upload.tar -C ${shellQuote(input.spec.cwd)}`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, skipped: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    async downloadWorkspace(opts) {
+      const tempDir = mkdtempSync(path24.join(tmpdir(), "poe-docker-download-"));
+      const archivePath = path24.join(tempDir, "workspace.tar");
+      try {
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote(input.spec.cwd)} .`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            `${containerRef}:/tmp/poe-workspace-download.tar`,
+            archivePath
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const extractMode = opts.conflictPolicy === "refuse" ? "-xkf" : "-xf";
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: [extractMode, archivePath, "-C", input.spec.cwd],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, conflicts: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    exec(spec) {
+      return input.runner.exec({
+        command: input.engine,
+        args: [
+          ...buildContextArgs(input.engine, input.context),
+          "exec",
+          ...spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : [],
+          ...spec.tty === true ? ["-t"] : [],
+          ...spec.cwd !== void 0 ? ["-w", spec.cwd] : [],
+          ...buildEnvArgs(spec.env),
+          containerRef,
+          spec.command,
+          ...spec.args ?? []
+        ],
+        stdin: spec.stdin,
+        stdout: spec.stdout,
+        stderr: spec.stderr,
+        tty: spec.tty
+      });
+    },
+    async detach() {
+      return createContainerJob(containerRef, input.runner, input.engine, input.context);
+    },
+    shell() {
+      const shellSpec = input.spec.shellSpec;
+      return this.exec({
+        command: shellSpec?.command ?? input.spec.env.SHELL ?? "sh",
+        ...shellSpec?.args ? { args: shellSpec.args } : {},
+        cwd: input.spec.cwd,
+        env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        tty: true
+      });
+    },
+    async close() {
+      await runOrThrow(input.runner, {
+        command: input.engine,
+        args: [...buildContextArgs(input.engine, input.context), "rm", "-f", containerRef],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    }
+  };
 }
-async function configureE2bSpawnAgentIfAvailable(opts) {
-  if (opts.factoryType !== "e2b") {
-    return;
-  }
-  const agentId = resolveAgentId(opts.openSpec.jobLabel.tool);
-  const agent = allAgents.find((candidate) => candidate.id === agentId);
-  const binaryName = agent?.binaryName;
-  if (!agentId || !binaryName) {
-    return;
+async function resolveImage(input) {
+  if (input.runtime.image !== void 0) {
+    return input.runtime.image;
   }
-  const commandEnv = resolveExecutionEnv(opts.openSpec);
-  const exists = await binaryExists(opts.env, {
-    binaryName,
-    cwd: opts.openSpec.cwd,
-    env: commandEnv
+  const result = await buildDockerRuntimeTemplate({
+    cwd: input.spec.cwd,
+    runtime: input.runtime,
+    state: input.spec.state,
+    runner: input.runner
   });
-  if (!exists) {
-    return;
+  return result.image;
+}
+async function buildDockerRuntimeTemplate(input) {
+  const runner = input.runner ?? createHostRunner();
+  const engine = input.runtime.engine ?? detectEngine();
+  const context = detectContext();
+  const dockerfilePath = path24.resolve(
+    input.cwd,
+    input.runtime.dockerfile ?? path24.join(".poe-code", "Dockerfile")
+  );
+  const buildContext = path24.resolve(input.cwd, input.runtime.build_context ?? ".");
+  const dockerfileBytes = await readFile10(dockerfilePath);
+  const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
+  const cached2 = input.force ? null : await input.state?.templates.get("docker", hash);
+  if (cached2?.image !== void 0) {
+    return {
+      backend: "docker",
+      hash,
+      image: cached2.image,
+      cached: true
+    };
   }
-  const result = await runProbeCommand(opts.env, {
-    command: "poe-code",
-    args: ["configure", "--yes", "--provider", "poe", agentId],
-    cwd: opts.openSpec.cwd,
-    env: commandEnv
+  const image = `poe-code/local:${hash}`;
+  await buildImage({
+    runner,
+    engine,
+    context,
+    image,
+    dockerfilePath,
+    buildContext,
+    buildArgs: input.runtime.build_args ?? {}
   });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Failed to configure ${agentId} for Poe inside E2B sandbox.
-${formatProbeResult(result)}`
-    );
-  }
+  await input.state?.templates.put("docker", {
+    hash,
+    image,
+    runtime_type: "docker",
+    dockerfile_path: dockerfilePath,
+    built_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    backend: "docker",
+    hash,
+    image,
+    cached: false
+  };
 }
-async function binaryExists(env, opts) {
-  for (const detector of createBinaryExistsDetectors(opts.binaryName)) {
-    const result = await runProbeCommand(env, {
-      ...detector,
-      cwd: opts.cwd,
-      env: opts.env
-    });
-    if (detector.validate(result)) {
-      return true;
-    }
+function hashDockerTemplate(dockerfileBytes, buildArgs) {
+  const hash = createHash3("sha256");
+  hash.update(dockerfileBytes);
+  hash.update("\0");
+  for (const [key, value] of sortedBuildArgs(buildArgs)) {
+    hash.update(key);
+    hash.update("=");
+    hash.update(value);
+    hash.update("\0");
   }
-  return false;
-}
-function resolveExecutionEnv(openSpec) {
-  const execution = openSpec.execution;
-  return execution?.env ?? openSpec.env;
+  return hash.digest("hex");
 }
-async function runProbeCommand(env, spec) {
-  const handle = env.exec({
-    command: spec.command,
-    args: spec.args,
-    cwd: spec.cwd,
-    env: spec.env,
-    stdin: "ignore",
+async function buildImage(input) {
+  await runOrThrow(input.runner, {
+    command: input.engine,
+    args: [
+      ...buildContextArgs(input.engine, input.context),
+      "build",
+      "--tag",
+      input.image,
+      "-f",
+      input.dockerfilePath,
+      ...sortedBuildArgs(input.buildArgs).flatMap(([key, value]) => [
+        "--build-arg",
+        `${key}=${value}`
+      ]),
+      input.buildContext
+    ],
     stdout: "pipe",
     stderr: "pipe"
   });
+}
+function parseDockerRuntime(runtime) {
+  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+    throw new Error("docker runtime must be an object");
+  }
+  const record = runtime;
+  if (record.type !== "docker") {
+    throw new Error('docker runtime type must be "docker"');
+  }
+  return record;
+}
+async function runAndRead(runner, spec) {
+  const handle = runner.exec(spec);
   const stdout = readStream(handle.stdout);
   const stderr = readStream(handle.stderr);
   const result = await handle.result;
-  return {
-    exitCode: result.exitCode,
-    stdout: await stdout,
-    stderr: await stderr
-  };
+  const output = await stdout;
+  if (result.exitCode !== 0) {
+    const errorOutput = await stderr;
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}${errorOutput ? `
+${errorOutput}` : ""}`
+    );
+  }
+  return output;
 }
-function readStream(stream) {
-  if (!stream) {
-    return Promise.resolve("");
+async function runOrThrow(runner, spec) {
+  await runAndRead(runner, spec);
+}
+async function readStream(stream) {
+  if (stream === null) {
+    return "";
   }
-  return new Promise((resolve2, reject) => {
-    let output = "";
-    stream.setEncoding("utf8");
-    stream.on("data", (chunk) => {
-      output += chunk.toString();
-    });
-    stream.on("error", reject);
-    stream.on("end", () => resolve2(output));
-  });
+  stream.setEncoding("utf8");
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
 }
-function formatProbeResult(result) {
-  return [
-    `Exit code: ${result.exitCode}`,
-    result.stdout.trim() ? `stdout:
-${result.stdout.trim()}` : "",
-    result.stderr.trim() ? `stderr:
-${result.stderr.trim()}` : ""
-  ].filter(Boolean).join("\n");
+function sortedBuildArgs(buildArgs) {
+  return Object.entries(buildArgs).sort(([left], [right]) => left.localeCompare(right));
 }
-async function runSync(opts) {
-  const execution = opts.openSpec.execution;
-  const capture = execution?.captureOutput === true;
-  const abort = createAbortSync(opts.signal, opts.handle, execution?.activityTimeoutMs);
-  const streamState = capture ? captureRunStreams(opts.handle, execution, abort.resetActivityTimer) : pipeRunStreams(opts.handle);
-  abort.resetActivityTimer();
-  try {
-    const { exitCode } = opts.wrapCommand ? await abort.waitForExit(opts.env, opts.jobId) : await abort.waitForHandle();
-    const download = await opts.env.downloadWorkspace({
-      conflictPolicy: opts.openSpec.runner?.download_conflict ?? "refuse"
-    });
-    if (opts.closeAfterDownload !== false) {
-      await opts.env.close();
+function buildEnvArgs(env) {
+  if (env === void 0) {
+    return [];
+  }
+  return Object.entries(env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
+}
+function createContainerName() {
+  return `poe-env-${randomBytes2(6).toString("hex")}`;
+}
+function createContainerJob(containerId, runner, engine, context, jobId = containerId) {
+  return {
+    id: jobId,
+    envId: containerId,
+    tool: "docker",
+    argv: ["attach", containerId],
+    async status() {
+      const handle = runner.exec({
+        command: engine,
+        args: [
+          ...buildContextArgs(engine, context),
+          "inspect",
+          "-f",
+          "{{.State.Status}}",
+          containerId
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      if (result.exitCode !== 0) {
+        return "lost";
+      }
+      return stdout.trim() === "running" ? "running" : "exited";
+    },
+    async *stream(opts) {
+      const handle = runner.exec({
+        command: engine,
+        args: [
+          ...buildContextArgs(engine, context),
+          "exec",
+          containerId,
+          "sh",
+          "-c",
+          `test -f ${shellQuote(`/tmp/poe-jobs/${jobId}.log`)} && tail -c +${(opts?.sinceByte ?? 0) + 1} ${shellQuote(`/tmp/poe-jobs/${jobId}.log`)} || true`
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      await handle.result;
+      if (stdout.length > 0) {
+        yield { byteOffset: opts?.sinceByte ?? 0, data: stdout };
+      }
+    },
+    async wait() {
+      const handle = runner.exec({
+        command: engine,
+        args: [...buildContextArgs(engine, context), "wait", containerId],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
+    },
+    async kill(signal) {
+      const args = signal === void 0 || signal === "SIGTERM" ? ["stop", containerId] : ["kill", ...signal === "SIGKILL" ? [] : [`--signal=${signal}`], containerId];
+      await runOrThrow(runner, {
+        command: engine,
+        args: [...buildContextArgs(engine, context), ...args],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
     }
-    return {
-      exitCode,
-      download,
-      ...capture ? { stdout: streamState.stdout(), stderr: streamState.stderr() } : {}
-    };
-  } finally {
-    abort.dispose();
-    streamState.dispose();
-  }
+  };
 }
-function pipeRunStreams(handle) {
-  handle.stdout?.pipe(process.stdout, { end: false });
-  handle.stderr?.pipe(process.stderr, { end: false });
+function createAttachedSpec(cwd = "/workspace") {
   return {
-    stdout: () => "",
-    stderr: () => "",
-    dispose() {
-      handle.stdout?.unpipe(process.stdout);
-      handle.stderr?.unpipe(process.stderr);
+    cwd,
+    runtime: {
+      type: "docker",
+      image: "attached",
+      build_args: {},
+      mounts: []
+    },
+    env: {},
+    uploadIgnoreFiles: [],
+    jobLabel: {
+      tool: "docker",
+      argv: []
     }
   };
 }
-function captureRunStreams(handle, execution, onActivity) {
-  let stdout = "";
-  let stderr = "";
-  const listeners = [];
-  const bind = (stream, onChunk) => {
-    if (!stream) return;
-    stream.setEncoding("utf8");
-    const listener = (chunk) => {
-      onActivity();
-      onChunk(chunk.toString());
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// packages/process-runner/src/host/host-execution-env.ts
+var hostExecutionEnvFactory = {
+  type: "host",
+  supportsDetach: false,
+  async open(openSpec) {
+    return {
+      id: "host",
+      job: null,
+      async uploadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          skipped: []
+        };
+      },
+      async downloadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          conflicts: []
+        };
+      },
+      exec(spec) {
+        return createHostRunner().exec(spec);
+      },
+      async detach() {
+        throw new Error("host runtime does not support detach because host has no addressable env");
+      },
+      shell() {
+        const shellSpec = openSpec.shellSpec;
+        return createHostRunner().exec({
+          command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+          ...shellSpec?.args ? { args: shellSpec.args } : {},
+          cwd: openSpec.cwd,
+          env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+          tty: true
+        });
+      },
+      async close() {
+      }
     };
-    stream.on("data", listener);
-    listeners.push(() => {
-      stream.off("data", listener);
-    });
-  };
-  bind(handle.stdout, (chunk) => {
-    stdout += chunk;
-    execution?.onStdout?.(chunk);
-  });
-  bind(handle.stderr, (chunk) => {
-    stderr += chunk;
-    execution?.onStderr?.(chunk);
-  });
-  return {
-    stdout: () => stdout,
-    stderr: () => stderr,
-    dispose() {
-      for (const remove2 of listeners) {
-        remove2();
+  },
+  async attach() {
+    throw new Error("host runtime does not support reattach");
+  }
+};
+
+// packages/process-runner/src/testing/mock-runner.ts
+import { Readable, Writable } from "node:stream";
+
+// packages/task-list/src/backends/utils.ts
+import path25 from "node:path";
+
+// packages/task-list/src/backends/markdown-dir.ts
+import path26 from "node:path";
+import { parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
+
+// packages/task-list/src/schema/task.schema.json
+var task_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json",
+  title: "Task",
+  description: "Persisted task payload used by task-list backends.",
+  type: "object",
+  properties: {
+    $schema: {
+      type: "string",
+      const: "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json"
+    },
+    kind: {
+      type: "string",
+      const: "task"
+    },
+    version: {
+      type: "integer",
+      const: 1
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    state: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    }
+  },
+  required: ["name", "state"],
+  additionalProperties: true
+};
+
+// packages/task-list/src/state.ts
+var defaultStateMachine = {
+  initial: "draft",
+  states: ["draft", "planned", "in-progress", "done", "archived"],
+  events: {
+    plan: { from: ["draft"], to: "planned" },
+    start: { from: ["planned"], to: "in-progress" },
+    complete: { from: ["in-progress"], to: "done" },
+    archive: { from: "*", to: "archived" }
+  }
+};
+function deriveLegacyTransitions(machine) {
+  const transitions = Object.fromEntries(
+    machine.states.map((state) => [state, /* @__PURE__ */ new Set()])
+  );
+  for (const fromState of machine.states) {
+    for (const eventName of Object.keys(machine.events)) {
+      const event = findEvent(machine, fromState, eventName);
+      if (event !== void 0) {
+        transitions[fromState].add(event.to);
       }
     }
-  };
+  }
+  const terminalState = machine.events.archive.to;
+  const activeStates = machine.states.filter((state) => state !== terminalState);
+  for (let index = 1; index < activeStates.length; index += 1) {
+    transitions[activeStates[index]].add(activeStates[index - 1]);
+  }
+  return transitions;
 }
-function createAbortSync(signal, handle, activityTimeoutMs) {
-  let activityTimer;
-  let timedOut = false;
-  const resetActivityTimer = activityTimeoutMs ? () => {
-    if (activityTimer) clearTimeout(activityTimer);
-    activityTimer = setTimeout(() => {
-      timedOut = true;
-      handle.kill("SIGTERM");
-      notifyAbort?.();
-    }, activityTimeoutMs);
-  } : () => {
-  };
-  let notifyAbort;
-  if (signal === void 0) {
-    return {
-      waitForExit: (env, jobId) => waitForExit(toLogStreamEnv(env), jobId),
-      waitForHandle: async () => {
-        const result = await handle.result;
-        if (timedOut) {
-          throw createActivityTimeoutError(activityTimeoutMs);
+var defaultTransitions = deriveLegacyTransitions(defaultStateMachine);
+
+// packages/task-list/src/backends/markdown-dir.ts
+var TASK_SCHEMA_ID = task_schema_default.$id;
+
+// packages/task-list/src/backends/yaml-file.ts
+import { isMap, parseDocument as parseDocument3 } from "yaml";
+
+// packages/task-list/src/schema/store.schema.json
+var store_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json",
+  title: "Task Store",
+  description: "YAML multi-list task store.",
+  type: "object",
+  properties: {
+    $schema: {
+      type: "string",
+      const: "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json"
+    },
+    kind: {
+      type: "string",
+      const: "task-store"
+    },
+    version: {
+      type: "integer",
+      const: 1
+    },
+    lists: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: {
+          $ref: "./task.schema.json"
         }
-        return result;
-      },
-      resetActivityTimer,
-      dispose() {
-        if (activityTimer) clearTimeout(activityTimer);
       }
-    };
+    }
+  },
+  required: ["$schema", "kind", "version", "lists"],
+  additionalProperties: false
+};
+
+// packages/task-list/src/backends/yaml-file.ts
+var STORE_SCHEMA_ID = store_schema_default.$id;
+var TASK_SCHEMA_ID2 = task_schema_default.$id;
+
+// packages/agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
   }
-  const exitWaitController = new AbortController();
-  let aborted = signal.aborted;
-  const abortedPromise = new Promise((resolve2) => {
-    notifyAbort = resolve2;
-  });
-  const kill = () => {
-    aborted = true;
-    handle.kill("SIGTERM");
-    notifyAbort?.();
-  };
-  if (signal.aborted) {
-    kill();
-  } else {
-    signal.addEventListener("abort", kill, { once: true });
+};
+
+// packages/agent-defs/src/agents/goose.ts
+var gooseAgent = {
+  id: "goose",
+  name: "goose",
+  label: "Goose",
+  summary: "Block's open-source AI agent with ACP support.",
+  binaryName: "goose",
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
   }
-  return {
-    async waitForExit(env, jobId) {
-      if (aborted) {
-        return handle.result;
-      }
-      const exit = waitForExit(toLogStreamEnv(env), jobId, {
-        signal: exitWaitController.signal
-      }).then(
-        (value) => ({ kind: "exit", value }),
-        (error2) => ({ kind: "error", error: error2 })
-      );
-      const result = await Promise.race([
-        exit,
-        abortedPromise.then(() => ({ kind: "abort" }))
-      ]);
-      if (result.kind === "exit") {
-        return result.value;
-      }
-      if (result.kind === "error") {
-        throw result.error;
-      }
-      exitWaitController.abort();
-      return handle.result;
-    },
-    async waitForHandle() {
-      const result = await Promise.race([
-        handle.result.then((value) => ({ kind: "exit", value })),
-        abortedPromise.then(() => ({ kind: "abort" }))
-      ]);
-      if (result.kind === "exit") {
-        if (aborted) {
-          throw createAbortError2();
-        }
-        if (timedOut) {
-          throw createActivityTimeoutError(activityTimeoutMs);
-        }
-        return result.value;
-      }
-      if (timedOut) {
-        throw createActivityTimeoutError(activityTimeoutMs);
-      }
-      throw createAbortError2();
-    },
-    resetActivityTimer,
-    dispose() {
-      if (activityTimer) clearTimeout(activityTimer);
-      exitWaitController.abort();
-      signal.removeEventListener("abort", kill);
+};
+
+// packages/agent-defs/src/agents/poe-agent.ts
+var poeAgentAgent = {
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  configPath: "~/.poe-code/config.json",
+  branding: {
+    colors: {
+      dark: "#A465F7",
+      light: "#7A3FD3"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent,
+  gooseAgent,
+  poeAgentAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
     }
-  };
-}
-function toLogStreamEnv(env) {
-  const candidate = env;
-  return candidate.fs === void 0 ? {} : { fs: candidate.fs };
-}
-function setDetachedJobContext(env, context) {
-  const candidate = env;
-  candidate.setDetachedJobContext?.(context);
-}
-function isPromiseLike(value) {
-  return typeof value.then === "function";
-}
-function createAbortError2() {
-  const error2 = new Error("Agent spawn aborted");
-  error2.name = "AbortError";
-  return error2;
-}
-function createActivityTimeoutError(timeoutMs) {
-  const error2 = new Error(`Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`);
-  error2.name = "ActivityTimeoutError";
-  return error2;
-}
-function createUlid() {
-  const time = BigInt(Date.now());
-  const random = randomBytes(10);
-  let randomValue = 0n;
-  for (const byte of random) {
-    randomValue = randomValue << 8n | BigInt(byte);
   }
-  return encodeBase32(time, 10) + encodeBase32(randomValue, 16);
 }
-function encodeBase32(value, length) {
-  const chars = Array.from({ length }, () => "0");
-  let remaining = value;
-  for (let index = length - 1; index >= 0; index -= 1) {
-    chars[index] = ULID_ALPHABET[Number(remaining & 31n)];
-    remaining >>= 5n;
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
   }
-  return chars.join("");
+  return lookup.get(input.toLowerCase());
 }
 
-// packages/agent-harness-tools/src/poe-command-execution.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import os3 from "node:os";
+// packages/agent-harness-tools/src/select-agent.ts
+var loopAgents = allAgents.filter(
+  (agent) => agent.binaryName !== void 0 || agent.id === "poe-agent"
+);
+var supportedAgents = loopAgents.map((agent) => agent.id).join(", ");
 
-// packages/agent-harness-tools/src/execution-env.ts
-var executionEnvFactories = /* @__PURE__ */ new Map();
-function registerExecutionEnvFactory(factory) {
-  executionEnvFactories.set(factory.type, factory);
+// packages/agent-harness-tools/src/run-logs.ts
+import path28 from "node:path";
+
+// packages/agent-harness-tools/src/log-stream.ts
+import nodeFs2 from "node:fs";
+var JOB_DIR = "/tmp/poe-jobs";
+var POLL_INTERVAL_MS = 250;
+function wrapForLogTee(argv, jobId) {
+  if (argv.length === 0) {
+    throw new Error("wrapForLogTee requires argv to contain at least one argument");
+  }
+  const command = argv.map(shellQuote2).join(" ");
+  const logFile = shellQuote2(jobLogPath(jobId));
+  const exitFile = shellQuote2(jobExitPath(jobId));
+  const exitTmpFile = shellQuote2(`${jobExitPath(jobId)}.tmp`);
+  const script = [
+    `mkdir -p ${shellQuote2(JOB_DIR)}`,
+    `({ (${command}); echo $? > ${exitTmpFile}; } 2>&1 | tee ${logFile}; mv ${exitTmpFile} ${exitFile})`
+  ].join(" && ");
+  return ["sh", "-c", script];
 }
-function selectExecutionEnv(runtime) {
-  return selectExecutionEnvFactory(runtime.type);
+async function* streamLogFile(env, jobId, opts) {
+  const fs14 = env.fs ?? nodeFs2;
+  const file = jobLogPath(jobId);
+  let byteOffset = opts.sinceByte ?? 0;
+  while (true) {
+    if (opts.since !== void 0 && !await wasModifiedSince(fs14, file, opts.since)) {
+      await waitForLogChange(fs14, file);
+      continue;
+    }
+    const result = await readLogChunk(fs14, file, byteOffset);
+    if (result !== null) {
+      byteOffset = result.nextByteOffset;
+      yield result.chunk;
+      continue;
+    }
+    await waitForLogChange(fs14, file);
+  }
 }
-function selectExecutionEnvFactory(type) {
-  const factory = executionEnvFactories.get(type);
-  if (factory === void 0) {
-    throw new Error(
-      `No execution environment factory registered for runtime type "${type}".`
-    );
+async function wasModifiedSince(fs14, file, since) {
+  if (fs14.promises.stat === void 0) {
+    return true;
+  }
+  try {
+    const stat7 = await fs14.promises.stat(file);
+    return stat7.mtimeMs >= since.getTime();
+  } catch (error2) {
+    if (isNodeError(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
   }
-  return factory;
 }
-
-// packages/agent-harness-tools/src/poe-command-execution.ts
-function resolvePoeCommandExecution(input) {
-  const homeDir = input.context?.homeDir ?? os3.homedir();
-  const runtimeConfigCwd = input.runtimeConfigCwd ?? input.cwd;
-  const loaded = loadRuntimeConfig(runtimeConfigCwd, homeDir);
-  const config = applyRuntimeOverrides(loaded, input.runtime, runtimeConfigCwd);
-  const resolved = resolveRuntime({ cwd: runtimeConfigCwd, config });
-  const factory = selectExecutionEnv(resolved.runtime);
-  const state = input.context?.state ?? loadState(homeDir);
-  return {
-    factory,
-    detach: factory.supportsDetach === true && config.runner.detach,
-    state,
-    openSpec: {
-      cwd: input.cwd,
-      runtimeCwd: runtimeConfigCwd,
-      runtime: resolved.runtime,
-      runner: config.runner,
-      state,
-      env: input.env,
-      uploadIgnoreFiles: config.runner.workspace?.exclude ?? [],
-      jobLabel: {
-        tool: input.tool,
-        argv: input.argv
-      },
-      ...input.openSpec
+async function waitForExit(env, jobId, opts = {}) {
+  const fs14 = env.fs ?? nodeFs2;
+  const file = jobExitPath(jobId);
+  while (true) {
+    throwIfAborted2(opts.signal);
+    const contents = await readTextFileIfExists(fs14, file);
+    if (contents !== null) {
+      const text5 = contents.trim();
+      const exitCode = Number(text5);
+      if (text5.length === 0 || !Number.isInteger(exitCode)) {
+        throw new Error(`Invalid exit code in ${file}: ${contents}`);
+      }
+      return { exitCode };
     }
-  };
-}
-function applyRuntimeOverrides(config, overrides, cwd = process.cwd()) {
-  if (!overrides) {
-    return { runtime: config.runtime, runner: config.runner };
+    await sleep3(POLL_INTERVAL_MS, opts.signal);
   }
-  const base = "rawScope" in config && config.rawScope ? { ...config.rawScope } : { ...config.runtime };
-  const runtime = parseRuntime({
-    ...base,
-    ...overrides.runtime !== void 0 ? { type: overrides.runtime } : {},
-    ...overrides.runtimeImage !== void 0 ? { image: overrides.runtimeImage } : {},
-    ...overrides.runtimeTemplate !== void 0 ? { template_id: overrides.runtimeTemplate } : {},
-    ...overrides.mountPoeCode === true ? { mounts: [...config.runtime.mounts, createPoeCodeMount(cwd)] } : {}
-  });
-  return {
-    runtime,
-    runner: {
-      ...config.runner,
-      ...overrides.detach === true ? { detach: true } : {},
-      ...overrides.runnerSync !== void 0 ? { sync: overrides.runnerSync } : {}
-    }
-  };
 }
-function createPoeCodeMount(cwd) {
-  return {
-    source: cwd,
-    target: "/usr/local/lib/poe-code",
-    readonly: true
-  };
+function jobLogPath(jobId) {
+  return `${JOB_DIR}/${jobId}.log`;
 }
-function loadRuntimeConfig(cwd, homeDir) {
-  const document = deepMergeDocuments(
-    readConfigDocument(resolveConfigPath(homeDir)),
-    readConfigDocument(resolveProjectConfigPath(cwd))
-  );
-  const runtimeScope = resolveScope(runtimeConfigScope.schema, document.runtime, process.env);
+function jobExitPath(jobId) {
+  return `${JOB_DIR}/${jobId}.exit`;
+}
+async function readLogChunk(fs14, file, byteOffset) {
+  const contents = await readFileIfExists2(fs14, file);
+  if (contents === null || byteOffset >= contents.byteLength) {
+    return null;
+  }
   return {
-    rawScope: { ...runtimeScope },
-    runtime: parseRuntime(runtimeScope),
-    runner: runtimeScope.runner
+    chunk: {
+      byteOffset,
+      data: contents.subarray(byteOffset).toString("utf8")
+    },
+    nextByteOffset: contents.byteLength
   };
 }
-function readConfigDocument(filePath) {
-  if (!existsSync2(filePath)) {
-    return {};
+async function readTextFileIfExists(fs14, file) {
+  const contents = await readFileIfExists2(fs14, file);
+  return contents?.toString("utf8") ?? null;
+}
+async function readFileIfExists2(fs14, file) {
+  try {
+    const contents = await fs14.promises.readFile(file);
+    return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
+  } catch (error2) {
+    if (isNodeError(error2) && error2.code === "ENOENT") {
+      return null;
+    }
+    throw error2;
   }
-  return JSON.parse(readFileSync(filePath, "utf8"));
 }
-function loadState(homeDir) {
-  if (process.env.VITEST === "true") {
-    return createMemoryStateManager();
+async function waitForLogChange(fs14, file) {
+  const watch = fs14.watch;
+  if (typeof watch !== "function") {
+    await sleep3(POLL_INTERVAL_MS);
+    return;
   }
-  return createStateManager(homeDir);
+  await new Promise((resolve2) => {
+    let watcher = null;
+    const timer = setTimeout(done, POLL_INTERVAL_MS);
+    function done() {
+      clearTimeout(timer);
+      watcher?.close();
+      resolve2();
+    }
+    try {
+      watcher = watch(file, done);
+    } catch {
+      done();
+    }
+  });
 }
-function createMemoryStateManager() {
-  const jobs = /* @__PURE__ */ new Map();
-  return {
-    templates: {
-      async get() {
-        return null;
-      },
-      async put() {
-      },
-      async remove() {
-      },
-      async list() {
-        return [];
-      }
-    },
-    jobs: {
-      async get(id) {
-        return jobs.get(id) ?? null;
-      },
-      async put(entry) {
-        jobs.set(entry.id, entry);
-      },
-      async update(id, patch) {
-        const current = jobs.get(id);
-        if (!current) {
-          return null;
-        }
-        const updated = { ...current, ...patch, id };
-        jobs.set(id, updated);
-        return updated;
-      },
-      async list(filter) {
-        const entries = Array.from(jobs.values());
-        if (!filter) {
-          return entries;
-        }
-        return entries.filter(
-          (entry) => Object.entries(filter).every(([key, value]) => entry[key] === value)
-        );
-      },
-      async remove(id) {
-        jobs.delete(id);
+function sleep3(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    let timer = null;
+    const abort = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
       }
+      reject(new Error("waitForExit aborted."));
+    };
+    if (signal?.aborted) {
+      abort();
+      return;
     }
-  };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve2();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw new Error("waitForExit aborted.");
+  }
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isNodeError(error2) {
+  return error2 instanceof Error && "code" in error2;
 }
 
-// packages/agent-harness-tools/src/workspace-transfer.ts
-import { createHash as createHash3 } from "node:crypto";
-import { promises as nodeFs3 } from "node:fs";
-import path24 from "node:path";
+// packages/agent-harness-tools/src/run-poe-command.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
 
-// packages/process-runner/src/docker/context.ts
-import { execSync } from "node:child_process";
-function detectContext() {
+// packages/agent-harness-tools/src/binary-exists.ts
+function createBinaryExistsDetectors(binaryName) {
+  const commonPaths = [
+    `/usr/local/bin/${binaryName}`,
+    `/usr/bin/${binaryName}`,
+    `$HOME/.local/bin/${binaryName}`,
+    `$HOME/.claude/local/bin/${binaryName}`
+  ];
+  return [
+    {
+      command: "which",
+      args: [binaryName],
+      validate: (result) => result.exitCode === 0
+    },
+    {
+      command: "where",
+      args: [binaryName],
+      validate: (result) => result.exitCode === 0 && result.stdout.trim().length > 0
+    },
+    {
+      command: "sh",
+      args: ["-c", commonPaths.map((p) => `test -f "${p}"`).join(" || ")],
+      validate: (result) => result.exitCode === 0
+    }
+  ];
+}
+
+// packages/agent-harness-tools/src/run-poe-command.ts
+var ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+async function runPoeCommand(opts) {
+  const jobId = createUlid();
+  const execution = opts.openSpec.execution;
+  const wrapCommand = execution?.wrapForLogTee !== false;
+  const pendingJob = opts.state.jobs.put({
+    id: jobId,
+    env_id: "",
+    env_kind: opts.factory.type,
+    tool: opts.openSpec.jobLabel.tool,
+    argv: opts.openSpec.jobLabel.argv,
+    cwd: opts.openSpec.cwd,
+    started_at: "",
+    status: "pending"
+  });
+  const opened = opts.factory.open(opts.openSpec);
+  const env = isPromiseLike(opened) ? await opened : opened;
+  let shouldClose = true;
   try {
-    const output = execSync("colima list --json", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
+    const upload = env.uploadWorkspace();
+    await Promise.all([pendingJob, upload]);
+    await configureE2bSpawnAgentIfAvailable({
+      env,
+      openSpec: opts.openSpec,
+      factoryType: opts.factory.type
+    });
+    const argv = wrapCommand ? wrapForLogTee(opts.openSpec.jobLabel.argv, jobId) : opts.openSpec.jobLabel.argv;
+    const handle = execution?.tty ? env.shell() : env.exec({
+      command: argv[0],
+      args: argv.slice(1),
+      cwd: opts.openSpec.cwd,
+      env: resolveExecutionEnv(opts.openSpec),
+      stdin: execution?.stdin ?? "inherit",
+      stdout: execution?.stdout ?? "pipe",
+      stderr: execution?.stderr ?? "pipe",
+      signal: opts.signal
+    });
+    if (execution?.input !== void 0) {
+      handle.stdin?.setDefaultEncoding("utf8");
+      handle.stdin?.end(execution.input);
+    }
+    const runningJob = opts.state.jobs.update(jobId, {
+      status: "running",
+      env_id: env.id,
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (opts.detach) {
+      await runningJob;
+      setDetachedJobContext(env, {
+        id: jobId,
+        tool: opts.openSpec.jobLabel.tool,
+        argv: opts.openSpec.jobLabel.argv
+      });
+      await env.detach();
+      shouldClose = false;
+      return { kind: "detached", jobId, envId: env.id };
+    }
+    const result = await runSync({
+      env,
+      handle,
+      jobId,
+      openSpec: opts.openSpec,
+      signal: opts.signal,
+      wrapCommand
     });
-    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}`;
-      }
+    await runningJob;
+    shouldClose = false;
+    await opts.state.jobs.update(jobId, {
+      status: "exited",
+      exit_code: result.exitCode,
+      exited_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      kind: "sync",
+      exitCode: result.exitCode,
+      download: result.download,
+      ...result.stdout !== void 0 ? { stdout: result.stdout } : {},
+      ...result.stderr !== void 0 ? { stderr: result.stderr } : {}
+    };
+  } finally {
+    if (shouldClose) {
+      await env.close();
     }
-  } catch {
-    return null;
   }
-  return null;
 }
-function buildContextArgs(engine, context) {
-  if (engine === "docker" && context) {
-    return ["--context", context];
+async function configureE2bSpawnAgentIfAvailable(opts) {
+  if (opts.factoryType !== "e2b") {
+    return;
   }
-  return [];
-}
-
-// packages/process-runner/src/docker/engine.ts
-import { execSync as execSync2 } from "node:child_process";
-function detectEngine() {
-  if (isEngineAvailable("docker")) {
-    return "docker";
+  const agentId = resolveAgentId(opts.openSpec.jobLabel.tool);
+  const agent = allAgents.find((candidate) => candidate.id === agentId);
+  const binaryName = agent?.binaryName;
+  if (!agentId || !binaryName) {
+    return;
   }
-  if (isEngineAvailable("podman")) {
-    return "podman";
+  const commandEnv = resolveExecutionEnv(opts.openSpec);
+  const exists = await binaryExists(opts.env, {
+    binaryName,
+    cwd: opts.openSpec.cwd,
+    env: commandEnv
+  });
+  if (!exists) {
+    return;
+  }
+  const result = await runProbeCommand(opts.env, {
+    command: "poe-code",
+    args: ["configure", "--yes", "--provider", "poe", agentId],
+    cwd: opts.openSpec.cwd,
+    env: commandEnv
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to configure ${agentId} for Poe inside E2B sandbox.
+${formatProbeResult(result)}`
+    );
   }
-  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"
+async function binaryExists(env, opts) {
+  for (const detector of createBinaryExistsDetectors(opts.binaryName)) {
+    const result = await runProbeCommand(env, {
+      ...detector,
+      cwd: opts.cwd,
+      env: opts.env
     });
-    return true;
-  } catch {
-    return false;
+    if (detector.validate(result)) {
+      return true;
+    }
   }
+  return false;
 }
-
-// packages/process-runner/src/docker/docker-runner.ts
-import * as childProcess from "node:child_process";
-import { randomBytes as randomBytes2 } from "node:crypto";
-
-// packages/process-runner/src/docker/args.ts
-import path25 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 = `${path25.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
-    args.push("-v", volume);
-  }
-  for (const port of input.ports) {
-    const mapping = `${port.host}:${port.container}${port.protocol === void 0 || port.protocol === "tcp" ? "" : `/${port.protocol}`}`;
-    args.push("-p", mapping);
-  }
-  if (input.network !== void 0) {
-    args.push("--network", input.network);
-  }
-  args.push(...input.extraArgs, input.image, input.command, ...input.args);
-  return args;
+function resolveExecutionEnv(openSpec) {
+  const execution = openSpec.execution;
+  return execution?.env ?? openSpec.env;
 }
-
-// packages/process-runner/src/docker/docker-execution-env.ts
-import { createHash as createHash4, randomBytes as randomBytes3 } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path26 from "node:path";
-
-// packages/process-runner/src/host/host-runner.ts
-import { spawn as spawnChildProcess } from "node:child_process";
-function createHostRunner(options = {}) {
-  const detached = options.detached === true;
+async function runProbeCommand(env, spec) {
+  const handle = env.exec({
+    command: spec.command,
+    args: spec.args,
+    cwd: spec.cwd,
+    env: spec.env,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdout = readStream2(handle.stdout);
+  const stderr = readStream2(handle.stderr);
+  const result = await handle.result;
   return {
-    name: "host",
-    exec(spec) {
-      const stdinMode = spec.stdin ?? "ignore";
-      const stdoutMode = spec.stdout ?? "pipe";
-      const stderrMode = spec.stderr ?? "pipe";
-      const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" ? "inherit" : [stdinMode, stdoutMode, stderrMode];
-      const child = spawnChildProcess(spec.command, spec.args ?? [], {
-        cwd: spec.cwd,
-        env: spec.env,
-        stdio,
-        ...detached ? { detached: true } : {}
-      });
-      if (detached) {
-        child.unref();
-      }
-      const kill = (signal) => {
-        if (detached && process.platform !== "win32" && child.pid !== void 0) {
-          process.kill(-child.pid, signal);
-          return;
-        }
-        child.kill(signal);
-      };
-      let settled = false;
-      let resolveResult = null;
-      const result = new Promise((resolve2) => {
-        resolveResult = resolve2;
-      });
-      const cleanupAbort = bindAbortSignal(spec.signal, () => {
-        kill("SIGTERM");
-      });
-      child.once("close", (code) => {
-        if (settled) return;
-        settled = true;
-        cleanupAbort();
-        resolveResult?.({ exitCode: code ?? 1 });
-      });
-      child.once("error", () => {
-        if (settled) return;
-        settled = true;
-        cleanupAbort();
-        resolveResult?.({ exitCode: 1 });
-      });
-      return {
-        pid: child.pid ?? null,
-        stdin: child.stdin,
-        stdout: child.stdout,
-        stderr: child.stderr,
-        result,
-        kill
-      };
+    exitCode: result.exitCode,
+    stdout: await stdout,
+    stderr: await stderr
+  };
+}
+function readStream2(stream) {
+  if (!stream) {
+    return Promise.resolve("");
+  }
+  return new Promise((resolve2, reject) => {
+    let output = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolve2(output));
+  });
+}
+function formatProbeResult(result) {
+  return [
+    `Exit code: ${result.exitCode}`,
+    result.stdout.trim() ? `stdout:
+${result.stdout.trim()}` : "",
+    result.stderr.trim() ? `stderr:
+${result.stderr.trim()}` : ""
+  ].filter(Boolean).join("\n");
+}
+async function runSync(opts) {
+  const execution = opts.openSpec.execution;
+  const capture = execution?.captureOutput === true;
+  const abort = createAbortSync(opts.signal, opts.handle, execution?.activityTimeoutMs);
+  const streamState = capture ? captureRunStreams(opts.handle, execution, abort.resetActivityTimer) : pipeRunStreams(opts.handle);
+  abort.resetActivityTimer();
+  try {
+    const { exitCode } = opts.wrapCommand ? await abort.waitForExit(opts.env, opts.jobId) : await abort.waitForHandle();
+    const download = await opts.env.downloadWorkspace({
+      conflictPolicy: opts.openSpec.runner?.download_conflict ?? "refuse"
+    });
+    if (opts.closeAfterDownload !== false) {
+      await opts.env.close();
     }
-  };
-}
-function bindAbortSignal(signal, onAbort) {
-  if (signal === void 0) {
-    return () => {
-    };
-  }
-  if (signal.aborted) {
-    onAbort();
-    return () => {
+    return {
+      exitCode,
+      download,
+      ...capture ? { stdout: streamState.stdout(), stderr: streamState.stderr() } : {}
     };
+  } finally {
+    abort.dispose();
+    streamState.dispose();
   }
-  signal.addEventListener("abort", onAbort, { once: true });
-  return () => {
-    signal.removeEventListener("abort", onAbort);
-  };
 }
-
-// packages/process-runner/src/docker/docker-execution-env.ts
-var containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
-var dockerExecutionEnvFactory = {
-  type: "docker",
-  supportsDetach: true,
-  async open(spec) {
-    const runtime = parseDockerRuntime(spec.runtime);
-    const runner = spec.hostRunner ?? createHostRunner();
-    const engine = runtime.engine ?? detectEngine();
-    const context = detectContext();
-    const image = await resolveImage({
-      spec,
-      runtime,
-      runner,
-      engine,
-      context
-    });
-    const containerName = createContainerName();
-    const runArgs = buildDockerRunArgs({
-      engine,
-      context,
-      image,
-      command: containerCommand[0],
-      args: containerCommand.slice(1),
-      cwd: void 0,
-      env: void 0,
-      mounts: runtime.mounts ?? [],
-      ports: [],
-      network: runtime.network,
-      containerName,
-      detached: true,
-      interactive: true,
-      tty: false,
-      rm: false,
-      extraArgs: runtime.extra_args ?? []
-    });
-    const [command, ...args] = runArgs;
-    const id = (await runAndRead(runner, { command, args, stdout: "pipe", stderr: "pipe" })).trim();
-    return createDockerEnv({
-      id,
-      spec,
-      runner,
-      engine,
-      context
-    });
-  },
-  async attach(envId, context) {
-    const engine = detectEngine();
-    return createDockerEnv({
-      id: envId,
-      spec: createAttachedSpec(context?.cwd),
-      runner: createHostRunner(),
-      engine,
-      context: detectContext(),
-      attachedJobId: context?.jobId
-    });
-  }
-};
-function createDockerEnv(input) {
-  const containerRef = input.id;
+function pipeRunStreams(handle) {
+  handle.stdout?.pipe(process.stdout, { end: false });
+  handle.stderr?.pipe(process.stderr, { end: false });
   return {
-    id: containerRef,
-    job: input.attachedJobId === void 0 ? null : createContainerJob(containerRef, input.runner, input.engine, input.context, input.attachedJobId),
-    async uploadWorkspace() {
-      const tempDir = mkdtempSync(path26.join(tmpdir(), "poe-docker-upload-"));
-      const archivePath = path26.join(tempDir, "workspace.tar");
-      try {
-        const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
-          "--exclude",
-          ignored
-        ]);
-        const tarArgs = [...excludeArgs, "-cf", archivePath, "-C", input.spec.cwd, "."];
-        await runOrThrow(input.runner, {
-          command: "tar",
-          args: tarArgs,
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await runOrThrow(input.runner, {
-          command: input.engine,
-          args: [
-            ...buildContextArgs(input.engine, input.context),
-            "cp",
-            archivePath,
-            `${containerRef}:/tmp/poe-workspace-upload.tar`
-          ],
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await runOrThrow(input.runner, {
-          command: input.engine,
-          args: [
-            ...buildContextArgs(input.engine, input.context),
-            "exec",
-            containerRef,
-            "sh",
-            "-c",
-            `mkdir -p ${shellQuote2(input.spec.cwd)} && tar -xf /tmp/poe-workspace-upload.tar -C ${shellQuote2(input.spec.cwd)}`
-          ],
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        return { files: 0, bytes: 0, skipped: [] };
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    },
-    async downloadWorkspace(opts) {
-      const tempDir = mkdtempSync(path26.join(tmpdir(), "poe-docker-download-"));
-      const archivePath = path26.join(tempDir, "workspace.tar");
-      try {
-        await runOrThrow(input.runner, {
-          command: input.engine,
-          args: [
-            ...buildContextArgs(input.engine, input.context),
-            "exec",
-            containerRef,
-            "sh",
-            "-c",
-            `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote2(input.spec.cwd)} .`
-          ],
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await runOrThrow(input.runner, {
-          command: input.engine,
-          args: [
-            ...buildContextArgs(input.engine, input.context),
-            "cp",
-            `${containerRef}:/tmp/poe-workspace-download.tar`,
-            archivePath
-          ],
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const extractMode = opts.conflictPolicy === "refuse" ? "-xkf" : "-xf";
-        await runOrThrow(input.runner, {
-          command: "tar",
-          args: [extractMode, archivePath, "-C", input.spec.cwd],
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        return { files: 0, bytes: 0, conflicts: [] };
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    },
-    exec(spec) {
-      return input.runner.exec({
-        command: input.engine,
-        args: [
-          ...buildContextArgs(input.engine, input.context),
-          "exec",
-          ...spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : [],
-          ...spec.tty === true ? ["-t"] : [],
-          ...spec.cwd !== void 0 ? ["-w", spec.cwd] : [],
-          ...buildEnvArgs(spec.env),
-          containerRef,
-          spec.command,
-          ...spec.args ?? []
-        ],
-        stdin: spec.stdin,
-        stdout: spec.stdout,
-        stderr: spec.stderr,
-        tty: spec.tty
-      });
-    },
-    async detach() {
-      return createContainerJob(containerRef, input.runner, input.engine, input.context);
-    },
-    shell() {
-      const shellSpec = input.spec.shellSpec;
-      return this.exec({
-        command: shellSpec?.command ?? input.spec.env.SHELL ?? "sh",
-        ...shellSpec?.args ? { args: shellSpec.args } : {},
-        cwd: input.spec.cwd,
-        env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-        tty: true
-      });
-    },
-    async close() {
-      await runOrThrow(input.runner, {
-        command: input.engine,
-        args: [...buildContextArgs(input.engine, input.context), "rm", "-f", containerRef],
-        stdout: "pipe",
-        stderr: "pipe"
-      });
+    stdout: () => "",
+    stderr: () => "",
+    dispose() {
+      handle.stdout?.unpipe(process.stdout);
+      handle.stderr?.unpipe(process.stderr);
     }
   };
 }
-async function resolveImage(input) {
-  if (input.runtime.image !== void 0) {
-    return input.runtime.image;
-  }
-  const result = await buildDockerRuntimeTemplate({
-    cwd: input.spec.cwd,
-    runtime: input.runtime,
-    state: input.spec.state,
-    runner: input.runner
+function captureRunStreams(handle, execution, onActivity) {
+  let stdout = "";
+  let stderr = "";
+  const listeners = [];
+  const bind = (stream, onChunk) => {
+    if (!stream) return;
+    stream.setEncoding("utf8");
+    const listener = (chunk) => {
+      onActivity();
+      onChunk(chunk.toString());
+    };
+    stream.on("data", listener);
+    listeners.push(() => {
+      stream.off("data", listener);
+    });
+  };
+  bind(handle.stdout, (chunk) => {
+    stdout += chunk;
+    execution?.onStdout?.(chunk);
   });
-  return result.image;
+  bind(handle.stderr, (chunk) => {
+    stderr += chunk;
+    execution?.onStderr?.(chunk);
+  });
+  return {
+    stdout: () => stdout,
+    stderr: () => stderr,
+    dispose() {
+      for (const remove2 of listeners) {
+        remove2();
+      }
+    }
+  };
 }
-async function buildDockerRuntimeTemplate(input) {
-  const runner = input.runner ?? createHostRunner();
-  const engine = input.runtime.engine ?? detectEngine();
-  const context = detectContext();
-  const dockerfilePath = path26.resolve(
-    input.cwd,
-    input.runtime.dockerfile ?? path26.join(".poe-code", "Dockerfile")
-  );
-  const buildContext = path26.resolve(input.cwd, input.runtime.build_context ?? ".");
-  const dockerfileBytes = await readFile10(dockerfilePath);
-  const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
-  const cached2 = input.force ? null : await input.state?.templates.get("docker", hash);
-  if (cached2?.image !== void 0) {
+function createAbortSync(signal, handle, activityTimeoutMs) {
+  let activityTimer;
+  let timedOut = false;
+  const resetActivityTimer = activityTimeoutMs ? () => {
+    if (activityTimer) clearTimeout(activityTimer);
+    activityTimer = setTimeout(() => {
+      timedOut = true;
+      handle.kill("SIGTERM");
+      notifyAbort?.();
+    }, activityTimeoutMs);
+  } : () => {
+  };
+  let notifyAbort;
+  if (signal === void 0) {
     return {
-      backend: "docker",
-      hash,
-      image: cached2.image,
-      cached: true
+      waitForExit: (env, jobId) => waitForExit(toLogStreamEnv(env), jobId),
+      waitForHandle: async () => {
+        const result = await handle.result;
+        if (timedOut) {
+          throw createActivityTimeoutError(activityTimeoutMs);
+        }
+        return result;
+      },
+      resetActivityTimer,
+      dispose() {
+        if (activityTimer) clearTimeout(activityTimer);
+      }
     };
   }
-  const image = `poe-code/local:${hash}`;
-  await buildImage({
-    runner,
-    engine,
-    context,
-    image,
-    dockerfilePath,
-    buildContext,
-    buildArgs: input.runtime.build_args ?? {}
-  });
-  await input.state?.templates.put("docker", {
-    hash,
-    image,
-    runtime_type: "docker",
-    dockerfile_path: dockerfilePath,
-    built_at: (/* @__PURE__ */ new Date()).toISOString()
+  const exitWaitController = new AbortController();
+  let aborted = signal.aborted;
+  const abortedPromise = new Promise((resolve2) => {
+    notifyAbort = resolve2;
   });
+  const kill = () => {
+    aborted = true;
+    handle.kill("SIGTERM");
+    notifyAbort?.();
+  };
+  if (signal.aborted) {
+    kill();
+  } else {
+    signal.addEventListener("abort", kill, { once: true });
+  }
   return {
-    backend: "docker",
-    hash,
-    image,
-    cached: false
+    async waitForExit(env, jobId) {
+      if (aborted) {
+        return handle.result;
+      }
+      const exit = waitForExit(toLogStreamEnv(env), jobId, {
+        signal: exitWaitController.signal
+      }).then(
+        (value) => ({ kind: "exit", value }),
+        (error2) => ({ kind: "error", error: error2 })
+      );
+      const result = await Promise.race([
+        exit,
+        abortedPromise.then(() => ({ kind: "abort" }))
+      ]);
+      if (result.kind === "exit") {
+        return result.value;
+      }
+      if (result.kind === "error") {
+        throw result.error;
+      }
+      exitWaitController.abort();
+      return handle.result;
+    },
+    async waitForHandle() {
+      const result = await Promise.race([
+        handle.result.then((value) => ({ kind: "exit", value })),
+        abortedPromise.then(() => ({ kind: "abort" }))
+      ]);
+      if (result.kind === "exit") {
+        if (aborted) {
+          throw createAbortError2();
+        }
+        if (timedOut) {
+          throw createActivityTimeoutError(activityTimeoutMs);
+        }
+        return result.value;
+      }
+      if (timedOut) {
+        throw createActivityTimeoutError(activityTimeoutMs);
+      }
+      throw createAbortError2();
+    },
+    resetActivityTimer,
+    dispose() {
+      if (activityTimer) clearTimeout(activityTimer);
+      exitWaitController.abort();
+      signal.removeEventListener("abort", kill);
+    }
   };
 }
-function hashDockerTemplate(dockerfileBytes, buildArgs) {
-  const hash = createHash4("sha256");
-  hash.update(dockerfileBytes);
-  hash.update("\0");
-  for (const [key, value] of sortedBuildArgs(buildArgs)) {
-    hash.update(key);
-    hash.update("=");
-    hash.update(value);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
+function toLogStreamEnv(env) {
+  const candidate = env;
+  return candidate.fs === void 0 ? {} : { fs: candidate.fs };
 }
-async function buildImage(input) {
-  await runOrThrow(input.runner, {
-    command: input.engine,
-    args: [
-      ...buildContextArgs(input.engine, input.context),
-      "build",
-      "--tag",
-      input.image,
-      "-f",
-      input.dockerfilePath,
-      ...sortedBuildArgs(input.buildArgs).flatMap(([key, value]) => [
-        "--build-arg",
-        `${key}=${value}`
-      ]),
-      input.buildContext
-    ],
-    stdout: "pipe",
-    stderr: "pipe"
-  });
+function setDetachedJobContext(env, context) {
+  const candidate = env;
+  candidate.setDetachedJobContext?.(context);
 }
-function parseDockerRuntime(runtime) {
-  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
-    throw new Error("docker runtime must be an object");
-  }
-  const record = runtime;
-  if (record.type !== "docker") {
-    throw new Error('docker runtime type must be "docker"');
+function isPromiseLike(value) {
+  return typeof value.then === "function";
+}
+function createAbortError2() {
+  const error2 = new Error("Agent spawn aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+function createActivityTimeoutError(timeoutMs) {
+  const error2 = new Error(`Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`);
+  error2.name = "ActivityTimeoutError";
+  return error2;
+}
+function createUlid() {
+  const time = BigInt(Date.now());
+  const random = randomBytes3(10);
+  let randomValue = 0n;
+  for (const byte of random) {
+    randomValue = randomValue << 8n | BigInt(byte);
   }
-  return record;
+  return encodeBase32(time, 10) + encodeBase32(randomValue, 16);
 }
-async function runAndRead(runner, spec) {
-  const handle = runner.exec(spec);
-  const stdout = readStream2(handle.stdout);
-  const stderr = readStream2(handle.stderr);
-  const result = await handle.result;
-  const output = await stdout;
-  if (result.exitCode !== 0) {
-    const errorOutput = await stderr;
-    throw new Error(
-      `Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}${errorOutput ? `
-${errorOutput}` : ""}`
-    );
+function encodeBase32(value, length) {
+  const chars = Array.from({ length }, () => "0");
+  let remaining = value;
+  for (let index = length - 1; index >= 0; index -= 1) {
+    chars[index] = ULID_ALPHABET[Number(remaining & 31n)];
+    remaining >>= 5n;
   }
-  return output;
+  return chars.join("");
 }
-async function runOrThrow(runner, spec) {
-  await runAndRead(runner, spec);
+
+// packages/agent-harness-tools/src/poe-command-execution.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import os3 from "node:os";
+
+// packages/agent-harness-tools/src/execution-env.ts
+var executionEnvFactories = /* @__PURE__ */ new Map();
+function registerExecutionEnvFactory(factory) {
+  executionEnvFactories.set(factory.type, factory);
 }
-async function readStream2(stream) {
-  if (stream === null) {
-    return "";
-  }
-  stream.setEncoding("utf8");
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(String(chunk));
+function selectExecutionEnv(runtime) {
+  return selectExecutionEnvFactory(runtime.type);
+}
+function selectExecutionEnvFactory(type) {
+  const factory = executionEnvFactories.get(type);
+  if (factory === void 0) {
+    throw new Error(
+      `No execution environment factory registered for runtime type "${type}".`
+    );
   }
-  return chunks.join("");
+  return factory;
 }
-function sortedBuildArgs(buildArgs) {
-  return Object.entries(buildArgs).sort(([left], [right]) => left.localeCompare(right));
+
+// packages/agent-harness-tools/src/poe-command-execution.ts
+function resolvePoeCommandExecution(input) {
+  const homeDir = input.context?.homeDir ?? os3.homedir();
+  const runtimeConfigCwd = input.runtimeConfigCwd ?? input.cwd;
+  const loaded = loadRuntimeConfig(runtimeConfigCwd, homeDir);
+  const config = applyRuntimeOverrides(loaded, input.runtime, runtimeConfigCwd);
+  const resolved = resolveRuntime({ cwd: runtimeConfigCwd, config });
+  const factory = selectExecutionEnv(resolved.runtime);
+  const state = input.context?.state ?? loadState(homeDir);
+  return {
+    factory,
+    detach: factory.supportsDetach === true && config.runner.detach,
+    state,
+    openSpec: {
+      cwd: input.cwd,
+      runtimeCwd: runtimeConfigCwd,
+      runtime: resolved.runtime,
+      runner: config.runner,
+      state,
+      env: input.env,
+      uploadIgnoreFiles: config.runner.workspace?.exclude ?? [],
+      jobLabel: {
+        tool: input.tool,
+        argv: input.argv
+      },
+      ...input.openSpec
+    }
+  };
 }
-function buildEnvArgs(env) {
-  if (env === void 0) {
-    return [];
+function applyRuntimeOverrides(config, overrides, cwd = process.cwd()) {
+  if (!overrides) {
+    return { runtime: config.runtime, runner: config.runner };
   }
-  return Object.entries(env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
-}
-function createContainerName() {
-  return `poe-env-${randomBytes3(6).toString("hex")}`;
-}
-function createContainerJob(containerId, runner, engine, context, jobId = containerId) {
+  const base = "rawScope" in config && config.rawScope ? { ...config.rawScope } : { ...config.runtime };
+  const runtime = parseRuntime({
+    ...base,
+    ...overrides.runtime !== void 0 ? { type: overrides.runtime } : {},
+    ...overrides.runtimeImage !== void 0 ? { image: overrides.runtimeImage } : {},
+    ...overrides.runtimeTemplate !== void 0 ? { template_id: overrides.runtimeTemplate } : {},
+    ...overrides.mountPoeCode === true ? { mounts: [...config.runtime.mounts, createPoeCodeMount(cwd)] } : {}
+  });
   return {
-    id: jobId,
-    envId: containerId,
-    tool: "docker",
-    argv: ["attach", containerId],
-    async status() {
-      const handle = runner.exec({
-        command: engine,
-        args: [
-          ...buildContextArgs(engine, context),
-          "inspect",
-          "-f",
-          "{{.State.Status}}",
-          containerId
-        ],
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const stdout = await readStream2(handle.stdout);
-      const result = await handle.result;
-      if (result.exitCode !== 0) {
-        return "lost";
-      }
-      return stdout.trim() === "running" ? "running" : "exited";
-    },
-    async *stream(opts) {
-      const handle = runner.exec({
-        command: engine,
-        args: [
-          ...buildContextArgs(engine, context),
-          "exec",
-          containerId,
-          "sh",
-          "-c",
-          `test -f ${shellQuote2(`/tmp/poe-jobs/${jobId}.log`)} && tail -c +${(opts?.sinceByte ?? 0) + 1} ${shellQuote2(`/tmp/poe-jobs/${jobId}.log`)} || true`
-        ],
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const stdout = await readStream2(handle.stdout);
-      await handle.result;
-      if (stdout.length > 0) {
-        yield { byteOffset: opts?.sinceByte ?? 0, data: stdout };
-      }
-    },
-    async wait() {
-      const handle = runner.exec({
-        command: engine,
-        args: [...buildContextArgs(engine, context), "wait", containerId],
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const stdout = await readStream2(handle.stdout);
-      const result = await handle.result;
-      return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
-    },
-    async kill(signal) {
-      const args = signal === void 0 || signal === "SIGTERM" ? ["stop", containerId] : ["kill", ...signal === "SIGKILL" ? [] : [`--signal=${signal}`], containerId];
-      await runOrThrow(runner, {
-        command: engine,
-        args: [...buildContextArgs(engine, context), ...args],
-        stdout: "pipe",
-        stderr: "pipe"
-      });
+    runtime,
+    runner: {
+      ...config.runner,
+      ...overrides.detach === true ? { detach: true } : {},
+      ...overrides.runnerSync !== void 0 ? { sync: overrides.runnerSync } : {}
     }
   };
 }
-function createAttachedSpec(cwd = "/workspace") {
+function createPoeCodeMount(cwd) {
   return {
-    cwd,
-    runtime: {
-      type: "docker",
-      image: "attached",
-      build_args: {},
-      mounts: []
-    },
-    env: {},
-    uploadIgnoreFiles: [],
-    jobLabel: {
-      tool: "docker",
-      argv: []
-    }
+    source: cwd,
+    target: "/usr/local/lib/poe-code",
+    readonly: true
   };
 }
-function shellQuote2(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
+function loadRuntimeConfig(cwd, homeDir) {
+  const document = deepMergeDocuments(
+    readConfigDocument(resolveConfigPath(homeDir)),
+    readConfigDocument(resolveProjectConfigPath(cwd))
+  );
+  const runtimeScope = resolveScope(runtimeConfigScope.schema, document.runtime, process.env);
+  return {
+    rawScope: { ...runtimeScope },
+    runtime: parseRuntime(runtimeScope),
+    runner: runtimeScope.runner
+  };
 }
-
-// packages/process-runner/src/host/host-execution-env.ts
-var hostExecutionEnvFactory = {
-  type: "host",
-  supportsDetach: false,
-  async open(openSpec) {
-    return {
-      id: "host",
-      job: null,
-      async uploadWorkspace() {
-        return {
-          files: 0,
-          bytes: 0,
-          skipped: []
-        };
+function readConfigDocument(filePath) {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function loadState(homeDir) {
+  if (process.env.VITEST === "true") {
+    return createMemoryStateManager();
+  }
+  return createStateManager(homeDir);
+}
+function createMemoryStateManager() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    templates: {
+      async get() {
+        return null;
       },
-      async downloadWorkspace() {
-        return {
-          files: 0,
-          bytes: 0,
-          conflicts: []
-        };
+      async put() {
       },
-      exec(spec) {
-        return createHostRunner().exec(spec);
+      async remove() {
       },
-      async detach() {
-        throw new Error("host runtime does not support detach because host has no addressable env");
+      async list() {
+        return [];
+      }
+    },
+    jobs: {
+      async get(id) {
+        return jobs.get(id) ?? null;
       },
-      shell() {
-        const shellSpec = openSpec.shellSpec;
-        return createHostRunner().exec({
-          command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
-          ...shellSpec?.args ? { args: shellSpec.args } : {},
-          cwd: openSpec.cwd,
-          env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
-          stdin: "inherit",
-          stdout: "inherit",
-          stderr: "inherit",
-          tty: true
-        });
+      async put(entry) {
+        jobs.set(entry.id, entry);
       },
-      async close() {
+      async update(id, patch) {
+        const current = jobs.get(id);
+        if (!current) {
+          return null;
+        }
+        const updated = { ...current, ...patch, id };
+        jobs.set(id, updated);
+        return updated;
+      },
+      async list(filter) {
+        const entries = Array.from(jobs.values());
+        if (!filter) {
+          return entries;
+        }
+        return entries.filter(
+          (entry) => Object.entries(filter).every(([key, value]) => entry[key] === value)
+        );
+      },
+      async remove(id) {
+        jobs.delete(id);
       }
-    };
-  },
-  async attach() {
-    throw new Error("host runtime does not support reattach");
-  }
-};
+    }
+  };
+}
 
-// packages/process-runner/src/testing/mock-runner.ts
-import { Readable, Writable } from "node:stream";
+// packages/agent-harness-tools/src/workspace-transfer.ts
+import { createHash as createHash4 } from "node:crypto";
+import { promises as nodeFs3 } from "node:fs";
+import path29 from "node:path";
 
 // packages/runner-e2b/src/factory.ts
-import path30 from "node:path";
+import path33 from "node:path";
 
 // packages/runner-e2b/src/sdk.ts
 import { Template, Sandbox } from "e2b";
@@ -5619,7 +5762,7 @@ async function readableToString(stream) {
 // packages/runner-e2b/src/template-build.ts
 import { createHash as createHash5 } from "node:crypto";
 import { readdir as readdir4, readFile as readFile11 } from "node:fs/promises";
-import path27 from "node:path";
+import path30 from "node:path";
 var BUILD_LOG_TAIL_SIZE = 30;
 async function buildE2bRuntimeTemplate(input) {
   const dockerfileBytes = await readFile11(input.dockerfilePath);
@@ -5700,10 +5843,10 @@ async function readBuildContextFiles(buildContext) {
   return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 async function collectBuildContextFiles(buildContext, relativeDir, files) {
-  const absoluteDir = path27.join(buildContext, relativeDir);
+  const absoluteDir = path30.join(buildContext, relativeDir);
   const entries = await readdir4(absoluteDir, { withFileTypes: true });
   for (const entry of entries) {
-    const relativePath = path27.join(relativeDir, entry.name);
+    const relativePath = path30.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       await collectBuildContextFiles(buildContext, relativePath, files);
       continue;
@@ -5712,8 +5855,8 @@ async function collectBuildContextFiles(buildContext, relativeDir, files) {
       continue;
     }
     files.push({
-      relativePath: relativePath.split(path27.sep).join("/"),
-      bytes: await readFile11(path27.join(buildContext, relativePath))
+      relativePath: relativePath.split(path30.sep).join("/"),
+      bytes: await readFile11(path30.join(buildContext, relativePath))
     });
   }
 }
@@ -5722,11 +5865,11 @@ async function collectBuildContextFiles(buildContext, relativeDir, files) {
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
 import { readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import path29 from "node:path";
+import path32 from "node:path";
 import { PassThrough, Writable as Writable2 } from "node:stream";
 
 // packages/runner-e2b/src/job-handle.ts
-import path28 from "node:path";
+import path31 from "node:path";
 var JOB_DIR2 = "/tmp/poe-jobs";
 function createE2bJobHandle(input) {
   const fs14 = createE2bLogStreamFs(input.sandbox);
@@ -5784,7 +5927,7 @@ function createE2bLogStreamFs(sandbox) {
     watch(filePath, listener) {
       let closed = false;
       let stop = null;
-      void sandbox.files.watchDir(path28.dirname(filePath), listener, { recursive: false }).then((handle) => {
+      void sandbox.files.watchDir(path31.dirname(filePath), listener, { recursive: false }).then((handle) => {
         if (closed) {
           void handle.stop();
           return;
@@ -5823,7 +5966,7 @@ async function readExitCode(sandbox, jobId) {
 var REMOTE_COMMAND_STDERR_TAIL_SIZE = 30;
 function createOpenedE2bEnv(input) {
   const hostRunner = input.spec.hostRunner ?? createHostRunner();
-  const hostWorkspaceDir = path29.resolve(input.spec.cwd);
+  const hostWorkspaceDir = path32.resolve(input.spec.cwd);
   const sandboxWorkspaceDir = normalizeSandboxWorkspaceDir(input.runtime.workspace_dir);
   let lastProcess = null;
   let detachedJobContext = null;
@@ -5831,7 +5974,7 @@ function createOpenedE2bEnv(input) {
     if (cwd === void 0) {
       return void 0;
     }
-    if (path29.isAbsolute(cwd) && path29.resolve(cwd) === hostWorkspaceDir) {
+    if (path32.isAbsolute(cwd) && path32.resolve(cwd) === hostWorkspaceDir) {
       return sandboxWorkspaceDir;
     }
     return cwd;
@@ -5855,8 +5998,8 @@ function createOpenedE2bEnv(input) {
       if (input.spec.runner?.sync === "none") {
         return { files: 0, bytes: 0, skipped: [] };
       }
-      const tempDir = mkdtempSync2(path29.join(tmpdir2(), "poe-e2b-upload-"));
-      const archivePath = path29.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync2(path32.join(tmpdir2(), "poe-e2b-upload-"));
+      const archivePath = path32.join(tempDir, "workspace.tar");
       try {
         await runOrThrow2(hostRunner, {
           command: "tar",
@@ -5888,8 +6031,8 @@ function createOpenedE2bEnv(input) {
       if (input.spec.runner?.sync === "upload" || input.spec.runner?.sync === "none") {
         return { files: 0, bytes: 0, conflicts: [] };
       }
-      const tempDir = mkdtempSync2(path29.join(tmpdir2(), "poe-e2b-download-"));
-      const archivePath = path29.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync2(path32.join(tmpdir2(), "poe-e2b-download-"));
+      const archivePath = path32.join(tempDir, "workspace.tar");
       try {
         await runRemoteOrThrow(
           input.sandbox,
@@ -6212,10 +6355,10 @@ function resolveSandboxCommandEnv(env) {
 }
 function normalizeSandboxWorkspaceDir(workspaceDir) {
   const resolvedWorkspaceDir = workspaceDir ?? "/workspace";
-  if (!path29.posix.isAbsolute(resolvedWorkspaceDir)) {
+  if (!path32.posix.isAbsolute(resolvedWorkspaceDir)) {
     throw new Error("E2B runtime workspace_dir must be an absolute sandbox path.");
   }
-  let normalized = path29.posix.normalize(resolvedWorkspaceDir);
+  let normalized = path32.posix.normalize(resolvedWorkspaceDir);
   while (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
@@ -6271,11 +6414,11 @@ var e2bExecutionEnvFactory = {
     const apiKey = await resolveE2bApiKey({ cwd: runtimeCwd });
     const templateId = runtime.template_id ?? (await buildE2bRuntimeTemplate({
       runtime,
-      dockerfilePath: path30.resolve(
+      dockerfilePath: path33.resolve(
         runtimeCwd,
-        runtime.dockerfile ?? path30.join(".poe-code", "Dockerfile")
+        runtime.dockerfile ?? path33.join(".poe-code", "Dockerfile")
       ),
-      buildContext: path30.resolve(runtimeCwd, runtime.build_context ?? "."),
+      buildContext: path33.resolve(runtimeCwd, runtime.build_context ?? "."),
       state: spec.state,
       apiKey
     })).templateId;
@@ -6716,7 +6859,7 @@ function listMcpSupportedAgents() {
 
 // packages/agent-spawn/src/spawn.ts
 import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path31 from "node:path";
+import path34 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -6945,11 +7088,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path31.join(options.logDir, options.logFileName);
+  return path34.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path31.dirname(filePath), { recursive: true });
+    mkdirSync(path34.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -6973,36 +7116,36 @@ function closeSpawnLog(fd) {
 // packages/design-system/src/tokens/colors.ts
 import chalk from "chalk";
 var dark = {
-  header: (text4) => chalk.magentaBright.bold(text4),
-  divider: (text4) => chalk.dim(text4),
-  prompt: (text4) => chalk.cyan(text4),
-  number: (text4) => chalk.cyanBright(text4),
-  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
+  header: (text5) => chalk.magentaBright.bold(text5),
+  divider: (text5) => chalk.dim(text5),
+  prompt: (text5) => chalk.cyan(text5),
+  number: (text5) => chalk.cyanBright(text5),
+  intro: (text5) => chalk.bgMagenta.white(` Poe - ${text5} `),
   resolvedSymbol: chalk.magenta("\u25C7"),
   errorSymbol: chalk.red("\u25A0"),
-  accent: (text4) => chalk.cyan(text4),
-  muted: (text4) => chalk.dim(text4),
-  success: (text4) => chalk.green(text4),
-  warning: (text4) => chalk.yellow(text4),
-  error: (text4) => chalk.red(text4),
-  info: (text4) => chalk.magenta(text4),
-  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
+  accent: (text5) => chalk.cyan(text5),
+  muted: (text5) => chalk.dim(text5),
+  success: (text5) => chalk.green(text5),
+  warning: (text5) => chalk.yellow(text5),
+  error: (text5) => chalk.red(text5),
+  info: (text5) => chalk.magenta(text5),
+  badge: (text5) => chalk.bgYellow.black(` ${text5} `)
 };
 var light = {
-  header: (text4) => chalk.hex("#a200ff").bold(text4),
-  divider: (text4) => chalk.hex("#666666")(text4),
-  prompt: (text4) => chalk.hex("#006699").bold(text4),
-  number: (text4) => chalk.hex("#0077cc").bold(text4),
-  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
+  header: (text5) => chalk.hex("#a200ff").bold(text5),
+  divider: (text5) => chalk.hex("#666666")(text5),
+  prompt: (text5) => chalk.hex("#006699").bold(text5),
+  number: (text5) => chalk.hex("#0077cc").bold(text5),
+  intro: (text5) => chalk.bgHex("#a200ff").white(` Poe - ${text5} `),
   resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
   errorSymbol: chalk.hex("#cc0000")("\u25A0"),
-  accent: (text4) => chalk.hex("#006699").bold(text4),
-  muted: (text4) => chalk.hex("#666666")(text4),
-  success: (text4) => chalk.hex("#008800")(text4),
-  warning: (text4) => chalk.hex("#cc6600")(text4),
-  error: (text4) => chalk.hex("#cc0000")(text4),
-  info: (text4) => chalk.hex("#a200ff")(text4),
-  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+  accent: (text5) => chalk.hex("#006699").bold(text5),
+  muted: (text5) => chalk.hex("#666666")(text5),
+  success: (text5) => chalk.hex("#008800")(text5),
+  warning: (text5) => chalk.hex("#cc6600")(text5),
+  error: (text5) => chalk.hex("#cc0000")(text5),
+  info: (text5) => chalk.hex("#a200ff")(text5),
+  badge: (text5) => chalk.bgHex("#cc6600").white(` ${text5} `)
 };
 
 // packages/design-system/src/tokens/typography.ts
@@ -7377,7 +7520,7 @@ import chalk16 from "chalk";
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path32 from "node:path";
+import path35 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { open as open2, readdir as readdir5 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -7391,18 +7534,18 @@ import {
 } from "node:child_process";
 
 // packages/poe-acp-client/src/run-report.ts
-import * as fsPromises3 from "node:fs/promises";
+import * as fsPromises5 from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path33 from "node:path";
+import path36 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { mkdir as mkdir5, open as open3 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
 import * as fs10 from "node:fs/promises";
-import path34 from "node:path";
+import path37 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -7411,19 +7554,19 @@ function createTokenizer(options = {}) {
   const encoding = options.encoding ?? DEFAULT_ENCODING;
   const tokenizer = get_encoding(encoding);
   const utf8Decoder = new TextDecoder();
-  const encode = (text4) => tokenizer.encode(text4);
+  const encode = (text5) => tokenizer.encode(text5);
   const decode = (tokens) => {
     const tokenArray = tokens instanceof Uint32Array ? tokens : Uint32Array.from(tokens);
     return utf8Decoder.decode(tokenizer.decode(tokenArray));
   };
-  const count = (text4) => encode(text4).length;
-  const truncate2 = (text4, tokenCount) => {
+  const count = (text5) => encode(text5).length;
+  const truncate2 = (text5, tokenCount) => {
     if (tokenCount <= 0) {
       return "";
     }
-    const tokens = encode(text4);
+    const tokens = encode(text5);
     if (tokens.length <= tokenCount) {
-      return text4;
+      return text5;
     }
     return decode(tokens.slice(0, tokenCount));
   };
@@ -7437,9 +7580,9 @@ function createTokenizer(options = {}) {
   };
 }
 var defaultTokenizer;
-function countTokens(text4) {
+function countTokens(text5) {
   defaultTokenizer ??= createTokenizer();
-  return defaultTokenizer.count(text4);
+  return defaultTokenizer.count(text5);
 }
 
 // packages/tokenfill/dist/corpus.js
@@ -7486,11 +7629,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path34.resolve(root, "..", "..");
+  const repoRoot = path37.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path34.isAbsolute(sourcePath) ? sourcePath : path34.resolve(repoRoot, sourcePath);
+    const absPath = path37.isAbsolute(sourcePath) ? sourcePath : path37.resolve(repoRoot, sourcePath);
     try {
       const content = await fs10.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -7541,10 +7684,10 @@ function resolveRunners(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs11.readFile(path35.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs11.readFile(path38.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs11,
-    filePath: path35.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path38.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -7634,7 +7777,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path35.resolve(root, "..", "..");
+  return path38.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -7986,8 +8129,8 @@ var File = class _File {
     const isText = isTextMimeType(mimeType);
     return new _File(data, mimeType, isText);
   }
-  static fromText(text4, mimeType = "text/plain") {
-    return new _File(text4, mimeType, true);
+  static fromText(text5, mimeType = "text/plain") {
+    return new _File(text5, mimeType, true);
   }
   static fromBase64(base64, mimeType) {
     const data = Buffer.from(base64, "base64");
@@ -7997,18 +8140,18 @@ var File = class _File {
   toContentBlock() {
     const uri = this.name ? `file:///${this.name}` : "file:///data";
     if (this.isText) {
-      let text4;
+      let text5;
       if (typeof this.data === "string") {
-        text4 = this.data;
+        text5 = this.data;
       } else {
-        text4 = new TextDecoder("utf-8").decode(this.data);
+        text5 = new TextDecoder("utf-8").decode(this.data);
       }
       return {
         type: "resource",
         resource: {
           uri,
           mimeType: this.mimeType,
-          text: text4
+          text: text5
         }
       };
     } else {
@@ -8393,7 +8536,7 @@ function printMcpConfig() {
 
 // packages/agent-skill-config/src/configs.ts
 import os5 from "node:os";
-import path36 from "node:path";
+import path39 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -8427,7 +8570,7 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 
 // packages/agent-skill-config/src/templates.ts
 import { readFile as readFile15, stat as stat6 } from "node:fs/promises";
-import path37 from "node:path";
+import path40 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -8560,7 +8703,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path38 from "node:path";
+import path41 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -8652,7 +8795,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path38.dirname(configPath);
+  return path41.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -8678,9 +8821,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path38.join(homeDir, configPath.slice(2));
+    return path41.join(homeDir, configPath.slice(2));
   }
-  return path38.join(homeDir, configPath.slice(1));
+  return path41.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -8713,7 +8856,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path38.dirname(absolutePath);
+  const configDir = path41.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -8891,7 +9034,7 @@ async function installMemory(options) {
 
 // packages/memory/src/query.ts
 import * as fs12 from "node:fs/promises";
-import path39 from "node:path";
+import path42 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -8905,7 +9048,7 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs12,
-    filePath: path39.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path42.join(inferRepoRoot2(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const context = await selectQueryContext(root, options.question, options.budget);
@@ -8920,7 +9063,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path39.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs12.readFile(path42.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -8950,8 +9093,8 @@ async function selectQueryContext(root, question, budget) {
 function rankPagesForQuery(pages, question) {
   const terms = tokenize(question);
   const documents = pages.map((page) => {
-    const text4 = [page.relPath, page.frontmatter.name ?? "", page.frontmatter.description ?? "", page.body].join("\n").toLowerCase();
-    const tokens = tokenize(text4);
+    const text5 = [page.relPath, page.frontmatter.name ?? "", page.frontmatter.description ?? "", page.body].join("\n").toLowerCase();
+    const tokens = tokenize(text5);
     const counts = /* @__PURE__ */ new Map();
     for (const token of tokens) {
       counts.set(token, (counts.get(token) ?? 0) + 1);
@@ -8995,16 +9138,16 @@ function buildQueryPrompt(question, indexText, pages) {
 function renderPageContext(page) {
   return [`FILE: ${page.relPath}`, page.body].join("\n");
 }
-function tokenize(text4) {
-  return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+function tokenize(text5) {
+  return text5.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path39.resolve(root, "..", "..");
+  return path42.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
 import * as fs13 from "node:fs/promises";
-import path40 from "node:path";
+import path43 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -9027,7 +9170,7 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs13,
-    filePath: path40.join(inferRepoRoot3(root), "poe-code.json")
+    filePath: path43.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const response = await spawn3(agentId, { prompt });
@@ -9076,7 +9219,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path40.resolve(root, "..", "..");
+  return path43.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -9089,9 +9232,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path41 from "node:path";
+import path44 from "node:path";
 function openMemory(opts) {
-  if (!path41.isAbsolute(opts.root)) {
+  if (!path44.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;