poe-code 3.0.191 → 3.0.193

package/packages/memory/dist/index.js

@@ -7,8 +7,8 @@ var MEMORY_PAGES_DIR_RELPATH = "pages";
 var MEMORY_CACHE_DIR_RELPATH = ".cache";
 var MEMORY_INGEST_CACHE_DIR_RELPATH = `${MEMORY_CACHE_DIR_RELPATH}/ingest`;
 var MemoryPathError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "MemoryPathError";
   }
 };
@@ -60,7 +60,7 @@ import path6 from "node:path";
 
 // packages/config-extends/src/discover.ts
 import path2 from "node:path";
-async function findBase(name, bases, fs13) {
+async function findBase(name, bases, fs14) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
@@ -68,14 +68,14 @@ async function findBase(name, bases, fs13) {
       checkedPaths.push(filePath);
       try {
         return {
-          content: await fs13.readFile(filePath, "utf8"),
+          content: await fs14.readFile(filePath, "utf8"),
           filePath
         };
-      } catch (error) {
-        if (hasCode(error, "ENOENT")) {
+      } catch (error2) {
+        if (hasCode(error2, "ENOENT")) {
           continue;
         }
-        throw error;
+        throw error2;
       }
     }
   }
@@ -83,8 +83,8 @@ async function findBase(name, bases, fs13) {
 Checked paths:
 - ${checkedPaths.join("\n- ")}`);
 }
-function hasCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+function hasCode(error2, code) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
 }
 
 // packages/config-extends/src/parse.ts
@@ -148,11 +148,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path25) {
+function mergeObjectLayers(layers, path30) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path25);
+    const resolved = resolveKey(layers, key, path30);
     if (resolved === void 0) {
       continue;
     }
@@ -170,7 +170,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path25) {
+function resolveKey(layers, key, path30) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -200,9 +200,9 @@ function resolveKey(layers, key, path25) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path25, key);
+  const fullPath = buildPath(path30, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path25, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path30, key]);
     return {
       value: merged.data,
       sources: {
@@ -227,8 +227,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path25, key) {
-  return [...path25, key].join(".");
+function buildPath(path30, key) {
+  return [...path30, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -333,11 +333,11 @@ async function resolveBaseChain({
       baseLayers.map((layer) => layer.path),
       options.fs
     );
-  } catch (error) {
-    if (optional && isBaseNotFoundError(error)) {
+  } catch (error2) {
+    if (optional && isBaseNotFoundError(error2)) {
       return void 0;
     }
-    throw error;
+    throw error2;
   }
   if (visited.has(discoveredBase.filePath)) {
     throw new Error(
@@ -466,8 +466,8 @@ function getBaseName(filePath) {
 function shouldResolveBase(parsedDocument, autoExtend) {
   return parsedDocument.extends || autoExtend === true && !parsedDocument.hasExtendsField;
 }
-function isBaseNotFoundError(error) {
-  return error instanceof Error && error.message.startsWith('Base "') && error.message.includes('" not found.\nChecked paths:');
+function isBaseNotFoundError(error2) {
+  return error2 instanceof Error && error2.message.startsWith('Base "') && error2.message.includes('" not found.\nChecked paths:');
 }
 function isDataLayer(layer) {
   return "data" in layer;
@@ -859,16 +859,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path25) {
-  const ext = getExtension(path25);
+function detectFormat2(path30) {
+  const ext = getExtension(path30);
   return extensionMap[ext];
 }
-function getExtension(path25) {
-  const lastDot = path25.lastIndexOf(".");
+function getExtension(path30) {
+  const lastDot = path30.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path25.slice(lastDot).toLowerCase();
+  return path30.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -916,28 +916,28 @@ function resolvePath(rawPath, homeDir, pathMapper) {
 }
 
 // packages/config-mutations/src/fs-utils.ts
-function isNotFound(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function isNotFound(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
-async function readFileIfExists(fs13, target) {
+async function readFileIfExists(fs14, target) {
   try {
-    return await fs13.readFile(target, "utf8");
-  } catch (error) {
-    if (isNotFound(error)) {
+    return await fs14.readFile(target, "utf8");
+  } catch (error2) {
+    if (isNotFound(error2)) {
       return null;
     }
-    throw error;
+    throw error2;
   }
 }
-async function pathExists(fs13, target) {
+async function pathExists(fs14, target) {
   try {
-    await fs13.stat(target);
+    await fs14.stat(target);
     return true;
-  } catch (error) {
-    if (isNotFound(error)) {
+  } catch (error2) {
+    if (isNotFound(error2)) {
       return false;
     }
-    throw error;
+    throw error2;
   }
 }
 function createTimestamp() {
@@ -955,9 +955,9 @@ function createInvalidDocumentBackupPath(targetPath) {
   const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
   return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs13, targetPath, content) {
+async function backupInvalidDocument(fs14, targetPath, content) {
   const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs13.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs14.writeFile(backupPath, content, { encoding: "utf8" });
 }
 function describeMutation(kind, targetPath) {
   const displayPath = targetPath ?? "target";
@@ -1145,14 +1145,14 @@ async function applyRemoveFile(mutation, context, options) {
       outcome: { changed: true, effect: "delete", detail: "delete" },
       details
     };
-  } catch (error) {
-    if (isNotFound(error)) {
+  } catch (error2) {
+    if (isNotFound(error2)) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
         details
       };
     }
-    throw error;
+    throw error2;
   }
 }
 async function applyChmod(mutation, context, options) {
@@ -1185,14 +1185,14 @@ async function applyChmod(mutation, context, options) {
       outcome: { changed: true, effect: "chmod", detail: "update" },
       details
     };
-  } catch (error) {
-    if (isNotFound(error)) {
+  } catch (error2) {
+    if (isNotFound(error2)) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
         details
       };
     }
-    throw error;
+    throw error2;
   }
 }
 async function applyBackup(mutation, context, options) {
@@ -1437,10 +1437,10 @@ async function applyTemplateMerge(mutation, context, options, formatName) {
   let templateDoc;
   try {
     templateDoc = format.parse(rendered);
-  } catch (error) {
+  } catch (error2) {
     throw new Error(
-      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
-      { cause: error }
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error2}`,
+      { cause: error2 }
     );
   }
   const rawContent = await readFileIfExists(context.fs, targetPath);
@@ -1501,16 +1501,16 @@ async function executeMutation(mutation, context, options) {
     const { outcome, details } = await applyMutation(mutation, context, options);
     context.observers?.onComplete?.(details, outcome);
     return { outcome, details };
-  } catch (error) {
+  } catch (error2) {
     context.observers?.onError?.(
       {
         kind: mutation.kind,
         label: mutation.label ?? mutation.kind,
         targetPath: void 0
       },
-      error
+      error2
     );
-    throw error;
+    throw error2;
   }
 }
 
@@ -1519,12 +1519,12 @@ import Mustache2 from "mustache";
 var originalEscape = Mustache2.escape;
 
 // packages/poe-code-config/src/store.ts
-async function readMergedDocument(fs13, globalPath, projectPath) {
-  const globalDocument = await readStoredDocument(fs13, globalPath);
+async function readMergedDocument(fs14, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs14, globalPath);
   if (!projectPath) {
     return globalDocument.data;
   }
-  const projectDocument = await readStoredDocument(fs13, projectPath);
+  const projectDocument = await readStoredDocument(fs14, projectPath);
   const resolved = await resolve(
     [
       {
@@ -1538,41 +1538,41 @@ async function readMergedDocument(fs13, globalPath, projectPath) {
       }
     ],
     {
-      fs: createResolvedConfigFs(fs13, globalPath, globalDocument.content),
+      fs: createResolvedConfigFs(fs14, globalPath, globalDocument.content),
       autoExtend: true
     }
   );
   return normalizeDocument(resolved.data);
 }
-async function readStoredDocument(fs13, filePath) {
+async function readStoredDocument(fs14, filePath) {
   try {
-    const raw = await fs13.readFile(filePath, "utf8");
-    return await parseStoredDocument(fs13, filePath, raw);
-  } catch (error) {
-    if (isNotFound(error)) {
+    const raw = await fs14.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs14, filePath, raw);
+  } catch (error2) {
+    if (isNotFound(error2)) {
       return {
         content: EMPTY_DOCUMENT,
         data: {}
       };
     }
-    throw error;
+    throw error2;
   }
 }
-async function parseStoredDocument(fs13, filePath, raw) {
+async function parseStoredDocument(fs14, filePath, raw) {
   try {
     return {
       content: raw,
       data: normalizeDocument(JSON.parse(raw))
     };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      await recoverInvalidDocument(fs13, filePath, raw);
+  } catch (error2) {
+    if (error2 instanceof SyntaxError) {
+      await recoverInvalidDocument(fs14, filePath, raw);
       return {
         content: EMPTY_DOCUMENT,
         data: {}
       };
     }
-    throw error;
+    throw error2;
   }
 }
 function normalizeDocument(value) {
@@ -1600,21 +1600,21 @@ function normalizeScopeValues(value) {
   }
   return normalized;
 }
-function createResolvedConfigFs(fs13, globalPath, globalContent) {
+function createResolvedConfigFs(fs14, globalPath, globalContent) {
   return {
     readFile(filePath, _encoding) {
       if (filePath === globalPath) {
         return Promise.resolve(globalContent);
       }
-      return fs13.readFile(filePath, "utf8");
+      return fs14.readFile(filePath, "utf8");
     }
   };
 }
-async function recoverInvalidDocument(fs13, filePath, content) {
-  await fs13.mkdir(path6.dirname(filePath), { recursive: true });
+async function recoverInvalidDocument(fs14, filePath, content) {
+  await fs14.mkdir(path6.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
-  await fs13.writeFile(backupPath, content, { encoding: "utf8" });
-  await fs13.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+  await fs14.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs14.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
   const directory = path6.dirname(filePath);
@@ -1709,14 +1709,14 @@ async function initMemory(root) {
 async function writeFileIfMissing(filePath, content) {
   try {
     await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
-  } catch (error) {
-    if (!hasErrorCode(error, "EEXIST")) {
-      throw error;
+  } catch (error2) {
+    if (!hasErrorCode(error2, "EEXIST")) {
+      throw error2;
     }
   }
 }
-function hasErrorCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+function hasErrorCode(error2, code) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
 }
 
 // packages/memory/src/pages.ts
@@ -1860,9 +1860,9 @@ function parseYamlFrontmatter(yamlBlock) {
   let parsed;
   try {
     parsed = parse5(normalizedYamlBlock);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown YAML parse error";
-    throw new Error(`Invalid YAML frontmatter: ${message}`);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : "Unknown YAML parse error";
+    throw new Error(`Invalid YAML frontmatter: ${message2}`);
   }
   if (parsed === null) {
     return {};
@@ -1901,10 +1901,10 @@ function parseSources(value) {
     if (!isRecord2(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path25 = readRequiredString(item.path, "sources[].path");
+    const path30 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path25, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path30, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -1960,9 +1960,9 @@ async function readPage(root, relPath) {
       bytes: Buffer.byteLength(content),
       mtimeMs: stat6.mtimeMs
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`Failed to parse frontmatter for "${normalizedRelPath}": ${message}`);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    console.warn(`Failed to parse frontmatter for "${normalizedRelPath}": ${message2}`);
     return {
       relPath: normalizedRelPath,
       frontmatter: {},
@@ -1982,11 +1982,11 @@ async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
   let entryNames;
   try {
     entryNames = await fs2.readdir(absPath);
-  } catch (error) {
-    if (isMissing(error)) {
+  } catch (error2) {
+    if (isMissing(error2)) {
       return;
     }
-    throw error;
+    throw error2;
   }
   for (const entryName of entryNames.sort((left, right) => left.localeCompare(right))) {
     const entryRelPath = currentRelPath.length === 0 ? entryName : path10.posix.join(currentRelPath, entryName);
@@ -2022,8 +2022,8 @@ function assertMarkdownRelPath(relPath) {
 function isMarkdownPath(relPath) {
   return path10.posix.extname(relPath).toLowerCase() === ".md";
 }
-function isMissing(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function isMissing(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
 
 // packages/memory/src/search.ts
@@ -2090,11 +2090,11 @@ async function pathExists2(targetPath) {
   try {
     await fs4.stat(targetPath);
     return true;
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+  } catch (error2) {
+    if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT") {
       return false;
     }
-    throw error;
+    throw error2;
   }
 }
 
@@ -2119,8 +2119,8 @@ function createDefaultFs() {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function hasErrorCode2(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+function hasErrorCode2(error2, code) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === code;
 }
 function lockDelay(attempt, minTimeoutMs, maxTimeoutMs) {
   return Math.min(maxTimeoutMs, minTimeoutMs * Math.pow(2, attempt));
@@ -2142,31 +2142,31 @@ function isPidRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (error) {
-    return !hasErrorCode2(error, "ESRCH");
+  } catch (error2) {
+    return !hasErrorCode2(error2, "ESRCH");
   }
 }
-async function removeLockFile(fs13, lockPath) {
+async function removeLockFile(fs14, lockPath) {
   try {
-    await fs13.unlink(lockPath);
-  } catch (error) {
-    if (!hasErrorCode2(error, "ENOENT")) {
-      throw error;
+    await fs14.unlink(lockPath);
+  } catch (error2) {
+    if (!hasErrorCode2(error2, "ENOENT")) {
+      throw error2;
     }
   }
 }
-async function readLockPid(fs13, lockPath) {
+async function readLockPid(fs14, lockPath) {
   try {
-    return parsePid(await fs13.readFile(lockPath, "utf8"));
-  } catch (error) {
-    if (hasErrorCode2(error, "ENOENT")) {
+    return parsePid(await fs14.readFile(lockPath, "utf8"));
+  } catch (error2) {
+    if (hasErrorCode2(error2, "ENOENT")) {
       return null;
     }
-    throw error;
+    throw error2;
   }
 }
 async function withLock(root, run, options = {}) {
-  const fs13 = options.fs ?? createDefaultFs();
+  const fs14 = options.fs ?? createDefaultFs();
   const lockPath = path13.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
@@ -2175,24 +2175,24 @@ async function withLock(root, run, options = {}) {
   const pidIsRunning = options.isPidRunning ?? isPidRunning;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
     try {
-      await fs13.writeFile(lockPath, `${pid}
+      await fs14.writeFile(lockPath, `${pid}
 `, { encoding: "utf8", flag: "wx" });
       try {
         return await run();
       } finally {
-        await removeLockFile(fs13, lockPath);
+        await removeLockFile(fs14, lockPath);
       }
-    } catch (error) {
-      if (!hasErrorCode2(error, "EEXIST")) {
-        throw error;
+    } catch (error2) {
+      if (!hasErrorCode2(error2, "EEXIST")) {
+        throw error2;
       }
     }
-    const existingPid = await readLockPid(fs13, lockPath);
+    const existingPid = await readLockPid(fs14, lockPath);
     if (existingPid === null) {
       continue;
     }
     if (existingPid === void 0 || !pidIsRunning(existingPid)) {
-      await removeLockFile(fs13, lockPath);
+      await removeLockFile(fs14, lockPath);
       continue;
     }
     if (attempt < retries) {
@@ -2452,10 +2452,10 @@ 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"))
   );
-  const diff = diffSnapshots(before, await snapshot(root));
+  const diff2 = diffSnapshots(before, await snapshot(root));
   await writeIndex(root);
-  await appendLogEntries(root, diff, detail, timestamp);
-  return diff;
+  await appendLogEntries(root, diff2, detail, timestamp);
+  return diff2;
 }
 function renderIndex(entries) {
   if (entries.length === 0) {
@@ -2471,11 +2471,11 @@ function renderIndex(entries) {
     ""
   ].join("\n");
 }
-async function appendLogEntries(root, diff, detail, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+async function appendLogEntries(root, diff2, detail, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
   const entries = [
-    ...diff.updated.map((relPath) => formatLogLine(timestamp, "update", relPath, detail)),
-    ...diff.deleted.map((relPath) => formatLogLine(timestamp, "delete", relPath, detail)),
-    ...diff.created.map((relPath) => formatLogLine(timestamp, "create", relPath, detail))
+    ...diff2.updated.map((relPath) => formatLogLine(timestamp, "update", relPath, detail)),
+    ...diff2.deleted.map((relPath) => formatLogLine(timestamp, "delete", relPath, detail)),
+    ...diff2.created.map((relPath) => formatLogLine(timestamp, "create", relPath, detail))
   ];
   if (entries.length === 0) {
     return;
@@ -2509,9 +2509,9 @@ async function writeIndex(root) {
 function parsePageMarkdown(relPath, markdown) {
   try {
     return parseFrontmatter(markdown);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`Failed to parse frontmatter for "${relPath}": ${message}`);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    console.warn(`Failed to parse frontmatter for "${relPath}": ${message2}`);
     return {
       frontmatter: {},
       body: markdown
@@ -2610,11 +2610,11 @@ function assertPageRelPath(relPath) {
 async function readMarkdownIfPresent(filePath) {
   try {
     return await fs6.readFile(filePath, "utf8");
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+  } catch (error2) {
+    if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT") {
       return void 0;
     }
-    throw error;
+    throw error2;
   }
 }
 
@@ -2634,13 +2634,13 @@ async function editPage(root, relPath, opts) {
       return { changed: false };
     }
     const parsed = parseFrontmatter(edited);
-    const diff = await writePage(root, relPath, parsed.body, {
+    const diff2 = await writePage(root, relPath, parsed.body, {
       frontmatter: parsed.frontmatter,
       reason: opts.reason
     });
     return {
       changed: true,
-      diff
+      diff: diff2
     };
   } finally {
     await fs7.rm(tempDir, { recursive: true, force: true });
@@ -2649,11 +2649,11 @@ async function editPage(root, relPath, opts) {
 async function readIfPresent(filePath) {
   try {
     return await fs7.readFile(filePath, "utf8");
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+  } catch (error2) {
+    if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT") {
       return void 0;
     }
-    throw error;
+    throw error2;
   }
 }
 
@@ -2675,8 +2675,8 @@ async function auditClaims(root, repoRoot, options = {}) {
     let claims;
     try {
       claims = parseClaims(page.body);
-    } catch (error) {
-      issues.push(formatError(error));
+    } catch (error2) {
+      issues.push(formatError(error2));
       audits.push({ page: page.relPath, issues });
       continue;
     }
@@ -2745,22 +2745,22 @@ function auditFrontmatterSources(frontmatterSources, inlineSources) {
   return issues;
 }
 function readSourceFile(absPath, sourceCache) {
-  const cached = sourceCache.get(absPath);
-  if (cached !== void 0) {
-    return cached;
+  const cached2 = sourceCache.get(absPath);
+  if (cached2 !== void 0) {
+    return cached2;
   }
   const pending = fs8.readFile(absPath, "utf8").then((content) => ({
     exists: true,
     absPath,
     lineCount: countLines(content)
-  })).catch((error) => {
-    if (isMissing2(error)) {
+  })).catch((error2) => {
+    if (isMissing2(error2)) {
       return {
         exists: false,
         absPath
       };
     }
-    throw error;
+    throw error2;
   });
   sourceCache.set(absPath, pending);
   return pending;
@@ -2773,11 +2773,11 @@ function countLines(content) {
   const trimmed = normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
   return trimmed.length === 0 ? 0 : trimmed.split("\n").length;
 }
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
+function formatError(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
 }
-function isMissing2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function isMissing2(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
 function isUrlLike(value) {
   return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
@@ -2807,17 +2807,17 @@ async function readCacheEntry(root, key) {
   let raw;
   try {
     raw = await fs9.readFile(cachePath, "utf8");
-  } catch (error) {
-    if (isMissing3(error)) {
+  } catch (error2) {
+    if (isMissing3(error2)) {
       return null;
     }
-    throw error;
+    throw error2;
   }
   try {
     return parseCacheEntry(JSON.parse(raw), key);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`Ignoring ingest cache entry "${key}": ${message}`);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    console.warn(`Ignoring ingest cache entry "${key}": ${message2}`);
     return null;
   }
 }
@@ -2904,67 +2904,1182 @@ function expectStringArray(value, field) {
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
     throw new Error(`Expected string[] at "${field}".`);
   }
-  return value;
+  return value;
+}
+async function readCacheFileNames(ingestDir) {
+  try {
+    return (await fs9.readdir(ingestDir)).filter((fileName) => path18.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
+  } catch (error2) {
+    if (isMissing3(error2)) {
+      return [];
+    }
+    throw error2;
+  }
+}
+async function removeEmptyDirectory(directoryPath) {
+  try {
+    const remainingEntries = await fs9.readdir(directoryPath);
+    if (remainingEntries.length === 0) {
+      await fs9.rmdir(directoryPath);
+    }
+  } catch (error2) {
+    if (isMissing3(error2)) {
+      return;
+    }
+    throw error2;
+  }
+}
+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");
+}
+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 path23 from "node:path";
+
+// packages/agent-spawn/src/run-command.ts
+import { spawn } from "node:child_process";
+
+// packages/agent-spawn/src/types.ts
+function resolveModeConfig(modeConfig) {
+  if (Array.isArray(modeConfig)) {
+    return { args: modeConfig };
+  }
+  return {
+    args: modeConfig.args ?? [],
+    env: modeConfig.env && Object.keys(modeConfig.env).length > 0 ? modeConfig.env : void 0
+  };
+}
+
+// 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 = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const mapped = { command: server.command };
+    if (server.args && server.args.length > 0) {
+      mapped.args = server.args;
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      mapped.env = server.env;
+    }
+    if (server.timeout !== void 0) {
+      mapped.timeout = server.timeout;
+    }
+    out[name] = mapped;
+  }
+  return out;
+}
+function toTomlString(value) {
+  return JSON.stringify(value);
+}
+function toTomlArray(values) {
+  const serialized = values.map((value) => toTomlString(value));
+  return `[${serialized.join(", ")}]`;
+}
+function toTomlInlineTable(values) {
+  const parts = [];
+  for (const [key, value] of Object.entries(values)) {
+    parts.push(`${JSON.stringify(key)}=${toTomlString(value)}`);
+  }
+  return `{${parts.join(", ")}}`;
+}
+function serializeJsonMcpArgs(servers) {
+  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
+}
+function serializeOpenCodeMcpEnv(servers) {
+  const mcp = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const entry = { type: "local", command: [server.command, ...server.args ?? []] };
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.environment = server.env;
+    }
+    mcp[name] = entry;
+  }
+  return { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp }) };
+}
+function serializeCodexMcpArgs(servers) {
+  const args = [];
+  for (const [name, server] of Object.entries(servers)) {
+    const prefix = `mcp_servers.${name}`;
+    args.push("-c", `${prefix}.command=${toTomlString(server.command)}`);
+    if (server.args && server.args.length > 0) {
+      args.push("-c", `${prefix}.args=${toTomlArray(server.args)}`);
+    }
+    if (server.env && Object.keys(server.env).length > 0) {
+      args.push("-c", `${prefix}.env=${toTomlInlineTable(server.env)}`);
+    }
+    if (server.timeout !== void 0) {
+      args.push("-c", `${prefix}.timeout=${server.timeout}`);
+    }
+  }
+  return args;
+}
+function serializeGooseMcpArgs(servers) {
+  return Object.values(servers).flatMap((server) => [
+    "--with-extension",
+    [server.command, ...server.args ?? []].join(" ")
+  ]);
+}
+
+// packages/agent-spawn/src/configs/claude-code.ts
+var claudeCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "claude-code",
+  // ACP adapter support: yes (adapter: "claude")
+  adapter: "claude",
+  promptFlag: "-p",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  modelTransform: (model) => model.replaceAll(".", "-"),
+  defaultArgs: [
+    "--output-format",
+    "stream-json",
+    "--verbose"
+  ],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--dangerously-skip-permissions"],
+    edit: ["--permission-mode", "acceptEdits", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,NotebookEdit"],
+    read: ["--permission-mode", "plan"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "text"]
+  },
+  interactive: {
+    defaultArgs: []
+  },
+  resumeCommand: (threadId) => ["--resume", threadId]
+};
+
+// packages/agent-spawn/src/configs/codex.ts
+var codexSpawnConfig = {
+  kind: "cli",
+  agentId: "codex",
+  // ACP adapter support: yes (adapter: "codex")
+  adapter: "codex",
+  promptFlag: "exec",
+  modelFlag: "--model",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--skip-git-repo-check", "--json"],
+  mcpArgs: serializeCodexMcpArgs,
+  mcpArgsBeforeCommand: true,
+  modes: {
+    yolo: ["-s", "danger-full-access"],
+    edit: ["-s", "workspace-write"],
+    read: ["-s", "read-only"]
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["-"]
+  },
+  interactive: {
+    defaultArgs: ["-a", "never"]
+  },
+  resumeCommand: (threadId, cwd) => ["resume", "-C", cwd, threadId]
+};
+
+// packages/agent-spawn/src/configs/opencode.ts
+var openCodeSpawnConfig = {
+  kind: "cli",
+  agentId: "opencode",
+  // ACP adapter support: yes (adapter: "opencode").
+  // OpenCode's `--format json` emits NDJSON events with `{ type, sessionID, part }`
+  // (no `{ event, ... }` field), so it needs the OpenCode adapter (not "native").
+  adapter: "opencode",
+  promptFlag: "run",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  modelTransform: (model) => {
+    return model.startsWith("poe/") ? model : `poe/${model}`;
+  },
+  defaultArgs: ["--format", "json"],
+  modes: {
+    yolo: [],
+    edit: [],
+    read: ["--agent", "plan"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "--prompt"
+  },
+  resumeCommand: (threadId, cwd) => [cwd, "--session", threadId],
+  mcpEnv: serializeOpenCodeMcpEnv
+};
+var openCodeAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "opencode",
+  acpArgs: ["acp"],
+  skipAuth: true,
+  mcpEnv: serializeOpenCodeMcpEnv
+};
+
+// packages/agent-spawn/src/configs/kimi.ts
+var kimiSpawnConfig = {
+  kind: "cli",
+  agentId: "kimi",
+  // ACP adapter support: yes (adapter: "kimi").
+  // Kimi's `--output-format stream-json` emits OpenAI-style `{ role, content }` JSON
+  // (no `{ event, ... }` field), so it needs the Kimi adapter (not "native").
+  adapter: "kimi",
+  promptFlag: "-p",
+  modelStripProviderPrefix: true,
+  defaultArgs: ["--print", "--output-format", "stream-json"],
+  mcpArgs: serializeJsonMcpArgs,
+  modes: {
+    yolo: ["--yolo"],
+    edit: [],
+    read: []
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--input-format", "stream-json"]
+  },
+  interactive: {
+    defaultArgs: [],
+    promptFlag: "-p"
+  },
+  resumeCommand: (threadId, cwd) => ["--session", threadId, "--work-dir", cwd]
+};
+var kimiAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "kimi",
+  acpArgs: ["acp"]
+};
+
+// packages/agent-spawn/src/configs/goose.ts
+var gooseSpawnConfig = {
+  kind: "cli",
+  agentId: "goose",
+  adapter: "native",
+  promptFlag: "--text",
+  modelFlag: "--model",
+  modelStripProviderPrefix: false,
+  defaultArgs: ["run", "--output-format", "stream-json"],
+  defaultArgsPosition: "beforePrompt",
+  mcpArgs: serializeGooseMcpArgs,
+  mcpArgsPosition: "beforePrompt",
+  modes: {
+    yolo: { env: { GOOSE_MODE: "auto" } },
+    edit: { env: { GOOSE_MODE: "smart_approve" } },
+    read: { env: { GOOSE_MODE: "chat" } }
+  },
+  stdinMode: {
+    omitPrompt: true,
+    extraArgs: ["--instructions", "-"]
+  },
+  interactive: {
+    defaultArgs: ["session"],
+    defaultArgsPosition: "beforePrompt"
+  },
+  resumeCommand: () => ["run", "--resume", "--text", "continue"]
+};
+var gooseAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "goose",
+  acpArgs: ["acp"],
+  skipAuth: true
+};
+
+// packages/agent-spawn/src/configs/index.ts
+var allSpawnConfigs = [
+  claudeCodeSpawnConfig,
+  codexSpawnConfig,
+  openCodeSpawnConfig,
+  kimiSpawnConfig,
+  gooseSpawnConfig
+];
+var lookup2 = /* @__PURE__ */ new Map();
+for (const config of allSpawnConfigs) {
+  lookup2.set(config.agentId, config);
+}
+var acpLookup = /* @__PURE__ */ new Map();
+acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
+acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
+acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
+function getSpawnConfig(input) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return void 0;
+  }
+  return lookup2.get(resolvedId);
+}
+function listMcpSupportedAgents() {
+  const supported = [];
+  for (const config of allSpawnConfigs) {
+    if (config.kind !== "cli" || typeof config.mcpArgs !== "function" && typeof config.mcpEnv !== "function") {
+      continue;
+    }
+    supported.push(config.agentId);
+  }
+  return supported;
+}
+
+// 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";
+
+// packages/agent-spawn/src/configs/resolve-config.ts
+function resolveConfig(agentId) {
+  const resolvedAgentId = resolveAgentId(agentId);
+  if (!resolvedAgentId) {
+    throw new Error(`Unknown agent "${agentId}".`);
+  }
+  const agentDefinition = allAgents.find((agent) => agent.id === resolvedAgentId);
+  if (!agentDefinition) {
+    throw new Error(`Unknown agent "${agentId}".`);
+  }
+  const spawnConfig = getSpawnConfig(resolvedAgentId);
+  const binaryName = agentDefinition.binaryName;
+  return { agentId: resolvedAgentId, binaryName, spawnConfig };
+}
+
+// packages/agent-spawn/src/mcp-args.ts
+function hasMcpServers(servers) {
+  if (!servers) {
+    return false;
+  }
+  return Object.keys(servers).length > 0;
+}
+function getMcpArgs(config, servers) {
+  if (!hasMcpServers(servers)) {
+    return [];
+  }
+  if (!config.mcpArgs && !config.mcpEnv) {
+    throw new Error(formatUnsupportedMcpSpawnMessage(config.agentId));
+  }
+  if (!config.mcpArgs) {
+    return [];
+  }
+  return config.mcpArgs(servers);
+}
+function formatUnsupportedMcpSpawnMessage(agentId) {
+  const supported = listMcpSupportedAgents();
+  const supportedText = supported.length > 0 ? supported.join(", ") : "(none)";
+  return `Agent "${agentId}" does not support MCP servers at spawn time.
+Agents with spawn-time MCP support: ${supportedText}`;
+}
+
+// packages/agent-spawn/src/model-utils.ts
+function stripModelNamespace(model) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex === -1 ? model : model.slice(slashIndex + 1);
+}
+
+// packages/agent-spawn/src/spawn.ts
+function createAbortError() {
+  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) {
+    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
+  }
+  if (resolved.spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  }
+  if (!resolved.binaryName) {
+    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
+  }
+  return {
+    agentId: resolved.agentId,
+    binaryName: resolved.binaryName,
+    spawnConfig: resolved.spawnConfig
+  };
+}
+function getDefaultArgsPosition(config) {
+  return config.defaultArgsPosition ?? "afterPrompt";
+}
+function getMcpArgsPosition(config) {
+  if (config.mcpArgsPosition) {
+    return config.mcpArgsPosition;
+  }
+  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+}
+function buildCliArgs(config, options, stdinMode) {
+  const mcpArgs = getMcpArgs(config, options.mcpServers);
+  const defaultArgsPosition = getDefaultArgsPosition(config);
+  const mcpArgsPosition = getMcpArgsPosition(config);
+  const args = [];
+  if (mcpArgsPosition === "beforeCommand") {
+    args.push(...mcpArgs);
+  }
+  if (defaultArgsPosition === "beforePrompt") {
+    args.push(...config.defaultArgs);
+  }
+  if (mcpArgsPosition === "beforePrompt") {
+    args.push(...mcpArgs);
+  }
+  if (stdinMode) {
+    args.push(
+      config.promptFlag,
+      ...stdinMode.omitPrompt ? [] : [options.prompt],
+      ...stdinMode.extraArgs
+    );
+  } else {
+    args.push(config.promptFlag, options.prompt);
+  }
+  if (options.model && config.modelFlag) {
+    let model = config.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
+    if (config.modelTransform) model = config.modelTransform(model);
+    args.push(config.modelFlag, model);
+  }
+  if (defaultArgsPosition === "afterPrompt") {
+    args.push(...config.defaultArgs);
+  }
+  if (mcpArgsPosition === "afterCommand") {
+    args.push(...mcpArgs);
+  }
+  const mode = resolveModeConfig(config.modes[options.mode ?? "yolo"]);
+  args.push(...mode.args);
+  if (options.args && options.args.length > 0) {
+    args.push(...options.args);
+  }
+  return { args, env: mode.env };
+}
+async function spawn2(agentId, options, context) {
+  if (options.signal?.aborted) {
+    throw createAbortError();
+  }
+  const { agentId: resolvedId, binaryName, spawnConfig } = resolveCliConfig(agentId);
+  const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
+  const { args: spawnArgs, env: modeEnv } = buildCliArgs(spawnConfig, options, stdinMode);
+  if (context?.dryRun) {
+    const rendered = [binaryName, ...spawnArgs].join(" ");
+    context.logger?.dryRun(rendered);
+    return { stdout: "", stderr: "", exitCode: 0 };
+  }
+  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;
+      }
+      reject(error2);
+    });
+    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,
+        ...logFilePath ? { logFile: logFilePath } : {}
+      });
+    });
+  });
+}
+function resolveSpawnLogPath(options) {
+  if (options.logPath) {
+    return options.logPath;
+  }
+  if (!options.logDir || !options.logFileName) {
+    return void 0;
+  }
+  return path19.join(options.logDir, options.logFileName);
+}
+function openSpawnLog(filePath) {
+  try {
+    mkdirSync(path19.dirname(filePath), { recursive: true });
+    return openSync(filePath, "a");
+  } catch {
+    return void 0;
+  }
+}
+function appendSpawnLog(fd, chunk) {
+  if (fd === void 0) return;
+  try {
+    writeSync(fd, chunk);
+  } catch {
+  }
+}
+function closeSpawnLog(fd) {
+  if (fd === void 0) return;
+  try {
+    closeSync(fd);
+  } catch {
+  }
+}
+
+// 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 = {
+  header: (text4) => chalk.magentaBright.bold(text4),
+  divider: (text4) => chalk.dim(text4),
+  prompt: (text4) => chalk.cyan(text4),
+  number: (text4) => chalk.cyanBright(text4),
+  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.magenta("\u25C7"),
+  errorSymbol: chalk.red("\u25A0"),
+  accent: (text4) => chalk.cyan(text4),
+  muted: (text4) => chalk.dim(text4),
+  success: (text4) => chalk.green(text4),
+  warning: (text4) => chalk.yellow(text4),
+  error: (text4) => chalk.red(text4),
+  info: (text4) => chalk.magenta(text4),
+  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
+};
+var light = {
+  header: (text4) => chalk.hex("#a200ff").bold(text4),
+  divider: (text4) => chalk.hex("#666666")(text4),
+  prompt: (text4) => chalk.hex("#006699").bold(text4),
+  number: (text4) => chalk.hex("#0077cc").bold(text4),
+  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
+  resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
+  errorSymbol: chalk.hex("#cc0000")("\u25A0"),
+  accent: (text4) => chalk.hex("#006699").bold(text4),
+  muted: (text4) => chalk.hex("#666666")(text4),
+  success: (text4) => chalk.hex("#008800")(text4),
+  warning: (text4) => chalk.hex("#cc6600")(text4),
+  error: (text4) => chalk.hex("#cc0000")(text4),
+  info: (text4) => chalk.hex("#a200ff")(text4),
+  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+};
+
+// packages/design-system/src/tokens/typography.ts
+import chalk2 from "chalk";
+
+// packages/design-system/src/components/text.ts
+import chalk3 from "chalk";
+
+// packages/design-system/src/internal/output-format.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
+var formatStorage = new AsyncLocalStorage();
+var cached;
+function resolveOutputFormat(env = process.env) {
+  const scoped = formatStorage.getStore();
+  if (scoped) {
+    return scoped;
+  }
+  if (cached) {
+    return cached;
+  }
+  const raw = env.OUTPUT_FORMAT?.toLowerCase();
+  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
+  return cached;
+}
+
+// packages/design-system/src/internal/theme-detect.ts
+function detectThemeFromEnv(env) {
+  const apple = env.APPLE_INTERFACE_STYLE;
+  if (typeof apple === "string") {
+    return apple.toLowerCase() === "dark" ? "dark" : "light";
+  }
+  const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
+  if (typeof vscodeKind === "string") {
+    const normalized = vscodeKind.toLowerCase();
+    if (normalized.includes("light")) {
+      return "light";
+    }
+    if (normalized.includes("dark")) {
+      return "dark";
+    }
+  }
+  const colorFGBG = env.COLORFGBG;
+  if (typeof colorFGBG === "string") {
+    const parts = colorFGBG.split(";").map((part) => Number.parseInt(part, 10));
+    const background = parts.at(-1);
+    if (Number.isFinite(background)) {
+      return background >= 8 ? "light" : "dark";
+    }
+  }
+  return void 0;
+}
+function resolveThemeName(env = process.env) {
+  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
+  if (raw === "light" || raw === "dark") {
+    return raw;
+  }
+  const detected = detectThemeFromEnv(env);
+  if (detected) {
+    return detected;
+  }
+  return "dark";
+}
+var cachedTheme;
+function getTheme(env) {
+  if (cachedTheme) {
+    return cachedTheme;
+  }
+  const themeName = resolveThemeName(env);
+  cachedTheme = themeName === "light" ? light : dark;
+  return cachedTheme;
+}
+
+// packages/design-system/src/components/symbols.ts
+import chalk4 from "chalk";
+var symbols = {
+  get info() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "info";
+    if (format === "markdown") return "(i)";
+    return chalk4.magenta("\u25CF");
+  },
+  get success() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "success";
+    if (format === "markdown") return "[ok]";
+    return chalk4.magenta("\u25C6");
+  },
+  get resolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "resolved";
+    if (format === "markdown") return ">";
+    return getTheme().resolvedSymbol;
+  },
+  get errorResolved() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "error";
+    if (format === "markdown") return "[!]";
+    return getTheme().errorSymbol;
+  },
+  get bar() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "";
+    if (format === "markdown") return "|";
+    return "\u2502";
+  },
+  cornerTopRight: "\u256E",
+  cornerBottomRight: "\u256F",
+  get warning() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "warning";
+    if (format === "markdown") return "[!]";
+    return "\u25B2";
+  },
+  get active() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "active";
+    if (format === "markdown") return "[x]";
+    return "\u25C6";
+  },
+  get inactive() {
+    const format = resolveOutputFormat();
+    if (format === "json") return "inactive";
+    if (format === "markdown") return "[ ]";
+    return "\u25CB";
+  }
+};
+
+// packages/design-system/src/components/logger.ts
+import chalk6 from "chalk";
+
+// packages/design-system/src/prompts/primitives/log.ts
+import chalk5 from "chalk";
+
+// packages/design-system/src/internal/strip-ansi.ts
+function stripAnsi(value) {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+// packages/design-system/src/prompts/primitives/log.ts
+function writeTerminalMessage(msg, {
+  symbol = chalk5.gray("\u2502"),
+  secondarySymbol = chalk5.gray("\u2502"),
+  spacing: spacing2 = 1,
+  withGuide = true
+} = {}) {
+  const lines = [];
+  const showGuide = withGuide !== false;
+  const contentLines = msg.split("\n");
+  const prefix = showGuide ? `${symbol}  ` : "";
+  const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
+  const emptyGuide = showGuide ? secondarySymbol : "";
+  for (let index = 0; index < spacing2; index += 1) {
+    lines.push(emptyGuide);
+  }
+  if (contentLines.length === 0) {
+    process.stdout.write("\n");
+    return;
+  }
+  const [firstLine = "", ...continuationLines] = contentLines;
+  if (firstLine.length > 0) {
+    lines.push(`${prefix}${firstLine}`);
+  } else {
+    lines.push(showGuide ? symbol : "");
+  }
+  for (const line of continuationLines) {
+    if (line.length > 0) {
+      lines.push(`${continuationPrefix}${line}`);
+      continue;
+    }
+    lines.push(emptyGuide);
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function message(msg, options) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "message", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  writeTerminalMessage(msg, options);
+}
+function info(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **info:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "info", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: symbols.info });
+}
+function success(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **success:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "success", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: symbols.success });
+}
+function warn(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **warning:** ${stripAnsi(msg)}
+`);
+    return;
+  }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: chalk5.yellow("\u25B2") });
 }
-async function readCacheFileNames(ingestDir) {
-  try {
-    return (await fs9.readdir(ingestDir)).filter((fileName) => path18.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
-  } catch (error) {
-    if (isMissing3(error)) {
-      return [];
-    }
-    throw error;
+function error(msg) {
+  const format = resolveOutputFormat();
+  if (format === "markdown") {
+    process.stdout.write(`- **error:** ${stripAnsi(msg)}
+`);
+    return;
   }
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
+`
+    );
+    return;
+  }
+  message(msg, { symbol: chalk5.red("\u25A0") });
 }
-async function removeEmptyDirectory(directoryPath) {
-  try {
-    const remainingEntries = await fs9.readdir(directoryPath);
-    if (remainingEntries.length === 0) {
-      await fs9.rmdir(directoryPath);
+var log = {
+  info,
+  success,
+  message,
+  warn,
+  error
+};
+
+// packages/design-system/src/components/logger.ts
+function createLogger(emitter) {
+  const emit = (level, message2) => {
+    if (emitter) {
+      emitter(message2);
+      return;
     }
-  } catch (error) {
-    if (isMissing3(error)) {
+    if (level === "success") {
+      log.success(message2);
       return;
     }
-    throw error;
-  }
-}
-function isMissing3(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    if (level === "warn") {
+      log.warn(message2);
+      return;
+    }
+    if (level === "error") {
+      log.error(message2);
+      return;
+    }
+    log.info(message2);
+  };
+  return {
+    info(message2) {
+      emit("info", message2);
+    },
+    success(message2) {
+      emit("success", message2);
+    },
+    warn(message2) {
+      emit("warn", message2);
+    },
+    error(message2) {
+      emit("error", message2);
+    },
+    resolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.resolved });
+    },
+    errorResolved(label, value) {
+      if (emitter) {
+        emitter(`${label}: ${value}`);
+        return;
+      }
+      log.message(`${label}
+   ${value}`, { symbol: symbols.errorResolved });
+    },
+    message(message2, symbol) {
+      if (emitter) {
+        emitter(message2);
+        return;
+      }
+      log.message(message2, { symbol: symbol ?? chalk6.gray("\u2502") });
+    }
+  };
 }
+var logger = createLogger();
 
-// 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/design-system/src/components/table.ts
+import { Table } from "console-table-printer";
 
-// packages/memory/src/ingest.ts
-import * as fs11 from "node:fs/promises";
+// packages/design-system/src/acp/components.ts
+import chalk7 from "chalk";
+
+// packages/design-system/src/acp/writer.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var storage = new AsyncLocalStorage2();
+
+// packages/design-system/src/acp/components.ts
+var AGENT_PREFIX = `${chalk7.green.bold("\u2713")} agent: `;
+
+// packages/design-system/src/dashboard/buffer.ts
+import chalk8 from "chalk";
+
+// packages/design-system/src/dashboard/terminal.ts
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+
+// packages/design-system/src/prompts/index.ts
+import chalk15 from "chalk";
+import * as clack from "@clack/prompts";
+
+// packages/design-system/src/prompts/primitives/cancel.ts
+import chalk9 from "chalk";
+import { isCancel } from "@clack/prompts";
+
+// packages/design-system/src/prompts/primitives/intro.ts
+import chalk10 from "chalk";
+
+// packages/design-system/src/prompts/primitives/note.ts
+import chalk11 from "chalk";
+
+// packages/design-system/src/prompts/primitives/outro.ts
+import chalk12 from "chalk";
+
+// packages/design-system/src/prompts/primitives/spinner.ts
+import chalk14 from "chalk";
+
+// packages/design-system/src/static/spinner.ts
+import chalk13 from "chalk";
+
+// packages/design-system/src/static/menu.ts
+import chalk16 from "chalk";
+
+// packages/agent-spawn/src/autonomous.ts
+var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
+
+// packages/agent-spawn/src/acp/replay.ts
 import path20 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { open, readdir as readdir4 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+// packages/poe-acp-client/src/acp-client.ts
+import { isAbsolute } from "node:path";
+
+// packages/poe-acp-client/src/acp-transport.ts
+import {
+  spawn as spawnChildProcess3
+} from "node:child_process";
+
+// packages/poe-acp-client/src/run-report.ts
+import * as fsPromises2 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 path21 from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { mkdir as mkdir5, open as open2 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
 import * as fs10 from "node:fs/promises";
-import path19 from "node:path";
+import path22 from "node:path";
 
 // packages/tokenfill/src/tokenizer.ts
 import { get_encoding } from "tiktoken";
@@ -2973,19 +4088,19 @@ function createTokenizer(options = {}) {
   const encoding = options.encoding ?? DEFAULT_ENCODING;
   const tokenizer = get_encoding(encoding);
   const utf8Decoder = new TextDecoder();
-  const encode = (text) => tokenizer.encode(text);
+  const encode = (text4) => tokenizer.encode(text4);
   const decode = (tokens) => {
     const tokenArray = tokens instanceof Uint32Array ? tokens : Uint32Array.from(tokens);
     return utf8Decoder.decode(tokenizer.decode(tokenArray));
   };
-  const count = (text) => encode(text).length;
-  const truncate = (text, tokenCount) => {
+  const count = (text4) => encode(text4).length;
+  const truncate2 = (text4, tokenCount) => {
     if (tokenCount <= 0) {
       return "";
     }
-    const tokens = encode(text);
+    const tokens = encode(text4);
     if (tokens.length <= tokenCount) {
-      return text;
+      return text4;
     }
     return decode(tokens.slice(0, tokenCount));
   };
@@ -2994,22 +4109,22 @@ function createTokenizer(options = {}) {
     encode,
     decode,
     count,
-    truncate,
+    truncate: truncate2,
     free: () => tokenizer.free()
   };
 }
 var defaultTokenizer;
-function countTokens(text) {
+function countTokens(text4) {
   defaultTokenizer ??= createTokenizer();
-  return defaultTokenizer.count(text);
+  return defaultTokenizer.count(text4);
 }
 
 // packages/tokenfill/src/corpus.ts
 import { readdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var CORPUS_ARTICLE_SEPARATOR = "\n\n";
-var corpusDirectoryPath = join(dirname(fileURLToPath(import.meta.url)), "corpus");
+var corpusDirectoryPath = join2(dirname(fileURLToPath(import.meta.url)), "corpus");
 function getCorpusFileNames() {
   return readdirSync(corpusDirectoryPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
 }
@@ -3018,7 +4133,7 @@ function loadBuiltInCorpusArticles() {
   if (corpusFileNames.length === 0) {
     throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
   }
-  return corpusFileNames.map((fileName) => readFileSync(join(corpusDirectoryPath, fileName), "utf8").trim());
+  return corpusFileNames.map((fileName) => readFileSync(join2(corpusDirectoryPath, fileName), "utf8").trim());
 }
 var BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
 
@@ -3048,20 +4163,20 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path19.resolve(root, "..", "..");
+  const repoRoot = path22.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path19.isAbsolute(sourcePath) ? sourcePath : path19.resolve(repoRoot, sourcePath);
+    const absPath = path22.isAbsolute(sourcePath) ? sourcePath : path22.resolve(repoRoot, sourcePath);
     try {
       const content = await fs10.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
-    } catch (error) {
-      if (isMissing4(error)) {
+    } catch (error2) {
+      if (isMissing4(error2)) {
         missingSources.push(sourcePath);
         continue;
       }
-      throw error;
+      throw error2;
     }
   }
   missingSources.sort((left, right) => left.localeCompare(right));
@@ -3077,42 +4192,53 @@ async function pathExists3(targetPath) {
   try {
     await fs10.stat(targetPath);
     return true;
-  } catch (error) {
-    if (isMissing4(error)) {
+  } catch (error2) {
+    if (isMissing4(error2)) {
       return false;
     }
-    throw error;
+    throw error2;
   }
 }
-function isMissing4(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function isMissing4(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
 
 // packages/memory/src/ingest.ts
 var INGEST_PROMPT_VERSION = "v1";
-async function ingest(root, opts) {
+function resolveRunners(overrides) {
+  return {
+    computeIngestKey: overrides?.computeIngestKey ?? computeIngestKey,
+    readCacheEntry: overrides?.readCacheEntry ?? readCacheEntry,
+    writeCacheEntry: overrides?.writeCacheEntry ?? writeCacheEntry,
+    computeTokenStats: overrides?.computeTokenStats ?? computeTokenStats,
+    snapshot: overrides?.snapshot ?? snapshot,
+    reconcile: overrides?.reconcile ?? reconcile
+  };
+}
+async function ingest(root, opts, runners) {
+  const resolved = resolveRunners(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs11.readFile(path20.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs11.readFile(path23.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs11,
-    filePath: path20.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path23.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
-  const key = computeIngestKey({
+  const key = resolved.computeIngestKey({
     sourceBytes: source.bytes,
     indexMdBytes,
     promptTemplateVersion: INGEST_PROMPT_VERSION,
     agentId
   });
   if (!opts.force && await cacheEnabled(configOptions)) {
-    const hit = await readCacheEntry(root, key);
+    const hit = await resolved.readCacheEntry(root, key);
     if (hit !== null) {
       return {
         diff: { created: [], updated: [], deleted: [] },
         exitCode: 0,
         durationMs: 0,
         cacheHit: true,
-        tokens: await computeTokenStats(root)
+        tokens: await resolved.computeTokenStats(root)
       };
     }
   }
@@ -3124,35 +4250,34 @@ async function ingest(root, opts) {
       exitCode: 0,
       durationMs: 0,
       cacheHit: false,
-      tokens: await computeTokenStats(root)
+      tokens: await resolved.computeTokenStats(root)
     };
   }
-  const before = await snapshot(root);
+  const before = await resolved.snapshot(root);
   let exitCode = 1;
   let durationMs = 0;
   let timeoutError;
   try {
-    const spawnFn = opts.spawnFn;
     const result = await runWithTimeout(
-      spawnFn?.(agentId, prompt) ?? Promise.resolve({ exitCode: 0, durationMs: 0 }),
+      spawn2(agentId, { prompt }),
       opts.timeoutMs ?? await configuredTimeout(configOptions)
     );
     exitCode = result.exitCode;
-    durationMs = result.durationMs;
-  } catch (error) {
-    timeoutError = error instanceof Error ? error : new Error(String(error));
+    durationMs = result.durationMs ?? 0;
+  } catch (error2) {
+    timeoutError = error2 instanceof Error ? error2 : new Error(String(error2));
   }
-  const diff = await reconcile(root, before, "ingest", opts.reason ?? `ingest ${source.label}`);
-  const tokens = await computeTokenStats(root);
+  const diff2 = await resolved.reconcile(root, before, "ingest", opts.reason ?? `ingest ${source.label}`);
+  const tokens = await resolved.computeTokenStats(root);
   if (timeoutError !== void 0) {
     throw timeoutError;
   }
   if (!opts.noCacheWrite && await cacheEnabled(configOptions) && exitCode === 0) {
-    await writeCacheEntry(root, {
+    await resolved.writeCacheEntry(root, {
       key,
       ingestedAt: (/* @__PURE__ */ new Date()).toISOString(),
       sourceLabel: source.label,
-      diff,
+      diff: diff2,
       exitCode,
       durationMs,
       memoryTokens: tokens.memoryTokens,
@@ -3161,7 +4286,7 @@ async function ingest(root, opts) {
       agentId
     });
   }
-  return { diff, exitCode, durationMs, cacheHit: false, tokens };
+  return { diff: diff2, exitCode, durationMs, cacheHit: false, tokens };
 }
 function buildIngestPrompt(root, sourceLabel, sourceText) {
   return [
@@ -3186,7 +4311,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path20.resolve(root, "..", "..");
+  return path23.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -3198,16 +4323,16 @@ async function runWithTimeout(promise, timeoutMs) {
         clearTimeout(timer);
         resolve2(value);
       },
-      (error) => {
+      (error2) => {
         clearTimeout(timer);
-        reject(error);
+        reject(error2);
       }
     );
   });
 }
 
 // packages/tiny-stdio-mcp-server/src/server.ts
-import * as readline from "readline";
+import * as readline2 from "readline";
 
 // packages/tiny-stdio-mcp-server/src/types.ts
 var JSON_RPC_ERROR_CODES = {
@@ -3218,8 +4343,8 @@ var JSON_RPC_ERROR_CODES = {
   INTERNAL_ERROR: -32603
 };
 var ToolError = class extends Error {
-  constructor(code, message) {
-    super(message);
+  constructor(code, message2) {
+    super(message2);
     this.code = code;
     this.name = "ToolError";
   }
@@ -3313,11 +4438,11 @@ function formatSuccessResponse(id, result) {
   };
   return JSON.stringify(response);
 }
-function formatErrorResponse(id, error) {
+function formatErrorResponse(id, error2) {
   const response = {
     jsonrpc: "2.0",
     id,
-    error
+    error: error2
   };
   return JSON.stringify(response);
 }
@@ -3529,8 +4654,8 @@ var File = class _File {
     const isText = isTextMimeType(mimeType);
     return new _File(data, mimeType, isText);
   }
-  static fromText(text, mimeType = "text/plain") {
-    return new _File(text, mimeType, true);
+  static fromText(text4, mimeType = "text/plain") {
+    return new _File(text4, mimeType, true);
   }
   static fromBase64(base64, mimeType) {
     const data = Buffer.from(base64, "base64");
@@ -3540,18 +4665,18 @@ var File = class _File {
   toContentBlock() {
     const uri = this.name ? `file:///${this.name}` : "file:///data";
     if (this.isText) {
-      let text;
+      let text4;
       if (typeof this.data === "string") {
-        text = this.data;
+        text4 = this.data;
       } else {
-        text = new TextDecoder("utf-8").decode(this.data);
+        text4 = new TextDecoder("utf-8").decode(this.data);
       }
       return {
         type: "resource",
         resource: {
           uri,
           mimeType: this.mimeType,
-          text
+          text: text4
         }
       };
     } else {
@@ -3682,7 +4807,7 @@ function createServer(options) {
       }
       try {
         const handlerResult = await tool.handler(toolArgs);
-        const result = { content: toContentBlocks(handlerResult) };
+        const result = isCallToolResult(handlerResult) ? handlerResult : { content: toContentBlocks(handlerResult) };
         return { result };
       } catch (err) {
         if (err instanceof ToolError) {
@@ -3715,7 +4840,7 @@ function createServer(options) {
       return;
     }
     const { request, isNotification } = parsed;
-    const { result, error } = await server.handleMessage(
+    const { result, error: error2 } = await server.handleMessage(
       request.method,
       request.params
     );
@@ -3723,8 +4848,8 @@ function createServer(options) {
       return;
     }
     const requestWithId = request;
-    if (error) {
-      write2(formatErrorResponse(requestWithId.id, error) + "\n");
+    if (error2) {
+      write2(formatErrorResponse(requestWithId.id, error2) + "\n");
     } else if (result !== void 0) {
       write2(formatSuccessResponse(requestWithId.id, result) + "\n");
     }
@@ -3775,7 +4900,7 @@ function createServer(options) {
           transport.writable.write(`${JSON.stringify(notification)}
 `);
         });
-        const rl = readline.createInterface({
+        const rl = readline2.createInterface({
           input: transport.readable,
           crlfDelay: Infinity
         });
@@ -3793,24 +4918,24 @@ function createServer(options) {
         const unsubscribe = server.onNotification((notification) => {
           void transport.send(notification);
         });
-        transport.onmessage = async (message) => {
-          if (!("method" in message)) {
+        transport.onmessage = async (message2) => {
+          if (!("method" in message2)) {
             return;
           }
-          if (!("id" in message) || message.id === void 0) {
-            await server.handleMessage(message.method, message.params);
+          if (!("id" in message2) || message2.id === void 0) {
+            await server.handleMessage(message2.method, message2.params);
             return;
           }
-          const request = message;
-          const { result, error } = await server.handleMessage(
+          const request = message2;
+          const { result, error: error2 } = await server.handleMessage(
             request.method,
             request.params
           );
-          if (error) {
+          if (error2) {
             const response = {
               jsonrpc: "2.0",
               id: request.id,
-              error
+              error: error2
             };
             await transport.send(response);
           } else if (result !== void 0) {
@@ -3832,6 +4957,12 @@ function createServer(options) {
   };
   return server;
 }
+function isCallToolResult(value) {
+  if (typeof value !== "object" || value === null || !("content" in value)) {
+    return false;
+  }
+  return Array.isArray(value.content);
+}
 
 // packages/tiny-stdio-mcp-server/src/schema.ts
 function defineSchema(definition) {
@@ -3854,13 +4985,13 @@ function defineSchema(definition) {
 }
 
 // packages/memory/src/mcp.ts
-async function startMemoryMcpServer(opts) {
+async function startMemoryMcpServer(handle, opts) {
   const server = createServer({
     name: "poe-code-memory",
     version: "0.0.1"
   });
   server.tool("list_pages", "List memory pages.", defineSchema({}), async () => ({
-    pages: (await listPages(opts.root)).map((page) => ({
+    pages: (await handle.listPages()).map((page) => ({
       rel_path: page.relPath,
       description: page.frontmatter.description ?? ""
     }))
@@ -3870,7 +5001,7 @@ async function startMemoryMcpServer(opts) {
     "Read a memory page.",
     defineSchema({ rel_path: { type: "string" } }),
     async ({ rel_path }) => {
-      const page = await readPage(opts.root, rel_path);
+      const page = await handle.readPage(rel_path);
       return {
         rel_path: page.relPath,
         frontmatter: page.frontmatter,
@@ -3887,11 +5018,11 @@ async function startMemoryMcpServer(opts) {
       limit: { type: "number", optional: true }
     }),
     async ({ query, limit }) => {
-      const hits = await searchMemory(opts.root, query);
+      const hits = await handle.searchMemory(query);
       return { hits: typeof limit === "number" ? hits.slice(0, limit) : hits };
     }
   );
-  server.tool("status", "Show memory status.", defineSchema({}), async () => statusOf(opts.root));
+  server.tool("status", "Show memory status.", defineSchema({}), async () => handle.statusOf());
   if (opts.allowWrites) {
     server.tool(
       "append_to_page",
@@ -3902,7 +5033,7 @@ async function startMemoryMcpServer(opts) {
         reason: { type: "string" }
       }),
       async ({ rel_path, content, reason }) => ({
-        diff: await appendToPage(opts.root, rel_path, content, { reason })
+        diff: await handle.appendToPage(rel_path, content, { reason })
       })
     );
   }
@@ -3930,148 +5061,7 @@ function printMcpConfig() {
 
 // packages/agent-skill-config/src/configs.ts
 import os from "node:os";
-import path21 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-skill-config/src/configs.ts
+import path24 from "node:path";
 var agentSkillConfigs = {
   "claude-code": {
     globalSkillDir: "~/.claude/skills",
@@ -4105,7 +5095,7 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
 
 // packages/agent-skill-config/src/templates.ts
 import { readFile as readFile11, stat as stat5 } from "node:fs/promises";
-import path22 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/agent-skill-config/src/apply.ts
@@ -4238,7 +5228,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path23 from "node:path";
+import path26 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -4330,7 +5320,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path23.dirname(configPath);
+  return path26.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -4356,9 +5346,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path23.join(homeDir, configPath.slice(2));
+    return path26.join(homeDir, configPath.slice(2));
   }
-  return path23.join(homeDir, configPath.slice(1));
+  return path26.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -4391,7 +5381,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path23.dirname(absolutePath);
+  const configDir = path26.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -4569,7 +5559,7 @@ async function installMemory(options) {
 
 // packages/memory/src/query.ts
 import * as fs12 from "node:fs/promises";
-import path24 from "node:path";
+import path27 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -4583,18 +5573,11 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs12,
-    filePath: path24.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path27.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 spawnFn = options.spawnFn;
-  const result = await spawnFn?.(agentId, context.prompt) ?? {
-    answer: "",
-    citations: [],
-    tokensUsed: context.tokensUsed,
-    budget: options.budget,
-    exitCode: 0
-  };
+  const result = await spawn2(agentId, { prompt: context.prompt });
   return {
     answer: result.answer,
     citations: result.citations,
@@ -4605,7 +5588,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path24.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs12.readFile(path27.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -4635,8 +5618,8 @@ async function selectQueryContext(root, question, budget) {
 function rankPagesForQuery(pages, question) {
   const terms = tokenize(question);
   const documents = pages.map((page) => {
-    const text = [page.relPath, page.frontmatter.name ?? "", page.frontmatter.description ?? "", page.body].join("\n").toLowerCase();
-    const tokens = tokenize(text);
+    const text4 = [page.relPath, page.frontmatter.name ?? "", page.frontmatter.description ?? "", page.body].join("\n").toLowerCase();
+    const tokens = tokenize(text4);
     const counts = /* @__PURE__ */ new Map();
     for (const token of tokens) {
       counts.set(token, (counts.get(token) ?? 0) + 1);
@@ -4680,14 +5663,16 @@ function buildQueryPrompt(question, indexText, pages) {
 function renderPageContext(page) {
   return [`FILE: ${page.relPath}`, page.body].join("\n");
 }
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+function tokenize(text4) {
+  return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path24.resolve(root, "..", "..");
+  return path27.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
+import * as fs13 from "node:fs/promises";
+import path28 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -4708,18 +5693,18 @@ async function explainPage(root, options) {
   if (tokensUsed > options.budget) {
     throw new Error(`budget too small; needs at least ${tokensUsed} tokens`);
   }
-  const spawnFn = options.spawnFn;
-  const response = await queryMemory(root, {
-    question: `explain ${options.relPath}`,
-    budget: options.budget,
-    agent: options.agent,
-    spawnFn: spawnFn === void 0 ? void 0 : async (...args) => {
-      const [agent] = args;
-      return spawnFn(agent, prompt);
-    }
-  });
+  const configOptions = {
+    fs: fs13,
+    filePath: path28.join(inferRepoRoot3(root), "poe-code.json")
+  };
+  const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
+  const response = await spawn2(agentId, { prompt });
   return {
-    ...response,
+    answer: response.answer,
+    citations: response.citations,
+    tokensUsed: response.tokensUsed,
+    budget: options.budget,
+    exitCode: response.exitCode,
     inboundPages: relatedPages.filter((page) => page.relPath !== targetPage.relPath).filter((page) => (page.frontmatter.sources ?? []).some((source) => source.path === targetPage.relPath)).map((page) => page.relPath),
     outboundSources: targetPage.frontmatter.sources ?? []
   };
@@ -4751,23 +5736,59 @@ function buildExplainPrompt(targetRelPath, pages) {
 async function readPageIfPresent(root, relPath) {
   try {
     return await readPage(root, relPath);
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+  } catch (error2) {
+    if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT") {
       return void 0;
     }
-    throw error;
+    throw error2;
   }
 }
+function inferRepoRoot3(root) {
+  return path28.resolve(root, "..", "..");
+}
 
 // packages/memory/src/explain.cli.ts
 async function runMemoryExplain(input) {
   return explainPage(input.root, {
     relPath: input.relPath,
     budget: input.budget,
-    agent: input.agent,
-    spawnFn: input.spawnFn
+    agent: input.agent
   });
 }
+
+// packages/memory/src/handle.ts
+import path29 from "node:path";
+function openMemory(opts) {
+  if (!path29.isAbsolute(opts.root)) {
+    throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
+  }
+  const root = opts.root;
+  const defaultAgent = opts.agent;
+  return {
+    root,
+    listPages: async () => await listPages(root),
+    readPage: async (relPath) => await readPage(root, relPath),
+    searchMemory: async (query) => await searchMemory(root, query),
+    statusOf: async () => await statusOf(root),
+    computeTokenStats: async () => await computeTokenStats(root),
+    explainPage: async (options) => await explainPage(root, withDefaultAgent(options, defaultAgent)),
+    writePage: async (relPath, body, options) => await writePage(root, relPath, body, options),
+    appendToPage: async (relPath, content, options) => await appendToPage(root, relPath, content, options),
+    clearMemory: async () => await clearMemory(root),
+    query: async (options) => await queryMemory(root, withDefaultAgent(options, defaultAgent)),
+    ingest: async (options) => await ingest(root, withDefaultAgent(options, defaultAgent)),
+    auditClaims: async ({ repoRoot, ...options }) => await auditClaims(root, repoRoot, options)
+  };
+}
+function withDefaultAgent(options, agent) {
+  if (options.agent !== void 0 || agent === void 0) {
+    return options;
+  }
+  return {
+    ...options,
+    agent
+  };
+}
 export {
   INGEST_PROMPT_VERSION,
   MEMORY_ROOT_ENV_VAR,
@@ -4783,6 +5804,7 @@ export {
   initMemory,
   installMemory,
   listPages,
+  openMemory,
   parseClaims,
   printMcpConfig,
   queryMemory,