poe-code 3.0.224 → 3.0.225

package/packages/memory/dist/index.js

@@ -523,7 +523,7 @@ import path7 from "node:path";
 
 // packages/config-extends/src/discover.ts
 import path3 from "node:path";
-async function findBase(name, bases, fs16) {
+async function findBase(name, bases, fs17) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
@@ -531,7 +531,7 @@ async function findBase(name, bases, fs16) {
       checkedPaths.push(filePath);
       try {
         return {
-          content: await fs16.readFile(filePath, "utf8"),
+          content: await fs17.readFile(filePath, "utf8"),
           filePath
         };
       } catch (error2) {
@@ -611,11 +611,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path50) {
+function mergeObjectLayers(layers, path55) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path50);
+    const resolved = resolveKey(layers, key, path55);
     if (resolved === void 0) {
       continue;
     }
@@ -633,7 +633,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path50) {
+function resolveKey(layers, key, path55) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -663,9 +663,9 @@ function resolveKey(layers, key, path50) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path50, key);
+  const fullPath = buildPath(path55, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path50, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path55, key]);
     return {
       value: merged.data,
       sources: {
@@ -690,8 +690,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path50, key) {
-  return [...path50, key].join(".");
+function buildPath(path55, key) {
+  return [...path55, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -2079,16 +2079,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path50) {
-  const ext = getExtension(path50);
+function detectFormat2(path55) {
+  const ext = getExtension(path55);
   return extensionMap[ext];
 }
-function getExtension(path50) {
-  const lastDot = path50.lastIndexOf(".");
+function getExtension(path55) {
+  const lastDot = path55.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path50.slice(lastDot).toLowerCase();
+  return path55.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -2139,9 +2139,9 @@ function resolvePath(rawPath, homeDir, pathMapper) {
 function isNotFound(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
-async function readFileIfExists(fs16, target) {
+async function readFileIfExists(fs17, target) {
   try {
-    return await fs16.readFile(target, "utf8");
+    return await fs17.readFile(target, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -2149,9 +2149,9 @@ async function readFileIfExists(fs16, target) {
     throw error2;
   }
 }
-async function pathExists(fs16, target) {
+async function pathExists(fs17, target) {
   try {
-    await fs16.stat(target);
+    await fs17.stat(target);
     return true;
   } catch (error2) {
     if (isNotFound(error2)) {
@@ -2175,9 +2175,9 @@ function createInvalidDocumentBackupPath(targetPath) {
   const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
   return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs16, targetPath, content) {
+async function backupInvalidDocument(fs17, targetPath, content) {
   const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs16.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs17.writeFile(backupPath, content, { encoding: "utf8" });
 }
 function describeMutation(kind, targetPath) {
   const displayPath = targetPath ?? "target";
@@ -2735,12 +2735,12 @@ async function executeMutation(mutation, context, options) {
 }
 
 // packages/poe-code-config/src/store.ts
-async function readMergedDocument(fs16, globalPath, projectPath) {
-  const globalDocument = await readStoredDocument(fs16, globalPath);
+async function readMergedDocument(fs17, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs17, globalPath);
   if (!projectPath || projectPath === globalPath) {
     return globalDocument.data;
   }
-  const projectDocument = await readStoredDocument(fs16, projectPath);
+  const projectDocument = await readStoredDocument(fs17, projectPath);
   const resolved = await resolve(
     [
       {
@@ -2754,16 +2754,16 @@ async function readMergedDocument(fs16, globalPath, projectPath) {
       }
     ],
     {
-      fs: createResolvedConfigFs(fs16, globalPath, globalDocument.content),
+      fs: createResolvedConfigFs(fs17, globalPath, globalDocument.content),
       autoExtend: true
     }
   );
   return normalizeDocument(resolved.data);
 }
-async function readStoredDocument(fs16, filePath) {
+async function readStoredDocument(fs17, filePath) {
   try {
-    const raw = await fs16.readFile(filePath, "utf8");
-    return await parseStoredDocument(fs16, filePath, raw);
+    const raw = await fs17.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs17, filePath, raw);
   } catch (error2) {
     if (isNotFound(error2)) {
       return {
@@ -2774,7 +2774,7 @@ async function readStoredDocument(fs16, filePath) {
     throw error2;
   }
 }
-async function parseStoredDocument(fs16, filePath, raw) {
+async function parseStoredDocument(fs17, filePath, raw) {
   try {
     return {
       content: raw,
@@ -2782,7 +2782,7 @@ async function parseStoredDocument(fs16, filePath, raw) {
     };
   } catch (error2) {
     if (error2 instanceof SyntaxError) {
-      await recoverInvalidDocument(fs16, filePath, raw);
+      await recoverInvalidDocument(fs17, filePath, raw);
       return {
         content: EMPTY_DOCUMENT,
         data: {}
@@ -2816,21 +2816,21 @@ function normalizeScopeValues(value) {
   }
   return normalized;
 }
-function createResolvedConfigFs(fs16, globalPath, globalContent) {
+function createResolvedConfigFs(fs17, globalPath, globalContent) {
   return {
     readFile(filePath, _encoding) {
       if (filePath === globalPath) {
         return Promise.resolve(globalContent);
       }
-      return fs16.readFile(filePath, "utf8");
+      return fs17.readFile(filePath, "utf8");
     }
   };
 }
-async function recoverInvalidDocument(fs16, filePath, content) {
-  await fs16.mkdir(path7.dirname(filePath), { recursive: true });
+async function recoverInvalidDocument(fs17, filePath, content) {
+  await fs17.mkdir(path7.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
-  await fs16.writeFile(backupPath, content, { encoding: "utf8" });
-  await fs16.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+  await fs17.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs17.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
   const directory = path7.dirname(filePath);
@@ -2954,7 +2954,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path50 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path55 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key of keys) {
@@ -2966,20 +2966,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path50 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path50, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path55, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord3(baseValue) && isRecord3(overrideValue)) {
-      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path50, key]);
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path55, key]);
       continue;
     }
     merged[key] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path50) {
-  return path50.join(".") === "mounts" || path50.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path55) {
+  return path55.join(".") === "mounts" || path55.join(".") === "runner.workspace.exclude";
 }
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -3088,6 +3088,24 @@ var codexAgent = {
   }
 };
 
+// packages/agent-defs/src/agents/gemini-cli.ts
+var geminiCliAgent = {
+  id: "gemini-cli",
+  name: "gemini-cli",
+  aliases: ["gemini"],
+  label: "Gemini CLI",
+  summary: "Configure Google's Gemini CLI to use a compatible Google generations API.",
+  binaryName: "gemini",
+  configPath: "~/.gemini/settings.json",
+  apiShapes: ["google-generations"],
+  branding: {
+    colors: {
+      dark: "#8AB4F8",
+      light: "#1A73E8"
+    }
+  }
+};
+
 // packages/agent-defs/src/agents/opencode.ts
 var openCodeAgent = {
   id: "opencode",
@@ -3161,6 +3179,7 @@ var allAgents = [
   claudeCodeAgent,
   claudeDesktopAgent,
   codexAgent,
+  geminiCliAgent,
   openCodeAgent,
   kimiAgent,
   gooseAgent,
@@ -3357,6 +3376,7 @@ var poeProvider = {
   label: "Poe",
   summary: "Route AI coding agents through Poe's API.",
   baseUrl: "https://api.poe.com",
+  agentBaseUrl: "https://api.poe.com",
   auth: {
     kind: "api-key",
     envVar: "POE_API_KEY",
@@ -3364,6 +3384,12 @@ var poeProvider = {
     prompt: { title: "Poe API key" },
     preferredLogin: "oauth"
   },
+  env: {
+    ANTHROPIC_CUSTOM_HEADERS: {
+      kind: "providerCredential",
+      prefix: "Authorization: Bearer "
+    }
+  },
   apiShapes: [
     {
       id: "openai-chat-completions",
@@ -3392,6 +3418,9 @@ var anthropicProvider = {
     storageKey: "provider:anthropic",
     prompt: { title: "Anthropic API key" }
   },
+  env: {
+    ANTHROPIC_API_KEY: { kind: "providerCredential" }
+  },
   apiShapes: [
     {
       id: "anthropic-messages",
@@ -3414,6 +3443,12 @@ var cloudflareProvider = {
     storageKey: "provider:cloudflare",
     prompt: { title: "Cloudflare AI Gateway token" }
   },
+  env: {
+    ANTHROPIC_CUSTOM_HEADERS: {
+      kind: "providerCredential",
+      prefix: "Authorization: Bearer "
+    }
+  },
   apiShapes: [
     {
       id: "openai-chat-completions",
@@ -3509,17 +3544,17 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path50, flags) => fsPromises.open(path50, flags),
-    readFile: (path50, encoding) => fsPromises.readFile(path50, encoding),
+    open: (path55, flags) => fsPromises.open(path55, flags),
+    readFile: (path55, encoding) => fsPromises.readFile(path55, encoding),
     stat: fsPromises.stat,
     unlink: fsPromises.unlink
   };
 }
-async function removeLockFile(fs16, lockPath, signal) {
+async function removeLockFile(fs17, lockPath, signal) {
   for (let attempt = 0; attempt <= 4; attempt += 1) {
     throwIfAborted(signal);
     try {
-      await fs16.unlink(lockPath);
+      await fs17.unlink(lockPath);
       return;
     } catch (error2) {
       if (hasErrorCode(error2, "ENOENT")) {
@@ -3550,12 +3585,12 @@ function parseLockMetadata(content) {
   }
   return void 0;
 }
-async function readLockMetadata(fs16, lockPath) {
-  if (!fs16.readFile) {
+async function readLockMetadata(fs17, lockPath) {
+  if (!fs17.readFile) {
     return void 0;
   }
   try {
-    return parseLockMetadata(await fs16.readFile(lockPath, "utf8"));
+    return parseLockMetadata(await fs17.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode(error2, "ENOENT")) {
       return null;
@@ -3589,7 +3624,7 @@ async function writeLockMetadata(handle) {
   }
 }
 async function acquireFileLock(filePath, options = {}) {
-  const fs16 = options.fs ?? createDefaultFs();
+  const fs17 = options.fs ?? createDefaultFs();
   const retries = options.retries ?? 20;
   const minTimeout = options.minTimeout ?? 25;
   const maxTimeout = options.maxTimeout ?? 250;
@@ -3600,7 +3635,7 @@ async function acquireFileLock(filePath, options = {}) {
   while (attempt <= retries) {
     throwIfAborted(options.signal);
     try {
-      const handle = await fs16.open(lockPath, "wx");
+      const handle = await fs17.open(lockPath, "wx");
       await writeLockMetadata(handle);
       let released = false;
       return async () => {
@@ -3608,7 +3643,7 @@ async function acquireFileLock(filePath, options = {}) {
           return;
         }
         released = true;
-        await removeLockFile(fs16, lockPath, options.signal);
+        await removeLockFile(fs17, lockPath, options.signal);
       };
     } catch (error2) {
       if (!hasErrorCode(error2, "EEXIST")) {
@@ -3617,7 +3652,7 @@ async function acquireFileLock(filePath, options = {}) {
     }
     let stat7;
     try {
-      stat7 = await fs16.stat(lockPath);
+      stat7 = await fs17.stat(lockPath);
     } catch (statError) {
       if (hasErrorCode(statError, "ENOENT")) {
         continue;
@@ -3625,7 +3660,7 @@ async function acquireFileLock(filePath, options = {}) {
       throw statError;
     }
     const reclaimLock = await shouldReclaimLock({
-      fs: fs16,
+      fs: fs17,
       isPidRunning: pidIsRunning,
       lockPath,
       staleMs,
@@ -3635,7 +3670,7 @@ async function acquireFileLock(filePath, options = {}) {
       continue;
     }
     if (reclaimLock) {
-      await removeLockFile(fs16, lockPath, options.signal);
+      await removeLockFile(fs17, lockPath, options.signal);
       continue;
     }
     if (attempt >= retries) {
@@ -3655,7 +3690,7 @@ function isNotFoundError(error2) {
 }
 
 // packages/poe-code-config/src/state/jobs.ts
-function createJobRegistry(homeDir, fs16 = defaultStateFs) {
+function createJobRegistry(homeDir, fs17 = defaultStateFs) {
   const jobsDir = path10.join(homeDir, ".poe-code", "state", "jobs");
   function jobPath(id) {
     assertSafeJobId(id);
@@ -3663,7 +3698,7 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   }
   async function get(id) {
     try {
-      return parseJobEntry(await fs16.readFile(jobPath(id), "utf8"));
+      return parseJobEntry(await fs17.readFile(jobPath(id), "utf8"));
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return null;
@@ -3674,8 +3709,8 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   async function put(entry) {
     assertJobEntry(entry);
     const filePath = jobPath(entry.id);
-    await fs16.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs16 });
+    await fs17.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs17 });
     try {
       await writeJobAtomically(filePath, entry);
     } finally {
@@ -3684,8 +3719,8 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   }
   async function update(id, patch) {
     const filePath = jobPath(id);
-    await fs16.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs16 });
+    await fs17.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs17 });
     try {
       const current = await get(id);
       if (current === null) {
@@ -3706,7 +3741,7 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   async function list(filter = {}) {
     let entries;
     try {
-      entries = await fs16.readdir(jobsDir);
+      entries = await fs17.readdir(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return [];
@@ -3719,11 +3754,11 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
         continue;
       }
       const filePath = path10.join(jobsDir, entry);
-      const stat7 = await fs16.stat(filePath);
+      const stat7 = await fs17.stat(filePath);
       if (!stat7.isFile()) {
         continue;
       }
-      const job = parseJobEntry(await fs16.readFile(filePath, "utf8"));
+      const job = parseJobEntry(await fs17.readFile(filePath, "utf8"));
       if (matchesFilter(job, filter)) {
         jobs.push(job);
       }
@@ -3733,16 +3768,16 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   async function remove2(id) {
     const filePath = jobPath(id);
     try {
-      await fs16.stat(jobsDir);
+      await fs17.stat(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return;
       }
       throw error2;
     }
-    const release = await acquireFileLock(filePath, { fs: fs16 });
+    const release = await acquireFileLock(filePath, { fs: fs17 });
     try {
-      await fs16.unlink(filePath);
+      await fs17.unlink(filePath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -3752,14 +3787,14 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
     }
   }
   async function writeJobAtomically(filePath, entry) {
-    await fs16.mkdir(path10.dirname(filePath), { recursive: true });
+    await fs17.mkdir(path10.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
     try {
-      await fs16.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
+      await fs17.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
 `, {
         encoding: "utf8"
       });
-      await fs16.rename(tempPath, filePath);
+      await fs17.rename(tempPath, filePath);
     } catch (error2) {
       await removeTempFile(tempPath);
       throw error2;
@@ -3767,7 +3802,7 @@ function createJobRegistry(homeDir, fs16 = defaultStateFs) {
   }
   async function removeTempFile(tempPath) {
     try {
-      await fs16.unlink(tempPath);
+      await fs17.unlink(tempPath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -3814,11 +3849,11 @@ function isRecord4(value) {
 
 // packages/poe-code-config/src/state/templates.ts
 import path11 from "node:path";
-function createTemplateRegistry(homeDir, fs16 = defaultStateFs) {
+function createTemplateRegistry(homeDir, fs17 = defaultStateFs) {
   const filePath = path11.join(homeDir, ".poe-code", "state", "templates.json");
   async function readState() {
     try {
-      const raw = await fs16.readFile(filePath, "utf8");
+      const raw = await fs17.readFile(filePath, "utf8");
       return normalizeTemplateState(JSON.parse(raw));
     } catch (error2) {
       if (isNotFoundError(error2)) {
@@ -3828,14 +3863,14 @@ function createTemplateRegistry(homeDir, fs16 = defaultStateFs) {
     }
   }
   async function writeState(state) {
-    await fs16.writeFile(filePath, `${JSON.stringify(state, null, 2)}
+    await fs17.writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, {
       encoding: "utf8"
     });
   }
   async function updateState(mutator) {
-    await fs16.mkdir(path11.dirname(filePath), { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs16 });
+    await fs17.mkdir(path11.dirname(filePath), { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs17 });
     try {
       const state = await readState();
       mutator(state);
@@ -3905,10 +3940,10 @@ function isRecord5(value) {
 }
 
 // packages/poe-code-config/src/state/index.ts
-function createStateManager(homeDir, fs16) {
+function createStateManager(homeDir, fs17) {
   return {
-    templates: createTemplateRegistry(homeDir, fs16),
-    jobs: createJobRegistry(homeDir, fs16)
+    templates: createTemplateRegistry(homeDir, fs17),
+    jobs: createJobRegistry(homeDir, fs17)
   };
 }
 
@@ -4136,10 +4171,10 @@ function parseSources(value) {
     if (!isRecord6(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path50 = readRequiredString(item.path, "sources[].path");
+    const path55 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path50, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path55, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -4381,18 +4416,18 @@ function isPidRunning2(pid) {
     return !hasErrorCode3(error2, "ESRCH");
   }
 }
-async function removeLockFile2(fs16, lockPath) {
+async function removeLockFile2(fs17, lockPath) {
   try {
-    await fs16.unlink(lockPath);
+    await fs17.unlink(lockPath);
   } catch (error2) {
     if (!hasErrorCode3(error2, "ENOENT")) {
       throw error2;
     }
   }
 }
-async function readLockPid(fs16, lockPath) {
+async function readLockPid(fs17, lockPath) {
   try {
-    return parsePid(await fs16.readFile(lockPath, "utf8"));
+    return parsePid(await fs17.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode3(error2, "ENOENT")) {
       return null;
@@ -4401,7 +4436,7 @@ async function readLockPid(fs16, lockPath) {
   }
 }
 async function withLock(root, run, options = {}) {
-  const fs16 = options.fs ?? createDefaultFs2();
+  const fs17 = options.fs ?? createDefaultFs2();
   const lockPath = path17.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
@@ -4410,24 +4445,24 @@ async function withLock(root, run, options = {}) {
   const pidIsRunning = options.isPidRunning ?? isPidRunning2;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
     try {
-      await fs16.writeFile(lockPath, `${pid}
+      await fs17.writeFile(lockPath, `${pid}
 `, { encoding: "utf8", flag: "wx" });
       try {
         return await run();
       } finally {
-        await removeLockFile2(fs16, lockPath);
+        await removeLockFile2(fs17, lockPath);
       }
     } catch (error2) {
       if (!hasErrorCode3(error2, "EEXIST")) {
         throw error2;
       }
     }
-    const existingPid = await readLockPid(fs16, lockPath);
+    const existingPid = await readLockPid(fs17, lockPath);
     if (existingPid === null) {
       continue;
     }
     if (existingPid === void 0 || !pidIsRunning(existingPid)) {
-      await removeLockFile2(fs16, lockPath);
+      await removeLockFile2(fs17, lockPath);
       continue;
     }
     if (attempt < retries) {
@@ -5194,8 +5229,8 @@ function parseOlderThan(value) {
 }
 
 // packages/memory/src/ingest.ts
-import * as fs13 from "node:fs/promises";
-import path45 from "node:path";
+import * as fs14 from "node:fs/promises";
+import path50 from "node:path";
 
 // packages/agent-spawn/src/register-factories.ts
 import { spawn as spawnChildProcess2 } from "node:child_process";
@@ -6031,29 +6066,29 @@ function wrapForLogTee(argv, jobId) {
   return ["sh", "-c", script];
 }
 async function* streamLogFile(env, jobId, opts) {
-  const fs16 = env.fs ?? nodeFs2;
+  const fs17 = env.fs ?? nodeFs2;
   const file = jobLogPath(jobId);
   let byteOffset = opts.sinceByte ?? 0;
   while (true) {
-    if (opts.since !== void 0 && !await wasModifiedSince(fs16, file, opts.since)) {
-      await waitForLogChange(fs16, file);
+    if (opts.since !== void 0 && !await wasModifiedSince(fs17, file, opts.since)) {
+      await waitForLogChange(fs17, file);
       continue;
     }
-    const result = await readLogChunk(fs16, file, byteOffset);
+    const result = await readLogChunk(fs17, file, byteOffset);
     if (result !== null) {
       byteOffset = result.nextByteOffset;
       yield result.chunk;
       continue;
     }
-    await waitForLogChange(fs16, file);
+    await waitForLogChange(fs17, file);
   }
 }
-async function wasModifiedSince(fs16, file, since) {
-  if (fs16.promises.stat === void 0) {
+async function wasModifiedSince(fs17, file, since) {
+  if (fs17.promises.stat === void 0) {
     return true;
   }
   try {
-    const stat7 = await fs16.promises.stat(file);
+    const stat7 = await fs17.promises.stat(file);
     return stat7.mtimeMs >= since.getTime();
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -6063,11 +6098,11 @@ async function wasModifiedSince(fs16, file, since) {
   }
 }
 async function waitForExit(env, jobId, opts = {}) {
-  const fs16 = env.fs ?? nodeFs2;
+  const fs17 = env.fs ?? nodeFs2;
   const file = jobExitPath(jobId);
   while (true) {
     throwIfAborted2(opts.signal);
-    const contents = await readTextFileIfExists(fs16, file);
+    const contents = await readTextFileIfExists(fs17, file);
     if (contents !== null) {
       const text5 = contents.trim();
       const exitCode = Number(text5);
@@ -6085,8 +6120,8 @@ function jobLogPath(jobId) {
 function jobExitPath(jobId) {
   return `${JOB_DIR}/${jobId}.exit`;
 }
-async function readLogChunk(fs16, file, byteOffset) {
-  const contents = await readFileIfExists2(fs16, file);
+async function readLogChunk(fs17, file, byteOffset) {
+  const contents = await readFileIfExists2(fs17, file);
   if (contents === null || byteOffset >= contents.byteLength) {
     return null;
   }
@@ -6098,13 +6133,13 @@ async function readLogChunk(fs16, file, byteOffset) {
     nextByteOffset: contents.byteLength
   };
 }
-async function readTextFileIfExists(fs16, file) {
-  const contents = await readFileIfExists2(fs16, file);
+async function readTextFileIfExists(fs17, file) {
+  const contents = await readFileIfExists2(fs17, file);
   return contents?.toString("utf8") ?? null;
 }
-async function readFileIfExists2(fs16, file) {
+async function readFileIfExists2(fs17, file) {
   try {
-    const contents = await fs16.promises.readFile(file);
+    const contents = await fs17.promises.readFile(file);
     return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -6113,8 +6148,8 @@ async function readFileIfExists2(fs16, file) {
     throw error2;
   }
 }
-async function waitForLogChange(fs16, file) {
-  const watch = fs16.watch;
+async function waitForLogChange(fs17, file) {
+  const watch = fs17.watch;
   if (typeof watch !== "function") {
     await sleep3(POLL_INTERVAL_MS);
     return;
@@ -6905,7 +6940,7 @@ import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream"
 import path33 from "node:path";
 var JOB_DIR2 = "/tmp/poe-jobs";
 function createE2bJobHandle(input) {
-  const fs16 = createE2bLogStreamFs(input.sandbox);
+  const fs17 = createE2bLogStreamFs(input.sandbox);
   return {
     id: input.jobId,
     envId: input.envId,
@@ -6921,10 +6956,10 @@ function createE2bJobHandle(input) {
       return isRunning ? "running" : "lost";
     },
     stream(opts = {}) {
-      return streamLogFile({ fs: fs16 }, input.jobId, opts);
+      return streamLogFile({ fs: fs17 }, input.jobId, opts);
     },
     async wait() {
-      const result = await waitForExit({ fs: fs16 }, input.jobId);
+      const result = await waitForExit({ fs: fs17 }, input.jobId);
       const preserveMs = input.preserveAfterExitHours * 60 * 60 * 1e3;
       if (preserveMs > 0) {
         await input.sandbox.setTimeout(preserveMs);
@@ -7421,10 +7456,10 @@ var e2bAuthScope = defineScope("e2b", {
 });
 async function resolveE2bApiKey(input) {
   const homeDir = input.homeDir ?? os4.homedir();
-  const fs16 = input.fs ?? nodeFs4;
+  const fs17 = input.fs ?? nodeFs4;
   const env = input.env ?? process.env;
   const document = await readMergedDocument(
-    fs16,
+    fs17,
     resolveConfigPath(homeDir),
     resolveProjectConfigPath(input.cwd)
   );
@@ -7931,6 +7966,23 @@ var gooseAcpSpawnConfig = {
   skipAuth: true
 };
 
+// packages/agent-spawn/src/configs/gemini-cli.ts
+var geminiCliAcpSpawnConfig = {
+  kind: "acp",
+  agentId: "gemini-cli",
+  acpArgs: ({ model, mcpServers }) => [
+    "--acp",
+    ...model ? ["--model", model] : [],
+    ...mcpServers ? ["--allowed-mcp-server-names", Object.keys(mcpServers).join(",")] : [],
+    ...mcpServers ? ["--skip-trust"] : [],
+    "--yolo"
+  ],
+  env: {
+    GEMINI_SANDBOX: "false"
+  },
+  skipAuth: true
+};
+
 // packages/agent-spawn/src/configs/index.ts
 var allSpawnConfigs = [
   claudeCodeSpawnConfig,
@@ -7947,6 +7999,7 @@ var acpLookup = /* @__PURE__ */ new Map();
 acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
 acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
 acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
+acpLookup.set(geminiCliAcpSpawnConfig.agentId, geminiCliAcpSpawnConfig);
 function getSpawnConfig(input) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
@@ -7966,8 +8019,8 @@ function listMcpSupportedAgents() {
 }
 
 // packages/agent-spawn/src/spawn.ts
-import { mkdirSync as mkdirSync3, openSync, writeSync, closeSync } from "node:fs";
-import path41 from "node:path";
+import { mkdirSync as mkdirSync5, openSync as openSync2, writeSync, closeSync as closeSync2 } from "node:fs";
+import path46 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -8368,7 +8421,7 @@ function createEventQueue() {
 
 // packages/agent-spawn/src/skill-bridge.ts
 import crypto from "node:crypto";
-import os6 from "node:os";
+import os7 from "node:os";
 
 // packages/agent-skill-config/src/configs.ts
 import os5 from "node:os";
@@ -8382,6 +8435,10 @@ var agentSkillConfigs = {
     globalSkillDir: "~/.codex/skills",
     localSkillDir: ".codex/skills"
   },
+  "gemini-cli": {
+    globalSkillDir: "~/.gemini/skills",
+    localSkillDir: ".gemini/skills"
+  },
   opencode: {
     globalSkillDir: "~/.config/opencode/skills",
     localSkillDir: ".opencode/skills"
@@ -8578,7 +8635,7 @@ function resolveSkillReference(ref, cwd, homeDir) {
 import { execFileSync } from "node:child_process";
 import * as fs10 from "node:fs";
 import path39 from "node:path";
-var markerPrefix = "# poe-code-spawn-skills:";
+var defaultMarkerPrefix = "poe-code-spawn-skills";
 function defaultGitDirRunner(cwd) {
   try {
     return execFileSync("git", ["rev-parse", "--git-dir"], {
@@ -8598,10 +8655,10 @@ function resolveExcludePath(cwd) {
   }
   return path39.join(path39.isAbsolute(gitDir) ? gitDir : path39.resolve(cwd, gitDir), "info/exclude");
 }
-function markers(runId) {
+function markers(runId, markerPrefix) {
   return {
-    begin: `${markerPrefix}${runId} begin`,
-    end: `${markerPrefix}${runId} end`
+    begin: `# ${markerPrefix}:${runId} begin`,
+    end: `# ${markerPrefix}:${runId} end`
   };
 }
 function readExcludeFile(excludePath) {
@@ -8617,8 +8674,8 @@ function readExcludeFile(excludePath) {
 function isNodeError2(error2) {
   return error2 instanceof Error && "code" in error2;
 }
-function removeBlock(content, runId) {
-  const { begin, end } = markers(runId);
+function removeBlock(content, runId, markerPrefix) {
+  const { begin, end } = markers(runId, markerPrefix);
   const lines = content.split("\n");
   const result = [];
   for (let index = 0; index < lines.length; index += 1) {
@@ -8633,23 +8690,27 @@ function removeBlock(content, runId) {
   }
   return result.join("\n");
 }
-function appendBlock(content, runId, entries) {
-  const { begin, end } = markers(runId);
+function appendBlock(content, runId, entries, markerPrefix) {
+  const { begin, end } = markers(runId, markerPrefix);
   const existing = content ?? "";
   const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}
 `;
   return `${prefix}${[begin, ...entries, end, ""].join("\n")}`;
 }
-function appendExcludeBlock(cwd, runId, entries) {
+function appendExcludeBlock(cwd, runId, entries, opts) {
   const excludePath = resolveExcludePath(cwd);
   if (excludePath === void 0) {
     return;
   }
   fs10.mkdirSync(path39.dirname(excludePath), { recursive: true });
   const content = readExcludeFile(excludePath);
-  fs10.writeFileSync(excludePath, appendBlock(content, runId, entries), "utf8");
+  fs10.writeFileSync(
+    excludePath,
+    appendBlock(content, runId, entries, opts?.markerPrefix ?? defaultMarkerPrefix),
+    "utf8"
+  );
 }
-function removeExcludeBlock(cwd, runId) {
+function removeExcludeBlock(cwd, runId, opts) {
   const excludePath = resolveExcludePath(cwd);
   if (excludePath === void 0) {
     return;
@@ -8658,7 +8719,11 @@ function removeExcludeBlock(cwd, runId) {
   if (content === void 0) {
     return;
   }
-  fs10.writeFileSync(excludePath, removeBlock(content, runId), "utf8");
+  fs10.writeFileSync(
+    excludePath,
+    removeBlock(content, runId, opts?.markerPrefix ?? defaultMarkerPrefix),
+    "utf8"
+  );
 }
 
 // packages/agent-skill-config/src/bridge-active-skills.ts
@@ -8864,22 +8929,679 @@ function cleanupBridgedSkills(manifest) {
   removeExcludeBlock(manifest.cwd, manifest.runId);
 }
 
+// packages/agent-hook-config/src/configs.ts
+import os6 from "node:os";
+import path41 from "node:path";
+var agentHookConfigs = {
+  "claude-code": {
+    globalHookPath: "~/.claude/settings.json",
+    localHookPath: ".claude/settings.json",
+    format: "claude-settings-json",
+    supportedEvents: [
+      "SessionStart",
+      "SessionEnd",
+      "UserPromptSubmit",
+      "PreToolUse",
+      "PostToolUse",
+      "PermissionRequest",
+      "Stop",
+      "StopFailure",
+      "Notification",
+      "PreCompact",
+      "PostCompact",
+      "SubagentStart",
+      "SubagentStop"
+    ],
+    supportedHandlerTypes: ["command", "http", "mcp_tool", "prompt", "agent"],
+    placeholders: {
+      projectDir: "${CLAUDE_PROJECT_DIR}",
+      pluginRoot: "${CLAUDE_PLUGIN_ROOT}",
+      pluginData: "${CLAUDE_PLUGIN_DATA}"
+    }
+  },
+  codex: {
+    globalHookPath: "~/.codex/hooks.json",
+    localHookPath: ".codex/hooks.json",
+    format: "codex-hooks-json",
+    supportedEvents: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PreToolUse",
+      "PostToolUse",
+      "PermissionRequest",
+      "Stop"
+    ],
+    supportedHandlerTypes: ["command"],
+    placeholders: {
+      projectDir: "$(git rev-parse --show-toplevel)",
+      pluginRoot: "$PLUGIN_ROOT",
+      pluginData: "$PLUGIN_DATA"
+    }
+  }
+};
+var supportedHookAgents = Object.keys(agentHookConfigs);
+function resolveAgentSupport2(input, registry = agentHookConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config = registry[resolvedId];
+  if (!config) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config };
+}
+function getAgentConfig2(agentId) {
+  const support = resolveAgentSupport2(agentId);
+  return support.status === "supported" ? support.config : void 0;
+}
+function expandHome3(targetPath, homeDir = os6.homedir()) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath === "~") {
+    return homeDir;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path41.join(homeDir, remainder);
+}
+function resolveHookPath(config, scope, cwd, homeDir) {
+  if (scope === "global") {
+    return path41.resolve(expandHome3(config.globalHookPath, homeDir));
+  }
+  return config.localHookPath ? path41.resolve(cwd, config.localHookPath) : void 0;
+}
+
+// packages/agent-hook-config/src/read-hooks.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path42 from "node:path";
+function readSettingsFile(filePath) {
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf8");
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return void 0;
+    }
+    throw error2;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error2) {
+    throw new Error(`Malformed JSON in ${filePath}`, { cause: error2 });
+  }
+}
+function readClaudeHooks(cwd, homeDir, opts) {
+  const projectPath = path42.resolve(cwd, ".claude/settings.json");
+  const userPath = path42.resolve(homeDir, ".claude/settings.json");
+  const scope = opts?.scope ?? "merged";
+  const sourcePaths = scope === "project" ? [projectPath] : scope === "user" ? [userPath] : [userPath, projectPath];
+  const result = { entries: [], readPaths: [] };
+  for (const sourcePath of sourcePaths) {
+    const settings = readSettingsFile(sourcePath);
+    if (settings === void 0) {
+      continue;
+    }
+    result.readPaths.push(sourcePath);
+    for (const [event, groups] of Object.entries(settings.hooks ?? {})) {
+      for (const group of groups) {
+        for (const handler of group.hooks) {
+          result.entries.push({ event, matcher: group.matcher, handler });
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// packages/agent-hook-config/src/event-mapping.ts
+function requireAgentConfig(agentId) {
+  const config = getAgentConfig2(agentId);
+  if (!config) {
+    throw new Error(`Unknown hook agent "${agentId}"`);
+  }
+  return config;
+}
+function getEventMappings(sourceAgentId, targetAgentId) {
+  const source = requireAgentConfig(sourceAgentId);
+  const target = requireAgentConfig(targetAgentId);
+  return source.supportedEvents.map((sourceEvent) => {
+    if (target.supportedEvents.includes(sourceEvent)) {
+      return { sourceEvent, targetEvent: sourceEvent };
+    }
+    return {
+      sourceEvent,
+      targetEvent: null,
+      dropReason: `${targetAgentId} has no ${sourceEvent} hook`
+    };
+  });
+}
+function getHandlerTypeRules(targetAgentId) {
+  const target = requireAgentConfig(targetAgentId);
+  const registeredTypes = supportedHookAgents.flatMap(
+    (agentId) => requireAgentConfig(agentId).supportedHandlerTypes
+  );
+  const sourceTypes = [...new Set(registeredTypes)];
+  const supportedTypes = target.supportedHandlerTypes.map((handlerType) => `"${handlerType}"`).join(", ");
+  return sourceTypes.map((sourceType) => {
+    if (target.supportedHandlerTypes.includes(sourceType)) {
+      return { sourceType, allowed: true };
+    }
+    return {
+      sourceType,
+      allowed: false,
+      dropReason: `${targetAgentId} only honors handlers of type ${supportedTypes}`
+    };
+  });
+}
+function getPlaceholderRewrites(sourceAgentId, targetAgentId) {
+  const source = requireAgentConfig(sourceAgentId);
+  const target = requireAgentConfig(targetAgentId);
+  return Object.keys(source.placeholders).flatMap((key) => {
+    const from = source.placeholders[key];
+    const to = target.placeholders[key];
+    if (!from || !to || from === to) {
+      return [];
+    }
+    return [{ from, to }];
+  });
+}
+
+// packages/agent-hook-config/src/transform-hooks.ts
+function applyPlaceholderRewrites(value, rewrites) {
+  return rewrites.reduce((rewrittenValue, rewrite) => {
+    return rewrittenValue.replaceAll(rewrite.from, rewrite.to);
+  }, value);
+}
+function transformHooks(source, sourceAgentId, targetAgentId, opts) {
+  const eventMappings = getEventMappings(sourceAgentId, targetAgentId);
+  const handlerRules = getHandlerTypeRules(targetAgentId);
+  const placeholderRewrites = getPlaceholderRewrites(sourceAgentId, targetAgentId);
+  const result = { entries: [], drops: [] };
+  for (const sourceEntry of source) {
+    const eventMapping = eventMappings.find((mapping) => mapping.sourceEvent === sourceEntry.event);
+    if (!eventMapping || eventMapping.targetEvent === null) {
+      result.drops.push({
+        reason: "unsupported-event",
+        detail: eventMapping?.dropReason ?? `${targetAgentId} has no ${sourceEntry.event} hook`,
+        source: sourceEntry
+      });
+      continue;
+    }
+    const handlerRule = handlerRules.find((rule) => rule.sourceType === sourceEntry.handler.type);
+    if (!handlerRule?.allowed) {
+      result.drops.push({
+        reason: "unsupported-handler-type",
+        detail: `Unsupported handler type "${sourceEntry.handler.type}": ${handlerRule?.dropReason ?? `${targetAgentId} does not honor it`}`,
+        source: sourceEntry
+      });
+      continue;
+    }
+    const handler = {
+      type: "command",
+      command: applyPlaceholderRewrites(sourceEntry.handler.command ?? "", placeholderRewrites),
+      statusMessage: `[generated:${opts.runId}] ${sourceEntry.handler.statusMessage ?? ""}`
+    };
+    if (sourceEntry.handler.args !== void 0) {
+      handler.args = sourceEntry.handler.args.map(
+        (arg) => applyPlaceholderRewrites(arg, placeholderRewrites)
+      );
+    }
+    if (sourceEntry.handler.timeout !== void 0) {
+      handler.timeout = sourceEntry.handler.timeout;
+    }
+    result.entries.push({
+      event: eventMapping.targetEvent,
+      matcher: sourceEntry.matcher,
+      handler,
+      generatedId: `generated-${opts.runId}-${result.entries.length}`
+    });
+  }
+  return result;
+}
+
+// packages/agent-hook-config/src/write-hooks.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path43 from "node:path";
+function isGeneratedHandler(handler) {
+  return handler.statusMessage?.startsWith("[generated:") ?? false;
+}
+function parseHooksFile(targetPath) {
+  let content;
+  try {
+    content = readFileSync4(targetPath, "utf8");
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return { file: { hooks: {} }, fileCreated: true };
+    }
+    throw error2;
+  }
+  try {
+    return { file: JSON.parse(content), fileCreated: false };
+  } catch (error2) {
+    throw new Error(`Malformed JSON in ${targetPath}`, { cause: error2 });
+  }
+}
+function validateEntries(entries) {
+  for (const entry of entries) {
+    if (!isGeneratedHandler(entry.handler)) {
+      throw new Error(
+        `Generated hook entry "${entry.generatedId}" has statusMessage that must start with "[generated:"`
+      );
+    }
+  }
+}
+function removeGeneratedHandlers(file) {
+  let removed = 0;
+  const hooks = file.hooks ?? (file.hooks = {});
+  for (const [event, groups] of Object.entries(hooks)) {
+    hooks[event] = groups.filter((group) => {
+      const initialCount = group.hooks.length;
+      const remainingHandlers = group.hooks.filter((handler) => {
+        if (isGeneratedHandler(handler)) {
+          removed += 1;
+          return false;
+        }
+        return true;
+      });
+      group.hooks = remainingHandlers;
+      return group.hooks.length > 0 || group.hooks.length === initialCount;
+    });
+  }
+  return removed;
+}
+function appendEntries(file, entries) {
+  const hooks = file.hooks ?? (file.hooks = {});
+  for (const entry of entries) {
+    const groups = hooks[entry.event] ?? (hooks[entry.event] = []);
+    let group = groups.find((candidate) => candidate.matcher === entry.matcher);
+    if (!group) {
+      group = entry.matcher === void 0 ? { hooks: [] } : { matcher: entry.matcher, hooks: [] };
+      groups.push(group);
+    }
+    group.hooks.push(entry.handler);
+  }
+}
+function writeCodexHooks(targetPath, entries, _runId) {
+  const { file, fileCreated } = parseHooksFile(targetPath);
+  validateEntries(entries);
+  const previousGeneratedRemoved = removeGeneratedHandlers(file);
+  appendEntries(file, entries);
+  mkdirSync3(path43.dirname(targetPath), { recursive: true });
+  const temporaryPath = `${targetPath}.tmp`;
+  writeFileSync2(temporaryPath, `${JSON.stringify(file, null, 2)}
+`);
+  renameSync(temporaryPath, targetPath);
+  return {
+    path: targetPath,
+    fileCreated,
+    previousGeneratedRemoved,
+    generatedWritten: entries.length
+  };
+}
+
+// packages/agent-hook-config/src/symlink-hooks.ts
+import {
+  closeSync,
+  lstatSync,
+  mkdirSync as mkdirSync4,
+  openSync,
+  readlinkSync,
+  readSync,
+  symlinkSync,
+  unlinkSync
+} from "node:fs";
+import path44 from "node:path";
+function requireAgentConfig2(agentId) {
+  const config = getAgentConfig2(agentId);
+  if (!config) {
+    throw new Error(`No hook configuration found for agent "${agentId}"`);
+  }
+  return config;
+}
+function resolveScopedPath(config, agentId, cwd, homeDir, scope) {
+  const targetPath = resolveHookPath(
+    config,
+    scope === "project" ? "local" : "global",
+    cwd,
+    homeDir
+  );
+  if (!targetPath) {
+    throw new Error(`Agent "${agentId}" has no ${scope} hook path`);
+  }
+  return targetPath;
+}
+function readFirstKilobyte(filePath) {
+  const descriptor = openSync(filePath, "r");
+  const buffer = Buffer.alloc(1024);
+  try {
+    const length = readSync(descriptor, buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, length);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFullyGeneratedFile(filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFirstKilobyte(filePath));
+  } catch {
+    return false;
+  }
+  if (!isRecord8(parsed)) {
+    return false;
+  }
+  if (Object.keys(parsed).some((key) => key !== "hooks")) {
+    return false;
+  }
+  const hooks = parsed.hooks;
+  if (!isRecord8(hooks)) {
+    return false;
+  }
+  let handlerFound = false;
+  for (const groups of Object.values(hooks)) {
+    if (!Array.isArray(groups)) {
+      return false;
+    }
+    for (const group of groups) {
+      if (!isRecord8(group) || !Array.isArray(group.hooks)) {
+        return false;
+      }
+      for (const handler of group.hooks) {
+        if (!isRecord8(handler)) {
+          return false;
+        }
+        handlerFound = true;
+        const statusMessage = handler.statusMessage;
+        if (typeof statusMessage !== "string" || !statusMessage.startsWith("[generated:")) {
+          return false;
+        }
+      }
+    }
+  }
+  return handlerFound;
+}
+function symlinkHooks(sourceAgentId, targetAgentId, cwd, homeDir, scope) {
+  const source = requireAgentConfig2(sourceAgentId);
+  const target = requireAgentConfig2(targetAgentId);
+  if (source.format !== target.format) {
+    throw new Error(
+      `Cannot symlink hook formats "${source.format}" and "${target.format}"; use transformation instead`
+    );
+  }
+  const targetPath = resolveScopedPath(source, sourceAgentId, cwd, homeDir, scope);
+  const symlinkPath = resolveScopedPath(target, targetAgentId, cwd, homeDir, scope);
+  let replaced = "none";
+  try {
+    const existing = lstatSync(symlinkPath);
+    if (existing.isSymbolicLink()) {
+      if (readlinkSync(symlinkPath) === targetPath) {
+        return { symlinkPath, targetPath, replaced };
+      }
+      unlinkSync(symlinkPath);
+      replaced = "stale-symlink";
+    } else if (existing.isFile() && isFullyGeneratedFile(symlinkPath)) {
+      unlinkSync(symlinkPath);
+      replaced = "generated-file";
+    } else {
+      throw new Error(`Refuse to replace user-authored hook file at ${symlinkPath}`);
+    }
+  } catch (error2) {
+    if (error2.code !== "ENOENT") {
+      throw error2;
+    }
+  }
+  mkdirSync4(path44.dirname(symlinkPath), { recursive: true });
+  symlinkSync(targetPath, symlinkPath);
+  return { symlinkPath, targetPath, replaced };
+}
+
+// packages/agent-hook-config/src/bridge-hooks.ts
+import * as fs12 from "node:fs";
+import path45 from "node:path";
+var hookExcludeMarkerPrefix = "poe-code-spawn-hooks";
+function isNodeError4(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+function pathExists4(targetPath) {
+  try {
+    fs12.lstatSync(targetPath);
+    return true;
+  } catch (error2) {
+    if (isNodeError4(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function collectMissingParents2(targetPath) {
+  const parents = [];
+  let current = path45.dirname(targetPath);
+  while (!pathExists4(current)) {
+    parents.push(current);
+    const parent = path45.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return parents.reverse();
+}
+function removeDirectoryIfEmpty2(targetPath) {
+  try {
+    fs12.rmdirSync(targetPath);
+  } catch (error2) {
+    if (isNodeError4(error2) && (error2.code === "ENOENT" || error2.code === "ENOTEMPTY" || error2.code === "EEXIST")) {
+      return;
+    }
+    throw error2;
+  }
+}
+function requireSupport(input, role) {
+  const support = resolveAgentSupport2(input);
+  if (support.status !== "supported" || !support.id || !support.config) {
+    throw new Error(
+      `Unsupported ${role} hook agent "${input}". Supported hook agents: ${supportedHookAgents.join(", ")}.`
+    );
+  }
+  return { id: support.id, config: support.config };
+}
+function requireTargetPath(targetId, config, cwd, homeDir) {
+  const targetPath = resolveHookPath(config, "local", cwd, homeDir);
+  if (!targetPath) {
+    throw new Error(`Agent "${targetId}" has no project hook path`);
+  }
+  return targetPath;
+}
+function readCodexFile(targetPath) {
+  let content;
+  try {
+    content = fs12.readFileSync(targetPath, "utf8");
+  } catch (error2) {
+    if (isNodeError4(error2) && error2.code === "ENOENT") {
+      return void 0;
+    }
+    throw error2;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error2) {
+    throw new Error(`Malformed JSON in ${targetPath}`, { cause: error2 });
+  }
+}
+function writeCodexFile(targetPath, file) {
+  fs12.writeFileSync(targetPath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+function hasOnlyEmptyHooks(file) {
+  return Object.keys(file).every((key) => key === "hooks") && Object.values(file.hooks ?? {}).every((groups) => groups.length === 0);
+}
+function relativeToCwd(cwd, targetPath) {
+  return path45.relative(cwd, targetPath);
+}
+function matcherKey(event, matcher) {
+  return `${event}\0${matcher === void 0 ? "<undefined>" : matcher}`;
+}
+function bridgeHooks(sourceAgentId, targetAgentId, cwd, homeDir, runId, opts) {
+  const source = requireSupport(sourceAgentId, "source");
+  const target = requireSupport(targetAgentId, "target");
+  const strategy = opts?.strategy ?? (source.config.format === target.config.format ? "symlink" : "transform");
+  const manifest = {
+    sourceAgentId,
+    targetAgentId,
+    cwd,
+    runId,
+    strategy,
+    drops: []
+  };
+  if (strategy === "symlink") {
+    const symlinkPath = requireTargetPath(target.id, target.config, cwd, homeDir);
+    manifest.createdParents = collectMissingParents2(symlinkPath);
+    const result = symlinkHooks(source.id, target.id, cwd, homeDir, "project");
+    manifest.symlinkPath = result.symlinkPath;
+    manifest.symlinkTarget = result.targetPath;
+    manifest.symlinkReplaced = result.replaced;
+    appendExcludeBlock(cwd, runId, [relativeToCwd(cwd, result.symlinkPath)], {
+      markerPrefix: hookExcludeMarkerPrefix
+    });
+    return manifest;
+  }
+  if (source.id !== "claude-code") {
+    throw new Error(`Transforming hooks from "${source.id}" is not supported yet`);
+  }
+  if (target.config.format !== "codex-hooks-json") {
+    throw new Error(
+      `Transforming hooks to "${target.id}" is not supported yet; only codex-hook targets can be written`
+    );
+  }
+  const targetPath = requireTargetPath(target.id, target.config, cwd, homeDir);
+  const priorFile = readCodexFile(targetPath);
+  const sourceHooks = readClaudeHooks(cwd, homeDir, { scope: opts?.scope ?? "merged" });
+  const transformed = transformHooks(sourceHooks.entries, source.id, target.id, { runId });
+  const createdParents = collectMissingParents2(targetPath);
+  const writeResult = writeCodexHooks(targetPath, transformed.entries, runId);
+  manifest.writtenPath = targetPath;
+  manifest.generatedEntryIds = transformed.entries.map((entry) => entry.generatedId);
+  manifest.drops = transformed.drops;
+  manifest.createdParents = createdParents;
+  manifest.fileCreated = writeResult.fileCreated;
+  manifest.preExistingEvents = Object.keys(priorFile?.hooks ?? {});
+  manifest.preExistingMatchers = Object.entries(priorFile?.hooks ?? {}).flatMap(
+    ([event, groups]) => groups.map((group) => ({
+      event,
+      ...group.matcher === void 0 ? {} : { matcher: group.matcher }
+    }))
+  );
+  appendExcludeBlock(cwd, runId, [relativeToCwd(cwd, targetPath)], {
+    markerPrefix: hookExcludeMarkerPrefix
+  });
+  return manifest;
+}
+function cleanupBridgedHooks(manifest) {
+  if (manifest.strategy === "symlink" && manifest.symlinkPath && manifest.symlinkTarget) {
+    try {
+      if (fs12.lstatSync(manifest.symlinkPath).isSymbolicLink() && fs12.readlinkSync(manifest.symlinkPath) === manifest.symlinkTarget) {
+        fs12.unlinkSync(manifest.symlinkPath);
+      }
+    } catch (error2) {
+      if (!isNodeError4(error2) || error2.code !== "ENOENT") {
+        throw error2;
+      }
+    }
+    for (const parent of [...manifest.createdParents ?? []].reverse()) {
+      removeDirectoryIfEmpty2(parent);
+    }
+  }
+  if (manifest.strategy === "transform" && manifest.writtenPath) {
+    const file = readCodexFile(manifest.writtenPath);
+    if (file) {
+      const generatedPrefix = `[generated:${manifest.runId}]`;
+      const preExistingEvents = new Set(manifest.preExistingEvents ?? []);
+      const preExistingMatchers = new Set(
+        (manifest.preExistingMatchers ?? []).map((group) => matcherKey(group.event, group.matcher))
+      );
+      const hooks = file.hooks ?? {};
+      for (const [event, groups] of Object.entries(hooks)) {
+        hooks[event] = groups.filter((group) => {
+          const priorLength = group.hooks.length;
+          group.hooks = group.hooks.filter(
+            (handler) => !handler.statusMessage?.startsWith(generatedPrefix)
+          );
+          return group.hooks.length > 0 || group.hooks.length === priorLength || preExistingMatchers.has(matcherKey(event, group.matcher));
+        });
+        if (hooks[event].length === 0 && !preExistingEvents.has(event)) {
+          delete hooks[event];
+        }
+      }
+      file.hooks = hooks;
+      if (manifest.fileCreated && hasOnlyEmptyHooks(file)) {
+        fs12.unlinkSync(manifest.writtenPath);
+      } else {
+        writeCodexFile(manifest.writtenPath, file);
+      }
+    }
+    for (const parent of [...manifest.createdParents ?? []].reverse()) {
+      removeDirectoryIfEmpty2(parent);
+    }
+  }
+  removeExcludeBlock(manifest.cwd, manifest.runId, { markerPrefix: hookExcludeMarkerPrefix });
+}
+
 // packages/agent-spawn/src/skill-bridge.ts
-function bridgeSkillsForRun(agentId, cwd, skills) {
-  if (!skills || skills.length === 0) {
+function bridgeResourcesForRun(agentId, cwd, skills, hooks) {
+  if ((!skills || skills.length === 0) && !hooks) {
     return void 0;
   }
-  const manifest = bridgeActiveSkills(agentId, cwd, skills, os6.homedir(), crypto.randomUUID());
-  for (const warning2 of manifest.warnings) {
-    logger.warn(warning2.message);
+  const runId = crypto.randomUUID();
+  const manifests = {};
+  try {
+    if (skills && skills.length > 0) {
+      manifests.skills = bridgeActiveSkills(agentId, cwd, skills, os7.homedir(), runId);
+      for (const warning2 of manifests.skills.warnings) {
+        logger.warn(warning2.message);
+      }
+    }
+    if (hooks) {
+      manifests.hooks = bridgeHooks(hooks.from, agentId, cwd, os7.homedir(), runId, {
+        strategy: hooks.strategy === "auto" ? void 0 : hooks.strategy,
+        scope: hooks.scope
+      });
+      for (const drop of manifests.hooks.drops) {
+        logger.warn(
+          `Dropped bridged hook event "${drop.source.event}" with handler type "${drop.source.handler.type}": ${drop.detail}`
+        );
+      }
+    }
+  } catch (error2) {
+    cleanupResourcesForRun(manifests);
+    throw error2;
   }
-  return manifest;
+  return manifests;
 }
-function cleanupSkillsForRun(manifest) {
+function cleanupResourcesForRun(manifest) {
   if (!manifest) {
     return;
   }
-  cleanupBridgedSkills(manifest);
+  if (manifest.hooks) {
+    cleanupBridgedHooks(manifest.hooks);
+  }
+  if (manifest.skills) {
+    cleanupBridgedSkills(manifest.skills);
+  }
 }
 
 // packages/agent-spawn/src/adapters/utils.ts
@@ -9005,21 +9727,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path50;
+        let path55;
         if (typeof item.content === "string") {
-          path50 = item.content;
+          path55 = item.content;
         } else {
           try {
-            path50 = JSON.stringify(item.content);
+            path55 = JSON.stringify(item.content);
           } catch {
-            path50 = String(item.content);
+            path55 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path50
+          path: path55
         };
       }
     }
@@ -9115,10 +9837,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path50 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path55 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path50 };
+        yield { event: "tool_complete", id: item.id, kind, path: path55 };
       }
     }
   }
@@ -9646,7 +10368,7 @@ function spawnStreaming(options) {
       };
     }
   };
-  const manifest = bridgeSkillsForRun(options.agentId, cwd, options.skills);
+  const manifest = bridgeResourcesForRun(options.agentId, cwd, options.skills, options.hooks);
   void (async () => {
     try {
       for await (const output of adapter(queue.lines())) {
@@ -9697,7 +10419,7 @@ function spawnStreaming(options) {
         ...ctx.logFile && !result.logFile ? { logFile: ctx.logFile } : {}
       };
     } finally {
-      cleanupSkillsForRun(manifest);
+      cleanupResourcesForRun(manifest);
     }
   })();
   return {
@@ -9833,7 +10555,7 @@ async function runSpawn(agentId, options, context) {
     return { stdout: "", stderr: "", exitCode: 0 };
   }
   const cwd = options.cwd ?? process.cwd();
-  const manifest = bridgeSkillsForRun(agentId, cwd, options.skills);
+  const manifest = bridgeResourcesForRun(agentId, cwd, options.skills, options.hooks);
   let logFd;
   try {
     const logFilePath = resolveSpawnLogPath(options);
@@ -9901,7 +10623,7 @@ async function runSpawn(agentId, options, context) {
     };
   } finally {
     closeSpawnLog(logFd);
-    cleanupSkillsForRun(manifest);
+    cleanupResourcesForRun(manifest);
   }
 }
 spawn4.retry = createSpawnRetry((service, options) => {
@@ -9923,12 +10645,12 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path41.join(options.logDir, options.logFileName);
+  return path46.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync3(path41.dirname(filePath), { recursive: true });
-    return openSync(filePath, "a");
+    mkdirSync5(path46.dirname(filePath), { recursive: true });
+    return openSync2(filePath, "a");
   } catch {
     return void 0;
   }
@@ -9943,7 +10665,7 @@ function appendSpawnLog(fd, chunk) {
 function closeSpawnLog(fd) {
   if (fd === void 0) return;
   try {
-    closeSync(fd);
+    closeSync2(fd);
   } catch {
   }
 }
@@ -9952,7 +10674,7 @@ function closeSpawnLog(fd) {
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path42 from "node:path";
+import path47 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { open as open2, readdir as readdir5 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -9971,13 +10693,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path43 from "node:path";
+import path48 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { mkdir as mkdir5, open as open3 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
-import * as fs12 from "node:fs/promises";
-import path44 from "node:path";
+import * as fs13 from "node:fs/promises";
+import path49 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -10018,7 +10740,7 @@ function countTokens(text5) {
 }
 
 // packages/tokenfill/dist/corpus.js
-import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CORPUS_ARTICLE_SEPARATOR = "\n\n";
@@ -10031,7 +10753,7 @@ function loadBuiltInCorpusArticles() {
   if (corpusFileNames.length === 0) {
     throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
   }
-  return corpusFileNames.map((fileName) => readFileSync3(join2(corpusDirectoryPath, fileName), "utf8").trim());
+  return corpusFileNames.map((fileName) => readFileSync6(join2(corpusDirectoryPath, fileName), "utf8").trim());
 }
 var BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
 
@@ -10041,7 +10763,7 @@ var builtInCorpusByteLength = Buffer.byteLength(builtInCorpusText, "utf8");
 
 // packages/memory/src/tokens.ts
 async function computeTokenStats(root) {
-  if (!await pathExists4(root)) {
+  if (!await pathExists5(root)) {
     return {
       memoryTokens: 0,
       sourceTokens: 0,
@@ -10061,13 +10783,13 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path44.resolve(root, "..", "..");
+  const repoRoot = path49.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path44.isAbsolute(sourcePath) ? sourcePath : path44.resolve(repoRoot, sourcePath);
+    const absPath = path49.isAbsolute(sourcePath) ? sourcePath : path49.resolve(repoRoot, sourcePath);
     try {
-      const content = await fs12.readFile(absPath, "utf8");
+      const content = await fs13.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
     } catch (error2) {
       if (isMissing4(error2)) {
@@ -10086,9 +10808,9 @@ async function computeTokenStats(root) {
     missingSources
   };
 }
-async function pathExists4(targetPath) {
+async function pathExists5(targetPath) {
   try {
-    await fs12.stat(targetPath);
+    await fs13.stat(targetPath);
     return true;
   } catch (error2) {
     if (isMissing4(error2)) {
@@ -10116,10 +10838,10 @@ function resolveRunners(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs13.readFile(path45.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs14.readFile(path50.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
-    fs: fs13,
-    filePath: path45.join(inferRepoRoot(root), "poe-code.json")
+    fs: fs14,
+    filePath: path50.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -10199,7 +10921,7 @@ function buildIngestPrompt(root, sourceLabel, sourceText) {
 }
 async function materializeSource(source) {
   if (source.kind === "file") {
-    const bytes = await fs13.readFile(source.absPath);
+    const bytes = await fs14.readFile(source.absPath);
     return {
       label: source.absPath,
       bytes,
@@ -10209,7 +10931,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path45.resolve(root, "..", "..");
+  return path50.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -11016,7 +11738,7 @@ var agentMcpConfigs = {
   }
 };
 var supportedAgents3 = Object.keys(agentMcpConfigs);
-function resolveAgentSupport2(input, registry = agentMcpConfigs) {
+function resolveAgentSupport3(input, registry = agentMcpConfigs) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
     return { status: "unknown", input };
@@ -11028,10 +11750,10 @@ function resolveAgentSupport2(input, registry = agentMcpConfigs) {
   return { status: "supported", input, id: resolvedId, config };
 }
 function isSupported(agentId) {
-  return resolveAgentSupport2(agentId).status === "supported";
+  return resolveAgentSupport3(agentId).status === "supported";
 }
-function getAgentConfig2(agentId) {
-  const support = resolveAgentSupport2(agentId);
+function getAgentConfig3(agentId) {
+  const support = resolveAgentSupport3(agentId);
   return support.status === "supported" ? support.config : void 0;
 }
 function resolveConfigPath2(config, platform) {
@@ -11042,7 +11764,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path46 from "node:path";
+import path51 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -11134,7 +11856,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path46.dirname(configPath);
+  return path51.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -11160,9 +11882,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path46.join(homeDir, configPath.slice(2));
+    return path51.join(homeDir, configPath.slice(2));
   }
-  return path46.join(homeDir, configPath.slice(1));
+  return path51.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -11195,7 +11917,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path46.dirname(absolutePath);
+  const configDir = path51.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -11222,7 +11944,7 @@ async function configure2(agentId, server, options) {
   if (!isSupported(agentId)) {
     throw new UnsupportedAgentError2(agentId);
   }
-  const config = getAgentConfig2(agentId);
+  const config = getAgentConfig3(agentId);
   const configPath = resolveConfigPath2(config, options.platform);
   const shapeTransformer = getShapeTransformer(config.shape);
   const shaped = shapeTransformer(server);
@@ -11278,7 +12000,7 @@ async function unconfigure2(agentId, serverName, options) {
   if (!isSupported(agentId)) {
     throw new UnsupportedAgentError2(agentId);
   }
-  const config = getAgentConfig2(agentId);
+  const config = getAgentConfig3(agentId);
   const configPath = resolveConfigPath2(config, options.platform);
   if (config.format === "yaml") {
     const document = await readYamlConfig(configPath, options);
@@ -11372,8 +12094,8 @@ async function installMemory(options) {
 }
 
 // packages/memory/src/query.ts
-import * as fs14 from "node:fs/promises";
-import path47 from "node:path";
+import * as fs15 from "node:fs/promises";
+import path52 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -11386,8 +12108,8 @@ async function queryMemory(root, options) {
     };
   }
   const configOptions = {
-    fs: fs14,
-    filePath: path47.join(inferRepoRoot2(root), "poe-code.json")
+    fs: fs15,
+    filePath: path52.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);
@@ -11402,7 +12124,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs14.readFile(path47.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs15.readFile(path52.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -11481,12 +12203,12 @@ function tokenize(text5) {
   return text5.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path47.resolve(root, "..", "..");
+  return path52.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
-import * as fs15 from "node:fs/promises";
-import path48 from "node:path";
+import * as fs16 from "node:fs/promises";
+import path53 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -11508,8 +12230,8 @@ async function explainPage(root, options) {
     throw new Error(`budget too small; needs at least ${tokensUsed} tokens`);
   }
   const configOptions = {
-    fs: fs15,
-    filePath: path48.join(inferRepoRoot3(root), "poe-code.json")
+    fs: fs16,
+    filePath: path53.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const response = await spawn4(agentId, { prompt });
@@ -11558,7 +12280,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path48.resolve(root, "..", "..");
+  return path53.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -11571,9 +12293,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path49 from "node:path";
+import path54 from "node:path";
 function openMemory(opts) {
-  if (!path49.isAbsolute(opts.root)) {
+  if (!path54.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;