poe-code 3.0.202 → 3.0.203

package/packages/memory/dist/index.js

@@ -165,6 +165,136 @@ function parseRunner(raw) {
     workspace: parseRunnerWorkspace(record.workspace)
   });
 }
+function parseRuntime(raw) {
+  if (raw === void 0) {
+    return {
+      type: "host",
+      build_args: {},
+      mounts: []
+    };
+  }
+  const record = asRecord(raw);
+  if (record === void 0) {
+    throw new Error("runtime: expected an object.");
+  }
+  const type = parseRuntimeType(record.type);
+  const shared = parseSharedRuntimeFields(record);
+  if (type === "docker") {
+    return omitUndefined({
+      ...shared,
+      type,
+      image: parseOptionalString(record.image),
+      dockerfile: parseOptionalString(record.dockerfile),
+      build_context: parseOptionalString(record.build_context),
+      engine: parseEngine(record.engine),
+      network: parseOptionalString(record.network),
+      extra_args: parseOptionalStringArray(record.extra_args)
+    });
+  }
+  if (type === "e2b") {
+    const preserveAfterExitHours = parseOptionalNumber(record.preserve_after_exit_hours) ?? 24;
+    if (preserveAfterExitHours < 0 || preserveAfterExitHours > 168) {
+      throw new Error("preserve_after_exit_hours: expected a number from 0 to 168.");
+    }
+    return omitUndefined({
+      ...shared,
+      type,
+      template_id: parseOptionalString(record.template_id),
+      dockerfile: parseOptionalString(record.dockerfile),
+      build_context: parseOptionalString(record.build_context),
+      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"
+    });
+  }
+  return {
+    ...shared,
+    type
+  };
+}
+function resolveRuntime({
+  cwd,
+  config
+}) {
+  const runtime = config.runtime;
+  return runtimeResolvers[runtime.type]({ cwd, runtime });
+}
+var runtimeResolvers = {
+  host({ runtime }) {
+    return {
+      runtime,
+      runner: "host",
+      dockerfilePath: null,
+      buildContext: null
+    };
+  },
+  docker({ cwd, runtime }) {
+    const dockerRuntime = runtime;
+    const { dockerfilePath, buildContext } = resolveRuntimeBuildPaths(cwd, dockerRuntime);
+    if (dockerRuntime.image !== void 0) {
+      return {
+        runtime: dockerRuntime,
+        runner: "docker",
+        dockerfilePath: null,
+        buildContext: null
+      };
+    }
+    if (!existsSync(dockerfilePath)) {
+      throw new Error(`Docker runtime requires image or a Dockerfile at ${dockerfilePath}.`);
+    }
+    return {
+      runtime: dockerRuntime,
+      runner: "docker",
+      dockerfilePath,
+      buildContext
+    };
+  },
+  e2b({ cwd, runtime }) {
+    const e2bRuntime = runtime;
+    const { dockerfilePath, buildContext } = resolveRuntimeBuildPaths(cwd, e2bRuntime);
+    if (e2bRuntime.template_id !== void 0) {
+      return {
+        runtime: e2bRuntime,
+        runner: "e2b",
+        dockerfilePath: null,
+        buildContext: null
+      };
+    }
+    if (!existsSync(dockerfilePath)) {
+      throw new Error(`E2B runtime requires template_id or a Dockerfile at ${dockerfilePath}.`);
+    }
+    return {
+      runtime: e2bRuntime,
+      runner: "e2b",
+      dockerfilePath,
+      buildContext
+    };
+  }
+};
+function resolveRuntimeBuildPaths(cwd, runtime) {
+  return {
+    dockerfilePath: path2.resolve(cwd, runtime.dockerfile ?? path2.join(".poe-code", "Dockerfile")),
+    buildContext: path2.resolve(cwd, runtime.build_context ?? ".")
+  };
+}
+function parseSharedRuntimeFields(record) {
+  return omitUndefined({
+    build_args: parseBuildArgs(record.build_args),
+    mounts: parseMounts(record.mounts),
+    link: parseOptionalString(record.link)
+  });
+}
+function parseRuntimeType(value) {
+  if (value === void 0) {
+    return "host";
+  }
+  if (value === "host" || value === "docker" || value === "e2b") {
+    return value;
+  }
+  throw new Error('type: expected "host", "docker", or "e2b".');
+}
 function createDefaultRunnerScope() {
   return {
     detach: false,
@@ -244,6 +374,18 @@ function parseMounts(value) {
     });
   });
 }
+function parseOptionalString(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error("expected a string.");
+  }
+  if (value.length === 0) {
+    return void 0;
+  }
+  return value;
+}
 function parseOptionalStringArray(value, key = "") {
   if (value === void 0) {
     return void 0;
@@ -258,6 +400,13 @@ function parseOptionalStringArray(value, key = "") {
     return entry;
   });
 }
+function parseEngine(value) {
+  const engine = parseOptionalString(value);
+  if (engine === void 0 || engine === "docker" || engine === "podman") {
+    return engine;
+  }
+  throw new Error('engine: expected "docker" or "podman".');
+}
 function parseOptionalNumber(value, key = "") {
   if (value === void 0) {
     return void 0;
@@ -397,11 +546,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path33) {
+function mergeObjectLayers(layers, path38) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path33);
+    const resolved = resolveKey(layers, key, path38);
     if (resolved === void 0) {
       continue;
     }
@@ -419,7 +568,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path33) {
+function resolveKey(layers, key, path38) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -449,9 +598,9 @@ function resolveKey(layers, key, path33) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path33, key);
+  const fullPath = buildPath(path38, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path33, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path38, key]);
     return {
       value: merged.data,
       sources: {
@@ -476,8 +625,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path33, key) {
-  return [...path33, key].join(".");
+function buildPath(path38, key) {
+  return [...path38, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1111,16 +1260,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path33) {
-  const ext = getExtension(path33);
+function detectFormat2(path38) {
+  const ext = getExtension(path38);
   return extensionMap[ext];
 }
-function getExtension(path33) {
-  const lastDot = path33.lastIndexOf(".");
+function getExtension(path38) {
+  const lastDot = path38.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path33.slice(lastDot).toLowerCase();
+  return path38.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -1876,9 +2025,151 @@ function createInvalidBackupPath(filePath) {
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function resolveConfigPath(homeDir) {
+  return path7.join(homeDir, ".poe-code", "config.json");
+}
+function resolveProjectConfigPath(cwd) {
+  return path7.join(cwd, ".poe-code", "config.json");
+}
 var EMPTY_DOCUMENT = `${JSON.stringify({}, null, 2)}
 `;
 
+// packages/poe-code-config/src/resolve.ts
+function resolveScope(schema, fileValues, env = {}) {
+  const resolved = {};
+  for (const key of Object.keys(schema)) {
+    const field = schema[key];
+    const envValue = resolveEnvValue(field, env, key);
+    const fileValue = resolveFileValue(field, fileValues?.[key], key);
+    resolved[key] = envValue ?? fileValue ?? field.default;
+  }
+  return resolved;
+}
+function resolveEnvValue(field, env, key) {
+  if (!field.env) {
+    return void 0;
+  }
+  const raw = env[field.env];
+  if (raw === void 0) {
+    return void 0;
+  }
+  return coerceValue(field, raw, key);
+}
+function resolveFileValue(field, value, key) {
+  return coerceValue(field, value, key);
+}
+function coerceValue(field, value, key) {
+  switch (field.type) {
+    case "string":
+      return typeof value === "string" ? value : void 0;
+    case "number":
+      return coerceNumber(value);
+    case "boolean":
+      return coerceBoolean(value);
+    case "json":
+      return coerceJson(field, value, key);
+  }
+}
+function coerceNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function coerceBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === "true" || value === "1") {
+    return true;
+  }
+  if (value === "false" || value === "0") {
+    return false;
+  }
+  return void 0;
+}
+function coerceJson(field, value, key) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsedValue = parseJsonValue(value, key);
+  try {
+    return field.parse(parsedValue);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : "Invalid JSON value.";
+    throw new Error(`Invalid config value for "${key}": ${message2}`);
+  }
+}
+function parseJsonValue(value, key) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Invalid config value for "${key}": expected valid JSON.`);
+  }
+}
+
+// packages/poe-code-config/src/merge.ts
+function deepMergeDocuments(base, override) {
+  const merged = {};
+  const scopes = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(override)]);
+  for (const scope of scopes) {
+    const baseScope = base[scope] ?? {};
+    const overrideScope = override[scope] ?? {};
+    const nextScope = mergeScope(scope, baseScope, overrideScope);
+    if (Object.keys(nextScope).length > 0) {
+      merged[scope] = nextScope;
+    }
+  }
+  return merged;
+}
+function mergeScope(scope, baseScope, overrideScope) {
+  if (scope === "runtime") {
+    return mergeRuntimeScope(baseScope, overrideScope);
+  }
+  const scopeEntries = Object.entries(overrideScope).filter(([, value]) => value !== void 0);
+  return {
+    ...baseScope,
+    ...Object.fromEntries(scopeEntries)
+  };
+}
+function mergeRuntimeScope(baseScope, overrideScope, path38 = []) {
+  const merged = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
+  for (const key of keys) {
+    const baseValue = baseScope[key];
+    const overrideValue = overrideScope[key];
+    if (overrideValue === void 0) {
+      if (baseValue !== void 0) {
+        merged[key] = baseValue;
+      }
+      continue;
+    }
+    if (isRuntimeConcatenativeArray([...path38, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+      merged[key] = [...baseValue, ...overrideValue];
+      continue;
+    }
+    if (isRecord2(baseValue) && isRecord2(overrideValue)) {
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path38, key]);
+      continue;
+    }
+    merged[key] = overrideValue;
+  }
+  return merged;
+}
+function isRuntimeConcatenativeArray(path38) {
+  return path38.join(".") === "mounts" || path38.join(".") === "runner.workspace.exclude";
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // packages/poe-code-config/src/memory.ts
 async function configuredMemoryRoot(options) {
   return (await resolveMemoryConfig(options)).root;
@@ -1938,115 +2229,567 @@ import path9 from "node:path";
 // packages/file-lock/src/lock.ts
 import * as fsPromises from "node:fs/promises";
 import * as os from "node:os";
-
-// packages/poe-code-config/src/state/fs.ts
-import * as nodeFs from "node:fs/promises";
-
-// packages/poe-code-config/src/state/templates.ts
-import path10 from "node:path";
-
-// packages/memory/src/resolve-root.ts
-var MEMORY_ROOT_ENV_VAR = "POE_CODE_MEMORY_ROOT";
-async function resolveConfiguredMemoryRoot(options) {
-  const envOverride = options.env[MEMORY_ROOT_ENV_VAR]?.trim();
-  if (envOverride && envOverride.length > 0) {
-    return resolveAgainstCwd(options.cwd, envOverride);
+var LockTimeoutError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "LockTimeoutError";
   }
-  const configOverride = (await configuredMemoryRoot({
-    fs: options.fs,
-    filePath: options.configPath,
-    projectFilePath: options.projectConfigPath
-  }))?.trim();
-  if (configOverride && configOverride.length > 0) {
-    return resolveAgainstCwd(options.cwd, configOverride);
+};
+function createAbortError() {
+  const error2 = new Error("The operation was aborted.");
+  error2.name = "AbortError";
+  return error2;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
   }
-  return resolveMemoryRoot(options.cwd);
 }
-function resolveAgainstCwd(cwd, value) {
-  return path11.isAbsolute(value) ? value : path11.resolve(cwd, value);
+function sleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  if (signal.aborted) {
+    return Promise.reject(createAbortError());
+  }
+  return new Promise((resolve2, reject) => {
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
 }
-
-// packages/memory/src/init.ts
-import * as fs from "node:fs/promises";
-import path12 from "node:path";
-async function initMemory(root) {
-  await fs.mkdir(path12.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
-  await writeFileIfMissing(path12.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
-  await writeFileIfMissing(path12.join(root, MEMORY_LOG_RELPATH), "");
+function backoff(attempt, minTimeout, maxTimeout) {
+  const delay = Math.min(maxTimeout, minTimeout * 2 ** attempt);
+  return delay + Math.random() * delay * 0.1;
 }
-async function writeFileIfMissing(filePath, content) {
+function hasErrorCode(error2, code) {
+  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
+}
+function hasAnyErrorCode(error2, codes) {
+  return codes.some((code) => hasErrorCode(error2, code));
+}
+function isPidRunning(pid) {
   try {
-    await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+    process.kill(pid, 0);
+    return true;
   } catch (error2) {
-    if (!hasErrorCode(error2, "EEXIST")) {
-      throw error2;
-    }
+    return !hasErrorCode(error2, "ESRCH");
   }
 }
-function hasErrorCode(error2, code) {
-  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
-}
-
-// packages/memory/src/pages.ts
-import * as fs2 from "node:fs/promises";
-import path13 from "node:path";
-
-// packages/memory/src/frontmatter.ts
-import { parse as parse5, stringify } from "yaml";
-function parseFrontmatter(markdown) {
-  const content = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
-  const openingLineBreak = readOpeningLineBreak(content);
-  if (openingLineBreak === void 0) {
-    return {
-      frontmatter: {},
-      body: markdown
-    };
-  }
-  const frontmatterStart = 3 + openingLineBreak.length;
-  const closingFenceIndex = findClosingFence(content, frontmatterStart);
-  const yamlBlock = content.slice(frontmatterStart, closingFenceIndex);
-  const bodyStart = closingFenceIndex + 4;
+function createDefaultFs() {
   return {
-    frontmatter: parsePageFrontmatter(parseYamlFrontmatter(yamlBlock)),
-    body: readBody(content, bodyStart)
+    open: (path38, flags) => fsPromises.open(path38, flags),
+    readFile: (path38, encoding) => fsPromises.readFile(path38, encoding),
+    stat: fsPromises.stat,
+    unlink: fsPromises.unlink
   };
 }
-function serializeFrontmatter(frontmatter, body) {
-  const serialized = {
-    ...frontmatter.name === void 0 ? {} : { name: frontmatter.name },
-    ...frontmatter.description === void 0 ? {} : { description: frontmatter.description },
-    ...frontmatter.lastTouchedAt === void 0 ? {} : { last_touched_at: frontmatter.lastTouchedAt },
-    ...frontmatter.sources === void 0 || frontmatter.sources.length === 0 ? {} : { sources: frontmatter.sources.map((source) => serializeSourceRef(source)) }
-  };
-  if (Object.keys(serialized).length === 0) {
-    return body;
+async function removeLockFile(fs14, lockPath, signal) {
+  for (let attempt = 0; attempt <= 4; attempt += 1) {
+    throwIfAborted(signal);
+    try {
+      await fs14.unlink(lockPath);
+      return;
+    } catch (error2) {
+      if (hasErrorCode(error2, "ENOENT")) {
+        return;
+      }
+      if (!hasAnyErrorCode(error2, ["EPERM", "EBUSY"]) || attempt === 4) {
+        throw error2;
+      }
+    }
+    await sleep(25 * 2 ** attempt, signal);
   }
-  return `---
-${stringify(serialized).trimEnd()}
----
-${body}`;
 }
-function parseSourceRef(serialized) {
-  const [rawPath, rawAnchor] = serialized.split("#", 2);
-  const normalizedPath = rawPath?.trim();
-  if (normalizedPath === void 0 || normalizedPath.length === 0) {
-    throw new Error(`Invalid source ref "${serialized}".`);
+function parseLockMetadata(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !("host" in parsed) || !("pid" in parsed)) {
+      return void 0;
+    }
+    const { host, pid } = parsed;
+    if (typeof host === "string" && typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0) {
+      return {
+        host,
+        pid
+      };
+    }
+  } catch (ignoredError) {
+    void ignoredError;
   }
-  if (rawAnchor === void 0) {
-    return { path: normalizedPath };
+  return void 0;
+}
+async function readLockMetadata(fs14, lockPath) {
+  if (!fs14.readFile) {
+    return void 0;
   }
-  const singleLineMatch = /^L(\d+)$/.exec(rawAnchor);
-  if (singleLineMatch !== null) {
-    const startLine = Number.parseInt(singleLineMatch[1], 10);
-    assertValidLineNumber(startLine, serialized);
-    return {
-      path: normalizedPath,
-      startLine
-    };
+  try {
+    return parseLockMetadata(await fs14.readFile(lockPath, "utf8"));
+  } catch (error2) {
+    if (hasErrorCode(error2, "ENOENT")) {
+      return null;
+    }
+    return void 0;
   }
-  const rangeMatch = /^L(\d+)-L?(\d+)$/.exec(rawAnchor);
-  if (rangeMatch !== null) {
-    const startLine = Number.parseInt(rangeMatch[1], 10);
+}
+async function shouldReclaimLock(options) {
+  const metadata = await readLockMetadata(options.fs, options.lockPath);
+  if (metadata === null) {
+    return "missing";
+  }
+  if (metadata?.host === os.hostname()) {
+    return !options.isPidRunning(metadata.pid);
+  }
+  return Date.now() - options.stat.mtimeMs > options.staleMs;
+}
+async function writeLockMetadata(handle) {
+  try {
+    await handle.writeFile(
+      JSON.stringify({ pid: process.pid, host: os.hostname(), acquiredAt: (/* @__PURE__ */ new Date()).toISOString() }),
+      { encoding: "utf8" }
+    );
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+  try {
+    await handle.close();
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+}
+async function acquireFileLock(filePath, options = {}) {
+  const fs14 = options.fs ?? createDefaultFs();
+  const retries = options.retries ?? 20;
+  const minTimeout = options.minTimeout ?? 25;
+  const maxTimeout = options.maxTimeout ?? 250;
+  const staleMs = options.staleMs ?? 1e3;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning;
+  const lockPath = `${filePath}.lock`;
+  let attempt = 0;
+  while (attempt <= retries) {
+    throwIfAborted(options.signal);
+    try {
+      const handle = await fs14.open(lockPath, "wx");
+      await writeLockMetadata(handle);
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        await removeLockFile(fs14, lockPath, options.signal);
+      };
+    } catch (error2) {
+      if (!hasErrorCode(error2, "EEXIST")) {
+        throw error2;
+      }
+    }
+    let stat7;
+    try {
+      stat7 = await fs14.stat(lockPath);
+    } catch (statError) {
+      if (hasErrorCode(statError, "ENOENT")) {
+        continue;
+      }
+      throw statError;
+    }
+    const reclaimLock = await shouldReclaimLock({
+      fs: fs14,
+      isPidRunning: pidIsRunning,
+      lockPath,
+      staleMs,
+      stat: stat7
+    });
+    if (reclaimLock === "missing") {
+      continue;
+    }
+    if (reclaimLock) {
+      await removeLockFile(fs14, lockPath, options.signal);
+      continue;
+    }
+    if (attempt >= retries) {
+      break;
+    }
+    await sleep(backoff(attempt, minTimeout, maxTimeout), options.signal);
+    attempt += 1;
+  }
+  throw new LockTimeoutError(`Failed to acquire lock on "${filePath}".`);
+}
+
+// packages/poe-code-config/src/state/fs.ts
+import * as nodeFs from "node:fs/promises";
+var defaultStateFs = nodeFs;
+function isNotFoundError(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+
+// packages/poe-code-config/src/state/jobs.ts
+function createJobRegistry(homeDir, fs14 = defaultStateFs) {
+  const jobsDir = path9.join(homeDir, ".poe-code", "state", "jobs");
+  function jobPath(id) {
+    assertSafeJobId(id);
+    return path9.join(jobsDir, `${id}.json`);
+  }
+  async function get(id) {
+    try {
+      return parseJobEntry(await fs14.readFile(jobPath(id), "utf8"));
+    } catch (error2) {
+      if (isNotFoundError(error2)) {
+        return null;
+      }
+      throw error2;
+    }
+  }
+  async function put(entry) {
+    assertJobEntry(entry);
+    const filePath = jobPath(entry.id);
+    await fs14.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs14 });
+    try {
+      await writeJobAtomically(filePath, entry);
+    } finally {
+      await release();
+    }
+  }
+  async function update(id, patch) {
+    const filePath = jobPath(id);
+    await fs14.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs14 });
+    try {
+      const current = await get(id);
+      if (current === null) {
+        return null;
+      }
+      const updated = {
+        ...current,
+        ...patch,
+        id: current.id
+      };
+      assertJobEntry(updated);
+      await writeJobAtomically(filePath, updated);
+      return updated;
+    } finally {
+      await release();
+    }
+  }
+  async function list(filter = {}) {
+    let entries;
+    try {
+      entries = await fs14.readdir(jobsDir);
+    } catch (error2) {
+      if (isNotFoundError(error2)) {
+        return [];
+      }
+      throw error2;
+    }
+    const jobs = [];
+    for (const entry of entries.sort()) {
+      if (!entry.endsWith(".json")) {
+        continue;
+      }
+      const filePath = path9.join(jobsDir, entry);
+      const stat7 = await fs14.stat(filePath);
+      if (!stat7.isFile()) {
+        continue;
+      }
+      const job = parseJobEntry(await fs14.readFile(filePath, "utf8"));
+      if (matchesFilter(job, filter)) {
+        jobs.push(job);
+      }
+    }
+    return jobs;
+  }
+  async function remove2(id) {
+    const filePath = jobPath(id);
+    try {
+      await fs14.stat(jobsDir);
+    } catch (error2) {
+      if (isNotFoundError(error2)) {
+        return;
+      }
+      throw error2;
+    }
+    const release = await acquireFileLock(filePath, { fs: fs14 });
+    try {
+      await fs14.unlink(filePath);
+    } catch (error2) {
+      if (!isNotFoundError(error2)) {
+        throw error2;
+      }
+    } finally {
+      await release();
+    }
+  }
+  async function writeJobAtomically(filePath, entry) {
+    await fs14.mkdir(path9.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+      await fs14.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
+`, {
+        encoding: "utf8"
+      });
+      await fs14.rename(tempPath, filePath);
+    } catch (error2) {
+      await removeTempFile(tempPath);
+      throw error2;
+    }
+  }
+  async function removeTempFile(tempPath) {
+    try {
+      await fs14.unlink(tempPath);
+    } catch (error2) {
+      if (!isNotFoundError(error2)) {
+        throw error2;
+      }
+    }
+  }
+  return {
+    get,
+    put,
+    update,
+    list,
+    remove: remove2
+  };
+}
+function assertSafeJobId(id) {
+  if (id.length === 0 || id === "." || id === ".." || path9.isAbsolute(id) || id.includes("/") || id.includes("\\") || id.includes("\0")) {
+    throw new Error("Invalid job id.");
+  }
+}
+function assertJobEntry(entry) {
+  if (!isJobEntry(entry)) {
+    throw new Error("Invalid job entry.");
+  }
+}
+function matchesFilter(job, filter) {
+  return (filter.env_id === void 0 || job.env_id === filter.env_id) && (filter.env_kind === void 0 || job.env_kind === filter.env_kind) && (filter.tool === void 0 || job.tool === filter.tool) && (filter.status === void 0 || job.status === filter.status);
+}
+function parseJobEntry(content) {
+  const parsed = JSON.parse(content);
+  if (!isJobEntry(parsed)) {
+    throw new Error("Invalid job state file.");
+  }
+  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");
+}
+function isJobStatus(value) {
+  return value === "pending" || value === "running" || value === "exited" || value === "killed" || value === "lost";
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// packages/poe-code-config/src/state/templates.ts
+import path10 from "node:path";
+function createTemplateRegistry(homeDir, fs14 = defaultStateFs) {
+  const filePath = path10.join(homeDir, ".poe-code", "state", "templates.json");
+  async function readState() {
+    try {
+      const raw = await fs14.readFile(filePath, "utf8");
+      return normalizeTemplateState(JSON.parse(raw));
+    } catch (error2) {
+      if (isNotFoundError(error2)) {
+        return createEmptyState();
+      }
+      throw error2;
+    }
+  }
+  async function writeState(state) {
+    await fs14.writeFile(filePath, `${JSON.stringify(state, null, 2)}
+`, {
+      encoding: "utf8"
+    });
+  }
+  async function updateState(mutator) {
+    await fs14.mkdir(path10.dirname(filePath), { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs14 });
+    try {
+      const state = await readState();
+      mutator(state);
+      await writeState(state);
+    } finally {
+      await release();
+    }
+  }
+  async function get(backend, hash) {
+    const state = await readState();
+    return state[backend][hash] ?? null;
+  }
+  async function put(backend, entry) {
+    await updateState((state) => {
+      state[backend][entry.hash] = entry;
+    });
+  }
+  async function remove2(backend, hash) {
+    await updateState((state) => {
+      delete state[backend][hash];
+    });
+  }
+  async function list(backend) {
+    const state = await readState();
+    const entries = backend === void 0 ? [...Object.values(state.docker), ...Object.values(state.e2b)] : Object.values(state[backend]);
+    return entries.sort((left, right) => left.hash.localeCompare(right.hash));
+  }
+  return {
+    get,
+    put,
+    remove: remove2,
+    list
+  };
+}
+function createEmptyState() {
+  return {
+    docker: {},
+    e2b: {}
+  };
+}
+function normalizeTemplateState(value) {
+  if (!isRecord4(value)) {
+    return createEmptyState();
+  }
+  return {
+    docker: normalizeTemplateEntries(value.docker),
+    e2b: normalizeTemplateEntries(value.e2b)
+  };
+}
+function normalizeTemplateEntries(value) {
+  if (!isRecord4(value)) {
+    return {};
+  }
+  const entries = {};
+  for (const [hash, entry] of Object.entries(value)) {
+    if (isTemplateEntry(entry) && entry.hash === hash) {
+      entries[hash] = entry;
+    }
+  }
+  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");
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// packages/poe-code-config/src/state/index.ts
+function createStateManager(homeDir, fs14) {
+  return {
+    templates: createTemplateRegistry(homeDir, fs14),
+    jobs: createJobRegistry(homeDir, fs14)
+  };
+}
+
+// packages/memory/src/resolve-root.ts
+var MEMORY_ROOT_ENV_VAR = "POE_CODE_MEMORY_ROOT";
+async function resolveConfiguredMemoryRoot(options) {
+  const envOverride = options.env[MEMORY_ROOT_ENV_VAR]?.trim();
+  if (envOverride && envOverride.length > 0) {
+    return resolveAgainstCwd(options.cwd, envOverride);
+  }
+  const configOverride = (await configuredMemoryRoot({
+    fs: options.fs,
+    filePath: options.configPath,
+    projectFilePath: options.projectConfigPath
+  }))?.trim();
+  if (configOverride && configOverride.length > 0) {
+    return resolveAgainstCwd(options.cwd, configOverride);
+  }
+  return resolveMemoryRoot(options.cwd);
+}
+function resolveAgainstCwd(cwd, value) {
+  return path11.isAbsolute(value) ? value : path11.resolve(cwd, value);
+}
+
+// packages/memory/src/init.ts
+import * as fs from "node:fs/promises";
+import path12 from "node:path";
+async function initMemory(root) {
+  await fs.mkdir(path12.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
+  await writeFileIfMissing(path12.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
+  await writeFileIfMissing(path12.join(root, MEMORY_LOG_RELPATH), "");
+}
+async function writeFileIfMissing(filePath, content) {
+  try {
+    await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+  } catch (error2) {
+    if (!hasErrorCode2(error2, "EEXIST")) {
+      throw error2;
+    }
+  }
+}
+function hasErrorCode2(error2, code) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
+}
+
+// packages/memory/src/pages.ts
+import * as fs2 from "node:fs/promises";
+import path13 from "node:path";
+
+// packages/memory/src/frontmatter.ts
+import { parse as parse5, stringify } from "yaml";
+function parseFrontmatter(markdown) {
+  const content = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
+  const openingLineBreak = readOpeningLineBreak(content);
+  if (openingLineBreak === void 0) {
+    return {
+      frontmatter: {},
+      body: markdown
+    };
+  }
+  const frontmatterStart = 3 + openingLineBreak.length;
+  const closingFenceIndex = findClosingFence(content, frontmatterStart);
+  const yamlBlock = content.slice(frontmatterStart, closingFenceIndex);
+  const bodyStart = closingFenceIndex + 4;
+  return {
+    frontmatter: parsePageFrontmatter(parseYamlFrontmatter(yamlBlock)),
+    body: readBody(content, bodyStart)
+  };
+}
+function serializeFrontmatter(frontmatter, body) {
+  const serialized = {
+    ...frontmatter.name === void 0 ? {} : { name: frontmatter.name },
+    ...frontmatter.description === void 0 ? {} : { description: frontmatter.description },
+    ...frontmatter.lastTouchedAt === void 0 ? {} : { last_touched_at: frontmatter.lastTouchedAt },
+    ...frontmatter.sources === void 0 || frontmatter.sources.length === 0 ? {} : { sources: frontmatter.sources.map((source) => serializeSourceRef(source)) }
+  };
+  if (Object.keys(serialized).length === 0) {
+    return body;
+  }
+  return `---
+${stringify(serialized).trimEnd()}
+---
+${body}`;
+}
+function parseSourceRef(serialized) {
+  const [rawPath, rawAnchor] = serialized.split("#", 2);
+  const normalizedPath = rawPath?.trim();
+  if (normalizedPath === void 0 || normalizedPath.length === 0) {
+    throw new Error(`Invalid source ref "${serialized}".`);
+  }
+  if (rawAnchor === void 0) {
+    return { path: normalizedPath };
+  }
+  const singleLineMatch = /^L(\d+)$/.exec(rawAnchor);
+  if (singleLineMatch !== null) {
+    const startLine = Number.parseInt(singleLineMatch[1], 10);
+    assertValidLineNumber(startLine, serialized);
+    return {
+      path: normalizedPath,
+      startLine
+    };
+  }
+  const rangeMatch = /^L(\d+)-L?(\d+)$/.exec(rawAnchor);
+  if (rangeMatch !== null) {
+    const startLine = Number.parseInt(rangeMatch[1], 10);
     const endLine = Number.parseInt(rangeMatch[2], 10);
     assertValidLineNumber(startLine, serialized);
     assertValidLineNumber(endLine, serialized);
@@ -2135,7 +2878,7 @@ function parseYamlFrontmatter(yamlBlock) {
   if (parsed === null) {
     return {};
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord5(parsed)) {
     throw new Error("YAML frontmatter must parse to an object.");
   }
   return parsed;
@@ -2166,13 +2909,13 @@ function parseSources(value) {
     if (typeof item === "string") {
       return parseSourceRef(item);
     }
-    if (!isRecord2(item)) {
+    if (!isRecord5(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path33 = readRequiredString(item.path, "sources[].path");
+    const path38 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path33, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path38, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -2205,7 +2948,7 @@ function assertValidLineNumber(line, value) {
     throw new Error(`Invalid source ref "${value}": line numbers must be positive integers.`);
   }
 }
-function isRecord2(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -2377,17 +3120,17 @@ import path18 from "node:path";
 // packages/memory/src/lock.ts
 import * as fsPromises2 from "node:fs/promises";
 import path16 from "node:path";
-function createDefaultFs() {
+function createDefaultFs2() {
   return {
     readFile: (filePath, encoding) => fsPromises2.readFile(filePath, encoding),
     unlink: fsPromises2.unlink,
     writeFile: (filePath, data, options) => fsPromises2.writeFile(filePath, data, options)
   };
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function hasErrorCode2(error2, code) {
+function hasErrorCode3(error2, code) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
 }
 function lockDelay(attempt, minTimeoutMs, maxTimeoutMs) {
@@ -2406,19 +3149,19 @@ function parsePid(input) {
   const pid = Number.parseInt(value, 10);
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
-function isPidRunning(pid) {
+function isPidRunning2(pid) {
   try {
     process.kill(pid, 0);
     return true;
   } catch (error2) {
-    return !hasErrorCode2(error2, "ESRCH");
+    return !hasErrorCode3(error2, "ESRCH");
   }
 }
-async function removeLockFile(fs14, lockPath) {
+async function removeLockFile2(fs14, lockPath) {
   try {
     await fs14.unlink(lockPath);
   } catch (error2) {
-    if (!hasErrorCode2(error2, "ENOENT")) {
+    if (!hasErrorCode3(error2, "ENOENT")) {
       throw error2;
     }
   }
@@ -2427,20 +3170,20 @@ async function readLockPid(fs14, lockPath) {
   try {
     return parsePid(await fs14.readFile(lockPath, "utf8"));
   } catch (error2) {
-    if (hasErrorCode2(error2, "ENOENT")) {
+    if (hasErrorCode3(error2, "ENOENT")) {
       return null;
     }
     throw error2;
   }
 }
 async function withLock(root, run, options = {}) {
-  const fs14 = options.fs ?? createDefaultFs();
+  const fs14 = options.fs ?? createDefaultFs2();
   const lockPath = path16.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
   const minTimeoutMs = options.minTimeoutMs ?? 25;
   const maxTimeoutMs = options.maxTimeoutMs ?? 250;
-  const pidIsRunning = options.isPidRunning ?? isPidRunning;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning2;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
     try {
       await fs14.writeFile(lockPath, `${pid}
@@ -2448,10 +3191,10 @@ async function withLock(root, run, options = {}) {
       try {
         return await run();
       } finally {
-        await removeLockFile(fs14, lockPath);
+        await removeLockFile2(fs14, lockPath);
       }
     } catch (error2) {
-      if (!hasErrorCode2(error2, "EEXIST")) {
+      if (!hasErrorCode3(error2, "EEXIST")) {
         throw error2;
       }
     }
@@ -2460,11 +3203,11 @@ async function withLock(root, run, options = {}) {
       continue;
     }
     if (existingPid === void 0 || !pidIsRunning(existingPid)) {
-      await removeLockFile(fs14, lockPath);
+      await removeLockFile2(fs14, lockPath);
       continue;
     }
     if (attempt < retries) {
-      await sleep(lockDelay(attempt, minTimeoutMs, maxTimeoutMs));
+      await sleep2(lockDelay(attempt, minTimeoutMs, maxTimeoutMs));
     }
   }
   throw new Error(`Failed to acquire memory lock at "${lockPath}".`);
@@ -3201,37 +3944,1401 @@ function isMissing3(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
 
-// packages/memory/src/cache.cli.ts
-import parseDuration from "parse-duration";
-async function runMemoryCacheStatus() {
-  console.log("cache status not implemented yet");
+// packages/memory/src/cache.cli.ts
+import parseDuration from "parse-duration";
+async function runMemoryCacheStatus() {
+  console.log("cache status not implemented yet");
+}
+async function runMemoryCacheClear(input) {
+  if (!input.yes) {
+    throw new Error("Refusing to clear cache without --yes.");
+  }
+  const olderThanMs = parseOlderThan(input.olderThan);
+  const result = await clearCache(input.root, olderThanMs === void 0 ? {} : { olderThanMs });
+  console.log(`removed ${result.removed} cache ${result.removed === 1 ? "entry" : "entries"}`);
+  return result;
+}
+function parseOlderThan(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const duration = parseDuration(value);
+  if (duration === null || Number.isNaN(duration) || duration < 0) {
+    throw new Error(`Invalid duration for --older-than: "${value}".`);
+  }
+  return duration;
+}
+
+// packages/memory/src/ingest.ts
+import * as fs11 from "node:fs/promises";
+import path31 from "node:path";
+
+// packages/agent-spawn/src/register-factories.ts
+import { spawn as spawnChildProcess2 } from "node:child_process";
+
+// packages/agent-harness-tools/src/paths.ts
+import path22 from "node:path";
+
+// packages/agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/goose.ts
+var gooseAgent = {
+  id: "goose",
+  name: "goose",
+  label: "Goose",
+  summary: "Block's open-source AI agent with ACP support.",
+  binaryName: "goose",
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/poe-agent.ts
+var poeAgentAgent = {
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  configPath: "~/.poe-code/config.json",
+  branding: {
+    colors: {
+      dark: "#A465F7",
+      light: "#7A3FD3"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent,
+  gooseAgent,
+  poeAgentAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup.get(input.toLowerCase());
+}
+
+// packages/agent-harness-tools/src/select-agent.ts
+var loopAgents = allAgents.filter(
+  (agent) => agent.binaryName !== void 0 || agent.id === "poe-agent"
+);
+var supportedAgents = loopAgents.map((agent) => agent.id).join(", ");
+
+// packages/agent-harness-tools/src/run-logs.ts
+import path23 from "node:path";
+
+// packages/agent-harness-tools/src/log-stream.ts
+import nodeFs2 from "node:fs";
+var JOB_DIR = "/tmp/poe-jobs";
+var POLL_INTERVAL_MS = 250;
+function wrapForLogTee(argv, jobId) {
+  if (argv.length === 0) {
+    throw new Error("wrapForLogTee requires argv to contain at least one argument");
+  }
+  const command = argv.map(shellQuote).join(" ");
+  const logFile = shellQuote(jobLogPath(jobId));
+  const exitFile = shellQuote(jobExitPath(jobId));
+  const exitTmpFile = shellQuote(`${jobExitPath(jobId)}.tmp`);
+  const script = [
+    `mkdir -p ${shellQuote(JOB_DIR)}`,
+    `({ (${command}); echo $? > ${exitTmpFile}; } 2>&1 | tee ${logFile}; mv ${exitTmpFile} ${exitFile})`
+  ].join(" && ");
+  return ["sh", "-c", script];
+}
+async function waitForExit(env, jobId, opts = {}) {
+  const fs14 = env.fs ?? nodeFs2;
+  const file = jobExitPath(jobId);
+  while (true) {
+    throwIfAborted2(opts.signal);
+    const contents = await readTextFileIfExists(fs14, file);
+    if (contents !== null) {
+      const text4 = contents.trim();
+      const exitCode = Number(text4);
+      if (text4.length === 0 || !Number.isInteger(exitCode)) {
+        throw new Error(`Invalid exit code in ${file}: ${contents}`);
+      }
+      return { exitCode };
+    }
+    await sleep3(POLL_INTERVAL_MS, opts.signal);
+  }
+}
+function jobLogPath(jobId) {
+  return `${JOB_DIR}/${jobId}.log`;
+}
+function jobExitPath(jobId) {
+  return `${JOB_DIR}/${jobId}.exit`;
+}
+async function readTextFileIfExists(fs14, file) {
+  const contents = await readFileIfExists2(fs14, file);
+  return contents?.toString("utf8") ?? null;
+}
+async function readFileIfExists2(fs14, file) {
+  try {
+    const contents = await fs14.promises.readFile(file);
+    return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
+  } catch (error2) {
+    if (isNodeError(error2) && error2.code === "ENOENT") {
+      return null;
+    }
+    throw error2;
+  }
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    let timer = null;
+    const abort = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+      }
+      reject(new Error("waitForExit aborted."));
+    };
+    if (signal?.aborted) {
+      abort();
+      return;
+    }
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve2();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw new Error("waitForExit aborted.");
+  }
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isNodeError(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+
+// packages/agent-harness-tools/src/run-poe-command.ts
+import { randomBytes } from "node:crypto";
+var ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+async function runPoeCommand(opts) {
+  const jobId = createUlid();
+  const execution = opts.openSpec.execution;
+  const wrapCommand = execution?.wrapForLogTee !== false;
+  const pendingJob = opts.state.jobs.put({
+    id: jobId,
+    env_id: "",
+    env_kind: opts.factory.type,
+    tool: opts.openSpec.jobLabel.tool,
+    argv: opts.openSpec.jobLabel.argv,
+    cwd: opts.openSpec.cwd,
+    started_at: "",
+    status: "pending"
+  });
+  const opened = opts.factory.open(opts.openSpec);
+  const env = isPromiseLike(opened) ? await opened : opened;
+  let shouldClose = true;
+  try {
+    const upload = env.uploadWorkspace();
+    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,
+      stdin: execution?.stdin ?? "inherit",
+      stdout: execution?.stdout ?? "pipe",
+      stderr: execution?.stderr ?? "pipe",
+      signal: opts.signal
+    });
+    if (execution?.input !== void 0) {
+      handle.stdin?.setDefaultEncoding("utf8");
+      handle.stdin?.end(execution.input);
+    }
+    const runningJob = Promise.all([pendingJob, upload]).then(
+      () => opts.state.jobs.update(jobId, {
+        status: "running",
+        env_id: env.id,
+        started_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    if (opts.detach) {
+      await runningJob;
+      shouldClose = false;
+      return { kind: "detached", jobId, envId: env.id };
+    }
+    const result = await runSync({
+      env,
+      handle,
+      jobId,
+      openSpec: opts.openSpec,
+      signal: opts.signal,
+      wrapCommand
+    });
+    await runningJob;
+    shouldClose = false;
+    await opts.state.jobs.update(jobId, {
+      status: "exited",
+      exit_code: result.exitCode,
+      exited_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      kind: "sync",
+      exitCode: result.exitCode,
+      download: result.download,
+      ...result.stdout !== void 0 ? { stdout: result.stdout } : {},
+      ...result.stderr !== void 0 ? { stderr: result.stderr } : {}
+    };
+  } finally {
+    if (shouldClose) {
+      await env.close();
+    }
+  }
+}
+async function runSync(opts) {
+  const execution = opts.openSpec.execution;
+  const capture = execution?.captureOutput === true;
+  const abort = createAbortSync(opts.signal, opts.handle, execution?.activityTimeoutMs);
+  const streamState = capture ? captureRunStreams(opts.handle, execution, abort.resetActivityTimer) : pipeRunStreams(opts.handle);
+  abort.resetActivityTimer();
+  try {
+    const { exitCode } = opts.wrapCommand ? await abort.waitForExit(opts.env, opts.jobId) : await abort.waitForHandle();
+    const download = await opts.env.downloadWorkspace({
+      conflictPolicy: opts.openSpec.runner?.download_conflict ?? "refuse"
+    });
+    await opts.env.close();
+    return {
+      exitCode,
+      download,
+      ...capture ? { stdout: streamState.stdout(), stderr: streamState.stderr() } : {}
+    };
+  } finally {
+    abort.dispose();
+    streamState.dispose();
+  }
+}
+function pipeRunStreams(handle) {
+  handle.stdout?.pipe(process.stdout, { end: false });
+  handle.stderr?.pipe(process.stderr, { end: false });
+  return {
+    stdout: () => "",
+    stderr: () => "",
+    dispose() {
+      handle.stdout?.unpipe(process.stdout);
+      handle.stderr?.unpipe(process.stderr);
+    }
+  };
+}
+function captureRunStreams(handle, execution, onActivity) {
+  let stdout = "";
+  let stderr = "";
+  const listeners = [];
+  const bind = (stream, onChunk) => {
+    if (!stream) return;
+    stream.setEncoding("utf8");
+    const listener = (chunk) => {
+      onActivity();
+      onChunk(chunk.toString());
+    };
+    stream.on("data", listener);
+    listeners.push(() => {
+      stream.off("data", listener);
+    });
+  };
+  bind(handle.stdout, (chunk) => {
+    stdout += chunk;
+    execution?.onStdout?.(chunk);
+  });
+  bind(handle.stderr, (chunk) => {
+    stderr += chunk;
+    execution?.onStderr?.(chunk);
+  });
+  return {
+    stdout: () => stdout,
+    stderr: () => stderr,
+    dispose() {
+      for (const remove2 of listeners) {
+        remove2();
+      }
+    }
+  };
+}
+function createAbortSync(signal, handle, activityTimeoutMs) {
+  let activityTimer;
+  let timedOut = false;
+  const resetActivityTimer = activityTimeoutMs ? () => {
+    if (activityTimer) clearTimeout(activityTimer);
+    activityTimer = setTimeout(() => {
+      timedOut = true;
+      handle.kill("SIGTERM");
+      notifyAbort?.();
+    }, activityTimeoutMs);
+  } : () => {
+  };
+  let notifyAbort;
+  if (signal === void 0) {
+    return {
+      waitForExit: (env, jobId) => waitForExit(toLogStreamEnv(env), jobId),
+      waitForHandle: async () => {
+        const result = await handle.result;
+        if (timedOut) {
+          throw createActivityTimeoutError(activityTimeoutMs);
+        }
+        return result;
+      },
+      resetActivityTimer,
+      dispose() {
+        if (activityTimer) clearTimeout(activityTimer);
+      }
+    };
+  }
+  const exitWaitController = new AbortController();
+  let aborted = signal.aborted;
+  const abortedPromise = new Promise((resolve2) => {
+    notifyAbort = resolve2;
+  });
+  const kill = () => {
+    aborted = true;
+    handle.kill("SIGTERM");
+    notifyAbort?.();
+  };
+  if (signal.aborted) {
+    kill();
+  } else {
+    signal.addEventListener("abort", kill, { once: true });
+  }
+  return {
+    async waitForExit(env, jobId) {
+      if (aborted) {
+        return handle.result;
+      }
+      const exit = waitForExit(toLogStreamEnv(env), jobId, {
+        signal: exitWaitController.signal
+      }).then(
+        (value) => ({ kind: "exit", value }),
+        (error2) => ({ kind: "error", error: error2 })
+      );
+      const result = await Promise.race([
+        exit,
+        abortedPromise.then(() => ({ kind: "abort" }))
+      ]);
+      if (result.kind === "exit") {
+        return result.value;
+      }
+      if (result.kind === "error") {
+        throw result.error;
+      }
+      exitWaitController.abort();
+      return handle.result;
+    },
+    async waitForHandle() {
+      const result = await Promise.race([
+        handle.result.then((value) => ({ kind: "exit", value })),
+        abortedPromise.then(() => ({ kind: "abort" }))
+      ]);
+      if (result.kind === "exit") {
+        if (aborted) {
+          throw createAbortError2();
+        }
+        if (timedOut) {
+          throw createActivityTimeoutError(activityTimeoutMs);
+        }
+        return result.value;
+      }
+      if (timedOut) {
+        throw createActivityTimeoutError(activityTimeoutMs);
+      }
+      throw createAbortError2();
+    },
+    resetActivityTimer,
+    dispose() {
+      if (activityTimer) clearTimeout(activityTimer);
+      exitWaitController.abort();
+      signal.removeEventListener("abort", kill);
+    }
+  };
+}
+function toLogStreamEnv(env) {
+  const candidate = env;
+  return candidate.fs === void 0 ? {} : { fs: candidate.fs };
+}
+function isPromiseLike(value) {
+  return typeof value.then === "function";
+}
+function createAbortError2() {
+  const error2 = new Error("Agent spawn aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+function createActivityTimeoutError(timeoutMs) {
+  const error2 = new Error(`Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`);
+  error2.name = "ActivityTimeoutError";
+  return error2;
+}
+function createUlid() {
+  const time = BigInt(Date.now());
+  const random = randomBytes(10);
+  let randomValue = 0n;
+  for (const byte of random) {
+    randomValue = randomValue << 8n | BigInt(byte);
+  }
+  return encodeBase32(time, 10) + encodeBase32(randomValue, 16);
+}
+function encodeBase32(value, length) {
+  const chars = Array.from({ length }, () => "0");
+  let remaining = value;
+  for (let index = length - 1; index >= 0; index -= 1) {
+    chars[index] = ULID_ALPHABET[Number(remaining & 31n)];
+    remaining >>= 5n;
+  }
+  return chars.join("");
+}
+
+// packages/agent-harness-tools/src/poe-command-execution.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import os3 from "node:os";
+
+// packages/agent-harness-tools/src/execution-env.ts
+var executionEnvFactories = /* @__PURE__ */ new Map();
+function registerExecutionEnvFactory(factory) {
+  executionEnvFactories.set(factory.type, factory);
+}
+function selectExecutionEnv(runtime) {
+  const factory = executionEnvFactories.get(runtime.type);
+  if (factory === void 0) {
+    throw new Error(
+      `No execution environment factory registered for runtime type "${runtime.type}".`
+    );
+  }
+  return factory;
+}
+
+// packages/agent-harness-tools/src/poe-command-execution.ts
+function resolvePoeCommandExecution(input) {
+  const homeDir = input.context?.homeDir ?? os3.homedir();
+  const config = applyRuntimeOverrides(loadRuntimeConfig(input.cwd, homeDir), input.runtime, input.cwd);
+  const resolved = resolveRuntime({ cwd: input.cwd, config });
+  const factory = selectExecutionEnv(resolved.runtime);
+  const state = input.context?.state ?? loadState(homeDir);
+  return {
+    factory,
+    detach: factory.supportsDetach === true && config.runner.detach,
+    state,
+    openSpec: {
+      cwd: input.cwd,
+      runtime: resolved.runtime,
+      runner: config.runner,
+      state,
+      env: input.env,
+      uploadIgnoreFiles: config.runner.workspace?.exclude ?? [],
+      jobLabel: {
+        tool: input.tool,
+        argv: input.argv
+      },
+      ...input.openSpec
+    }
+  };
+}
+function applyRuntimeOverrides(config, overrides, cwd = process.cwd()) {
+  if (!overrides) {
+    return config;
+  }
+  const runtime = parseRuntime({
+    ...config.runtime,
+    ...overrides.runtime !== void 0 ? { type: overrides.runtime } : {},
+    ...overrides.runtimeImage !== void 0 ? { image: overrides.runtimeImage } : {},
+    ...overrides.runtimeTemplate !== void 0 ? { template_id: overrides.runtimeTemplate } : {},
+    ...overrides.mountPoeCode === true ? { mounts: [...config.runtime.mounts, createPoeCodeMount(cwd)] } : {}
+  });
+  return {
+    runtime,
+    runner: {
+      ...config.runner,
+      ...overrides.detach === true ? { detach: true } : {}
+    }
+  };
+}
+function createPoeCodeMount(cwd) {
+  return {
+    source: cwd,
+    target: "/usr/local/lib/poe-code",
+    readonly: true
+  };
+}
+function loadRuntimeConfig(cwd, homeDir) {
+  const document = deepMergeDocuments(
+    readConfigDocument(resolveConfigPath(homeDir)),
+    readConfigDocument(resolveProjectConfigPath(cwd))
+  );
+  const runtimeScope = resolveScope(runtimeConfigScope.schema, document.runtime, process.env);
+  return {
+    runtime: parseRuntime(runtimeScope),
+    runner: runtimeScope.runner
+  };
+}
+function readConfigDocument(filePath) {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function loadState(homeDir) {
+  if (process.env.VITEST === "true") {
+    return createMemoryStateManager();
+  }
+  return createStateManager(homeDir);
+}
+function createMemoryStateManager() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    templates: {
+      async get() {
+        return null;
+      },
+      async put() {
+      },
+      async remove() {
+      },
+      async list() {
+        return [];
+      }
+    },
+    jobs: {
+      async get(id) {
+        return jobs.get(id) ?? null;
+      },
+      async put(entry) {
+        jobs.set(entry.id, entry);
+      },
+      async update(id, patch) {
+        const current = jobs.get(id);
+        if (!current) {
+          return null;
+        }
+        const updated = { ...current, ...patch, id };
+        jobs.set(id, updated);
+        return updated;
+      },
+      async list(filter) {
+        const entries = Array.from(jobs.values());
+        if (!filter) {
+          return entries;
+        }
+        return entries.filter(
+          (entry) => Object.entries(filter).every(([key, value]) => entry[key] === value)
+        );
+      },
+      async remove(id) {
+        jobs.delete(id);
+      }
+    }
+  };
+}
+
+// packages/agent-harness-tools/src/workspace-transfer.ts
+import { createHash as createHash3 } from "node:crypto";
+import { promises as nodeFs3 } from "node:fs";
+import path24 from "node:path";
+
+// packages/process-runner/src/docker/context.ts
+import { execSync } from "node:child_process";
+function detectContext() {
+  try {
+    const output = execSync("colima list --json", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const lines = output.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const profile = JSON.parse(line);
+      if (profile.status === "Running" && profile.runtime === "docker") {
+        const name = profile.name ?? profile.profile;
+        if (!name) {
+          continue;
+        }
+        return name === "default" ? "colima" : `colima-${name}`;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function buildContextArgs(engine, context) {
+  if (engine === "docker" && context) {
+    return ["--context", context];
+  }
+  return [];
+}
+
+// packages/process-runner/src/docker/engine.ts
+import { execSync as execSync2 } from "node:child_process";
+function detectEngine() {
+  if (isEngineAvailable("docker")) {
+    return "docker";
+  }
+  if (isEngineAvailable("podman")) {
+    return "podman";
+  }
+  throw new Error(
+    "No container engine found. Please install Docker or Podman:\n  - Docker Desktop: https://www.docker.com/products/docker-desktop\n  - Colima (macOS): brew install colima && colima start\n  - Podman: https://podman.io/docs/installation"
+  );
+}
+function isEngineAvailable(engine) {
+  try {
+    execSync2(`${engine} --version`, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/process-runner/src/docker/docker-runner.ts
+import * as childProcess from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// packages/process-runner/src/docker/args.ts
+import path25 from "node:path";
+function buildDockerRunArgs(input) {
+  const args = [input.engine];
+  if (input.engine === "docker" && input.context) {
+    args.push("--context", input.context);
+  }
+  args.push("run");
+  if (input.rm) {
+    args.push("--rm");
+  }
+  if (input.detached) {
+    args.push("-d");
+  }
+  if (input.interactive) {
+    args.push("-i");
+  }
+  if (input.tty) {
+    args.push("-t");
+  }
+  args.push("--name", input.containerName);
+  if (input.cwd !== void 0) {
+    args.push("-w", input.cwd);
+  }
+  for (const [key, value] of Object.entries(input.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  for (const mount of input.mounts) {
+    const volume = `${path25.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    args.push("-v", volume);
+  }
+  for (const port of input.ports) {
+    const mapping = `${port.host}:${port.container}${port.protocol === void 0 || port.protocol === "tcp" ? "" : `/${port.protocol}`}`;
+    args.push("-p", mapping);
+  }
+  if (input.network !== void 0) {
+    args.push("--network", input.network);
+  }
+  args.push(...input.extraArgs, input.image, input.command, ...input.args);
+  return args;
+}
+
+// packages/process-runner/src/docker/docker-execution-env.ts
+import { createHash as createHash4, randomBytes as randomBytes3 } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path26 from "node:path";
+
+// packages/process-runner/src/host/host-runner.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+function createHostRunner(options = {}) {
+  const detached = options.detached === true;
+  return {
+    name: "host",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" ? "inherit" : [stdinMode, stdoutMode, stderrMode];
+      const child = spawnChildProcess(spec.command, spec.args ?? [], {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio,
+        ...detached ? { detached: true } : {}
+      });
+      if (detached) {
+        child.unref();
+      }
+      const kill = (signal) => {
+        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+          process.kill(-child.pid, signal);
+          return;
+        }
+        child.kill(signal);
+      };
+      let settled = false;
+      let resolveResult = null;
+      const result = new Promise((resolve2) => {
+        resolveResult = resolve2;
+      });
+      const cleanupAbort = bindAbortSignal(spec.signal, () => {
+        kill("SIGTERM");
+      });
+      child.once("close", (code) => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: code ?? 1 });
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: 1 });
+      });
+      return {
+        pid: child.pid ?? null,
+        stdin: child.stdin,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        result,
+        kill
+      };
+    }
+  };
+}
+function bindAbortSignal(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
+}
+
+// packages/process-runner/src/docker/docker-execution-env.ts
+var containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
+var dockerExecutionEnvFactory = {
+  type: "docker",
+  supportsDetach: true,
+  async open(spec) {
+    const runtime = parseDockerRuntime(spec.runtime);
+    const runner = spec.hostRunner ?? createHostRunner();
+    const engine = runtime.engine ?? detectEngine();
+    const context = detectContext();
+    const image = await resolveImage({
+      spec,
+      runtime,
+      runner,
+      engine,
+      context
+    });
+    const containerName = createContainerName();
+    const runArgs = buildDockerRunArgs({
+      engine,
+      context,
+      image,
+      command: containerCommand[0],
+      args: containerCommand.slice(1),
+      cwd: void 0,
+      env: void 0,
+      mounts: runtime.mounts ?? [],
+      ports: [],
+      network: runtime.network,
+      containerName,
+      detached: true,
+      interactive: true,
+      tty: false,
+      rm: false,
+      extraArgs: runtime.extra_args ?? []
+    });
+    const [command, ...args] = runArgs;
+    const id = (await runAndRead(runner, { command, args, stdout: "pipe", stderr: "pipe" })).trim();
+    return createDockerEnv({
+      id,
+      spec,
+      runner,
+      engine,
+      context
+    });
+  },
+  async attach(envId) {
+    const engine = detectEngine();
+    return createDockerEnv({
+      id: envId,
+      spec: createAttachedSpec(),
+      runner: createHostRunner(),
+      engine,
+      context: detectContext()
+    });
+  }
+};
+function createDockerEnv(input) {
+  const containerRef = input.id;
+  return {
+    id: containerRef,
+    job: null,
+    async uploadWorkspace() {
+      const tempDir = mkdtempSync(path26.join(tmpdir(), "poe-docker-upload-"));
+      const archivePath = path26.join(tempDir, "workspace.tar");
+      try {
+        const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
+          "--exclude",
+          ignored
+        ]);
+        const tarArgs = [...excludeArgs, "-cf", archivePath, "-C", input.spec.cwd, "."];
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: tarArgs,
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            archivePath,
+            `${containerRef}:/tmp/poe-workspace-upload.tar`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `mkdir -p ${shellQuote2(input.spec.cwd)} && tar -xf /tmp/poe-workspace-upload.tar -C ${shellQuote2(input.spec.cwd)}`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, skipped: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    async downloadWorkspace(opts) {
+      const tempDir = mkdtempSync(path26.join(tmpdir(), "poe-docker-download-"));
+      const archivePath = path26.join(tempDir, "workspace.tar");
+      try {
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "exec",
+            containerRef,
+            "sh",
+            "-c",
+            `tar -cf /tmp/poe-workspace-download.tar -C ${shellQuote2(input.spec.cwd)} .`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await runOrThrow(input.runner, {
+          command: input.engine,
+          args: [
+            ...buildContextArgs(input.engine, input.context),
+            "cp",
+            `${containerRef}:/tmp/poe-workspace-download.tar`,
+            archivePath
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const extractMode = opts.conflictPolicy === "refuse" ? "-xkf" : "-xf";
+        await runOrThrow(input.runner, {
+          command: "tar",
+          args: [extractMode, archivePath, "-C", input.spec.cwd],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { files: 0, bytes: 0, conflicts: [] };
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    },
+    exec(spec) {
+      return input.runner.exec({
+        command: input.engine,
+        args: [
+          ...buildContextArgs(input.engine, input.context),
+          "exec",
+          ...spec.stdin === "pipe" || spec.stdin === "inherit" ? ["-i"] : [],
+          ...spec.tty === true ? ["-t"] : [],
+          ...spec.cwd !== void 0 ? ["-w", spec.cwd] : [],
+          ...buildEnvArgs(spec.env),
+          containerRef,
+          spec.command,
+          ...spec.args ?? []
+        ],
+        stdin: spec.stdin,
+        stdout: spec.stdout,
+        stderr: spec.stderr,
+        tty: spec.tty
+      });
+    },
+    async detach() {
+      return createContainerJob(containerRef, input.runner, input.engine, input.context);
+    },
+    shell() {
+      const shellSpec = input.spec.shellSpec;
+      return this.exec({
+        command: shellSpec?.command ?? input.spec.env.SHELL ?? "sh",
+        ...shellSpec?.args ? { args: shellSpec.args } : {},
+        cwd: input.spec.cwd,
+        env: shellSpec && "env" in shellSpec ? shellSpec.env : input.spec.env,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        tty: true
+      });
+    },
+    async close() {
+      await runOrThrow(input.runner, {
+        command: input.engine,
+        args: [...buildContextArgs(input.engine, input.context), "rm", "-f", containerRef],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    }
+  };
+}
+async function resolveImage(input) {
+  if (input.runtime.image !== void 0) {
+    return input.runtime.image;
+  }
+  const dockerfilePath = path26.resolve(
+    input.spec.cwd,
+    input.runtime.dockerfile ?? path26.join(".poe-code", "Dockerfile")
+  );
+  const buildContext = path26.resolve(input.spec.cwd, input.runtime.build_context ?? ".");
+  const dockerfileBytes = await readFile10(dockerfilePath);
+  const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
+  const cached2 = await input.spec.state?.templates.get("docker", hash);
+  if (cached2?.image !== void 0) {
+    return cached2.image;
+  }
+  const image = `poe-code/local:${hash}`;
+  await buildImage({
+    runner: input.runner,
+    engine: input.engine,
+    context: input.context,
+    image,
+    dockerfilePath,
+    buildContext,
+    buildArgs: input.runtime.build_args ?? {}
+  });
+  await input.spec.state?.templates.put("docker", {
+    hash,
+    image,
+    runtime_type: "docker",
+    dockerfile_path: dockerfilePath,
+    built_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return image;
+}
+function hashDockerTemplate(dockerfileBytes, buildArgs) {
+  const hash = createHash4("sha256");
+  hash.update(dockerfileBytes);
+  hash.update("\0");
+  for (const [key, value] of sortedBuildArgs(buildArgs)) {
+    hash.update(key);
+    hash.update("=");
+    hash.update(value);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function buildImage(input) {
+  await runOrThrow(input.runner, {
+    command: input.engine,
+    args: [
+      ...buildContextArgs(input.engine, input.context),
+      "build",
+      "--tag",
+      input.image,
+      "-f",
+      input.dockerfilePath,
+      ...sortedBuildArgs(input.buildArgs).flatMap(([key, value]) => [
+        "--build-arg",
+        `${key}=${value}`
+      ]),
+      input.buildContext
+    ],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+}
+function parseDockerRuntime(runtime) {
+  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+    throw new Error("docker runtime must be an object");
+  }
+  const record = runtime;
+  if (record.type !== "docker") {
+    throw new Error('docker runtime type must be "docker"');
+  }
+  return record;
+}
+async function runAndRead(runner, spec) {
+  const handle = runner.exec(spec);
+  const stdout = readStream(handle.stdout);
+  const stderr = readStream(handle.stderr);
+  const result = await handle.result;
+  const output = await stdout;
+  if (result.exitCode !== 0) {
+    const errorOutput = await stderr;
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${spec.command} ${(spec.args ?? []).join(" ")}${errorOutput ? `
+${errorOutput}` : ""}`
+    );
+  }
+  return output;
+}
+async function runOrThrow(runner, spec) {
+  await runAndRead(runner, spec);
+}
+async function readStream(stream) {
+  if (stream === null) {
+    return "";
+  }
+  stream.setEncoding("utf8");
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
+}
+function sortedBuildArgs(buildArgs) {
+  return Object.entries(buildArgs).sort(([left], [right]) => left.localeCompare(right));
+}
+function buildEnvArgs(env) {
+  if (env === void 0) {
+    return [];
+  }
+  return Object.entries(env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
+}
+function createContainerName() {
+  return `poe-env-${randomBytes3(6).toString("hex")}`;
+}
+async function createContainerJob(containerId, runner, engine, context) {
+  return {
+    id: containerId,
+    envId: containerId,
+    tool: "docker",
+    argv: ["attach", containerId],
+    async status() {
+      const handle = runner.exec({
+        command: engine,
+        args: [
+          ...buildContextArgs(engine, context),
+          "inspect",
+          "-f",
+          "{{.State.Status}}",
+          containerId
+        ],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      if (result.exitCode !== 0) {
+        return "lost";
+      }
+      return stdout.trim() === "running" ? "running" : "exited";
+    },
+    async *stream() {
+    },
+    async wait() {
+      const handle = runner.exec({
+        command: engine,
+        args: [...buildContextArgs(engine, context), "wait", containerId],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout = await readStream(handle.stdout);
+      const result = await handle.result;
+      return { exitCode: Number.parseInt(stdout.trim(), 10) || result.exitCode };
+    },
+    async kill(signal) {
+      const args = signal === void 0 || signal === "SIGTERM" ? ["stop", containerId] : ["kill", ...signal === "SIGKILL" ? [] : [`--signal=${signal}`], containerId];
+      await runOrThrow(runner, {
+        command: engine,
+        args: [...buildContextArgs(engine, context), ...args],
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    }
+  };
+}
+function createAttachedSpec() {
+  return {
+    cwd: "/workspace",
+    runtime: {
+      type: "docker",
+      image: "attached",
+      build_args: {},
+      mounts: []
+    },
+    env: {},
+    uploadIgnoreFiles: [],
+    jobLabel: {
+      tool: "docker",
+      argv: []
+    }
+  };
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// packages/process-runner/src/host/host-execution-env.ts
+var hostExecutionEnvFactory = {
+  type: "host",
+  supportsDetach: false,
+  async open(openSpec) {
+    return {
+      id: "host",
+      job: null,
+      async uploadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          skipped: []
+        };
+      },
+      async downloadWorkspace() {
+        return {
+          files: 0,
+          bytes: 0,
+          conflicts: []
+        };
+      },
+      exec(spec) {
+        return createHostRunner().exec(spec);
+      },
+      async detach() {
+        throw new Error("host runtime does not support detach because host has no addressable env");
+      },
+      shell() {
+        const shellSpec = openSpec.shellSpec;
+        return createHostRunner().exec({
+          command: shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+          ...shellSpec?.args ? { args: shellSpec.args } : {},
+          cwd: openSpec.cwd,
+          env: shellSpec && "env" in shellSpec ? shellSpec.env : openSpec.env,
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+          tty: true
+        });
+      },
+      async close() {
+      }
+    };
+  },
+  async attach() {
+    throw new Error("host runtime does not support reattach");
+  }
+};
+
+// packages/process-runner/src/testing/mock-runner.ts
+import { Readable, Writable } from "node:stream";
+
+// packages/agent-spawn/src/register-factories.ts
+registerExecutionEnvFactory(hostExecutionEnvFactory);
+registerExecutionEnvFactory(dockerExecutionEnvFactory);
+if (process.env.VITEST === "true") {
+  registerExecutionEnvFactory(createTestHostExecutionEnvFactory());
 }
-async function runMemoryCacheClear(input) {
-  if (!input.yes) {
-    throw new Error("Refusing to clear cache without --yes.");
-  }
-  const olderThanMs = parseOlderThan(input.olderThan);
-  const result = await clearCache(input.root, olderThanMs === void 0 ? {} : { olderThanMs });
-  console.log(`removed ${result.removed} cache ${result.removed === 1 ? "entry" : "entries"}`);
-  return result;
+function createTestHostExecutionEnvFactory() {
+  return {
+    type: "host",
+    supportsDetach: false,
+    open: ((openSpec) => {
+      return {
+        id: "host",
+        job: null,
+        async uploadWorkspace() {
+          return { files: 0, bytes: 0, skipped: [] };
+        },
+        async downloadWorkspace() {
+          return { files: 0, bytes: 0, conflicts: [] };
+        },
+        exec(spec) {
+          return runHost(spawnChildProcess2, spec);
+        },
+        async detach() {
+          throw new Error(
+            "host runtime does not support detach because host has no addressable env"
+          );
+        },
+        shell() {
+          return runHost(spawnChildProcess2, {
+            command: openSpec.shellSpec?.command ?? openSpec.env.SHELL ?? process.env.SHELL ?? "sh",
+            args: openSpec.shellSpec?.args,
+            cwd: openSpec.cwd,
+            env: openSpec.shellSpec && "env" in openSpec.shellSpec ? openSpec.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");
+    }
+  };
 }
-function parseOlderThan(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const duration = parseDuration(value);
-  if (duration === null || Number.isNaN(duration) || duration < 0) {
-    throw new Error(`Invalid duration for --older-than: "${value}".`);
+function runHost(spawnProcess, spec) {
+  const stdin = spec.stdin ?? "ignore";
+  const stdout = spec.stdout ?? "pipe";
+  const stderr = spec.stderr ?? "pipe";
+  const stdio = stdin === "inherit" && stdout === "inherit" && stderr === "inherit" ? "inherit" : [stdin, stdout, stderr];
+  const child = spawnProcess(spec.command, spec.args ?? [], {
+    cwd: spec.cwd,
+    env: spec.env,
+    stdio
+  });
+  const result = new Promise((resolve2) => {
+    child.once("close", (code) => {
+      resolve2({ exitCode: code ?? 1 });
+    });
+    child.once("error", () => {
+      resolve2({ exitCode: 1 });
+    });
+  });
+  const kill = (signal) => {
+    child.kill(signal);
+  };
+  if (spec.signal?.aborted) {
+    kill("SIGTERM");
+  } else {
+    spec.signal?.addEventListener("abort", () => kill("SIGTERM"), { once: true });
   }
-  return duration;
+  return {
+    pid: child.pid ?? null,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    result,
+    kill
+  };
 }
 
-// packages/memory/src/ingest.ts
-import * as fs11 from "node:fs/promises";
-import path26 from "node:path";
-
 // packages/agent-spawn/src/run-command.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // packages/agent-spawn/src/types.ts
 function resolveModeConfig(modeConfig) {
@@ -3244,145 +5351,6 @@ function resolveModeConfig(modeConfig) {
   };
 }
 
-// packages/agent-defs/src/agents/claude-code.ts
-var claudeCodeAgent = {
-  id: "claude-code",
-  name: "claude-code",
-  label: "Claude Code",
-  summary: "Configure Claude Code to route through Poe.",
-  aliases: ["claude"],
-  binaryName: "claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#C15F3C",
-      light: "#C15F3C"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/claude-desktop.ts
-var claudeDesktopAgent = {
-  id: "claude-desktop",
-  name: "claude-desktop",
-  label: "Claude Desktop",
-  summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#D97757",
-      light: "#D97757"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/codex.ts
-var codexAgent = {
-  id: "codex",
-  name: "codex",
-  label: "Codex",
-  summary: "Configure Codex to use Poe as the model provider.",
-  binaryName: "codex",
-  configPath: "~/.codex/config.toml",
-  branding: {
-    colors: {
-      dark: "#D5D9DF",
-      light: "#7A7F86"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/opencode.ts
-var openCodeAgent = {
-  id: "opencode",
-  name: "opencode",
-  label: "OpenCode CLI",
-  summary: "Configure OpenCode CLI to use the Poe API.",
-  binaryName: "opencode",
-  configPath: "~/.config/opencode/config.json",
-  branding: {
-    colors: {
-      dark: "#4A4F55",
-      light: "#2F3338"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/kimi.ts
-var kimiAgent = {
-  id: "kimi",
-  name: "kimi",
-  label: "Kimi",
-  summary: "Configure Kimi CLI to use Poe API",
-  aliases: ["kimi-cli"],
-  binaryName: "kimi",
-  configPath: "~/.kimi/config.toml",
-  branding: {
-    colors: {
-      dark: "#7B68EE",
-      light: "#6A5ACD"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/goose.ts
-var gooseAgent = {
-  id: "goose",
-  name: "goose",
-  label: "Goose",
-  summary: "Block's open-source AI agent with ACP support.",
-  binaryName: "goose",
-  configPath: "~/.config/goose/config.yaml",
-  branding: {
-    colors: {
-      dark: "#FF6B35",
-      light: "#E85D26"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/poe-agent.ts
-var poeAgentAgent = {
-  id: "poe-agent",
-  name: "poe-agent",
-  label: "Poe Agent",
-  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
-  configPath: "~/.poe-code/config.json",
-  branding: {
-    colors: {
-      dark: "#A465F7",
-      light: "#7A3FD3"
-    }
-  }
-};
-
-// packages/agent-defs/src/registry.ts
-var allAgents = [
-  claudeCodeAgent,
-  claudeDesktopAgent,
-  codexAgent,
-  openCodeAgent,
-  kimiAgent,
-  gooseAgent,
-  poeAgentAgent
-];
-var lookup = /* @__PURE__ */ new Map();
-for (const agent of allAgents) {
-  const values = [agent.id, agent.name, ...agent.aliases ?? []];
-  for (const value of values) {
-    const normalized = value.toLowerCase();
-    if (!lookup.has(normalized)) {
-      lookup.set(normalized, agent.id);
-    }
-  }
-}
-function resolveAgentId(input) {
-  if (!input) {
-    return void 0;
-  }
-  return lookup.get(input.toLowerCase());
-}
-
 // packages/agent-spawn/src/configs/mcp.ts
 function toJsonMcpServers(servers) {
   const out = {};
@@ -3650,9 +5618,8 @@ function listMcpSupportedAgents() {
 }
 
 // packages/agent-spawn/src/spawn.ts
-import { spawn as spawnChildProcess } from "node:child_process";
 import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path22 from "node:path";
+import path27 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -3702,18 +5669,11 @@ function stripModelNamespace(model) {
 }
 
 // packages/agent-spawn/src/spawn.ts
-function createAbortError() {
+function createAbortError3() {
   const error2 = new Error("Agent spawn aborted");
   error2.name = "AbortError";
   return error2;
 }
-function createActivityTimeoutError(timeoutMs) {
-  const error2 = new Error(
-    `Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`
-  );
-  error2.name = "ActivityTimeoutError";
-  return error2;
-}
 function resolveCliConfig(agentId) {
   const resolved = resolveConfig(agentId);
   if (!resolved.spawnConfig) {
@@ -3781,9 +5741,9 @@ function buildCliArgs(config, options, stdinMode) {
   }
   return { args, env: mode.env };
 }
-async function spawn2(agentId, options, context) {
+async function spawn3(agentId, options, context) {
   if (options.signal?.aborted) {
-    throw createAbortError();
+    throw createAbortError3();
   }
   const { agentId: resolvedId, binaryName, spawnConfig } = resolveCliConfig(agentId);
   const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
@@ -3795,89 +5755,68 @@ async function spawn2(agentId, options, context) {
   }
   const logFilePath = resolveSpawnLogPath(options);
   const logFd = logFilePath ? openSpawnLog(logFilePath) : void 0;
-  const child = spawnChildProcess(binaryName, spawnArgs, {
-    cwd: options.cwd,
-    stdio: [stdinMode ? "pipe" : "inherit", "pipe", "pipe"],
-    ...modeEnv ? { env: { ...process.env, ...modeEnv } } : {}
-  });
-  if (!child.stdout || !child.stderr) {
-    throw new Error(`Failed to spawn "${resolvedId}": missing stdio pipes.`);
-  }
-  const stdoutStream = child.stdout;
-  const stderrStream = child.stderr;
-  if (stdinMode) {
-    if (!child.stdin) {
-      throw new Error(`Failed to spawn "${resolvedId}": missing stdin pipe.`);
-    }
-    child.stdin.setDefaultEncoding("utf8");
-    child.stdin.write(options.prompt);
-    child.stdin.end();
-  }
-  return new Promise((resolve2, reject) => {
-    let stdout = "";
-    let stderr = "";
-    let aborted = false;
-    let timedOut = false;
-    const onAbort = () => {
-      aborted = true;
-      child.kill("SIGTERM");
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    let activityTimer;
-    const resetActivityTimer = options.activityTimeoutMs ? () => {
-      if (activityTimer) clearTimeout(activityTimer);
-      activityTimer = setTimeout(() => {
-        timedOut = true;
-        child.kill("SIGTERM");
-      }, options.activityTimeoutMs);
-    } : void 0;
-    resetActivityTimer?.();
-    const cleanup = () => {
-      options.signal?.removeEventListener("abort", onAbort);
-      if (activityTimer) clearTimeout(activityTimer);
-    };
-    stdoutStream.setEncoding("utf8");
-    stdoutStream.on("data", (chunk) => {
-      stdout += chunk;
-      resetActivityTimer?.();
-      if (options.tee?.stdout) options.tee.stdout.write(chunk);
-      appendSpawnLog(logFd, chunk);
-    });
-    stderrStream.setEncoding("utf8");
-    stderrStream.on("data", (chunk) => {
-      stderr += chunk;
-      resetActivityTimer?.();
-      if (options.tee?.stderr) options.tee.stderr.write(chunk);
-      appendSpawnLog(logFd, chunk);
-    });
-    child.on("error", (error2) => {
-      cleanup();
-      closeSpawnLog(logFd);
-      if (aborted) {
-        reject(createAbortError());
-        return;
+  const processEnv = modeEnv ? { ...process.env, ...modeEnv } : void 0;
+  const argv = [binaryName, ...spawnArgs];
+  const execution = resolvePoeCommandExecution({
+    cwd: options.cwd ?? process.cwd(),
+    env: processEnv ?? process.env,
+    argv,
+    tool: resolvedId,
+    runtime: {
+      runtime: options.runtime,
+      runtimeImage: options.runtimeImage,
+      runtimeTemplate: options.runtimeTemplate,
+      detach: options.detach,
+      mountPoeCode: options.mountPoeCode
+    },
+    context,
+    openSpec: {
+      execution: {
+        wrapForLogTee: false,
+        stdin: stdinMode ? "pipe" : "inherit",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: processEnv,
+        input: stdinMode ? options.prompt : void 0,
+        captureOutput: true,
+        activityTimeoutMs: options.activityTimeoutMs,
+        onStdout(chunk) {
+          options.tee?.stdout?.write(chunk);
+          appendSpawnLog(logFd, chunk);
+        },
+        onStderr(chunk) {
+          options.tee?.stderr?.write(chunk);
+          appendSpawnLog(logFd, chunk);
+        }
       }
-      reject(error2);
+    }
+  });
+  try {
+    const result = await runPoeCommand({
+      factory: execution.factory,
+      openSpec: execution.openSpec,
+      detach: execution.detach,
+      state: execution.state,
+      signal: options.signal
     });
-    child.on("close", (code) => {
-      cleanup();
-      closeSpawnLog(logFd);
-      if (aborted) {
-        reject(createAbortError());
-        return;
-      }
-      if (timedOut) {
-        reject(createActivityTimeoutError(options.activityTimeoutMs));
-        return;
-      }
-      resolve2({
-        stdout,
-        stderr,
-        exitCode: code ?? 1,
+    if (result.kind === "detached") {
+      return {
+        stdout: "",
+        stderr: "",
+        exitCode: 0,
         ...logFilePath ? { logFile: logFilePath } : {}
-      });
-    });
-  });
+      };
+    }
+    const captured = result;
+    return {
+      stdout: captured.stdout ?? "",
+      stderr: captured.stderr ?? "",
+      exitCode: result.exitCode,
+      ...logFilePath ? { logFile: logFilePath } : {}
+    };
+  } finally {
+    closeSpawnLog(logFd);
+  }
 }
 function resolveSpawnLogPath(options) {
   if (options.logPath) {
@@ -3886,11 +5825,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path22.join(options.logDir, options.logFileName);
+  return path27.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path22.dirname(filePath), { recursive: true });
+    mkdirSync(path27.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -3911,9 +5850,6 @@ function closeSpawnLog(fd) {
   }
 }
 
-// packages/agent-spawn/src/spawn-interactive.ts
-import { spawn as spawnChildProcess2 } from "node:child_process";
-
 // packages/design-system/src/tokens/colors.ts
 import chalk from "chalk";
 var dark = {
@@ -4321,7 +6257,7 @@ import chalk16 from "chalk";
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path23 from "node:path";
+import path28 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { open as open2, readdir as readdir4 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -4339,17 +6275,14 @@ import * as fsPromises3 from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-// packages/agent-spawn/src/acp/spawn.ts
-import { spawn as spawnChildProcess4 } from "node:child_process";
-
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path24 from "node:path";
+import path29 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { mkdir as mkdir5, open as open3 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
 import * as fs10 from "node:fs/promises";
-import path25 from "node:path";
+import path30 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -4390,7 +6323,7 @@ function countTokens(text4) {
 }
 
 // packages/tokenfill/dist/corpus.js
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var CORPUS_ARTICLE_SEPARATOR = "\n\n";
@@ -4403,7 +6336,7 @@ function loadBuiltInCorpusArticles() {
   if (corpusFileNames.length === 0) {
     throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
   }
-  return corpusFileNames.map((fileName) => readFileSync(join2(corpusDirectoryPath, fileName), "utf8").trim());
+  return corpusFileNames.map((fileName) => readFileSync2(join2(corpusDirectoryPath, fileName), "utf8").trim());
 }
 var BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
 
@@ -4433,11 +6366,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path25.resolve(root, "..", "..");
+  const repoRoot = path30.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path25.isAbsolute(sourcePath) ? sourcePath : path25.resolve(repoRoot, sourcePath);
+    const absPath = path30.isAbsolute(sourcePath) ? sourcePath : path30.resolve(repoRoot, sourcePath);
     try {
       const content = await fs10.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -4488,10 +6421,10 @@ function resolveRunners(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs11.readFile(path26.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs11.readFile(path31.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs11,
-    filePath: path26.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path31.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -4529,7 +6462,7 @@ async function ingest(root, opts, runners) {
   let timeoutError;
   try {
     const result = await runWithTimeout(
-      spawn2(agentId, { prompt }),
+      spawn3(agentId, { prompt }),
       opts.timeoutMs ?? await configuredTimeout(configOptions)
     );
     exitCode = result.exitCode;
@@ -4581,7 +6514,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path26.resolve(root, "..", "..");
+  return path31.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -5339,8 +7272,8 @@ function printMcpConfig() {
 }
 
 // packages/agent-skill-config/src/configs.ts
-import os3 from "node:os";
-import path27 from "node:path";
+import os4 from "node:os";
+import path32 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -5359,7 +7292,7 @@ var agentSkillConfigs = {
     localSkillDir: ".agents/skills"
   }
 };
-var supportedAgents = Object.keys(agentSkillConfigs);
+var supportedAgents2 = Object.keys(agentSkillConfigs);
 function resolveAgentSupport(input, registry = agentSkillConfigs) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
@@ -5373,8 +7306,8 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 }
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile12, stat as stat6 } from "node:fs/promises";
-import path28 from "node:path";
+import { readFile as readFile13, stat as stat6 } from "node:fs/promises";
+import path33 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -5480,7 +7413,7 @@ var agentMcpConfigs = {
     shape: "goose"
   }
 };
-var supportedAgents2 = Object.keys(agentMcpConfigs);
+var supportedAgents3 = Object.keys(agentMcpConfigs);
 function resolveAgentSupport2(input, registry = agentMcpConfigs) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
@@ -5507,7 +7440,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path29 from "node:path";
+import path34 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -5599,7 +7532,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path29.dirname(configPath);
+  return path34.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -5625,9 +7558,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path29.join(homeDir, configPath.slice(2));
+    return path34.join(homeDir, configPath.slice(2));
   }
-  return path29.join(homeDir, configPath.slice(1));
+  return path34.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -5660,7 +7593,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path29.dirname(absolutePath);
+  const configDir = path34.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -5838,7 +7771,7 @@ async function installMemory(options) {
 
 // packages/memory/src/query.ts
 import * as fs12 from "node:fs/promises";
-import path30 from "node:path";
+import path35 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -5852,11 +7785,11 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs12,
-    filePath: path30.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path35.join(inferRepoRoot2(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const context = await selectQueryContext(root, options.question, options.budget);
-  const result = await spawn2(agentId, { prompt: context.prompt });
+  const result = await spawn3(agentId, { prompt: context.prompt });
   return {
     answer: result.answer,
     citations: result.citations,
@@ -5867,7 +7800,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path30.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs12.readFile(path35.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -5946,12 +7879,12 @@ function tokenize(text4) {
   return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path30.resolve(root, "..", "..");
+  return path35.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
 import * as fs13 from "node:fs/promises";
-import path31 from "node:path";
+import path36 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -5974,10 +7907,10 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs13,
-    filePath: path31.join(inferRepoRoot3(root), "poe-code.json")
+    filePath: path36.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
-  const response = await spawn2(agentId, { prompt });
+  const response = await spawn3(agentId, { prompt });
   return {
     answer: response.answer,
     citations: response.citations,
@@ -6023,7 +7956,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path31.resolve(root, "..", "..");
+  return path36.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -6036,9 +7969,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path32 from "node:path";
+import path37 from "node:path";
 function openMemory(opts) {
-  if (!path32.isAbsolute(opts.root)) {
+  if (!path37.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;