poe-code 3.0.200 → 3.0.202

package/packages/memory/dist/index.js

@@ -35,7 +35,256 @@ function assertSafeRelPath(input) {
 }
 
 // packages/memory/src/resolve-root.ts
-import path8 from "node:path";
+import path11 from "node:path";
+
+// packages/poe-code-config/src/runtime.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+var defaultWorkspaceExclude = [
+  ".git",
+  "node_modules",
+  "dist",
+  ".turbo",
+  ".next",
+  ".poe-code/state.json"
+];
+var runtimeConfigScope = {
+  scope: "runtime",
+  schema: {
+    type: {
+      type: "string",
+      default: "host",
+      doc: "Runtime backend: host, docker, or e2b"
+    },
+    build_args: {
+      type: "json",
+      default: {},
+      parse: parseBuildArgs,
+      doc: "Build arguments passed to the runtime image build"
+    },
+    mounts: {
+      type: "json",
+      default: [],
+      parse: parseMounts,
+      doc: "Additional runtime mounts"
+    },
+    runner: {
+      type: "json",
+      default: createDefaultRunnerScope(),
+      parse: parseRunner,
+      doc: "Runner process and workspace transfer settings"
+    },
+    link: {
+      type: "string",
+      default: "",
+      doc: "Informational link for the runtime definition"
+    },
+    image: {
+      type: "string",
+      default: "",
+      doc: "Prebuilt Docker image"
+    },
+    dockerfile: {
+      type: "string",
+      default: "",
+      doc: "Path to the Dockerfile used for docker or e2b builds"
+    },
+    build_context: {
+      type: "string",
+      default: "",
+      doc: "Path to the Docker build context"
+    },
+    engine: {
+      type: "string",
+      default: "",
+      doc: "Container engine for Docker runtime"
+    },
+    network: {
+      type: "string",
+      default: "",
+      doc: "Docker network"
+    },
+    extra_args: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalStringArray,
+      doc: "Extra Docker runtime arguments"
+    },
+    template_id: {
+      type: "string",
+      default: "",
+      doc: "Prebuilt E2B template id"
+    },
+    cpu: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B CPU count"
+    },
+    memory_mb: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B memory in megabytes"
+    },
+    timeout_minutes: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "E2B timeout in minutes"
+    },
+    preserve_after_exit_hours: {
+      type: "json",
+      default: void 0,
+      parse: parseOptionalNumber,
+      doc: "Hours to keep an E2B sandbox alive after job exit"
+    },
+    api_key_env: {
+      type: "string",
+      default: "",
+      doc: "Environment variable name containing the E2B API key"
+    }
+  }
+};
+function parseRunner(raw) {
+  if (raw === void 0) {
+    return createDefaultRunnerScope();
+  }
+  const record = asRecord(raw);
+  if (record === void 0) {
+    throw new Error("runner: expected an object.");
+  }
+  const uploadMaxFileMb = parseOptionalNumber(record.upload_max_file_mb, "runner.upload_max_file_mb") ?? 100;
+  if (uploadMaxFileMb <= 0) {
+    throw new Error("runner.upload_max_file_mb: expected a positive finite number.");
+  }
+  return omitUndefined({
+    detach: parseOptionalBoolean(record.detach, "runner.detach") ?? false,
+    upload_max_file_mb: uploadMaxFileMb,
+    download_conflict: parseDownloadConflict(record.download_conflict),
+    workspace: parseRunnerWorkspace(record.workspace)
+  });
+}
+function createDefaultRunnerScope() {
+  return {
+    detach: false,
+    upload_max_file_mb: 100,
+    download_conflict: "refuse",
+    workspace: {
+      exclude: [...defaultWorkspaceExclude]
+    }
+  };
+}
+function parseRunnerWorkspace(value) {
+  if (value === void 0) {
+    return {
+      exclude: [...defaultWorkspaceExclude]
+    };
+  }
+  const record = asRecord(value);
+  if (record === void 0) {
+    throw new Error("runner.workspace: expected an object.");
+  }
+  return {
+    exclude: parseOptionalStringArray(record.exclude, "runner.workspace.exclude") ?? [
+      ...defaultWorkspaceExclude
+    ]
+  };
+}
+function parseDownloadConflict(value) {
+  if (value === void 0) {
+    return "refuse";
+  }
+  if (value === "refuse" || value === "overwrite") {
+    return value;
+  }
+  throw new Error('runner.download_conflict: expected "refuse" or "overwrite".');
+}
+function parseBuildArgs(value) {
+  if (value === void 0) {
+    return {};
+  }
+  const record = asRecord(value);
+  if (record === void 0) {
+    throw new Error("build_args: expected an object.");
+  }
+  const parsed = {};
+  for (const [key, entry] of Object.entries(record)) {
+    if (typeof entry !== "string") {
+      throw new Error(`build_args.${key}: expected a string.`);
+    }
+    parsed[key] = entry;
+  }
+  return parsed;
+}
+function parseMounts(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("mounts: expected an array.");
+  }
+  return value.map((entry, index) => {
+    const record = asRecord(entry);
+    if (record === void 0) {
+      throw new Error(`mounts[${index}]: expected an object.`);
+    }
+    const source = record.source;
+    const target = record.target;
+    if (typeof source !== "string") {
+      throw new Error(`mounts[${index}].source: expected a string.`);
+    }
+    if (typeof target !== "string") {
+      throw new Error(`mounts[${index}].target: expected a string.`);
+    }
+    return omitUndefined({
+      source,
+      target,
+      readonly: parseOptionalBoolean(record.readonly, `mounts[${index}].readonly`)
+    });
+  });
+}
+function parseOptionalStringArray(value, key = "") {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`${key ? `${key}: ` : ""}expected an array.`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw new Error(`${key}[${index}]: expected a string.`);
+    }
+    return entry;
+  });
+}
+function parseOptionalNumber(value, key = "") {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${key ? `${key}: ` : ""}expected a finite number.`);
+  }
+  return value;
+}
+function parseOptionalBoolean(value, key) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`${key}: expected a boolean.`);
+  }
+  return value;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function omitUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
 
 // packages/poe-code-config/src/schema.ts
 function defineScope(scope, schema) {
@@ -56,15 +305,15 @@ var planConfigScope = defineScope("plan", {
 });
 
 // packages/poe-code-config/src/store.ts
-import path6 from "node:path";
+import path7 from "node:path";
 
 // packages/config-extends/src/discover.ts
-import path2 from "node:path";
+import path3 from "node:path";
 async function findBase(name, bases, fs14) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
-      const filePath = path2.join(basePath, `${name}${extension}`);
+      const filePath = path3.join(basePath, `${name}${extension}`);
       checkedPaths.push(filePath);
       try {
         return {
@@ -88,7 +337,7 @@ function hasCode(error2, code) {
 }
 
 // packages/config-extends/src/parse.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import matter from "gray-matter";
 import { parse as parseYaml } from "yaml";
 function parseDocument(content, filePath) {
@@ -106,7 +355,7 @@ function parseDocument(content, filePath) {
   };
 }
 function detectFormat(content, filePath) {
-  const extension = path3.extname(filePath).toLowerCase();
+  const extension = path4.extname(filePath).toLowerCase();
   if (extension === ".md") {
     return "markdown";
   }
@@ -148,11 +397,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path30) {
+function mergeObjectLayers(layers, path33) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path30);
+    const resolved = resolveKey(layers, key, path33);
     if (resolved === void 0) {
       continue;
     }
@@ -170,7 +419,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path30) {
+function resolveKey(layers, key, path33) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -200,9 +449,9 @@ function resolveKey(layers, key, path30) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path30, key);
+  const fullPath = buildPath(path33, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path30, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path33, key]);
     return {
       value: merged.data,
       sources: {
@@ -227,8 +476,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path30, key) {
-  return [...path30, key].join(".");
+function buildPath(path33, key) {
+  return [...path33, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -252,7 +501,7 @@ function cloneValue(value) {
 }
 
 // packages/config-extends/src/resolve.ts
-import path4 from "node:path";
+import path5 from "node:path";
 var MAX_EXTENDS_DEPTH = 5;
 var YIELD_TOKEN = "{{yield}}";
 async function resolve(chain, options) {
@@ -350,7 +599,7 @@ Visited files:
     );
   }
   const matchedBaseIndex = baseLayers.findIndex(
-    (layer) => layer.path === path4.dirname(discoveredBase.filePath)
+    (layer) => layer.path === path5.dirname(discoveredBase.filePath)
   );
   if (matchedBaseIndex === -1) {
     throw new Error(`Resolved base is outside configured base paths: ${discoveredBase.filePath}`);
@@ -464,7 +713,7 @@ function stripResolvedBasePrompts(layers, consumedBaseIndexes) {
   });
 }
 function getBaseName(filePath) {
-  return path4.basename(filePath, path4.extname(filePath));
+  return path5.basename(filePath, path5.extname(filePath));
 }
 function shouldResolveBase(parsedDocument, autoExtend) {
   return parsedDocument.extends || autoExtend === true && !parsedDocument.hasExtendsField;
@@ -862,20 +1111,20 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path30) {
-  const ext = getExtension(path30);
+function detectFormat2(path33) {
+  const ext = getExtension(path33);
   return extensionMap[ext];
 }
-function getExtension(path30) {
-  const lastDot = path30.lastIndexOf(".");
+function getExtension(path33) {
+  const lastDot = path33.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path30.slice(lastDot).toLowerCase();
+  return path33.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
-import path5 from "node:path";
+import path6 from "node:path";
 function expandHome(targetPath, homeDir) {
   if (!targetPath?.startsWith("~")) {
     return targetPath;
@@ -892,7 +1141,7 @@ function expandHome(targetPath, homeDir) {
       remainder = remainder.slice(1);
     }
   }
-  return remainder.length === 0 ? homeDir : path5.join(homeDir, remainder);
+  return remainder.length === 0 ? homeDir : path6.join(homeDir, remainder);
 }
 function validateHomePath(targetPath) {
   if (typeof targetPath !== "string" || targetPath.length === 0) {
@@ -910,12 +1159,12 @@ function resolvePath(rawPath, homeDir, pathMapper) {
   if (!pathMapper) {
     return expanded;
   }
-  const rawDirectory = path5.dirname(expanded);
+  const rawDirectory = path6.dirname(expanded);
   const mappedDirectory = pathMapper.mapTargetDirectory({
     targetDirectory: rawDirectory
   });
-  const filename = path5.basename(expanded);
-  return filename.length === 0 ? mappedDirectory : path5.join(mappedDirectory, filename);
+  const filename = path6.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path6.join(mappedDirectory, filename);
 }
 
 // packages/config-mutations/src/fs-utils.ts
@@ -1173,8 +1422,8 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
-    const stat6 = await context.fs.stat(targetPath);
-    const currentMode = typeof stat6.mode === "number" ? stat6.mode & 511 : null;
+    const stat7 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat7.mode === "number" ? stat7.mode & 511 : null;
     if (currentMode === mutation.mode) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
@@ -1537,7 +1786,7 @@ async function readMergedDocument(fs14, globalPath, projectPath) {
       },
       {
         source: "base",
-        path: path6.dirname(globalPath)
+        path: path7.dirname(globalPath)
       }
     ],
     {
@@ -1614,15 +1863,15 @@ function createResolvedConfigFs(fs14, globalPath, globalContent) {
   };
 }
 async function recoverInvalidDocument(fs14, filePath, content) {
-  await fs14.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs14.mkdir(path7.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
   await fs14.writeFile(backupPath, content, { encoding: "utf8" });
   await fs14.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
-  const directory = path6.dirname(filePath);
-  const baseName = path6.basename(filePath);
-  return path6.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
+  const directory = path7.dirname(filePath);
+  const baseName = path7.basename(filePath);
+  return path7.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -1646,10 +1895,10 @@ async function cacheEnabled(options) {
 }
 async function resolveMemoryConfig(options) {
   const document = await readMergedDocument(options.fs, options.filePath, options.projectFilePath);
-  const memory = asRecord(document.memory);
-  const cache = asRecord(memory?.cache);
-  const mcp = asRecord(memory?.mcp);
-  const query = asRecord(memory?.query);
+  const memory = asRecord2(document.memory);
+  const cache = asRecord2(memory?.cache);
+  const mcp = asRecord2(memory?.mcp);
+  const query = asRecord2(memory?.query);
   return {
     root: readString(memory?.root),
     ingestAgent: readString(memory?.ingestAgent),
@@ -1659,7 +1908,7 @@ async function resolveMemoryConfig(options) {
     defaultQueryBudget: readNumber(query?.defaultBudgetTokens) ?? 4096
   };
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
@@ -1676,10 +1925,26 @@ function readBoolean(value) {
 }
 
 // packages/poe-code-config/src/inspect.ts
-import path7 from "node:path";
+import path8 from "node:path";
 var EMPTY_DOCUMENT2 = `${JSON.stringify({}, null, 2)}
 `;
 
+// packages/poe-code-config/src/state/index.ts
+import os2 from "node:os";
+
+// packages/poe-code-config/src/state/jobs.ts
+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) {
@@ -1698,16 +1963,16 @@ async function resolveConfiguredMemoryRoot(options) {
   return resolveMemoryRoot(options.cwd);
 }
 function resolveAgainstCwd(cwd, value) {
-  return path8.isAbsolute(value) ? value : path8.resolve(cwd, value);
+  return path11.isAbsolute(value) ? value : path11.resolve(cwd, value);
 }
 
 // packages/memory/src/init.ts
 import * as fs from "node:fs/promises";
-import path9 from "node:path";
+import path12 from "node:path";
 async function initMemory(root) {
-  await fs.mkdir(path9.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
-  await writeFileIfMissing(path9.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
-  await writeFileIfMissing(path9.join(root, MEMORY_LOG_RELPATH), "");
+  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 {
@@ -1724,7 +1989,7 @@ function hasErrorCode(error2, code) {
 
 // packages/memory/src/pages.ts
 import * as fs2 from "node:fs/promises";
-import path10 from "node:path";
+import path13 from "node:path";
 
 // packages/memory/src/frontmatter.ts
 import { parse as parse5, stringify } from "yaml";
@@ -1904,10 +2169,10 @@ function parseSources(value) {
     if (!isRecord2(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path30 = readRequiredString(item.path, "sources[].path");
+    const path33 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path30, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path33, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -1952,8 +2217,8 @@ async function listPages(root) {
 }
 async function readPage(root, relPath) {
   const normalizedRelPath = assertMarkdownRelPath(relPath);
-  const absPath = path10.join(root, normalizedRelPath);
-  const [content, stat6] = await Promise.all([fs2.readFile(absPath, "utf8"), fs2.stat(absPath)]);
+  const absPath = path13.join(root, normalizedRelPath);
+  const [content, stat7] = await Promise.all([fs2.readFile(absPath, "utf8"), fs2.stat(absPath)]);
   try {
     const parsed = parseFrontmatter(content);
     return {
@@ -1961,7 +2226,7 @@ async function readPage(root, relPath) {
       frontmatter: parsed.frontmatter,
       body: parsed.body,
       bytes: Buffer.byteLength(content),
-      mtimeMs: stat6.mtimeMs
+      mtimeMs: stat7.mtimeMs
     };
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
@@ -1971,7 +2236,7 @@ async function readPage(root, relPath) {
       frontmatter: {},
       body: content,
       bytes: Buffer.byteLength(content),
-      mtimeMs: stat6.mtimeMs
+      mtimeMs: stat7.mtimeMs
     };
   }
 }
@@ -1981,7 +2246,7 @@ async function collectMarkdownRelPaths(root, startRelPath = "") {
   return relPaths.sort((left, right) => left.localeCompare(right));
 }
 async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
-  const absPath = path10.join(root, currentRelPath);
+  const absPath = path13.join(root, currentRelPath);
   let entryNames;
   try {
     entryNames = await fs2.readdir(absPath);
@@ -1992,8 +2257,8 @@ async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
     throw error2;
   }
   for (const entryName of entryNames.sort((left, right) => left.localeCompare(right))) {
-    const entryRelPath = currentRelPath.length === 0 ? entryName : path10.posix.join(currentRelPath, entryName);
-    const entryAbsPath = path10.join(root, entryRelPath);
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path13.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path13.join(root, entryRelPath);
     const entryStat = await fs2.stat(entryAbsPath);
     if (entryStat.isDirectory()) {
       if (entryName === MEMORY_CACHE_DIR_RELPATH) {
@@ -2023,7 +2288,7 @@ function assertMarkdownRelPath(relPath) {
   return normalizedRelPath;
 }
 function isMarkdownPath(relPath) {
-  return path10.posix.extname(relPath).toLowerCase() === ".md";
+  return path13.posix.extname(relPath).toLowerCase() === ".md";
 }
 function isMissing(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
@@ -2031,7 +2296,7 @@ function isMissing(error2) {
 
 // packages/memory/src/search.ts
 import * as fs3 from "node:fs/promises";
-import path11 from "node:path";
+import path14 from "node:path";
 async function searchMemory(root, query) {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) {
@@ -2040,7 +2305,7 @@ async function searchMemory(root, query) {
   const relPaths = await collectMarkdownRelPaths(root);
   const hits = [];
   for (const relPath of relPaths) {
-    const content = await fs3.readFile(path11.join(root, relPath), "utf8");
+    const content = await fs3.readFile(path14.join(root, relPath), "utf8");
     if (content.length === 0) {
       continue;
     }
@@ -2061,7 +2326,7 @@ async function searchMemory(root, query) {
 
 // packages/memory/src/status.ts
 import * as fs4 from "node:fs/promises";
-import path12 from "node:path";
+import path15 from "node:path";
 async function statusOf(root) {
   if (!await pathExists2(root)) {
     return {
@@ -2078,9 +2343,9 @@ async function statusOf(root) {
   let totalBytes = 0;
   let lastWriteAtMs = Number.NEGATIVE_INFINITY;
   for (const relPath of markdownRelPaths) {
-    const stat6 = await fs4.stat(path12.join(root, relPath));
-    totalBytes += stat6.size;
-    lastWriteAtMs = Math.max(lastWriteAtMs, stat6.mtimeMs);
+    const stat7 = await fs4.stat(path15.join(root, relPath));
+    totalBytes += stat7.size;
+    lastWriteAtMs = Math.max(lastWriteAtMs, stat7.mtimeMs);
   }
   return {
     pageCount: pageRelPaths.length,
@@ -2103,20 +2368,20 @@ async function pathExists2(targetPath) {
 
 // packages/memory/src/edit.ts
 import * as fs7 from "node:fs/promises";
-import path16 from "node:path";
+import path19 from "node:path";
 
 // packages/memory/src/write.ts
 import * as fs6 from "node:fs/promises";
-import path15 from "node:path";
+import path18 from "node:path";
 
 // packages/memory/src/lock.ts
-import * as fsPromises from "node:fs/promises";
-import path13 from "node:path";
+import * as fsPromises2 from "node:fs/promises";
+import path16 from "node:path";
 function createDefaultFs() {
   return {
-    readFile: (filePath, encoding) => fsPromises.readFile(filePath, encoding),
-    unlink: fsPromises.unlink,
-    writeFile: (filePath, data, options) => fsPromises.writeFile(filePath, data, options)
+    readFile: (filePath, encoding) => fsPromises2.readFile(filePath, encoding),
+    unlink: fsPromises2.unlink,
+    writeFile: (filePath, data, options) => fsPromises2.writeFile(filePath, data, options)
   };
 }
 function sleep(ms) {
@@ -2170,7 +2435,7 @@ async function readLockPid(fs14, lockPath) {
 }
 async function withLock(root, run, options = {}) {
   const fs14 = options.fs ?? createDefaultFs();
-  const lockPath = path13.join(root, MEMORY_LOCK_RELPATH);
+  const lockPath = path16.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
   const minTimeoutMs = options.minTimeoutMs ?? 25;
@@ -2208,7 +2473,7 @@ async function withLock(root, run, options = {}) {
 // packages/memory/src/reconcile.ts
 import { createHash } from "node:crypto";
 import * as fs5 from "node:fs/promises";
-import path14 from "node:path";
+import path17 from "node:path";
 
 // packages/memory/src/confidence.ts
 var TAG_RE = /^<!--\s*memory:(?<verb>extracted|inferred|ambiguous)(?<rest>[^>]*?)-->\s*$/;
@@ -2420,7 +2685,7 @@ async function snapshot(root) {
     await Promise.all(
       (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => [
         relPath,
-        hashContent(await fs5.readFile(path14.join(root, relPath), "utf8"))
+        hashContent(await fs5.readFile(path17.join(root, relPath), "utf8"))
       ])
     )
   );
@@ -2431,7 +2696,7 @@ async function reconcile(root, before, _verb, detail) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const currentPages = await Promise.all(
     (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => {
-      const absPath = path14.join(root, relPath);
+      const absPath = path17.join(root, relPath);
       const markdown = await fs5.readFile(absPath, "utf8");
       const parsed = parsePageMarkdown(relPath, markdown);
       const normalizedFrontmatter = withDenormalizedSources(parsed.frontmatter, parsed.body);
@@ -2453,7 +2718,7 @@ async function reconcile(root, before, _verb, detail) {
     })
   );
   await Promise.all(
-    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs5.writeFile(path14.join(root, page.relPath), page.nextMarkdown, "utf8"))
+    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs5.writeFile(path17.join(root, page.relPath), page.nextMarkdown, "utf8"))
   );
   const diff2 = diffSnapshots(before, await snapshot(root));
   await writeIndex(root);
@@ -2483,7 +2748,7 @@ async function appendLogEntries(root, diff2, detail, timestamp = (/* @__PURE__ *
   if (entries.length === 0) {
     return;
   }
-  const logPath = path14.join(root, MEMORY_LOG_RELPATH);
+  const logPath = path17.join(root, MEMORY_LOG_RELPATH);
   const existing = await fs5.readFile(logPath, "utf8");
   const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   await fs5.writeFile(logPath, `${existing}${separator}${entries.join("\n")}
@@ -2507,7 +2772,7 @@ async function writeIndex(root) {
       description: page.frontmatter.description ?? ""
     }))
   );
-  await fs5.writeFile(path14.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
+  await fs5.writeFile(path17.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
 }
 function parsePageMarkdown(relPath, markdown) {
   try {
@@ -2552,9 +2817,9 @@ async function writePage(root, relPath, body, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    await fs6.mkdir(path15.dirname(path15.join(root, pageRelPath)), { recursive: true });
+    await fs6.mkdir(path18.dirname(path18.join(root, pageRelPath)), { recursive: true });
     await fs6.writeFile(
-      path15.join(root, pageRelPath),
+      path18.join(root, pageRelPath),
       serializeFrontmatter(opts.frontmatter ?? {}, body),
       "utf8"
     );
@@ -2565,8 +2830,8 @@ async function appendToPage(root, relPath, content, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    const pagePath = path15.join(root, pageRelPath);
-    await fs6.mkdir(path15.dirname(pagePath), { recursive: true });
+    const pagePath = path18.join(root, pageRelPath);
+    await fs6.mkdir(path18.dirname(pagePath), { recursive: true });
     const existing = await readMarkdownIfPresent(pagePath);
     const parsed = existing === void 0 ? { frontmatter: {}, body: "" } : parseFrontmatter(existing);
     await fs6.writeFile(
@@ -2588,13 +2853,13 @@ async function removeChildren(directoryPath) {
     if (entryName === MEMORY_LOCK_RELPATH) {
       continue;
     }
-    const entryPath = path15.join(directoryPath, entryName);
-    const stat6 = await fs6.stat(entryPath);
-    if (stat6.isDirectory()) {
+    const entryPath = path18.join(directoryPath, entryName);
+    const stat7 = await fs6.stat(entryPath);
+    if (stat7.isDirectory()) {
       await removeDirectory2(entryPath);
       continue;
     }
-    if (stat6.isFile()) {
+    if (stat7.isFile()) {
       await fs6.unlink(entryPath);
     }
   }
@@ -2605,7 +2870,7 @@ async function removeDirectory2(directoryPath) {
 }
 function assertPageRelPath(relPath) {
   const normalizedRelPath = assertSafeRelPath(relPath);
-  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path15.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
+  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path18.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
     throw new Error(`Expected a markdown page path under "${MEMORY_PAGES_DIR_RELPATH}/".`);
   }
   return normalizedRelPath;
@@ -2623,12 +2888,12 @@ async function readMarkdownIfPresent(filePath) {
 
 // packages/memory/src/edit.ts
 async function editPage(root, relPath, opts) {
-  const pagePath = path16.join(root, relPath);
+  const pagePath = path19.join(root, relPath);
   const original = await readIfPresent(pagePath);
-  const tempRoot = path16.join(root, ".tmp");
+  const tempRoot = path19.join(root, ".tmp");
   await fs7.mkdir(tempRoot, { recursive: true });
-  const tempDir = await fs7.mkdtemp(path16.join(tempRoot, "poe-code-memory-edit-"));
-  const tempPath = path16.join(tempDir, path16.basename(relPath));
+  const tempDir = await fs7.mkdtemp(path19.join(tempRoot, "poe-code-memory-edit-"));
+  const tempPath = path19.join(tempDir, path19.basename(relPath));
   try {
     await fs7.writeFile(tempPath, original ?? "", "utf8");
     await opts.launchEditor(tempPath);
@@ -2662,7 +2927,7 @@ async function readIfPresent(filePath) {
 
 // packages/memory/src/audit.ts
 import * as fs8 from "node:fs/promises";
-import path17 from "node:path";
+import path20 from "node:path";
 var DEFAULT_MIN_INFERRED_CONFIDENCE = 0.3;
 var DEFAULT_REJECT_UNTAGGED = false;
 var DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS = 200;
@@ -2717,10 +2982,10 @@ async function auditSourceRef(source, claimLineNumber, repoRoot, sourceCache) {
   if (isUrlLike(source.path)) {
     return void 0;
   }
-  if (path17.isAbsolute(source.path)) {
+  if (path20.isAbsolute(source.path)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but source paths must be repo-relative or URLs.`;
   }
-  const absPath = path17.resolve(repoRoot, source.path);
+  const absPath = path20.resolve(repoRoot, source.path);
   if (!isWithinRoot(repoRoot, absPath)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", which resolves outside the repo root.`;
   }
@@ -2786,14 +3051,14 @@ function isUrlLike(value) {
   return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
 }
 function isWithinRoot(root, absPath) {
-  const relative = path17.relative(root, absPath);
-  return relative === "" || !relative.startsWith("..") && !path17.isAbsolute(relative);
+  const relative = path20.relative(root, absPath);
+  return relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative);
 }
 
 // packages/memory/src/cache.ts
 import { createHash as createHash2 } from "node:crypto";
 import * as fs9 from "node:fs/promises";
-import path18 from "node:path";
+import path21 from "node:path";
 function computeIngestKey(input) {
   const hash = createHash2("sha256");
   hash.update(input.sourceBytes);
@@ -2806,7 +3071,7 @@ function computeIngestKey(input) {
   return hash.digest("hex");
 }
 async function readCacheEntry(root, key) {
-  const cachePath = path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
+  const cachePath = path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
   let raw;
   try {
     raw = await fs9.readFile(cachePath, "utf8");
@@ -2825,17 +3090,17 @@ async function readCacheEntry(root, key) {
   }
 }
 async function writeCacheEntry(root, entry) {
-  await fs9.mkdir(path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+  await fs9.mkdir(path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
   await fs9.writeFile(
-    path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
+    path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
     `${JSON.stringify(entry)}
 `,
     "utf8"
   );
 }
 async function clearCache(root, opts = {}) {
-  const ingestDir = path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
-  const cacheDir = path18.join(root, MEMORY_CACHE_DIR_RELPATH);
+  const ingestDir = path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+  const cacheDir = path21.join(root, MEMORY_CACHE_DIR_RELPATH);
   const fileNames = await readCacheFileNames(ingestDir);
   if (fileNames.length === 0) {
     if (opts.olderThanMs === void 0) {
@@ -2855,7 +3120,7 @@ async function clearCache(root, opts = {}) {
     if (entry === null || Date.parse(entry.ingestedAt) > cutoff) {
       continue;
     }
-    await fs9.rm(path18.join(ingestDir, fileName), { force: true });
+    await fs9.rm(path21.join(ingestDir, fileName), { force: true });
     removed += 1;
   }
   await removeEmptyDirectory(ingestDir);
@@ -2911,7 +3176,7 @@ function expectStringArray(value, field) {
 }
 async function readCacheFileNames(ingestDir) {
   try {
-    return (await fs9.readdir(ingestDir)).filter((fileName) => path18.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
+    return (await fs9.readdir(ingestDir)).filter((fileName) => path21.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
   } catch (error2) {
     if (isMissing3(error2)) {
       return [];
@@ -2963,7 +3228,7 @@ function parseOlderThan(value) {
 
 // packages/memory/src/ingest.ts
 import * as fs11 from "node:fs/promises";
-import path23 from "node:path";
+import path26 from "node:path";
 
 // packages/agent-spawn/src/run-command.ts
 import { spawn } from "node:child_process";
@@ -3387,7 +3652,7 @@ 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 path19 from "node:path";
+import path22 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -3621,11 +3886,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path19.join(options.logDir, options.logFileName);
+  return path22.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path19.dirname(filePath), { recursive: true });
+    mkdirSync(path22.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -4056,9 +4321,9 @@ import chalk16 from "chalk";
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path20 from "node:path";
+import path23 from "node:path";
 import { homedir as homedir2 } from "node:os";
-import { open, readdir as readdir4 } from "node:fs/promises";
+import { open as open2, readdir as readdir4 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 
 // packages/poe-acp-client/src/acp-client.ts
@@ -4070,7 +4335,7 @@ import {
 } from "node:child_process";
 
 // packages/poe-acp-client/src/run-report.ts
-import * as fsPromises2 from "node:fs/promises";
+import * as fsPromises3 from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -4078,13 +4343,13 @@ import { join } from "node:path";
 import { spawn as spawnChildProcess4 } from "node:child_process";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path21 from "node:path";
+import path24 from "node:path";
 import { homedir as homedir3 } from "node:os";
-import { mkdir as mkdir5, open as open2 } from "node:fs/promises";
+import { mkdir as mkdir5, open as open3 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
 import * as fs10 from "node:fs/promises";
-import path22 from "node:path";
+import path25 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -4168,11 +4433,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path22.resolve(root, "..", "..");
+  const repoRoot = path25.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path22.isAbsolute(sourcePath) ? sourcePath : path22.resolve(repoRoot, sourcePath);
+    const absPath = path25.isAbsolute(sourcePath) ? sourcePath : path25.resolve(repoRoot, sourcePath);
     try {
       const content = await fs10.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -4223,10 +4488,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(path23.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs11.readFile(path26.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs11,
-    filePath: path23.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path26.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -4316,7 +4581,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path23.resolve(root, "..", "..");
+  return path26.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -5074,8 +5339,8 @@ function printMcpConfig() {
 }
 
 // packages/agent-skill-config/src/configs.ts
-import os from "node:os";
-import path24 from "node:path";
+import os3 from "node:os";
+import path27 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -5108,8 +5373,8 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 }
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile11, stat as stat5 } from "node:fs/promises";
-import path25 from "node:path";
+import { readFile as readFile12, stat as stat6 } from "node:fs/promises";
+import path28 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -5242,7 +5507,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path26 from "node:path";
+import path29 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -5334,7 +5599,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path26.dirname(configPath);
+  return path29.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -5360,9 +5625,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path26.join(homeDir, configPath.slice(2));
+    return path29.join(homeDir, configPath.slice(2));
   }
-  return path26.join(homeDir, configPath.slice(1));
+  return path29.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -5395,7 +5660,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path26.dirname(absolutePath);
+  const configDir = path29.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -5573,7 +5838,7 @@ async function installMemory(options) {
 
 // packages/memory/src/query.ts
 import * as fs12 from "node:fs/promises";
-import path27 from "node:path";
+import path30 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -5587,7 +5852,7 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs12,
-    filePath: path27.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path30.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);
@@ -5602,7 +5867,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path27.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs12.readFile(path30.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -5681,12 +5946,12 @@ function tokenize(text4) {
   return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path27.resolve(root, "..", "..");
+  return path30.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
 import * as fs13 from "node:fs/promises";
-import path28 from "node:path";
+import path31 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -5709,7 +5974,7 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs13,
-    filePath: path28.join(inferRepoRoot3(root), "poe-code.json")
+    filePath: path31.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const response = await spawn2(agentId, { prompt });
@@ -5758,7 +6023,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path28.resolve(root, "..", "..");
+  return path31.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -5771,9 +6036,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path29 from "node:path";
+import path32 from "node:path";
 function openMemory(opts) {
-  if (!path29.isAbsolute(opts.root)) {
+  if (!path32.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;