poe-code 3.0.203 → 3.0.204

package/packages/memory/dist/index.js

@@ -94,6 +94,11 @@ var runtimeConfigScope = {
       default: "",
       doc: "Path to the Docker build context"
     },
+    workspace_dir: {
+      type: "string",
+      default: "/workspace",
+      doc: "Sandbox-local workspace directory for E2B runtime upload, execution, and download"
+    },
     engine: {
       type: "string",
       default: "",
@@ -115,6 +120,11 @@ var runtimeConfigScope = {
       default: "",
       doc: "Prebuilt E2B template id"
     },
+    from_template: {
+      type: "string",
+      default: "",
+      doc: "Existing E2B template alias to extend instead of using the Dockerfile FROM image"
+    },
     cpu: {
       type: "json",
       default: void 0,
@@ -138,11 +148,6 @@ var runtimeConfigScope = {
       default: void 0,
       parse: parseOptionalNumber,
       doc: "Hours to keep an E2B sandbox alive after job exit"
-    },
-    api_key_env: {
-      type: "string",
-      default: "",
-      doc: "Environment variable name containing the E2B API key"
     }
   }
 };
@@ -162,6 +167,7 @@ function parseRunner(raw) {
     detach: parseOptionalBoolean(record.detach, "runner.detach") ?? false,
     upload_max_file_mb: uploadMaxFileMb,
     download_conflict: parseDownloadConflict(record.download_conflict),
+    sync: parseRunnerSync(record.sync),
     workspace: parseRunnerWorkspace(record.workspace)
   });
 }
@@ -200,13 +206,14 @@ function parseRuntime(raw) {
       ...shared,
       type,
       template_id: parseOptionalString(record.template_id),
+      from_template: parseOptionalString(record.from_template),
       dockerfile: parseOptionalString(record.dockerfile),
       build_context: parseOptionalString(record.build_context),
+      workspace_dir: parseWorkspaceDir(record.workspace_dir),
       cpu: parseOptionalNumber(record.cpu),
       memory_mb: parseOptionalNumber(record.memory_mb),
       timeout_minutes: parseOptionalNumber(record.timeout_minutes),
-      preserve_after_exit_hours: preserveAfterExitHours,
-      api_key_env: parseOptionalString(record.api_key_env) ?? "E2B_API_KEY"
+      preserve_after_exit_hours: preserveAfterExitHours
     });
   }
   return {
@@ -295,11 +302,23 @@ function parseRuntimeType(value) {
   }
   throw new Error('type: expected "host", "docker", or "e2b".');
 }
+function parseWorkspaceDir(value) {
+  const workspaceDir = parseOptionalString(value) ?? "/workspace";
+  if (!path2.posix.isAbsolute(workspaceDir)) {
+    throw new Error("workspace_dir: expected an absolute sandbox path.");
+  }
+  let normalized = path2.posix.normalize(workspaceDir);
+  while (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
 function createDefaultRunnerScope() {
   return {
     detach: false,
     upload_max_file_mb: 100,
     download_conflict: "refuse",
+    sync: "both",
     workspace: {
       exclude: [...defaultWorkspaceExclude]
     }
@@ -330,6 +349,15 @@ function parseDownloadConflict(value) {
   }
   throw new Error('runner.download_conflict: expected "refuse" or "overwrite".');
 }
+function parseRunnerSync(value) {
+  if (value === void 0) {
+    return "both";
+  }
+  if (value === "both" || value === "upload" || value === "none") {
+    return value;
+  }
+  throw new Error('runner.sync: expected "both", "upload", or "none".');
+}
 function parseBuildArgs(value) {
   if (value === void 0) {
     return {};
@@ -442,6 +470,43 @@ function defineScope(scope, schema) {
     schema
   };
 }
+var integrationsConfigScope = defineScope("integrations", {
+  braintrust: {
+    type: "json",
+    default: {
+      enabled: false
+    },
+    parse: parseBraintrustIntegrationConfig,
+    doc: "Braintrust integration configuration"
+  }
+});
+function parseBraintrustIntegrationConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error("expected an object");
+  }
+  const enabled = value.enabled === void 0 ? false : value.enabled;
+  if (typeof enabled !== "boolean") {
+    throw new Error("enabled must be a boolean");
+  }
+  return {
+    enabled,
+    ...optionalStringEntry("apiKey", value.apiKey),
+    ...optionalStringEntry("apiUrl", value.apiUrl),
+    ...optionalStringEntry("project", value.project)
+  };
+}
+function optionalStringEntry(key, value) {
+  if (value === void 0) {
+    return {};
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string`);
+  }
+  return { [key]: value };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // packages/poe-code-config/src/plan-scope.ts
 var planConfigScope = defineScope("plan", {
@@ -546,11 +611,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path38) {
+function mergeObjectLayers(layers, path42) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path38);
+    const resolved = resolveKey(layers, key, path42);
     if (resolved === void 0) {
       continue;
     }
@@ -568,7 +633,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path38) {
+function resolveKey(layers, key, path42) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -598,9 +663,9 @@ function resolveKey(layers, key, path38) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path38, key);
+  const fullPath = buildPath(path42, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path38, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path42, key]);
     return {
       value: merged.data,
       sources: {
@@ -625,8 +690,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path38, key) {
-  return [...path38, key].join(".");
+function buildPath(path42, key) {
+  return [...path42, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1260,16 +1325,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path38) {
-  const ext = getExtension(path38);
+function detectFormat2(path42) {
+  const ext = getExtension(path42);
   return extensionMap[ext];
 }
-function getExtension(path38) {
-  const lastDot = path38.lastIndexOf(".");
+function getExtension(path42) {
+  const lastDot = path42.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path38.slice(lastDot).toLowerCase();
+  return path42.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -1977,7 +2042,7 @@ async function parseStoredDocument(fs14, filePath, raw) {
   }
 }
 function normalizeDocument(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {};
   }
   const document = {};
@@ -1990,7 +2055,7 @@ function normalizeDocument(value) {
   return document;
 }
 function normalizeScopeValues(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {};
   }
   const normalized = {};
@@ -2022,7 +2087,7 @@ function createInvalidBackupPath(filePath) {
   const baseName = path7.basename(filePath);
   return path7.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function resolveConfigPath(homeDir) {
@@ -2139,7 +2204,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path38 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path42 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key of keys) {
@@ -2151,22 +2216,22 @@ function mergeRuntimeScope(baseScope, overrideScope, path38 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path38, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path42, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key] = [...baseValue, ...overrideValue];
       continue;
     }
-    if (isRecord2(baseValue) && isRecord2(overrideValue)) {
-      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path38, key]);
+    if (isRecord3(baseValue) && isRecord3(overrideValue)) {
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path42, key]);
       continue;
     }
     merged[key] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path38) {
-  return path38.join(".") === "mounts" || path38.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path42) {
+  return path42.join(".") === "mounts" || path42.join(".") === "runner.workspace.exclude";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -2285,8 +2350,8 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path38, flags) => fsPromises.open(path38, flags),
-    readFile: (path38, encoding) => fsPromises.readFile(path38, encoding),
+    open: (path42, flags) => fsPromises.open(path42, flags),
+    readFile: (path42, encoding) => fsPromises.readFile(path42, encoding),
     stat: fsPromises.stat,
     unlink: fsPromises.unlink
   };
@@ -2579,12 +2644,12 @@ function parseJobEntry(content) {
   return parsed;
 }
 function isJobEntry(value) {
-  return isRecord3(value) && typeof value.id === "string" && typeof value.env_id === "string" && typeof value.env_kind === "string" && typeof value.tool === "string" && Array.isArray(value.argv) && value.argv.every((arg) => typeof arg === "string") && typeof value.cwd === "string" && typeof value.started_at === "string" && isJobStatus(value.status) && (value.exit_code === void 0 || typeof value.exit_code === "number") && (value.exited_at === void 0 || typeof value.exited_at === "string") && (value.log_file === void 0 || typeof value.log_file === "string");
+  return isRecord4(value) && typeof value.id === "string" && typeof value.env_id === "string" && typeof value.env_kind === "string" && typeof value.tool === "string" && Array.isArray(value.argv) && value.argv.every((arg) => typeof arg === "string") && typeof value.cwd === "string" && typeof value.started_at === "string" && isJobStatus(value.status) && (value.exit_code === void 0 || typeof value.exit_code === "number") && (value.exited_at === void 0 || typeof value.exited_at === "string") && (value.log_file === void 0 || typeof value.log_file === "string");
 }
 function isJobStatus(value) {
   return value === "pending" || value === "running" || value === "exited" || value === "killed" || value === "lost";
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -2653,7 +2718,7 @@ function createEmptyState() {
   };
 }
 function normalizeTemplateState(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return createEmptyState();
   }
   return {
@@ -2662,7 +2727,7 @@ function normalizeTemplateState(value) {
   };
 }
 function normalizeTemplateEntries(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return {};
   }
   const entries = {};
@@ -2674,9 +2739,9 @@ function normalizeTemplateEntries(value) {
   return entries;
 }
 function isTemplateEntry(value) {
-  return isRecord4(value) && typeof value.hash === "string" && typeof value.runtime_type === "string" && typeof value.dockerfile_path === "string" && typeof value.built_at === "string" && (value.template_id === void 0 || typeof value.template_id === "string") && (value.image === void 0 || typeof value.image === "string");
+  return isRecord5(value) && typeof value.hash === "string" && typeof value.runtime_type === "string" && typeof value.dockerfile_path === "string" && typeof value.built_at === "string" && (value.template_id === void 0 || typeof value.template_id === "string") && (value.image === void 0 || typeof value.image === "string");
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -2878,7 +2943,7 @@ function parseYamlFrontmatter(yamlBlock) {
   if (parsed === null) {
     return {};
   }
-  if (!isRecord5(parsed)) {
+  if (!isRecord6(parsed)) {
     throw new Error("YAML frontmatter must parse to an object.");
   }
   return parsed;
@@ -2909,13 +2974,13 @@ function parseSources(value) {
     if (typeof item === "string") {
       return parseSourceRef(item);
     }
-    if (!isRecord5(item)) {
+    if (!isRecord6(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path38 = readRequiredString(item.path, "sources[].path");
+    const path42 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path38, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path42, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -2948,7 +3013,7 @@ function assertValidLineNumber(line, value) {
     throw new Error(`Invalid source ref "${value}": line numbers must be positive integers.`);
   }
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -3971,7 +4036,7 @@ function parseOlderThan(value) {
 
 // packages/memory/src/ingest.ts
 import * as fs11 from "node:fs/promises";
-import path31 from "node:path";
+import path35 from "node:path";
 
 // packages/agent-spawn/src/register-factories.ts
 import { spawn as spawnChildProcess2 } from "node:child_process";
@@ -4145,6 +4210,38 @@ function wrapForLogTee(argv, jobId) {
   ].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);
+  }
+}
+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;
+  }
+}
 async function waitForExit(env, jobId, opts = {}) {
   const fs14 = env.fs ?? nodeFs2;
   const file = jobExitPath(jobId);
@@ -4168,6 +4265,19 @@ function jobLogPath(jobId) {
 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 {
+    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;
@@ -4183,6 +4293,27 @@ async function readFileIfExists2(fs14, file) {
     throw error2;
   }
 }
+async function waitForLogChange(fs14, file) {
+  const watch = fs14.watch;
+  if (typeof watch !== "function") {
+    await sleep3(POLL_INTERVAL_MS);
+    return;
+  }
+  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;
@@ -4217,6 +4348,35 @@ function isNodeError(error2) {
 
 // packages/agent-harness-tools/src/run-poe-command.ts
 import { randomBytes } from "node:crypto";
+
+// 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();
@@ -4237,12 +4397,18 @@ async function runPoeCommand(opts) {
   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: execution && "env" in execution ? execution.env : opts.openSpec.env,
+      env: resolveExecutionEnv(opts.openSpec),
       stdin: execution?.stdin ?? "inherit",
       stdout: execution?.stdout ?? "pipe",
       stderr: execution?.stderr ?? "pipe",
@@ -4252,15 +4418,19 @@ async function runPoeCommand(opts) {
       handle.stdin?.setDefaultEncoding("utf8");
       handle.stdin?.end(execution.input);
     }
-    const runningJob = Promise.all([pendingJob, upload]).then(
-      () => opts.state.jobs.update(jobId, {
-        status: "running",
-        env_id: env.id,
-        started_at: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    );
+    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 };
     }
@@ -4292,6 +4462,97 @@ async function runPoeCommand(opts) {
     }
   }
 }
+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;
+  }
+  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)}`
+    );
+  }
+}
+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;
+    }
+  }
+  return false;
+}
+function resolveExecutionEnv(openSpec) {
+  const execution = openSpec.execution;
+  return execution?.env ?? openSpec.env;
+}
+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 = readStream(handle.stdout);
+  const stderr = readStream(handle.stderr);
+  const result = await handle.result;
+  return {
+    exitCode: result.exitCode,
+    stdout: await stdout,
+    stderr: await stderr
+  };
+}
+function readStream(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;
@@ -4303,7 +4564,9 @@ async function runSync(opts) {
     const download = await opts.env.downloadWorkspace({
       conflictPolicy: opts.openSpec.runner?.download_conflict ?? "refuse"
     });
-    await opts.env.close();
+    if (opts.closeAfterDownload !== false) {
+      await opts.env.close();
+    }
     return {
       exitCode,
       download,
@@ -4459,6 +4722,10 @@ 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";
 }
@@ -4501,10 +4768,13 @@ function registerExecutionEnvFactory(factory) {
   executionEnvFactories.set(factory.type, factory);
 }
 function selectExecutionEnv(runtime) {
-  const factory = executionEnvFactories.get(runtime.type);
+  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 "${runtime.type}".`
+      `No execution environment factory registered for runtime type "${type}".`
     );
   }
   return factory;
@@ -4513,8 +4783,10 @@ function selectExecutionEnv(runtime) {
 // packages/agent-harness-tools/src/poe-command-execution.ts
 function resolvePoeCommandExecution(input) {
   const homeDir = input.context?.homeDir ?? os3.homedir();
-  const config = applyRuntimeOverrides(loadRuntimeConfig(input.cwd, homeDir), input.runtime, input.cwd);
-  const resolved = resolveRuntime({ cwd: input.cwd, config });
+  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 {
@@ -4523,6 +4795,7 @@ function resolvePoeCommandExecution(input) {
     state,
     openSpec: {
       cwd: input.cwd,
+      runtimeCwd: runtimeConfigCwd,
       runtime: resolved.runtime,
       runner: config.runner,
       state,
@@ -4538,10 +4811,11 @@ function resolvePoeCommandExecution(input) {
 }
 function applyRuntimeOverrides(config, overrides, cwd = process.cwd()) {
   if (!overrides) {
-    return config;
+    return { runtime: config.runtime, runner: config.runner };
   }
+  const base = "rawScope" in config && config.rawScope ? { ...config.rawScope } : { ...config.runtime };
   const runtime = parseRuntime({
-    ...config.runtime,
+    ...base,
     ...overrides.runtime !== void 0 ? { type: overrides.runtime } : {},
     ...overrides.runtimeImage !== void 0 ? { image: overrides.runtimeImage } : {},
     ...overrides.runtimeTemplate !== void 0 ? { template_id: overrides.runtimeTemplate } : {},
@@ -4551,7 +4825,8 @@ function applyRuntimeOverrides(config, overrides, cwd = process.cwd()) {
     runtime,
     runner: {
       ...config.runner,
-      ...overrides.detach === true ? { detach: true } : {}
+      ...overrides.detach === true ? { detach: true } : {},
+      ...overrides.runnerSync !== void 0 ? { sync: overrides.runnerSync } : {}
     }
   };
 }
@@ -4569,6 +4844,7 @@ function loadRuntimeConfig(cwd, homeDir) {
   );
   const runtimeScope = resolveScope(runtimeConfigScope.schema, document.runtime, process.env);
   return {
+    rawScope: { ...runtimeScope },
     runtime: parseRuntime(runtimeScope),
     runner: runtimeScope.runner
   };
@@ -4865,14 +5141,15 @@ var dockerExecutionEnvFactory = {
       context
     });
   },
-  async attach(envId) {
+  async attach(envId, context) {
     const engine = detectEngine();
     return createDockerEnv({
       id: envId,
-      spec: createAttachedSpec(),
+      spec: createAttachedSpec(context?.cwd),
       runner: createHostRunner(),
       engine,
-      context: detectContext()
+      context: detectContext(),
+      attachedJobId: context?.jobId
     });
   }
 };
@@ -4880,7 +5157,7 @@ function createDockerEnv(input) {
   const containerRef = input.id;
   return {
     id: containerRef,
-    job: null,
+    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");
@@ -5015,35 +5292,57 @@ 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
+  });
+  return result.image;
+}
+async function buildDockerRuntimeTemplate(input) {
+  const runner = input.runner ?? createHostRunner();
+  const engine = input.runtime.engine ?? detectEngine();
+  const context = detectContext();
   const dockerfilePath = path26.resolve(
-    input.spec.cwd,
+    input.cwd,
     input.runtime.dockerfile ?? path26.join(".poe-code", "Dockerfile")
   );
-  const buildContext = path26.resolve(input.spec.cwd, input.runtime.build_context ?? ".");
+  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 = await input.spec.state?.templates.get("docker", hash);
+  const cached2 = input.force ? null : await input.state?.templates.get("docker", hash);
   if (cached2?.image !== void 0) {
-    return cached2.image;
+    return {
+      backend: "docker",
+      hash,
+      image: cached2.image,
+      cached: true
+    };
   }
   const image = `poe-code/local:${hash}`;
   await buildImage({
-    runner: input.runner,
-    engine: input.engine,
-    context: input.context,
+    runner,
+    engine,
+    context,
     image,
     dockerfilePath,
     buildContext,
     buildArgs: input.runtime.build_args ?? {}
   });
-  await input.spec.state?.templates.put("docker", {
+  await input.state?.templates.put("docker", {
     hash,
     image,
     runtime_type: "docker",
     dockerfile_path: dockerfilePath,
     built_at: (/* @__PURE__ */ new Date()).toISOString()
   });
-  return image;
+  return {
+    backend: "docker",
+    hash,
+    image,
+    cached: false
+  };
 }
 function hashDockerTemplate(dockerfileBytes, buildArgs) {
   const hash = createHash4("sha256");
@@ -5089,8 +5388,8 @@ function parseDockerRuntime(runtime) {
 }
 async function runAndRead(runner, spec) {
   const handle = runner.exec(spec);
-  const stdout = readStream(handle.stdout);
-  const stderr = readStream(handle.stderr);
+  const stdout = readStream2(handle.stdout);
+  const stderr = readStream2(handle.stderr);
   const result = await handle.result;
   const output = await stdout;
   if (result.exitCode !== 0) {
@@ -5105,7 +5404,7 @@ ${errorOutput}` : ""}`
 async function runOrThrow(runner, spec) {
   await runAndRead(runner, spec);
 }
-async function readStream(stream) {
+async function readStream2(stream) {
   if (stream === null) {
     return "";
   }
@@ -5128,9 +5427,9 @@ function buildEnvArgs(env) {
 function createContainerName() {
   return `poe-env-${randomBytes3(6).toString("hex")}`;
 }
-async function createContainerJob(containerId, runner, engine, context) {
+function createContainerJob(containerId, runner, engine, context, jobId = containerId) {
   return {
-    id: containerId,
+    id: jobId,
     envId: containerId,
     tool: "docker",
     argv: ["attach", containerId],
@@ -5147,14 +5446,32 @@ async function createContainerJob(containerId, runner, engine, context) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const stdout = await readStream(handle.stdout);
+      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() {
+    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({
@@ -5163,7 +5480,7 @@ async function createContainerJob(containerId, runner, engine, context) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const stdout = await readStream(handle.stdout);
+      const stdout = await readStream2(handle.stdout);
       const result = await handle.result;
       return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
     },
@@ -5178,9 +5495,9 @@ async function createContainerJob(containerId, runner, engine, context) {
     }
   };
 }
-function createAttachedSpec() {
+function createAttachedSpec(cwd = "/workspace") {
   return {
-    cwd: "/workspace",
+    cwd,
     runtime: {
       type: "docker",
       image: "attached",
@@ -5252,12 +5569,778 @@ var hostExecutionEnvFactory = {
 // packages/process-runner/src/testing/mock-runner.ts
 import { Readable, Writable } from "node:stream";
 
+// packages/runner-e2b/src/factory.ts
+import path30 from "node:path";
+
+// packages/runner-e2b/src/sdk.ts
+import { Template, Sandbox } from "e2b";
+async function createSandbox(opts) {
+  return Sandbox.create(opts.templateId, {
+    apiKey: opts.apiKey,
+    envs: opts.env,
+    ...opts.timeoutMinutes === void 0 ? {} : { timeoutMs: opts.timeoutMinutes * 6e4 }
+  });
+}
+async function connectSandbox(id, apiKey) {
+  return Sandbox.connect(id, apiKey === void 0 ? void 0 : { apiKey });
+}
+async function buildTemplate(opts) {
+  const template = Template({ fileContextPath: opts.buildContext }).fromDockerfile(
+    opts.dockerfilePath
+  );
+  if (opts.fromTemplate !== void 0 && opts.fromTemplate.length > 0) {
+    template.fromTemplate(opts.fromTemplate);
+  }
+  const result = await Template.build(template, opts.name, {
+    apiKey: opts.apiKey,
+    ...opts.cpu === void 0 ? {} : { cpuCount: opts.cpu },
+    ...opts.memoryMb === void 0 ? {} : { memoryMB: opts.memoryMb },
+    ...opts.onLog ? { onBuildLogs: opts.onLog } : {}
+  });
+  return { templateId: result.templateId };
+}
+function toArrayBuffer(buffer) {
+  const output = new ArrayBuffer(buffer.byteLength);
+  new Uint8Array(output).set(buffer);
+  return output;
+}
+async function readableToString(stream) {
+  if (stream === null) {
+    return "";
+  }
+  stream.setEncoding("utf8");
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
+}
+
+// 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";
+var BUILD_LOG_TAIL_SIZE = 30;
+async function buildE2bRuntimeTemplate(input) {
+  const dockerfileBytes = await readFile11(input.dockerfilePath);
+  const buildContextFiles = await readBuildContextFiles(input.buildContext);
+  const hash = hashTemplate(dockerfileBytes, buildContextFiles, input.runtime.build_args);
+  const cached2 = input.force === true ? null : await input.state?.templates.get("e2b", hash);
+  if (cached2?.template_id !== void 0) {
+    return { backend: "e2b", hash, templateId: cached2.template_id, cached: true };
+  }
+  const tail = [];
+  const onLog = (entry) => {
+    tail.push(entry.message);
+    if (tail.length > BUILD_LOG_TAIL_SIZE) {
+      tail.shift();
+    }
+    input.onLog?.(entry);
+  };
+  let built;
+  try {
+    built = await buildTemplate({
+      apiKey: input.apiKey,
+      name: `poe-code-${hash.slice(0, 32)}`,
+      dockerfilePath: input.dockerfilePath,
+      buildContext: input.buildContext,
+      cpu: input.runtime.cpu,
+      memoryMb: input.runtime.memory_mb,
+      fromTemplate: input.runtime.from_template,
+      onLog
+    });
+  } catch (error2) {
+    throw decorateBuildError(error2, tail);
+  }
+  await input.state?.templates.put("e2b", {
+    hash,
+    template_id: built.templateId,
+    runtime_type: "e2b",
+    dockerfile_path: input.dockerfilePath,
+    built_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { backend: "e2b", hash, templateId: built.templateId, cached: false };
+}
+function decorateBuildError(error2, tail) {
+  const original = error2 instanceof Error ? error2 : new Error(String(error2));
+  if (tail.length === 0) {
+    return original;
+  }
+  const decorated = new Error(`${original.message}
+
+Last build output:
+${tail.join("\n")}`);
+  decorated.stack = original.stack;
+  decorated.cause = original;
+  return decorated;
+}
+function hashTemplate(dockerfileBytes, buildContextFiles, buildArgs) {
+  const hash = createHash5("sha256");
+  hash.update(dockerfileBytes);
+  hash.update("\0");
+  for (const file of buildContextFiles) {
+    hash.update(file.relativePath);
+    hash.update("\0");
+    hash.update(file.bytes);
+    hash.update("\0");
+  }
+  for (const [key, value] of Object.entries(buildArgs).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    hash.update(key);
+    hash.update("=");
+    hash.update(value);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function readBuildContextFiles(buildContext) {
+  const files = [];
+  await collectBuildContextFiles(buildContext, "", files);
+  return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function collectBuildContextFiles(buildContext, relativeDir, files) {
+  const absoluteDir = path27.join(buildContext, relativeDir);
+  const entries = await readdir4(absoluteDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = path27.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      await collectBuildContextFiles(buildContext, relativePath, files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push({
+      relativePath: relativePath.split(path27.sep).join("/"),
+      bytes: await readFile11(path27.join(buildContext, relativePath))
+    });
+  }
+}
+
+// packages/runner-e2b/src/opened-env.ts
+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 { PassThrough, Writable as Writable2 } from "node:stream";
+
+// packages/runner-e2b/src/job-handle.ts
+import path28 from "node:path";
+var JOB_DIR2 = "/tmp/poe-jobs";
+function createE2bJobHandle(input) {
+  const fs14 = createE2bLogStreamFs(input.sandbox);
+  return {
+    id: input.jobId,
+    envId: input.envId,
+    tool: input.tool,
+    argv: input.argv,
+    async status() {
+      const exit = await readExitCode(input.sandbox, input.jobId);
+      if (exit !== null) {
+        return "exited";
+      }
+      const processes = await input.sandbox.commands.list();
+      const isRunning = input.pid === void 0 ? processes.some((process2) => processMentionsJob(process2, input.jobId)) : processes.some((process2) => process2.pid === input.pid);
+      return isRunning ? "running" : "lost";
+    },
+    stream(opts = {}) {
+      return streamLogFile({ fs: fs14 }, input.jobId, opts);
+    },
+    async wait() {
+      const result = await waitForExit({ fs: fs14 }, input.jobId);
+      const preserveMs = input.preserveAfterExitHours * 60 * 60 * 1e3;
+      if (preserveMs > 0) {
+        await input.sandbox.setTimeout(preserveMs);
+      }
+      return result;
+    },
+    async kill() {
+      const pids = input.pid === void 0 ? (await input.sandbox.commands.list()).filter((process2) => processMentionsJob(process2, input.jobId)).map((process2) => process2.pid) : [input.pid];
+      await Promise.all(pids.map((pid) => input.sandbox.commands.kill(pid)));
+    }
+  };
+}
+function createE2bLogStreamFs(sandbox) {
+  return {
+    promises: {
+      async readFile(filePath) {
+        return Buffer.from(await sandbox.files.read(filePath, { format: "bytes" }));
+      },
+      async stat(filePath) {
+        const result = await sandbox.commands.run(
+          `stat -c %Y ${shellQuote3(filePath)} 2>/dev/null || stat -f %m ${shellQuote3(filePath)}`
+        );
+        if (!("stdout" in result)) {
+          throw new Error(`Unable to stat ${filePath}`);
+        }
+        const seconds = Number(result.stdout?.trim());
+        if (!Number.isFinite(seconds)) {
+          throw new Error(`Unable to stat ${filePath}`);
+        }
+        return { mtimeMs: seconds * 1e3 };
+      }
+    },
+    watch(filePath, listener) {
+      let closed = false;
+      let stop = null;
+      void sandbox.files.watchDir(path28.dirname(filePath), listener, { recursive: false }).then((handle) => {
+        if (closed) {
+          void handle.stop();
+          return;
+        }
+        stop = () => {
+          void handle.stop();
+        };
+      });
+      return {
+        close() {
+          closed = true;
+          stop?.();
+        }
+      };
+    }
+  };
+}
+function processMentionsJob(process2, jobId) {
+  const needle = `/tmp/poe-jobs/${jobId}`;
+  return process2.cmd.includes(needle) || process2.args.some((arg) => arg.includes(needle));
+}
+function shellQuote3(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function readExitCode(sandbox, jobId) {
+  try {
+    const contents = await sandbox.files.read(`${JOB_DIR2}/${jobId}.exit`);
+    const exitCode = Number(contents.trim());
+    return Number.isInteger(exitCode) ? exitCode : null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/runner-e2b/src/opened-env.ts
+var REMOTE_COMMAND_STDERR_TAIL_SIZE = 30;
+function createOpenedE2bEnv(input) {
+  const hostRunner = input.spec.hostRunner ?? createHostRunner();
+  const hostWorkspaceDir = path29.resolve(input.spec.cwd);
+  const sandboxWorkspaceDir = normalizeSandboxWorkspaceDir(input.runtime.workspace_dir);
+  let lastProcess = null;
+  let detachedJobContext = null;
+  const mapWorkspaceCwd = (cwd) => {
+    if (cwd === void 0) {
+      return void 0;
+    }
+    if (path29.isAbsolute(cwd) && path29.resolve(cwd) === hostWorkspaceDir) {
+      return sandboxWorkspaceDir;
+    }
+    return cwd;
+  };
+  const attachedJobId = input.spec.detachedJobId;
+  const env = {
+    id: input.sandbox.sandboxId,
+    job: attachedJobId ? createE2bJobHandle({
+      sandbox: input.sandbox,
+      envId: input.sandbox.sandboxId,
+      jobId: attachedJobId,
+      tool: input.spec.jobLabel.tool,
+      argv: input.spec.jobLabel.argv,
+      preserveAfterExitHours: input.runtime.preserve_after_exit_hours ?? 24
+    }) : null,
+    fs: createE2bLogStreamFs(input.sandbox),
+    setDetachedJobContext(context) {
+      detachedJobContext = context;
+    },
+    async uploadWorkspace() {
+      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");
+      try {
+        await runOrThrow2(hostRunner, {
+          command: "tar",
+          args: [
+            ...input.spec.uploadIgnoreFiles.flatMap((ignored) => ["--exclude", ignored]),
+            "-cf",
+            archivePath,
+            "-C",
+            input.spec.cwd,
+            "."
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await input.sandbox.files.write(
+          "/tmp/poe-workspace-upload.tar",
+          toArrayBuffer(await readFile12(archivePath))
+        );
+        await runRemoteOrThrow(
+          input.sandbox,
+          createUploadWorkspaceCommand(sandboxWorkspaceDir)
+        );
+        return { files: 0, bytes: 0, skipped: [] };
+      } finally {
+        rmSync2(tempDir, { recursive: true, force: true });
+      }
+    },
+    async downloadWorkspace(opts) {
+      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");
+      try {
+        await runRemoteOrThrow(
+          input.sandbox,
+          `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote4(sandboxWorkspaceDir)} .`
+        );
+        const archive = await input.sandbox.files.read("/tmp/poe-workspace-download.tar", {
+          format: "bytes"
+        });
+        await writeFile7(archivePath, Buffer.from(archive));
+        await runOrThrow2(hostRunner, {
+          command: "tar",
+          args: [
+            opts.conflictPolicy === "refuse" ? "-xkf" : "-xf",
+            archivePath,
+            "-C",
+            input.spec.cwd
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: archive.byteLength, conflicts: [] };
+      } finally {
+        rmSync2(tempDir, { recursive: true, force: true });
+      }
+    },
+    exec(spec) {
+      const handle = runE2bCommand(input.sandbox, {
+        ...spec,
+        cwd: mapWorkspaceCwd(spec.cwd),
+        env: resolveSandboxCommandEnv(spec.env)
+      });
+      lastProcess = { started: handle.started };
+      return handle;
+    },
+    async detach() {
+      if (detachedJobContext === null) {
+        throw new Error("Cannot detach E2B environment before a job context is registered.");
+      }
+      if (lastProcess === null) {
+        throw new Error("Cannot detach E2B environment before a command is running.");
+      }
+      const command = await lastProcess.started;
+      const preserveAfterExitHours = input.runtime.preserve_after_exit_hours ?? 24;
+      const preserveMs = preserveAfterExitHours * 60 * 60 * 1e3;
+      if (preserveMs > 0) {
+        await input.sandbox.setTimeout(preserveMs);
+      }
+      return createE2bJobHandle({
+        sandbox: input.sandbox,
+        envId: input.sandbox.sandboxId,
+        jobId: detachedJobContext.id,
+        tool: detachedJobContext.tool,
+        argv: detachedJobContext.argv,
+        pid: command.pid,
+        preserveAfterExitHours
+      });
+    },
+    shell() {
+      const shellSpec = input.spec.shellSpec;
+      const command = shellSpec?.command ?? input.spec.env.SHELL ?? "sh";
+      return runE2bPty(input.sandbox, {
+        command,
+        ...shellSpec?.args ? { args: shellSpec.args } : {},
+        cwd: mapWorkspaceCwd(shellSpec?.cwd ?? input.spec.cwd),
+        env: resolveSandboxCommandEnv(
+          shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env
+        ),
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        tty: true
+      });
+    },
+    async close() {
+      await input.sandbox.kill();
+    }
+  };
+  return env;
+}
+function runE2bCommand(sandbox, spec) {
+  const stdout = spec.stdout === "inherit" ? null : new PassThrough();
+  const stderr = spec.stderr === "inherit" ? null : new PassThrough();
+  let e2bHandle = null;
+  const command = shellCommand([spec.command, ...spec.args ?? []]);
+  const started = sandbox.commands.run(command, {
+    background: true,
+    cwd: spec.cwd,
+    envs: spec.env,
+    stdin: spec.stdin === "pipe",
+    onStdout(data) {
+      stdout?.write(data);
+      if (spec.stdout === "inherit") {
+        process.stdout.write(data);
+      }
+    },
+    onStderr(data) {
+      stderr?.write(data);
+      if (spec.stderr === "inherit") {
+        process.stderr.write(data);
+      }
+    }
+  });
+  const stdin = spec.stdin === "pipe" ? new Writable2({
+    write(chunk, _encoding, callback) {
+      started.then(
+        (handle) => sandbox.commands.sendStdin(
+          handle.pid,
+          Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))
+        )
+      ).then(() => callback(), callback);
+    },
+    final(callback) {
+      if (sandbox.commands.closeStdin === void 0) {
+        callback();
+        return;
+      }
+      started.then((handle) => sandbox.commands.closeStdin(handle.pid)).then(() => callback(), callback);
+    }
+  }) : null;
+  const result = started.then((handle) => {
+    e2bHandle = handle;
+    return handle.wait();
+  }).then(
+    (result2) => {
+      stdout?.end();
+      stderr?.end();
+      return { exitCode: result2.exitCode ?? 0 };
+    },
+    (error2) => {
+      stdout?.end();
+      stderr?.end();
+      if (isExitError(error2)) {
+        return { exitCode: error2.exitCode };
+      }
+      return { exitCode: 1 };
+    }
+  );
+  return {
+    get pid() {
+      return e2bHandle?.pid ?? null;
+    },
+    stdin,
+    stdout,
+    stderr,
+    result,
+    kill() {
+      void e2bHandle?.kill();
+    },
+    get e2bHandle() {
+      return e2bHandle;
+    },
+    started
+  };
+}
+function runE2bPty(sandbox, spec) {
+  const stdout = new PassThrough();
+  let handleRef = null;
+  const stdin = new Writable2({
+    write(chunk, _encoding, callback) {
+      if (handleRef === null) {
+        callback(new Error("E2B PTY stdin is not ready."));
+        return;
+      }
+      sandbox.pty.sendInput(handleRef.pid, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))).then(() => callback(), callback);
+    }
+  });
+  const started = sandbox.pty.create({
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+    cwd: spec.cwd,
+    envs: spec.env,
+    onData(data) {
+      stdout.write(Buffer.from(data));
+      if (spec.stdout === "inherit") {
+        process.stdout.write(Buffer.from(data));
+      }
+    }
+  });
+  const result = started.then((handle) => {
+    handleRef = handle;
+    return handle.wait();
+  }).then(
+    (result2) => {
+      stdout.end();
+      return { exitCode: result2.exitCode ?? 0 };
+    },
+    () => {
+      stdout.end();
+      return { exitCode: 1 };
+    }
+  );
+  return {
+    get pid() {
+      return handleRef?.pid ?? null;
+    },
+    stdin: spec.stdin === "inherit" ? process.stdin : stdin,
+    stdout: spec.stdout === "inherit" ? null : stdout,
+    stderr: null,
+    result,
+    kill() {
+      void (handleRef === null ? void 0 : sandbox.pty.kill(handleRef.pid));
+    }
+  };
+}
+async function runRemoteOrThrow(sandbox, command) {
+  const stdoutTail = createLineTail(REMOTE_COMMAND_STDERR_TAIL_SIZE);
+  const stderrTail = createLineTail(REMOTE_COMMAND_STDERR_TAIL_SIZE);
+  let result;
+  try {
+    result = await sandbox.commands.run(command, {
+      onStdout(data) {
+        stdoutTail.push(data);
+      },
+      onStderr(data) {
+        stderrTail.push(data);
+      }
+    });
+  } catch (error2) {
+    appendRemoteCommandOutput(error2, stdoutTail, stderrTail);
+    if (isCommandExitError(error2)) {
+      throw decorateRemoteCommandError(error2, command, stderrTail.values());
+    }
+    throw error2;
+  }
+  appendRemoteCommandOutput(result, stdoutTail, stderrTail);
+  if ("exitCode" in result && result.exitCode !== 0) {
+    throw decorateRemoteCommandError(
+      new Error(`E2B command failed with exit code ${result.exitCode}`),
+      command,
+      stderrTail.values()
+    );
+  }
+}
+function appendRemoteCommandOutput(source, stdoutTail, stderrTail) {
+  if (!source || typeof source !== "object") {
+    return;
+  }
+  const output = source;
+  if (typeof output.stdout === "string") {
+    stdoutTail.push(output.stdout);
+  }
+  if (typeof output.stderr === "string") {
+    stderrTail.push(output.stderr);
+  }
+}
+function decorateRemoteCommandError(error2, command, stderrTail) {
+  const original = error2 instanceof Error ? error2 : new Error(String(error2));
+  const tail = stderrTail.length === 0 ? "" : `
+
+Last stderr output:
+${stderrTail.join("\n")}`;
+  const decorated = new Error(`E2B command failed: ${command}
+${original.message}${tail}`);
+  decorated.stack = original.stack;
+  decorated.cause = original;
+  return decorated;
+}
+function createLineTail(maxLines) {
+  const lines = [];
+  let pending = "";
+  const appendLine = (line) => {
+    lines.push(trimTrailingCarriageReturn(line));
+    while (lines.length > maxLines) {
+      lines.shift();
+    }
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      const parts = pending.split("\n");
+      pending = parts.pop() ?? "";
+      for (const line of parts) {
+        appendLine(line);
+      }
+    },
+    values() {
+      const output = [...lines];
+      if (pending.length > 0) {
+        output.push(trimTrailingCarriageReturn(pending));
+      }
+      return output.slice(-maxLines);
+    }
+  };
+}
+function trimTrailingCarriageReturn(value) {
+  return value.endsWith("\r") ? value.slice(0, -1) : value;
+}
+async function runOrThrow2(runner, spec) {
+  const handle = runner.exec(spec);
+  const stderr = readableToString(handle.stderr);
+  const result = await handle.result;
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}
+${await stderr}`
+    );
+  }
+}
+function shellCommand(argv) {
+  return argv.map(shellQuote4).join(" ");
+}
+function shellQuote4(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function createUploadWorkspaceCommand(sandboxWorkspaceDir) {
+  const quotedWorkspaceDir = shellQuote4(sandboxWorkspaceDir);
+  return [
+    `mkdir -p ${quotedWorkspaceDir} || { command -v sudo >/dev/null 2>&1 && sudo mkdir -p ${quotedWorkspaceDir} && sudo chown "$(id -u):$(id -g)" ${quotedWorkspaceDir}; }`,
+    `test -w ${quotedWorkspaceDir} && tar -xf /tmp/poe-workspace-upload.tar -C ${quotedWorkspaceDir}`
+  ].join("\n");
+}
+function resolveSandboxCommandEnv(env) {
+  if (env === void 0) {
+    return void 0;
+  }
+  return {
+    ...env,
+    HOME: "/home/user"
+  };
+}
+function normalizeSandboxWorkspaceDir(workspaceDir) {
+  const resolvedWorkspaceDir = workspaceDir ?? "/workspace";
+  if (!path29.posix.isAbsolute(resolvedWorkspaceDir)) {
+    throw new Error("E2B runtime workspace_dir must be an absolute sandbox path.");
+  }
+  let normalized = path29.posix.normalize(resolvedWorkspaceDir);
+  while (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function isExitError(error2) {
+  return Boolean(
+    error2 && typeof error2 === "object" && typeof error2.exitCode === "number"
+  );
+}
+function isCommandExitError(error2) {
+  return isExitError(error2) || Boolean(
+    error2 && typeof error2 === "object" && error2.name === "CommandExitError"
+  );
+}
+
+// packages/runner-e2b/src/auth-scope.ts
+import os4 from "node:os";
+import { promises as nodeFs4 } from "node:fs";
+var e2bAuthScope = defineScope("e2b", {
+  api_key: {
+    type: "string",
+    default: "",
+    doc: "E2B API key",
+    env: "E2B_API_KEY"
+  }
+});
+async function resolveE2bApiKey(input) {
+  const homeDir = input.homeDir ?? os4.homedir();
+  const fs14 = input.fs ?? nodeFs4;
+  const env = input.env ?? process.env;
+  const document = await readMergedDocument(
+    fs14,
+    resolveConfigPath(homeDir),
+    resolveProjectConfigPath(input.cwd)
+  );
+  const resolved = resolveScope(e2bAuthScope.schema, document.e2b, env);
+  if (resolved.api_key.length === 0) {
+    throw new Error(
+      "No E2B API key. Set E2B_API_KEY or e2b.api_key in ~/.poe-code/config.json."
+    );
+  }
+  return resolved.api_key;
+}
+
+// packages/runner-e2b/src/factory.ts
+var e2bExecutionEnvFactory = {
+  type: "e2b",
+  supportsDetach: true,
+  async open(spec) {
+    const runtime = parseE2bRuntime(spec.runtime);
+    const runtimeCwd = spec.runtimeCwd ?? spec.cwd;
+    const apiKey = await resolveE2bApiKey({ cwd: runtimeCwd });
+    const templateId = runtime.template_id ?? (await buildE2bRuntimeTemplate({
+      runtime,
+      dockerfilePath: path30.resolve(
+        runtimeCwd,
+        runtime.dockerfile ?? path30.join(".poe-code", "Dockerfile")
+      ),
+      buildContext: path30.resolve(runtimeCwd, runtime.build_context ?? "."),
+      state: spec.state,
+      apiKey
+    })).templateId;
+    const sandbox = await createSandbox({
+      apiKey,
+      templateId,
+      env: spec.env,
+      timeoutMinutes: runtime.timeout_minutes
+    });
+    return createOpenedE2bEnv({ sandbox, spec, runtime });
+  },
+  async attach(envId, context) {
+    const cwd = context?.cwd ?? process.cwd();
+    const apiKey = await resolveE2bApiKey({ cwd });
+    const sandbox = await connectSandbox(envId, apiKey);
+    return createOpenedE2bEnv({
+      sandbox,
+      spec: {
+        cwd: context?.cwd ?? "/workspace",
+        runtime: {
+          type: "e2b",
+          build_args: {},
+          mounts: [],
+          workspace_dir: "/workspace",
+          preserve_after_exit_hours: 24
+        },
+        env: {},
+        uploadIgnoreFiles: [],
+        jobLabel: { tool: context?.tool ?? "e2b", argv: context?.argv ?? [] },
+        ...context?.jobId ? { detachedJobId: context.jobId } : {}
+      },
+      runtime: {
+        type: "e2b",
+        build_args: {},
+        mounts: [],
+        workspace_dir: "/workspace",
+        preserve_after_exit_hours: 24
+      }
+    });
+  }
+};
+function parseE2bRuntime(runtime) {
+  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+    throw new Error("e2b runtime must be an object");
+  }
+  const record = runtime;
+  if (record.type !== "e2b") {
+    throw new Error('e2b runtime type must be "e2b"');
+  }
+  return record;
+}
+
+// packages/runner-e2b/src/index.ts
+var e2bExecutionEnvFactory2 = e2bExecutionEnvFactory;
+
 // packages/agent-spawn/src/register-factories.ts
 registerExecutionEnvFactory(hostExecutionEnvFactory);
 registerExecutionEnvFactory(dockerExecutionEnvFactory);
-if (process.env.VITEST === "true") {
+registerExecutionEnvFactory(e2bExecutionEnvFactory2);
+if (isVitest()) {
   registerExecutionEnvFactory(createTestHostExecutionEnvFactory());
 }
+function isVitest() {
+  return process.env.VITEST !== void 0 || process.env.VITEST_POOL_ID !== void 0;
+}
 function createTestHostExecutionEnvFactory() {
   return {
     type: "host",
@@ -5619,7 +6702,7 @@ function listMcpSupportedAgents() {
 
 // packages/agent-spawn/src/spawn.ts
 import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path27 from "node:path";
+import path31 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -5759,6 +6842,7 @@ async function spawn3(agentId, options, context) {
   const argv = [binaryName, ...spawnArgs];
   const execution = resolvePoeCommandExecution({
     cwd: options.cwd ?? process.cwd(),
+    runtimeConfigCwd: options.runtimeConfigCwd,
     env: processEnv ?? process.env,
     argv,
     tool: resolvedId,
@@ -5767,7 +6851,8 @@ async function spawn3(agentId, options, context) {
       runtimeImage: options.runtimeImage,
       runtimeTemplate: options.runtimeTemplate,
       detach: options.detach,
-      mountPoeCode: options.mountPoeCode
+      mountPoeCode: options.mountPoeCode,
+      runnerSync: options.runnerSync
     },
     context,
     openSpec: {
@@ -5804,6 +6889,7 @@ async function spawn3(agentId, options, context) {
         stdout: "",
         stderr: "",
         exitCode: 0,
+        detached: { jobId: result.jobId, envId: result.envId },
         ...logFilePath ? { logFile: logFilePath } : {}
       };
     }
@@ -5825,11 +6911,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path27.join(options.logDir, options.logFileName);
+  return path31.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path27.dirname(filePath), { recursive: true });
+    mkdirSync(path31.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -6225,7 +7311,7 @@ import chalk8 from "chalk";
 
 // packages/design-system/src/dashboard/terminal.ts
 import readline from "node:readline";
-import { PassThrough } from "node:stream";
+import { PassThrough as PassThrough2 } from "node:stream";
 
 // packages/design-system/src/prompts/index.ts
 import chalk15 from "chalk";
@@ -6257,9 +7343,9 @@ import chalk16 from "chalk";
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path28 from "node:path";
+import path32 from "node:path";
 import { homedir as homedir2 } from "node:os";
-import { open as open2, readdir as readdir4 } from "node:fs/promises";
+import { open as open2, readdir as readdir5 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 
 // packages/poe-acp-client/src/acp-client.ts
@@ -6276,13 +7362,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path29 from "node:path";
+import path33 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 path30 from "node:path";
+import path34 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -6366,11 +7452,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path30.resolve(root, "..", "..");
+  const repoRoot = path34.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path30.isAbsolute(sourcePath) ? sourcePath : path30.resolve(repoRoot, sourcePath);
+    const absPath = path34.isAbsolute(sourcePath) ? sourcePath : path34.resolve(repoRoot, sourcePath);
     try {
       const content = await fs10.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -6421,10 +7507,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(path31.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs11.readFile(path35.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs11,
-    filePath: path31.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path35.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -6514,7 +7600,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path31.resolve(root, "..", "..");
+  return path35.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -7272,8 +8358,8 @@ function printMcpConfig() {
 }
 
 // packages/agent-skill-config/src/configs.ts
-import os4 from "node:os";
-import path32 from "node:path";
+import os5 from "node:os";
+import path36 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -7306,8 +8392,8 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 }
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile13, stat as stat6 } from "node:fs/promises";
-import path33 from "node:path";
+import { readFile as readFile15, stat as stat6 } from "node:fs/promises";
+import path37 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -7440,7 +8526,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path34 from "node:path";
+import path38 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -7532,7 +8618,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path34.dirname(configPath);
+  return path38.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -7558,9 +8644,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path34.join(homeDir, configPath.slice(2));
+    return path38.join(homeDir, configPath.slice(2));
   }
-  return path34.join(homeDir, configPath.slice(1));
+  return path38.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -7593,7 +8679,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path34.dirname(absolutePath);
+  const configDir = path38.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -7771,7 +8857,7 @@ async function installMemory(options) {
 
 // packages/memory/src/query.ts
 import * as fs12 from "node:fs/promises";
-import path35 from "node:path";
+import path39 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -7785,7 +8871,7 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs12,
-    filePath: path35.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path39.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);
@@ -7800,7 +8886,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path35.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs12.readFile(path39.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -7879,12 +8965,12 @@ function tokenize(text4) {
   return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path35.resolve(root, "..", "..");
+  return path39.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
 import * as fs13 from "node:fs/promises";
-import path36 from "node:path";
+import path40 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -7907,7 +8993,7 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs13,
-    filePath: path36.join(inferRepoRoot3(root), "poe-code.json")
+    filePath: path40.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const response = await spawn3(agentId, { prompt });
@@ -7956,7 +9042,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path36.resolve(root, "..", "..");
+  return path40.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -7969,9 +9055,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path37 from "node:path";
+import path41 from "node:path";
 function openMemory(opts) {
-  if (!path37.isAbsolute(opts.root)) {
+  if (!path41.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;