poe-code 3.0.203 → 3.0.205

package/dist/providers/poe-agent.js

@@ -609,8 +609,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path37) {
-  if (!isAbsolute(path37)) {
+function assertAbsolutePath(path41) {
+  if (!isAbsolute(path41)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -1383,6 +1383,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)
   });
 }
@@ -1421,13 +1422,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 {
@@ -1464,11 +1466,23 @@ function parseRuntimeType(value) {
   }
   throw new Error('type: expected "host", "docker", or "e2b".');
 }
+function parseWorkspaceDir(value) {
+  const workspaceDir = parseOptionalString(value) ?? "/workspace";
+  if (!path.posix.isAbsolute(workspaceDir)) {
+    throw new Error("workspace_dir: expected an absolute sandbox path.");
+  }
+  let normalized = path.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]
     }
@@ -1499,6 +1513,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 {};
@@ -1661,6 +1684,11 @@ var init_runtime = __esm({
           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: "",
@@ -1682,6 +1710,11 @@ var init_runtime = __esm({
           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,
@@ -1705,11 +1738,6 @@ var init_runtime = __esm({
           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"
         }
       }
     };
@@ -1775,10 +1803,48 @@ function defineScope(scope, schema) {
     schema
   };
 }
+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(key2, value) {
+  if (value === void 0) {
+    return {};
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key2} must be a string`);
+  }
+  return { [key2]: value };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var integrationsConfigScope;
 var init_schema = __esm({
   "packages/poe-code-config/src/schema.ts"() {
     "use strict";
     init_runtime();
+    integrationsConfigScope = defineScope("integrations", {
+      braintrust: {
+        type: "json",
+        default: {
+          enabled: false
+        },
+        parse: parseBraintrustIntegrationConfig,
+        doc: "Braintrust integration configuration"
+      }
+    });
   }
 });
 
@@ -1899,11 +1965,11 @@ var init_parse = __esm({
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path37) {
+function mergeObjectLayers(layers, path41) {
   const data = {};
   const sources = {};
   for (const key2 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key2, path37);
+    const resolved = resolveKey(layers, key2, path41);
     if (resolved === void 0) {
       continue;
     }
@@ -1921,7 +1987,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key2, path37) {
+function resolveKey(layers, key2, path41) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -1951,9 +2017,9 @@ function resolveKey(layers, key2, path37) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path37, key2);
+  const fullPath = buildPath(path41, key2);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path37, key2]);
+    const merged = mergeObjectLayers(objectLayers, [...path41, key2]);
     return {
       value: merged.data,
       sources: {
@@ -1978,8 +2044,8 @@ function isWinningCandidate(key2, value) {
   }
   return true;
 }
-function buildPath(path37, key2) {
-  return [...path37, key2].join(".");
+function buildPath(path41, key2) {
+  return [...path41, key2].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -2625,16 +2691,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path37) {
-  const ext = getExtension(path37);
+function detectFormat2(path41) {
+  const ext = getExtension(path41);
   return extensionMap[ext];
 }
-function getExtension(path37) {
-  const lastDot = path37.lastIndexOf(".");
+function getExtension(path41) {
+  const lastDot = path41.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path37.slice(lastDot).toLowerCase();
+  return path41.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -3432,7 +3498,7 @@ async function parseStoredDocument(fs4, filePath, raw) {
   }
 }
 function normalizeDocument(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {};
   }
   const document = {};
@@ -3445,7 +3511,7 @@ function normalizeDocument(value) {
   return document;
 }
 function normalizeScopeValues(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {};
   }
   const normalized = {};
@@ -3484,7 +3550,7 @@ function createInvalidBackupPath(filePath) {
   const baseName = path6.basename(filePath);
   return path6.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function resolveConfigPath(homeDir) {
@@ -3651,7 +3717,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path37 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path41 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key2 of keys) {
@@ -3663,22 +3729,22 @@ function mergeRuntimeScope(baseScope, overrideScope, path37 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path37, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path41, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key2] = [...baseValue, ...overrideValue];
       continue;
     }
-    if (isRecord2(baseValue) && isRecord2(overrideValue)) {
-      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path37, key2]);
+    if (isRecord3(baseValue) && isRecord3(overrideValue)) {
+      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path41, key2]);
       continue;
     }
     merged[key2] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path37) {
-  return path37.join(".") === "mounts" || path37.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path41) {
+  return path41.join(".") === "mounts" || path41.join(".") === "runner.workspace.exclude";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 var init_merge2 = __esm({
@@ -3687,6 +3753,59 @@ var init_merge2 = __esm({
   }
 });
 
+// packages/poe-code-config/src/merge-callbacks.ts
+function mergeLoopCallbacks(user, added) {
+  return mergeCallbacks(user, added);
+}
+function mergeCallbacks(user, added) {
+  if (!user) {
+    return added;
+  }
+  if (!added) {
+    return user;
+  }
+  const userCallbacks = user;
+  const addedCallbacks = added;
+  const result = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(user), ...Object.keys(added)]);
+  for (const key2 of keys) {
+    const userCallback = userCallbacks[key2];
+    const addedCallback = addedCallbacks[key2];
+    if (userCallback && addedCallback) {
+      result[key2] = function mergedCallback(...args) {
+        const userResult = userCallback.apply(this, args);
+        try {
+          addedCallback.apply(this, args);
+        } catch (error2) {
+          console.warn(`Added callback ${key2} failed`, error2);
+        }
+        return userResult;
+      };
+      continue;
+    }
+    result[key2] = userCallback ?? addedCallback;
+  }
+  return result;
+}
+var init_merge_callbacks = __esm({
+  "packages/poe-code-config/src/merge-callbacks.ts"() {
+    "use strict";
+  }
+});
+
+// packages/poe-code-config/src/integrations-loader.ts
+async function loadIntegrations(config) {
+  if (!config.integrations?.braintrust?.enabled) return null;
+  const packageName = "@poe-code/braintrust";
+  const mod = await import(packageName);
+  return mod.bootstrap(config);
+}
+var init_integrations_loader = __esm({
+  "packages/poe-code-config/src/integrations-loader.ts"() {
+    "use strict";
+  }
+});
+
 // packages/poe-code-config/src/models.ts
 var init_models = __esm({
   "packages/poe-code-config/src/models.ts"() {
@@ -3768,8 +3887,8 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path37, flags) => fsPromises2.open(path37, flags),
-    readFile: (path37, encoding) => fsPromises2.readFile(path37, encoding),
+    open: (path41, flags) => fsPromises2.open(path41, flags),
+    readFile: (path41, encoding) => fsPromises2.readFile(path41, encoding),
     stat: fsPromises2.stat,
     unlink: fsPromises2.unlink
   };
@@ -4089,12 +4208,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));
 }
 var init_jobs = __esm({
@@ -4170,7 +4289,7 @@ function createEmptyState() {
   };
 }
 function normalizeTemplateState(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return createEmptyState();
   }
   return {
@@ -4179,7 +4298,7 @@ function normalizeTemplateState(value) {
   };
 }
 function normalizeTemplateEntries(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return {};
   }
   const entries = {};
@@ -4191,9 +4310,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));
 }
 var init_templates = __esm({
@@ -4231,6 +4350,8 @@ var init_src5 = __esm({
     init_plan_scope();
     init_config();
     init_merge2();
+    init_merge_callbacks();
+    init_integrations_loader();
     init_models();
     init_memory();
     init_resolve2();
@@ -6414,7 +6535,7 @@ async function deriveEncryptionKey(getMachineIdentity, salt) {
 function parseEncryptedDocument(raw) {
   try {
     const parsed = JSON.parse(raw);
-    if (!isRecord5(parsed)) {
+    if (!isRecord6(parsed)) {
       return null;
     }
     if (parsed.version !== ENCRYPTION_VERSION) {
@@ -6433,7 +6554,7 @@ function parseEncryptedDocument(raw) {
     return null;
   }
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isNotFoundError2(error2) {
@@ -12518,6 +12639,38 @@ function wrapForLogTee(argv, jobId) {
   ].join(" && ");
   return ["sh", "-c", script];
 }
+async function* streamLogFile(env, jobId, opts) {
+  const fs4 = env.fs ?? nodeFs2;
+  const file = jobLogPath(jobId);
+  let byteOffset = opts.sinceByte ?? 0;
+  while (true) {
+    if (opts.since !== void 0 && !await wasModifiedSince(fs4, file, opts.since)) {
+      await waitForLogChange(fs4, file);
+      continue;
+    }
+    const result = await readLogChunk(fs4, file, byteOffset);
+    if (result !== null) {
+      byteOffset = result.nextByteOffset;
+      yield result.chunk;
+      continue;
+    }
+    await waitForLogChange(fs4, file);
+  }
+}
+async function wasModifiedSince(fs4, file, since) {
+  if (fs4.promises.stat === void 0) {
+    return true;
+  }
+  try {
+    const stat7 = await fs4.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 fs4 = env.fs ?? nodeFs2;
   const file = jobExitPath(jobId);
@@ -12541,6 +12694,19 @@ function jobLogPath(jobId) {
 function jobExitPath(jobId) {
   return `${JOB_DIR}/${jobId}.exit`;
 }
+async function readLogChunk(fs4, file, byteOffset) {
+  const contents = await readFileIfExists2(fs4, file);
+  if (contents === null || byteOffset >= contents.byteLength) {
+    return null;
+  }
+  return {
+    chunk: {
+      byteOffset,
+      data: contents.subarray(byteOffset).toString("utf8")
+    },
+    nextByteOffset: contents.byteLength
+  };
+}
 async function readTextFileIfExists(fs4, file) {
   const contents = await readFileIfExists2(fs4, file);
   return contents?.toString("utf8") ?? null;
@@ -12556,6 +12722,27 @@ async function readFileIfExists2(fs4, file) {
     throw error2;
   }
 }
+async function waitForLogChange(fs4, file) {
+  const watch = fs4.watch;
+  if (typeof watch !== "function") {
+    await sleep2(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 sleep2(ms, signal) {
   return new Promise((resolve2, reject) => {
     let timer = null;
@@ -12596,6 +12783,38 @@ var init_log_stream = __esm({
   }
 });
 
+// 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
+    }
+  ];
+}
+var init_binary_exists = __esm({
+  "packages/agent-harness-tools/src/binary-exists.ts"() {
+    "use strict";
+  }
+});
+
 // packages/agent-harness-tools/src/run-poe-command.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 async function runPoeCommand(opts) {
@@ -12617,12 +12836,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",
@@ -12632,15 +12857,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 };
     }
@@ -12672,6 +12901,97 @@ async function runPoeCommand(opts) {
     }
   }
 }
+async function configureE2bSpawnAgentIfAvailable(opts) {
+  if (opts.factoryType !== "e2b") {
+    return;
+  }
+  const agentId = resolveAgentId(opts.openSpec.jobLabel.tool);
+  const agent2 = allAgents.find((candidate) => candidate.id === agentId);
+  const binaryName = agent2?.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, spec10) {
+  const handle = env.exec({
+    command: spec10.command,
+    args: spec10.args,
+    cwd: spec10.cwd,
+    env: spec10.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;
@@ -12683,7 +13003,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,
@@ -12839,6 +13161,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";
 }
@@ -12874,6 +13200,8 @@ var ULID_ALPHABET;
 var init_run_poe_command = __esm({
   "packages/agent-harness-tools/src/run-poe-command.ts"() {
     "use strict";
+    init_src8();
+    init_binary_exists();
     init_log_stream();
     ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
   }
@@ -12884,10 +13212,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;
@@ -12905,8 +13236,10 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:f
 import os4 from "node:os";
 function resolvePoeCommandExecution(input) {
   const homeDir = input.context?.homeDir ?? os4.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 {
@@ -12915,6 +13248,7 @@ function resolvePoeCommandExecution(input) {
     state,
     openSpec: {
       cwd: input.cwd,
+      runtimeCwd: runtimeConfigCwd,
       runtime: resolved.runtime,
       runner: config.runner,
       state,
@@ -12930,10 +13264,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 } : {},
@@ -12943,7 +13278,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 } : {}
     }
   };
 }
@@ -12961,6 +13297,7 @@ function loadRuntimeConfig(cwd, homeDir) {
   );
   const runtimeScope = resolveScope(runtimeConfigScope.schema, document.runtime, process.env);
   return {
+    rawScope: { ...runtimeScope },
     runtime: parseRuntime(runtimeScope),
     runner: runtimeScope.runner
   };
@@ -13070,6 +13407,7 @@ var init_src9 = __esm({
     init_run_logs();
     init_log_stream();
     init_run_poe_command();
+    init_binary_exists();
     init_poe_command_execution();
     init_skill_config();
     init_execution_env();
@@ -13290,7 +13628,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(path21.join(tmpdir(), "poe-docker-upload-"));
       const archivePath = path21.join(tempDir, "workspace.tar");
@@ -13425,35 +13763,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 = path21.resolve(
-    input.spec.cwd,
+    input.cwd,
     input.runtime.dockerfile ?? path21.join(".poe-code", "Dockerfile")
   );
-  const buildContext = path21.resolve(input.spec.cwd, input.runtime.build_context ?? ".");
+  const buildContext = path21.resolve(input.cwd, input.runtime.build_context ?? ".");
   const dockerfileBytes = await readFile3(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 = createHash2("sha256");
@@ -13499,8 +13859,8 @@ function parseDockerRuntime(runtime) {
 }
 async function runAndRead(runner, spec10) {
   const handle = runner.exec(spec10);
-  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) {
@@ -13515,7 +13875,7 @@ ${errorOutput}` : ""}`
 async function runOrThrow(runner, spec10) {
   await runAndRead(runner, spec10);
 }
-async function readStream(stream) {
+async function readStream2(stream) {
   if (stream === null) {
     return "";
   }
@@ -13538,9 +13898,9 @@ function buildEnvArgs(env) {
 function createContainerName() {
   return `poe-env-${randomBytes4(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],
@@ -13557,14 +13917,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({
@@ -13573,7 +13951,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 };
     },
@@ -13588,9 +13966,9 @@ async function createContainerJob(containerId, runner, engine, context) {
     }
   };
 }
-function createAttachedSpec() {
+function createAttachedSpec(cwd = "/workspace") {
   return {
-    cwd: "/workspace",
+    cwd,
     runtime: {
       type: "docker",
       image: "attached",
@@ -13661,109 +14039,925 @@ var init_docker_execution_env = __esm({
           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
         });
       }
-    };
+    };
+  }
+});
+
+// packages/process-runner/src/host/host-execution-env.ts
+var hostExecutionEnvFactory;
+var init_host_execution_env = __esm({
+  "packages/process-runner/src/host/host-execution-env.ts"() {
+    "use strict";
+    init_host_runner();
+    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(spec10) {
+            return createHostRunner().exec(spec10);
+          },
+          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() {
+          }
+        };
+      },
+      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";
+var init_mock_runner = __esm({
+  "packages/process-runner/src/testing/mock-runner.ts"() {
+    "use strict";
+  }
+});
+
+// packages/process-runner/src/testing/index.ts
+var init_testing = __esm({
+  "packages/process-runner/src/testing/index.ts"() {
+    "use strict";
+    init_mock_runner();
+  }
+});
+
+// packages/process-runner/src/index.ts
+var init_src10 = __esm({
+  "packages/process-runner/src/index.ts"() {
+    "use strict";
+    init_context();
+    init_engine();
+    init_docker_runner();
+    init_docker_execution_env();
+    init_host_execution_env();
+    init_host_runner();
+    init_testing();
+  }
+});
+
+// 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("");
+}
+var init_sdk = __esm({
+  "packages/runner-e2b/src/sdk.ts"() {
+    "use strict";
+  }
+});
+
+// packages/runner-e2b/src/template-build.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readdir, readFile as readFile4 } from "node:fs/promises";
+import path22 from "node:path";
+async function buildE2bRuntimeTemplate(input) {
+  const dockerfileBytes = await readFile4(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 = createHash3("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 [key2, value] of Object.entries(buildArgs).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    hash.update(key2);
+    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 = path22.join(buildContext, relativeDir);
+  const entries = await readdir(absoluteDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = path22.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      await collectBuildContextFiles(buildContext, relativePath, files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push({
+      relativePath: relativePath.split(path22.sep).join("/"),
+      bytes: await readFile4(path22.join(buildContext, relativePath))
+    });
+  }
+}
+var BUILD_LOG_TAIL_SIZE;
+var init_template_build = __esm({
+  "packages/runner-e2b/src/template-build.ts"() {
+    "use strict";
+    init_sdk();
+    BUILD_LOG_TAIL_SIZE = 30;
+  }
+});
+
+// packages/runner-e2b/src/job-handle.ts
+import path23 from "node:path";
+function createE2bJobHandle(input) {
+  const fs4 = 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: fs4 }, input.jobId, opts);
+    },
+    async wait() {
+      const result = await waitForExit({ fs: fs4 }, 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(path23.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;
+  }
+}
+var JOB_DIR2;
+var init_job_handle = __esm({
+  "packages/runner-e2b/src/job-handle.ts"() {
+    "use strict";
+    init_src9();
+    JOB_DIR2 = "/tmp/poe-jobs";
+  }
+});
+
+// packages/runner-e2b/src/opened-env.ts
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
+import { readFile as readFile5, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path24 from "node:path";
+import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream";
+function createOpenedE2bEnv(input) {
+  const hostRunner = input.spec.hostRunner ?? createHostRunner();
+  const hostWorkspaceDir = path24.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 (path24.isAbsolute(cwd) && path24.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(path24.join(tmpdir2(), "poe-e2b-upload-"));
+      const archivePath = path24.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 readFile5(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(path24.join(tmpdir2(), "poe-e2b-download-"));
+      const archivePath = path24.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 writeFile(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(spec10) {
+      const handle = runE2bCommand(input.sandbox, {
+        ...spec10,
+        cwd: mapWorkspaceCwd(spec10.cwd),
+        env: resolveSandboxCommandEnv(spec10.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, spec10) {
+  const stdout = spec10.stdout === "inherit" ? null : new PassThrough2();
+  const stderr = spec10.stderr === "inherit" ? null : new PassThrough2();
+  let e2bHandle = null;
+  const command = shellCommand([spec10.command, ...spec10.args ?? []]);
+  const started = sandbox.commands.run(command, {
+    background: true,
+    cwd: spec10.cwd,
+    envs: spec10.env,
+    stdin: spec10.stdin === "pipe",
+    onStdout(data) {
+      stdout?.write(data);
+      if (spec10.stdout === "inherit") {
+        process.stdout.write(data);
+      }
+    },
+    onStderr(data) {
+      stderr?.write(data);
+      if (spec10.stderr === "inherit") {
+        process.stderr.write(data);
+      }
+    }
+  });
+  const stdin = spec10.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, spec10) {
+  const stdout = new PassThrough2();
+  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: spec10.cwd,
+    envs: spec10.env,
+    onData(data) {
+      stdout.write(Buffer.from(data));
+      if (spec10.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: spec10.stdin === "inherit" ? process.stdin : stdin,
+    stdout: spec10.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, spec10) {
+  const handle = runner.exec(spec10);
+  const stderr = readableToString(handle.stderr);
+  const result = await handle.result;
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${spec10.command} ${(spec10.args ?? []).join(" ")}
+${await stderr}`
+    );
   }
-});
-
-// packages/process-runner/src/host/host-execution-env.ts
-var hostExecutionEnvFactory;
-var init_host_execution_env = __esm({
-  "packages/process-runner/src/host/host-execution-env.ts"() {
+}
+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 (!path24.posix.isAbsolute(resolvedWorkspaceDir)) {
+    throw new Error("E2B runtime workspace_dir must be an absolute sandbox path.");
+  }
+  let normalized = path24.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"
+  );
+}
+var REMOTE_COMMAND_STDERR_TAIL_SIZE;
+var init_opened_env = __esm({
+  "packages/runner-e2b/src/opened-env.ts"() {
     "use strict";
-    init_host_runner();
-    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(spec10) {
-            return createHostRunner().exec(spec10);
-          },
-          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() {
-          }
-        };
-      },
-      async attach() {
-        throw new Error("host runtime does not support reattach");
-      }
-    };
+    init_src10();
+    init_job_handle();
+    init_sdk();
+    REMOTE_COMMAND_STDERR_TAIL_SIZE = 30;
   }
 });
 
-// packages/process-runner/src/testing/mock-runner.ts
-import { Readable, Writable } from "node:stream";
-var init_mock_runner = __esm({
-  "packages/process-runner/src/testing/mock-runner.ts"() {
+// packages/runner-e2b/src/auth-scope.ts
+import os5 from "node:os";
+import { promises as nodeFs4 } from "node:fs";
+async function resolveE2bApiKey(input) {
+  const homeDir = input.homeDir ?? os5.homedir();
+  const fs4 = input.fs ?? nodeFs4;
+  const env = input.env ?? process.env;
+  const document = await readMergedDocument(
+    fs4,
+    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;
+}
+var e2bAuthScope;
+var init_auth_scope = __esm({
+  "packages/runner-e2b/src/auth-scope.ts"() {
     "use strict";
+    init_src5();
+    e2bAuthScope = defineScope("e2b", {
+      api_key: {
+        type: "string",
+        default: "",
+        doc: "E2B API key",
+        env: "E2B_API_KEY"
+      }
+    });
   }
 });
 
-// packages/process-runner/src/testing/index.ts
-var init_testing = __esm({
-  "packages/process-runner/src/testing/index.ts"() {
+// packages/runner-e2b/src/factory.ts
+import path25 from "node:path";
+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;
+}
+var e2bExecutionEnvFactory;
+var init_factory = __esm({
+  "packages/runner-e2b/src/factory.ts"() {
     "use strict";
-    init_mock_runner();
+    init_sdk();
+    init_template_build();
+    init_opened_env();
+    init_auth_scope();
+    e2bExecutionEnvFactory = {
+      type: "e2b",
+      supportsDetach: true,
+      async open(spec10) {
+        const runtime = parseE2bRuntime(spec10.runtime);
+        const runtimeCwd = spec10.runtimeCwd ?? spec10.cwd;
+        const apiKey = await resolveE2bApiKey({ cwd: runtimeCwd });
+        const templateId = runtime.template_id ?? (await buildE2bRuntimeTemplate({
+          runtime,
+          dockerfilePath: path25.resolve(
+            runtimeCwd,
+            runtime.dockerfile ?? path25.join(".poe-code", "Dockerfile")
+          ),
+          buildContext: path25.resolve(runtimeCwd, runtime.build_context ?? "."),
+          state: spec10.state,
+          apiKey
+        })).templateId;
+        const sandbox = await createSandbox({
+          apiKey,
+          templateId,
+          env: spec10.env,
+          timeoutMinutes: runtime.timeout_minutes
+        });
+        return createOpenedE2bEnv({ sandbox, spec: spec10, 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
+          }
+        });
+      }
+    };
   }
 });
 
-// packages/process-runner/src/index.ts
-var init_src10 = __esm({
-  "packages/process-runner/src/index.ts"() {
+// packages/runner-e2b/src/index.ts
+var e2bExecutionEnvFactory2;
+var init_src11 = __esm({
+  "packages/runner-e2b/src/index.ts"() {
     "use strict";
-    init_context();
-    init_engine();
-    init_docker_runner();
-    init_docker_execution_env();
-    init_host_execution_env();
-    init_host_runner();
-    init_testing();
+    init_factory();
+    init_auth_scope();
+    init_template_build();
+    e2bExecutionEnvFactory2 = e2bExecutionEnvFactory;
   }
 });
 
 // packages/agent-spawn/src/register-factories.ts
 import { spawn as spawnChildProcess3 } from "node:child_process";
+function isVitest() {
+  return process.env.VITEST !== void 0 || process.env.VITEST_POOL_ID !== void 0;
+}
 function createTestHostExecutionEnvFactory() {
   return {
     type: "host",
@@ -13847,9 +15041,11 @@ var init_register_factories = __esm({
     "use strict";
     init_src9();
     init_src10();
+    init_src11();
     registerExecutionEnvFactory(hostExecutionEnvFactory);
     registerExecutionEnvFactory(dockerExecutionEnvFactory);
-    if (process.env.VITEST === "true") {
+    registerExecutionEnvFactory(e2bExecutionEnvFactory2);
+    if (isVitest()) {
       registerExecutionEnvFactory(createTestHostExecutionEnvFactory());
     }
   }
@@ -14322,7 +15518,7 @@ var init_runtime2 = __esm({
 
 // packages/agent-spawn/src/spawn.ts
 import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path22 from "node:path";
+import path26 from "node:path";
 function createAbortError3() {
   const error2 = new Error("Agent spawn aborted");
   error2.name = "AbortError";
@@ -14419,6 +15615,7 @@ async function spawn6(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,
@@ -14427,7 +15624,8 @@ async function spawn6(agentId, options, context) {
       runtimeImage: options.runtimeImage,
       runtimeTemplate: options.runtimeTemplate,
       detach: options.detach,
-      mountPoeCode: options.mountPoeCode
+      mountPoeCode: options.mountPoeCode,
+      runnerSync: options.runnerSync
     },
     context,
     openSpec: {
@@ -14464,6 +15662,7 @@ async function spawn6(agentId, options, context) {
         stdout: "",
         stderr: "",
         exitCode: 0,
+        detached: { jobId: result.jobId, envId: result.envId },
         ...logFilePath ? { logFile: logFilePath } : {}
       };
     }
@@ -14485,11 +15684,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path22.join(options.logDir, options.logFileName);
+  return path26.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path22.dirname(filePath), { recursive: true });
+    mkdirSync(path26.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -14735,6 +15934,12 @@ var init_text = __esm({
         if (format === "markdown") return `**${content}**`;
         return typography.bold(content);
       },
+      sectionHeader(content) {
+        const format = resolveOutputFormat();
+        if (format === "json") return content;
+        if (format === "markdown") return `## ${content}`;
+        return typography.bold(content.toUpperCase());
+      },
       command(content) {
         const format = resolveOutputFormat();
         if (format === "json") return content;
@@ -15079,7 +16284,13 @@ var init_help_formatter = __esm({
   "packages/design-system/src/components/help-formatter.ts"() {
     "use strict";
     init_text();
-    init_widths();
+  }
+});
+
+// packages/design-system/src/components/help-formatter-plain.ts
+var init_help_formatter_plain = __esm({
+  "packages/design-system/src/components/help-formatter-plain.ts"() {
+    "use strict";
   }
 });
 
@@ -20412,7 +21623,7 @@ var init_store2 = __esm({
 
 // packages/design-system/src/dashboard/terminal.ts
 import readline from "node:readline";
-import { PassThrough as PassThrough2 } from "node:stream";
+import { PassThrough as PassThrough3 } from "node:stream";
 function createTerminalDriver(opts) {
   const stdin = opts?.stdin ?? process.stdin;
   const stdout = opts?.stdout ?? process.stdout;
@@ -20967,7 +22178,7 @@ var init_static = __esm({
 });
 
 // packages/design-system/src/index.ts
-var init_src11 = __esm({
+var init_src12 = __esm({
   "packages/design-system/src/index.ts"() {
     "use strict";
     init_tokens();
@@ -20979,6 +22190,7 @@ var init_src11 = __esm({
     init_symbols();
     init_logger();
     init_help_formatter();
+    init_help_formatter_plain();
     init_command_errors();
     init_command_errors();
     init_table();
@@ -21091,7 +22303,7 @@ async function renderAcpStream(events) {
 var init_renderer2 = __esm({
   "packages/agent-spawn/src/acp/renderer.ts"() {
     "use strict";
-    init_src11();
+    init_src12();
     init_session_update_converter();
   }
 });
@@ -21108,9 +22320,9 @@ var init_autonomous = __esm({
 });
 
 // packages/agent-spawn/src/acp/replay.ts
-import path23 from "node:path";
+import path27 from "node:path";
 import { homedir as homedir3 } from "node:os";
-import { open as open2, readdir } from "node:fs/promises";
+import { open as open2, readdir as readdir2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 var init_replay = __esm({
   "packages/agent-spawn/src/acp/replay.ts"() {
@@ -21228,21 +22440,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path37;
+        let path41;
         if (typeof item.content === "string") {
-          path37 = item.content;
+          path41 = item.content;
         } else {
           try {
-            path37 = JSON.stringify(item.content);
+            path41 = JSON.stringify(item.content);
           } catch {
-            path37 = String(item.content);
+            path41 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path37
+          path: path41
         };
       }
     }
@@ -21365,10 +22577,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path37 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path41 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path37 };
+        yield { event: "tool_complete", id: item.id, kind, path: path41 };
       }
     }
   }
@@ -21751,6 +22963,7 @@ function spawnStreaming(options) {
   const argv = [binaryName, ...args];
   const execution = resolvePoeCommandExecution({
     cwd: options.cwd ?? process.cwd(),
+    runtimeConfigCwd: options.runtimeConfigCwd,
     env: processEnv ?? process.env,
     argv,
     tool: agentId,
@@ -21759,7 +22972,8 @@ function spawnStreaming(options) {
       runtimeImage: options.runtimeImage,
       runtimeTemplate: options.runtimeTemplate,
       detach: options.detach,
-      mountPoeCode: options.mountPoeCode
+      mountPoeCode: options.mountPoeCode,
+      runnerSync: options.runnerSync
     },
     openSpec: {
       execution: {
@@ -21798,7 +23012,12 @@ function spawnStreaming(options) {
         signal: options.signal
       });
       if (runResult.kind === "detached") {
-        return { stdout: "", stderr: "", exitCode: 0 };
+        return {
+          stdout: "",
+          stderr: "",
+          exitCode: 0,
+          detached: { jobId: runResult.jobId, envId: runResult.envId }
+        };
       }
       result.stderr = runResult.stderr ?? "";
       result.exitCode = runResult.exitCode;
@@ -21923,7 +23142,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path37 = readString(event.path);
+  const path41 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -21938,8 +23157,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path37) {
-    toolCall.path = path37;
+  if (path41) {
+    toolCall.path = path41;
   }
 }
 var sessionCapture;
@@ -22025,7 +23244,7 @@ var init_usage_capture = __esm({
 });
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path24 from "node:path";
+import path28 from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { mkdir as mkdir2, open as open3 } from "node:fs/promises";
 function pad2(value, width) {
@@ -22062,14 +23281,14 @@ function resolveLogFilePath(ctx) {
   if (ctx.logPath) {
     return ctx.logPath;
   }
-  const baseDir = ctx.logDir ?? path24.join(homedir4(), ".poe-code", "spawn-logs");
+  const baseDir = ctx.logDir ?? path28.join(homedir4(), ".poe-code", "spawn-logs");
   if (ctx.logFileName) {
-    return path24.join(baseDir, ctx.logFileName);
+    return path28.join(baseDir, ctx.logFileName);
   }
   const startedAt = resolveStartedAt(ctx.startedAt);
   const { day, time, milliseconds } = formatTimestamp(startedAt);
   const fileName = `${day}-${time}-${milliseconds}-${normalizeAgent(ctx.agent)}.jsonl`;
-  return path24.join(baseDir, fileName);
+  return path28.join(baseDir, fileName);
 }
 async function writePreloadedEvents(writer, events) {
   for (const event of events) {
@@ -22087,7 +23306,7 @@ var init_spawn_log = __esm({
       logDirPath;
       constructor(ctx) {
         this.filePath = resolveLogFilePath(ctx);
-        this.logDirPath = path24.dirname(this.filePath);
+        this.logDirPath = path28.dirname(this.filePath);
       }
       async writeEvent(event) {
         if (this.isDisabled) {
@@ -22155,7 +23374,7 @@ var init_spawn_log = __esm({
 });
 
 // packages/agent-spawn/src/index.ts
-var init_src12 = __esm({
+var init_src13 = __esm({
   "packages/agent-spawn/src/index.ts"() {
     "use strict";
     init_register_factories();
@@ -22185,7 +23404,7 @@ var gitContext, poe_agent_plugin_git_context_default;
 var init_poe_agent_plugin_git_context = __esm({
   "packages/poe-agent/src/plugins/poe-agent-plugin-git-context.ts"() {
     "use strict";
-    init_src12();
+    init_src13();
     gitContext = (cwd) => ({
       name: "git-context",
       async prompt(ctx) {
@@ -22424,7 +23643,7 @@ __export(src_exports, {
   systemPromptPlugin: () => poe_agent_plugin_system_prompt_default,
   webPlugin: () => poe_agent_plugin_web_default
 });
-var init_src13 = __esm({
+var init_src14 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent();
@@ -22456,7 +23675,7 @@ var init_src13 = __esm({
 
 // src/providers/poe-agent.ts
 import fsPromises8 from "node:fs/promises";
-import os6 from "node:os";
+import os7 from "node:os";
 
 // src/cli/constants.ts
 var DEFAULT_FRONTIER_MODEL = "anthropic/claude-opus-4.7";
@@ -22650,16 +23869,16 @@ function createInstallRunner(definition) {
 // src/services/config.ts
 init_src3();
 init_src5();
-init_src13();
-import path36 from "node:path";
+init_src14();
+import path40 from "node:path";
 
 // packages/superintendent/src/document/parse.ts
-import path25 from "node:path";
+import path29 from "node:path";
 import { parseDocument as parseDocument2 } from "yaml";
 var superintendentDocumentSchemaId = "https://poe-platform.github.io/poe-code/schemas/plans/superintendent.schema.json";
 var validStatusStates = /* @__PURE__ */ new Set(["in_progress", "review", "completed"]);
 function parseSuperintendentDoc(filePath, content) {
-  const resolvedFilePath = path25.resolve(filePath);
+  const resolvedFilePath = path29.resolve(filePath);
   const { frontmatterText, body } = splitFrontmatter(resolvedFilePath, content);
   const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
   return {
@@ -22669,7 +23888,7 @@ function parseSuperintendentDoc(filePath, content) {
   };
 }
 function readExplicitBuilderAgent(filePath, content) {
-  const resolvedFilePath = path25.resolve(filePath);
+  const resolvedFilePath = path29.resolve(filePath);
   const { frontmatterText } = splitFrontmatter(resolvedFilePath, content);
   const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
   const frontmatter = expectRecord(parsedFrontmatter, "frontmatter", resolvedFilePath);
@@ -22826,7 +24045,7 @@ function parseStatusBlock(value, filePath) {
   };
 }
 function expectRecord(value, fieldName, filePath) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     throw new Error(`${filePath}: ${fieldName} must be a mapping`);
   }
   return value;
@@ -22855,12 +24074,12 @@ function expectStringArray(value, fieldName, filePath) {
   }
   return value;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // packages/superintendent/src/document/write.ts
-import path26 from "node:path";
+import path30 from "node:path";
 import { isMap, parseDocument as parseDocument3 } from "yaml";
 function updateStatus(filePath, content, status) {
   return updateFrontmatter(filePath, content, (frontmatterDocument) => {
@@ -22881,7 +24100,7 @@ function setStatusReason(filePath, content, reason) {
   });
 }
 function updateFrontmatter(filePath, content, mutate) {
-  const resolvedFilePath = path26.resolve(filePath);
+  const resolvedFilePath = path30.resolve(filePath);
   const parts = splitDocument(resolvedFilePath, content);
   const frontmatterDocument = parseDocument3(parts.frontmatterText);
   if (frontmatterDocument.errors.length > 0) {
@@ -23005,7 +24224,7 @@ function formatFrontmatter(serialized, lineBreak) {
 }
 
 // packages/superintendent/src/document/tasks.ts
-init_src11();
+init_src12();
 function parseTaskBoard(body) {
   const sectionNodes = readTaskBoardSection(body);
   const tasks = [];
@@ -23107,7 +24326,7 @@ function extractText(node) {
 
 // packages/superintendent/src/runtime/loop.ts
 init_src9();
-import path29 from "node:path";
+import path33 from "node:path";
 import * as fsPromises6 from "node:fs/promises";
 
 // packages/superintendent/src/state/machine.ts
@@ -23126,9 +24345,9 @@ function createLoopState(doc) {
 // packages/superintendent/src/runtime/agent-runner.ts
 init_register_factories();
 init_src9();
-init_src12();
+init_src13();
 import { mkdirSync as mkdirSync2, openSync as openSync2, writeSync as writeSync2, closeSync as closeSync2 } from "node:fs";
-import path27 from "node:path";
+import path31 from "node:path";
 var injectedRunner;
 async function withAutonomousAgentRunner(runner, operation) {
   const previous = injectedRunner;
@@ -23151,7 +24370,8 @@ async function runAutonomousAgent(input) {
       ...input.runtimeImage ? { runtimeImage: input.runtimeImage } : {},
       ...input.runtimeTemplate ? { runtimeTemplate: input.runtimeTemplate } : {},
       ...input.detach ? { detach: input.detach } : {},
-      ...input.mountPoeCode ? { mountPoeCode: input.mountPoeCode } : {}
+      ...input.mountPoeCode ? { mountPoeCode: input.mountPoeCode } : {},
+      ...input.runnerSync ? { runnerSync: input.runnerSync } : {}
     });
   }
   const spawnArgs = buildSpawnArgs(input.agent, {
@@ -23172,7 +24392,8 @@ async function runAutonomousAgent(input) {
       runtimeImage: input.runtimeImage,
       runtimeTemplate: input.runtimeTemplate,
       detach: input.detach,
-      mountPoeCode: input.mountPoeCode
+      mountPoeCode: input.mountPoeCode,
+      runnerSync: input.runnerSync
     },
     openSpec: {
       execution: {
@@ -23214,7 +24435,7 @@ async function runAutonomousAgent(input) {
 }
 function openSpawnLog2(filePath) {
   try {
-    mkdirSync2(path27.dirname(filePath), { recursive: true });
+    mkdirSync2(path31.dirname(filePath), { recursive: true });
     return openSync2(filePath, "a");
   } catch {
     return void 0;
@@ -23239,15 +24460,15 @@ function closeSpawnLog2(fd) {
 init_register_factories();
 
 // packages/superintendent/src/runtime/resolve-cwd.ts
-import path28 from "node:path";
+import path32 from "node:path";
 function resolveRoleCwd(role, docPath, defaultCwd) {
   if (role.cwd === void 0) {
     return defaultCwd;
   }
-  if (path28.isAbsolute(role.cwd)) {
+  if (path32.isAbsolute(role.cwd)) {
     return role.cwd;
   }
-  return path28.resolve(path28.dirname(docPath), role.cwd);
+  return path32.resolve(path32.dirname(docPath), role.cwd);
 }
 
 // packages/superintendent/src/runtime/templates.ts
@@ -23267,9 +24488,9 @@ function collectReferencedInspectors(template) {
   return names;
 }
 function readTemplateValue(context, variablePath) {
-  return variablePath.split(".").reduce((value, segment) => isRecord7(value) ? value[segment] : void 0, context);
+  return variablePath.split(".").reduce((value, segment) => isRecord8(value) ? value[segment] : void 0, context);
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -23528,7 +24749,7 @@ function createWorkflowTool(role, state) {
   };
 }
 function parseWorkflowCall(input) {
-  if (!isRecord8(input)) {
+  if (!isRecord9(input)) {
     throw invalidActionError();
   }
   const { action } = input;
@@ -23600,7 +24821,7 @@ function invalidActionError() {
     'workflow_transition action must be one of "request_review", "approve_completion", or "request_changes"'
   );
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -23690,7 +24911,7 @@ function collectToolNames(result) {
   }
   const names = [];
   collectToolNamesFrom(result.toolCalls, names);
-  if (isRecord9(result.sessionResult)) {
+  if (isRecord10(result.sessionResult)) {
     collectToolNamesFrom(result.sessionResult.toolCalls, names);
   }
   return names;
@@ -23735,13 +24956,13 @@ function readTransitionFromToolCalls(value) {
   return void 0;
 }
 function readTransitionFromSessionResult(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     return void 0;
   }
   return readTransitionFromToolCalls(value.toolCalls);
 }
 function readToolCall(value) {
-  return isRecord9(value) ? value : void 0;
+  return isRecord10(value) ? value : void 0;
 }
 function readToolCallName(toolCall) {
   return readString4(toolCall.name) ?? readString4(toolCall.tool) ?? readString4(toolCall.title) ?? readString4(toolCall.path);
@@ -23778,7 +24999,7 @@ function encodeJson(value) {
 function readString4(value) {
   return typeof value === "string" ? value : void 0;
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -23887,7 +25108,7 @@ function readTransitionFromToolCalls2(value) {
   return void 0;
 }
 function readTransitionFromSessionResult2(value) {
-  if (!isRecord10(value)) {
+  if (!isRecord11(value)) {
     return void 0;
   }
   return readTransitionFromToolCalls2(value.toolCalls);
@@ -23912,7 +25133,7 @@ function extractOutputText(result) {
   return readString5(result.output) ?? readString5(result.stdout) ?? readString5(result.text) ?? "";
 }
 function readToolCall2(value) {
-  return isRecord10(value) ? value : void 0;
+  return isRecord11(value) ? value : void 0;
 }
 function readToolCallName2(toolCall) {
   return readString5(toolCall.name) ?? readString5(toolCall.tool) ?? readString5(toolCall.title) ?? readString5(toolCall.path);
@@ -23952,7 +25173,7 @@ function splitLines(value) {
 function readString5(value) {
   return typeof value === "string" ? value : void 0;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -24302,7 +25523,7 @@ async function executeSuperintendent(options, context) {
 function buildRoleOptions(options, role) {
   return {
     defaultCwd: options.cwd,
-    ...options.logDir ? { logPath: path29.join(options.logDir, makeRunLogFileName(role)) } : {}
+    ...options.logDir ? { logPath: path33.join(options.logDir, makeRunLogFileName(role)) } : {}
   };
 }
 function shouldContinueReview(doc) {
@@ -24549,7 +25770,7 @@ var S = {
 
 // packages/toolcraft/src/package-metadata.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "node:fs";
-import path30 from "node:path";
+import path34 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/toolcraft/src/index.ts
@@ -24895,7 +26116,7 @@ function defineGroup(config) {
 }
 
 // packages/superintendent/src/commands/builder-group.ts
-init_src11();
+init_src12();
 var builderRunParams = S.Object({
   path: S.String({ description: "Path to the superintendent markdown document" })
 });
@@ -24966,15 +26187,15 @@ function hasCode2(error2, code) {
 }
 
 // packages/superintendent/src/commands/install.ts
-import path33 from "node:path";
-import { readFile as readFile6, stat as stat4, mkdir as mkdir4, writeFile as writeFile2, unlink as unlink3, readdir as readdir3, chmod as chmod2 } from "node:fs/promises";
+import path37 from "node:path";
+import { readFile as readFile8, stat as stat4, mkdir as mkdir4, writeFile as writeFile3, unlink as unlink3, readdir as readdir4, chmod as chmod2 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 init_src5();
 
 // packages/agent-skill-config/src/configs.ts
 init_src8();
-import os5 from "node:os";
-import path31 from "node:path";
+import os6 from "node:os";
+import path35 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -25010,8 +26231,8 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 init_src3();
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile5, stat as stat3 } from "node:fs/promises";
-import path32 from "node:path";
+import { readFile as readFile7, stat as stat3 } from "node:fs/promises";
+import path36 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -25071,12 +26292,12 @@ async function installSkill(agentId, skill, options) {
 // packages/superintendent/src/commands/install.ts
 init_src9();
 var fs2 = {
-  readFile: (p, encoding) => readFile6(p, encoding),
-  writeFile: (p, content) => writeFile2(p, content),
+  readFile: (p, encoding) => readFile8(p, encoding),
+  writeFile: (p, content) => writeFile3(p, content),
   mkdir: (p, options) => mkdir4(p, options).then(() => void 0),
   unlink: (p) => unlink3(p),
   stat: (p) => stat4(p).then((s) => ({ mode: s.mode })),
-  readdir: (p) => readdir3(p),
+  readdir: (p) => readdir4(p),
   chmod: (p, mode) => chmod2(p, mode)
 };
 var installParams = S.Object({
@@ -25166,9 +26387,9 @@ async function resolvePlanDirectory(cwd, homeDir, env) {
 }
 function resolveAbsoluteDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path33.join(homeDir, dir.slice(2));
+    return path37.join(homeDir, dir.slice(2));
   }
-  return path33.isAbsolute(dir) ? dir : path33.resolve(cwd, dir);
+  return path37.isAbsolute(dir) ? dir : path37.resolve(cwd, dir);
 }
 async function pathExists2(targetPath) {
   try {
@@ -25188,15 +26409,15 @@ async function loadSkillTemplate() {
   }
   const packageRoot = await findPackageRoot(fileURLToPath5(import.meta.url));
   const templateRoots = [
-    path33.join(packageRoot, "src", "templates"),
-    path33.join(packageRoot, "dist", "templates")
+    path37.join(packageRoot, "src", "templates"),
+    path37.join(packageRoot, "dist", "templates")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExists2(templateRoot)) {
       continue;
     }
-    skillTemplateCache = await readFile6(
-      path33.join(templateRoot, "SKILL_superintendent.md"),
+    skillTemplateCache = await readFile8(
+      path37.join(templateRoot, "SKILL_superintendent.md"),
       "utf8"
     );
     return skillTemplateCache;
@@ -25204,12 +26425,12 @@ async function loadSkillTemplate() {
   throw new Error("Unable to locate Superintendent skill template.");
 }
 async function findPackageRoot(entryFilePath) {
-  let currentPath = path33.dirname(entryFilePath);
+  let currentPath = path37.dirname(entryFilePath);
   while (true) {
-    if (await pathExists2(path33.join(currentPath, "package.json"))) {
+    if (await pathExists2(path37.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path33.dirname(currentPath);
+    const parentPath = path37.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Superintendent templates.");
     }
@@ -25351,7 +26572,7 @@ function hasCode3(error2, code) {
 }
 
 // packages/superintendent/src/commands/superintendent-group.ts
-init_src11();
+init_src12();
 
 // packages/superintendent/src/commands/complete.ts
 var completeParams = S.Object({
@@ -25407,16 +26628,16 @@ function hasCode4(error2, code) {
 }
 
 // packages/superintendent/src/commands/plan-path.ts
-import path34 from "node:path";
-import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir5, unlink as unlink4, stat as stat5, readdir as readdir4 } from "node:fs/promises";
+import path38 from "node:path";
+import { readFile as readFile9, writeFile as writeFile4, mkdir as mkdir5, unlink as unlink4, stat as stat5, readdir as readdir5 } from "node:fs/promises";
 init_src5();
 var fs3 = {
-  readFile: (p, encoding) => readFile7(p, encoding),
-  writeFile: (p, content) => writeFile3(p, content),
+  readFile: (p, encoding) => readFile9(p, encoding),
+  writeFile: (p, content) => writeFile4(p, content),
   mkdir: (p, options) => mkdir5(p, options).then(() => void 0),
   unlink: (p) => unlink4(p),
   stat: (p) => stat5(p).then((s) => ({ mode: s.mode })),
-  readdir: (p) => readdir4(p)
+  readdir: (p) => readdir5(p)
 };
 var planPathCommand = defineCommand({
   name: "plan-path",
@@ -25443,22 +26664,22 @@ var planPathCommand = defineCommand({
 });
 function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path34.join(homeDir, dir.slice(2));
+    return path38.join(homeDir, dir.slice(2));
   }
-  return path34.isAbsolute(dir) ? dir : path34.resolve(cwd, dir);
+  return path38.isAbsolute(dir) ? dir : path38.resolve(cwd, dir);
 }
 
 // packages/superintendent/src/commands/run.ts
 init_src9();
-init_src12();
+init_src13();
 init_src8();
-import path35 from "node:path";
+import path39 from "node:path";
 import * as fsPromises7 from "node:fs/promises";
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 
 // packages/superintendent/src/commands/poe-agent-runner.ts
 init_src8();
-init_src13();
+init_src14();
 async function executePoeAgent(agentSpec, input, createAgent = agent) {
   const { model } = parseAgentSpecifier(agentSpec);
   if (!model) {
@@ -25475,7 +26696,7 @@ async function executePoeAgent(agentSpec, input, createAgent = agent) {
 }
 
 // packages/superintendent/src/commands/run.ts
-init_src11();
+init_src12();
 init_src5();
 
 // packages/superintendent/src/config-scope.ts
@@ -25512,6 +26733,9 @@ var runParams = S.Object({
   mountPoeCode: S.Optional(S.Boolean({
     description: "Mount the local poe-code checkout into the runtime"
   })),
+  runnerSync: S.Optional(S.Enum(["both", "upload", "none"], {
+    description: "Override runner workspace sync: both, upload, or none"
+  })),
   tui: S.Optional(S.Boolean({ description: "Show a live dashboard while Superintendent is running" }))
 });
 var runCommand2 = defineCommand({
@@ -25524,24 +26748,36 @@ var runCommand2 = defineCommand({
     const cwd = process.cwd();
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? cwd;
     const commandConfig = await resolveSuperintendentCommandConfig(cwd, homeDir, process.env);
+    const integrations = await loadIntegrations(commandConfig.configDoc);
     const tuiEnabled = params.tui ?? commandConfig.tui;
-    return runSuperintendentCommand({
-      cwd,
-      homeDir,
-      docPath: params.doc,
-      ...params.agent ? { builderAgent: params.agent } : {},
-      ...params.runtime ? { runtime: params.runtime } : {},
-      ...params.runtimeImage ? { runtimeImage: params.runtimeImage } : {},
-      ...params.runtimeTemplate ? { runtimeTemplate: params.runtimeTemplate } : {},
-      ...params.detach ? { detach: params.detach } : {},
-      ...params.mountPoeCode ? { mountPoeCode: params.mountPoeCode } : {},
-      configuredDefaultAgent: commandConfig.configuredDefaultAgent,
-      assumeYes: process.argv.includes("--yes"),
-      interactive: Boolean(process.stdin.isTTY),
-      useDashboard: shouldUseInteractiveDashboard(tuiEnabled) && resolveOutputFormat() === "terminal",
-      env: process.env,
-      ...commandConfig.planDirectory ? { planDirectory: commandConfig.planDirectory } : {}
-    });
+    try {
+      const runOptions = {
+        cwd,
+        homeDir,
+        docPath: params.doc,
+        ...params.agent ? { builderAgent: params.agent } : {},
+        ...params.runtime ? { runtime: params.runtime } : {},
+        ...params.runtimeImage ? { runtimeImage: params.runtimeImage } : {},
+        ...params.runtimeTemplate ? { runtimeTemplate: params.runtimeTemplate } : {},
+        ...params.detach ? { detach: params.detach } : {},
+        ...params.mountPoeCode ? { mountPoeCode: params.mountPoeCode } : {},
+        ...params.runnerSync ? { runnerSync: params.runnerSync } : {},
+        configuredDefaultAgent: commandConfig.configuredDefaultAgent,
+        assumeYes: process.argv.includes("--yes"),
+        interactive: Boolean(process.stdin.isTTY),
+        useDashboard: shouldUseInteractiveDashboard(tuiEnabled) && resolveOutputFormat() === "terminal",
+        env: process.env,
+        integrations,
+        ...commandConfig.planDirectory ? { planDirectory: commandConfig.planDirectory } : {}
+      };
+      return integrations ? await integrations.traceRun(
+        "superintendent",
+        params.doc ?? "run",
+        () => runSuperintendentCommand(runOptions)
+      ) : await runSuperintendentCommand(runOptions);
+    } finally {
+      await integrations?.shutdown();
+    }
   },
   render: {
     rich: (result, { logger: logger2 }) => {
@@ -25582,24 +26818,35 @@ function createRunMcpCommand(runners) {
       const cwd = process.cwd();
       const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? cwd;
       const commandConfig = await resolveSuperintendentCommandConfig(cwd, homeDir, process.env);
-      return runSuperintendentCommand({
-        cwd,
-        homeDir,
-        docPath: params.doc,
-        ...params.agent ? { builderAgent: params.agent } : {},
-        ...params.runtime ? { runtime: params.runtime } : {},
-        ...params.runtimeImage ? { runtimeImage: params.runtimeImage } : {},
-        ...params.runtimeTemplate ? { runtimeTemplate: params.runtimeTemplate } : {},
-        ...params.detach ? { detach: params.detach } : {},
-        ...params.mountPoeCode ? { mountPoeCode: params.mountPoeCode } : {},
-        configuredDefaultAgent: commandConfig.configuredDefaultAgent,
-        assumeYes: true,
-        interactive: false,
-        useDashboard: false,
-        env: process.env,
-        ...commandConfig.planDirectory ? { planDirectory: commandConfig.planDirectory } : {},
-        ...runners?.runLoop ? { runLoop: runners.runLoop } : {}
-      });
+      const integrations = await loadIntegrations(commandConfig.configDoc);
+      try {
+        const runOptions = {
+          cwd,
+          homeDir,
+          docPath: params.doc,
+          ...params.agent ? { builderAgent: params.agent } : {},
+          ...params.runtime ? { runtime: params.runtime } : {},
+          ...params.runtimeImage ? { runtimeImage: params.runtimeImage } : {},
+          ...params.runtimeTemplate ? { runtimeTemplate: params.runtimeTemplate } : {},
+          ...params.detach ? { detach: params.detach } : {},
+          ...params.mountPoeCode ? { mountPoeCode: params.mountPoeCode } : {},
+          configuredDefaultAgent: commandConfig.configuredDefaultAgent,
+          assumeYes: true,
+          interactive: false,
+          useDashboard: false,
+          env: process.env,
+          integrations,
+          ...commandConfig.planDirectory ? { planDirectory: commandConfig.planDirectory } : {},
+          ...runners?.runLoop ? { runLoop: runners.runLoop } : {}
+        };
+        return integrations ? await integrations.traceRun(
+          "superintendent",
+          params.doc ?? "run",
+          () => runSuperintendentCommand(runOptions)
+        ) : await runSuperintendentCommand(runOptions);
+      } finally {
+        await integrations?.shutdown();
+      }
     },
     render: runCommand2.render
   });
@@ -25622,12 +26869,13 @@ async function resolveSuperintendentCommandConfig(cwd, homeDir, env, fs4) {
     );
     const coreResolved = resolveScope(coreDefaultAgentConfigSchema, document.core, env);
     return {
+      configDoc: document,
       configuredDefaultAgent: normalizeAgentSelection(coreResolved.defaultAgent) ?? null,
       ...planDirectory ? { planDirectory } : {},
       tui: superintendentResolved.tui === true
     };
   } catch {
-    return { configuredDefaultAgent: null, tui: false };
+    return { configDoc: {}, configuredDefaultAgent: null, tui: false };
   }
 }
 async function resolveSuperintendentPlanDirectory(cwd, homeDir, env, fs4) {
@@ -25684,6 +26932,16 @@ async function runSuperintendentCommand(options) {
   const useDashboard = options.useDashboard ?? resolveOutputFormat() === "terminal";
   const stderr = options.stderr ?? process.stderr;
   const exitProcess = options.exit ?? ((code) => process.exit(code));
+  const integrations = options.integrations ?? null;
+  const shutdownAndExit = (code) => {
+    if (!integrations) {
+      exitProcess(code);
+      return;
+    }
+    void integrations.shutdown().finally(() => {
+      exitProcess(code);
+    });
+  };
   const selectedDocPath = await resolveDocPath({
     cwd: options.cwd,
     homeDir: options.homeDir,
@@ -25724,7 +26982,7 @@ async function runSuperintendentCommand(options) {
     const headlessAbort = new AbortController();
     const headlessSigint = () => {
       headlessAbort.abort();
-      exitProcess(130);
+      shutdownAndExit(130);
     };
     process.on("SIGINT", headlessSigint);
     try {
@@ -25735,7 +26993,7 @@ async function runSuperintendentCommand(options) {
         ...options.fs ? { fs: fs4 } : {},
         signal: headlessAbort.signal,
         logDir: runLogDir,
-        callbacks: {
+        callbacks: mergeLoopCallbacks({
           onBuilderStart: () => {
             activeStage = "builder";
           },
@@ -25766,17 +27024,19 @@ async function runSuperintendentCommand(options) {
           onOwnerComplete: () => {
             activeStage = void 0;
           }
-        },
+        }, integrations?.superintendentCallbacks),
         runAgent: createAgentRunner({
           session: void 0,
           executeAgent: options.executeAgent,
           selectedBuilderAgent,
+          integrations,
           runtime: {
             runtime: options.runtime,
             runtimeImage: options.runtimeImage,
             runtimeTemplate: options.runtimeTemplate,
             detach: options.detach,
-            mountPoeCode: options.mountPoeCode
+            mountPoeCode: options.mountPoeCode,
+            runnerSync: options.runnerSync
           },
           activeStage: () => activeStage,
           now,
@@ -25937,7 +27197,7 @@ async function runSuperintendentCommand(options) {
     abortController.abort();
     session.dashboard.stop();
     session.dashboard.destroy();
-    exitProcess(130);
+    shutdownAndExit(130);
   };
   const handleDashboardCommand = (command) => {
     if (command === "forceQuit") {
@@ -25989,7 +27249,7 @@ async function runSuperintendentCommand(options) {
         session.pauseRequested = true;
       }
       editPlan(session.dashboard, session.latestLogFile, env, options.openInEditor);
-      appendEvent("info", `Log opened: ${path35.basename(session.latestLogFile)}`);
+      appendEvent("info", `Log opened: ${path39.basename(session.latestLogFile)}`);
       syncStats();
     }
   };
@@ -26010,19 +27270,21 @@ async function runSuperintendentCommand(options) {
         cwd: options.cwd,
         homeDir: options.homeDir,
         ...options.fs ? { fs: fs4 } : {},
-        callbacks,
+        callbacks: mergeLoopCallbacks(callbacks, integrations?.superintendentCallbacks),
         signal: abortController.signal,
         logDir: runLogDir,
         runAgent: createAgentRunner({
           session,
           executeAgent: options.executeAgent,
           selectedBuilderAgent,
+          integrations,
           runtime: {
             runtime: options.runtime,
             runtimeImage: options.runtimeImage,
             runtimeTemplate: options.runtimeTemplate,
             detach: options.detach,
-            mountPoeCode: options.mountPoeCode
+            mountPoeCode: options.mountPoeCode,
+            runnerSync: options.runnerSync
           },
           activeStage: () => session.activeStage,
           now,
@@ -26145,13 +27407,13 @@ async function listPlanDirectoryDocs(fs4, planDirectory, cwd, homeDir) {
     }
     throw error2;
   }
-  return entries.filter((entry) => entry.toLowerCase().endsWith(".md")).map((entry) => path35.join(absoluteDir, entry)).sort((left, right) => left.localeCompare(right));
+  return entries.filter((entry) => entry.toLowerCase().endsWith(".md")).map((entry) => path39.join(absoluteDir, entry)).sort((left, right) => left.localeCompare(right));
 }
 function resolveAbsolutePlanDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path35.join(homeDir, dir.slice(2));
+    return path39.join(homeDir, dir.slice(2));
   }
-  return path35.isAbsolute(dir) ? dir : path35.resolve(cwd, dir);
+  return path39.isAbsolute(dir) ? dir : path39.resolve(cwd, dir);
 }
 function normalizeAgentSelection(value) {
   if (typeof value !== "string") {
@@ -26171,7 +27433,7 @@ function createAgentRunner(options) {
   return async (input) => {
     const activeStage = options.activeStage();
     const agent2 = activeStage === "builder" ? options.selectedBuilderAgent : input.agent;
-    const executeAgent = options.executeAgent ?? executeSpawnAgent;
+    const executeAgent = options.executeAgent ?? ((nextAgent, nextInput) => executeSpawnAgent(nextAgent, nextInput, options.integrations));
     const stageLabel = formatStageLabel(activeStage);
     const emitLine = (kind, line) => {
       if (line.length === 0) {
@@ -26242,12 +27504,12 @@ function formatStageLabel(stage) {
   }
   return `inspector:${stage.inspector}`;
 }
-async function executeSpawnAgent(agent2, input) {
+async function executeSpawnAgent(agent2, input, integrations) {
   if (parseAgentSpecifier(agent2).agent === "poe-agent") {
     return executePoeAgent(agent2, input);
   }
   if ((input.onStdout || input.onStderr) && supportsStreaming(agent2)) {
-    return executeSpawnAgentStreaming(agent2, input);
+    return executeSpawnAgentStreaming(agent2, input, integrations);
   }
   const tee = input.onStdout || input.onStderr ? {
     ...input.onStdout ? { stdout: { write: input.onStdout } } : {},
@@ -26266,6 +27528,7 @@ async function executeSpawnAgent(agent2, input) {
     ...input.runtimeTemplate ? { runtimeTemplate: input.runtimeTemplate } : {},
     ...input.detach ? { detach: input.detach } : {},
     ...input.mountPoeCode ? { mountPoeCode: input.mountPoeCode } : {},
+    ...input.runnerSync ? { runnerSync: input.runnerSync } : {},
     ...tee ? { tee } : {}
   });
   return {
@@ -26280,7 +27543,7 @@ function supportsStreaming(agent2) {
   const config = getSpawnConfig(agent2);
   return config?.kind === "cli";
 }
-async function executeSpawnAgentStreaming(agent2, input) {
+async function executeSpawnAgentStreaming(agent2, input, integrations) {
   const writer = (line) => {
     input.onStdout?.(`${line}
 `);
@@ -26298,6 +27561,7 @@ async function executeSpawnAgentStreaming(agent2, input) {
     ...input.runtimeTemplate ? { runtimeTemplate: input.runtimeTemplate } : {},
     ...input.detach ? { detach: input.detach } : {},
     ...input.mountPoeCode ? { mountPoeCode: input.mountPoeCode } : {},
+    ...input.runnerSync ? { runnerSync: input.runnerSync } : {},
     ...input.onStderr ? { tee: { stderr: { write: input.onStderr } } } : {}
   });
   const middlewareContext = {
@@ -26312,7 +27576,15 @@ async function executeSpawnAgentStreaming(agent2, input) {
     ...input.logPath ? { logPath: input.logPath } : {},
     ...input.mode ? { mode: input.mode } : {}
   };
-  await applyMiddlewares([spawnLog, usageCapture, sessionCapture], middlewareContext);
+  await applyMiddlewares(
+    [
+      spawnLog,
+      usageCapture,
+      sessionCapture,
+      ...integrations?.spawnMiddleware ? [integrations.spawnMiddleware] : []
+    ],
+    middlewareContext
+  );
   await acp_exports.withAcpWriter(writer, () => renderAcpStream(middlewareContext.eventStream ?? rawEvents));
   const final = await done;
   const logFile = middlewareContext.logFile ?? final.logFile;
@@ -26403,7 +27675,7 @@ function resolveEditor(env) {
   const parts = raw.split(/\s+/);
   const command = parts[0] ?? "vi";
   const args = parts.slice(1);
-  const binary = path35.basename(command);
+  const binary = path39.basename(command);
   const mode = GUI_EDITOR_BINARIES.has(binary) ? "gui" : "tty";
   return { command, args, mode };
 }
@@ -26430,11 +27702,11 @@ function stripStopReason(result) {
   };
 }
 function displayPath(filePath, cwd, homeDir) {
-  if (filePath.startsWith(`${cwd}${path35.sep}`)) {
-    return path35.relative(cwd, filePath);
+  if (filePath.startsWith(`${cwd}${path39.sep}`)) {
+    return path39.relative(cwd, filePath);
   }
-  if (filePath.startsWith(`${homeDir}${path35.sep}`)) {
-    return `~/${path35.relative(homeDir, filePath)}`;
+  if (filePath.startsWith(`${homeDir}${path39.sep}`)) {
+    return `~/${path39.relative(homeDir, filePath)}`;
   }
   return filePath;
 }
@@ -27057,7 +28329,7 @@ function emitEvent(callback, event) {
 }
 async function loadConfiguredPlugins(options) {
   const fs4 = createConfigFileSystem(options.fs);
-  const homeDir = options.homeDir ?? os6.homedir();
+  const homeDir = options.homeDir ?? os7.homedir();
   const store = createConfigStore({
     fs: fs4,
     filePath: options.configPath ?? resolveConfigPath(homeDir),
@@ -27128,7 +28400,7 @@ function createInMemoryAcpTransport2(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src13(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src14(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
           cwd: request.cwd || options.cwd,