poe-code 3.0.224 → 3.0.225

package/dist/providers/codex.js

@@ -804,17 +804,17 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path32, flags) => fsPromises.open(path32, flags),
-    readFile: (path32, encoding) => fsPromises.readFile(path32, encoding),
+    open: (path37, flags) => fsPromises.open(path37, flags),
+    readFile: (path37, encoding) => fsPromises.readFile(path37, encoding),
     stat: fsPromises.stat,
     unlink: fsPromises.unlink
   };
 }
-async function removeLockFile(fs3, lockPath, signal) {
+async function removeLockFile(fs4, lockPath, signal) {
   for (let attempt = 0; attempt <= 4; attempt += 1) {
     throwIfAborted(signal);
     try {
-      await fs3.unlink(lockPath);
+      await fs4.unlink(lockPath);
       return;
     } catch (error2) {
       if (hasErrorCode(error2, "ENOENT")) {
@@ -845,12 +845,12 @@ function parseLockMetadata(content) {
   }
   return void 0;
 }
-async function readLockMetadata(fs3, lockPath) {
-  if (!fs3.readFile) {
+async function readLockMetadata(fs4, lockPath) {
+  if (!fs4.readFile) {
     return void 0;
   }
   try {
-    return parseLockMetadata(await fs3.readFile(lockPath, "utf8"));
+    return parseLockMetadata(await fs4.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode(error2, "ENOENT")) {
       return null;
@@ -884,7 +884,7 @@ async function writeLockMetadata(handle) {
   }
 }
 async function acquireFileLock(filePath, options = {}) {
-  const fs3 = options.fs ?? createDefaultFs();
+  const fs4 = options.fs ?? createDefaultFs();
   const retries = options.retries ?? 20;
   const minTimeout = options.minTimeout ?? 25;
   const maxTimeout = options.maxTimeout ?? 250;
@@ -895,7 +895,7 @@ async function acquireFileLock(filePath, options = {}) {
   while (attempt <= retries) {
     throwIfAborted(options.signal);
     try {
-      const handle = await fs3.open(lockPath, "wx");
+      const handle = await fs4.open(lockPath, "wx");
       await writeLockMetadata(handle);
       let released = false;
       return async () => {
@@ -903,7 +903,7 @@ async function acquireFileLock(filePath, options = {}) {
           return;
         }
         released = true;
-        await removeLockFile(fs3, lockPath, options.signal);
+        await removeLockFile(fs4, lockPath, options.signal);
       };
     } catch (error2) {
       if (!hasErrorCode(error2, "EEXIST")) {
@@ -912,7 +912,7 @@ async function acquireFileLock(filePath, options = {}) {
     }
     let stat3;
     try {
-      stat3 = await fs3.stat(lockPath);
+      stat3 = await fs4.stat(lockPath);
     } catch (statError) {
       if (hasErrorCode(statError, "ENOENT")) {
         continue;
@@ -920,7 +920,7 @@ async function acquireFileLock(filePath, options = {}) {
       throw statError;
     }
     const reclaimLock = await shouldReclaimLock({
-      fs: fs3,
+      fs: fs4,
       isPidRunning: pidIsRunning,
       lockPath,
       staleMs,
@@ -930,7 +930,7 @@ async function acquireFileLock(filePath, options = {}) {
       continue;
     }
     if (reclaimLock) {
-      await removeLockFile(fs3, lockPath, options.signal);
+      await removeLockFile(fs4, lockPath, options.signal);
       continue;
     }
     if (attempt >= retries) {
@@ -1107,6 +1107,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",
@@ -1180,6 +1198,7 @@ var allAgents = [
   claudeCodeAgent,
   claudeDesktopAgent,
   codexAgent,
+  geminiCliAgent,
   openCodeAgent,
   kimiAgent,
   gooseAgent,
@@ -1230,29 +1249,29 @@ function wrapForLogTee(argv, jobId) {
   return ["sh", "-c", script];
 }
 async function* streamLogFile(env, jobId, opts) {
-  const fs3 = env.fs ?? nodeFs;
+  const fs4 = env.fs ?? nodeFs;
   const file = jobLogPath(jobId);
   let byteOffset = opts.sinceByte ?? 0;
   while (true) {
-    if (opts.since !== void 0 && !await wasModifiedSince(fs3, file, opts.since)) {
-      await waitForLogChange(fs3, file);
+    if (opts.since !== void 0 && !await wasModifiedSince(fs4, file, opts.since)) {
+      await waitForLogChange(fs4, file);
       continue;
     }
-    const result = await readLogChunk(fs3, file, byteOffset);
+    const result = await readLogChunk(fs4, file, byteOffset);
     if (result !== null) {
       byteOffset = result.nextByteOffset;
       yield result.chunk;
       continue;
     }
-    await waitForLogChange(fs3, file);
+    await waitForLogChange(fs4, file);
   }
 }
-async function wasModifiedSince(fs3, file, since) {
-  if (fs3.promises.stat === void 0) {
+async function wasModifiedSince(fs4, file, since) {
+  if (fs4.promises.stat === void 0) {
     return true;
   }
   try {
-    const stat3 = await fs3.promises.stat(file);
+    const stat3 = await fs4.promises.stat(file);
     return stat3.mtimeMs >= since.getTime();
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -1262,11 +1281,11 @@ async function wasModifiedSince(fs3, file, since) {
   }
 }
 async function waitForExit(env, jobId, opts = {}) {
-  const fs3 = env.fs ?? nodeFs;
+  const fs4 = env.fs ?? nodeFs;
   const file = jobExitPath(jobId);
   while (true) {
     throwIfAborted2(opts.signal);
-    const contents = await readTextFileIfExists(fs3, file);
+    const contents = await readTextFileIfExists(fs4, file);
     if (contents !== null) {
       const text5 = contents.trim();
       const exitCode = Number(text5);
@@ -1284,8 +1303,8 @@ function jobLogPath(jobId) {
 function jobExitPath(jobId) {
   return `${JOB_DIR}/${jobId}.exit`;
 }
-async function readLogChunk(fs3, file, byteOffset) {
-  const contents = await readFileIfExists(fs3, file);
+async function readLogChunk(fs4, file, byteOffset) {
+  const contents = await readFileIfExists(fs4, file);
   if (contents === null || byteOffset >= contents.byteLength) {
     return null;
   }
@@ -1297,13 +1316,13 @@ async function readLogChunk(fs3, file, byteOffset) {
     nextByteOffset: contents.byteLength
   };
 }
-async function readTextFileIfExists(fs3, file) {
-  const contents = await readFileIfExists(fs3, file);
+async function readTextFileIfExists(fs4, file) {
+  const contents = await readFileIfExists(fs4, file);
   return contents?.toString("utf8") ?? null;
 }
-async function readFileIfExists(fs3, file) {
+async function readFileIfExists(fs4, file) {
   try {
-    const contents = await fs3.promises.readFile(file);
+    const contents = await fs4.promises.readFile(file);
     return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -1312,8 +1331,8 @@ async function readFileIfExists(fs3, file) {
     throw error2;
   }
 }
-async function waitForLogChange(fs3, file) {
-  const watch = fs3.watch;
+async function waitForLogChange(fs4, file) {
+  const watch = fs4.watch;
   if (typeof watch !== "function") {
     await sleep2(POLL_INTERVAL_MS);
     return;
@@ -2279,7 +2298,7 @@ import path14 from "node:path";
 
 // packages/config-extends/src/discover.ts
 import path10 from "node:path";
-async function findBase(name, bases, fs3) {
+async function findBase(name, bases, fs4) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
@@ -2287,7 +2306,7 @@ async function findBase(name, bases, fs3) {
       checkedPaths.push(filePath);
       try {
         return {
-          content: await fs3.readFile(filePath, "utf8"),
+          content: await fs4.readFile(filePath, "utf8"),
           filePath
         };
       } catch (error2) {
@@ -2367,11 +2386,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path32) {
+function mergeObjectLayers(layers, path37) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path32);
+    const resolved = resolveKey(layers, key, path37);
     if (resolved === void 0) {
       continue;
     }
@@ -2389,7 +2408,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path32) {
+function resolveKey(layers, key, path37) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -2419,9 +2438,9 @@ function resolveKey(layers, key, path32) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path32, key);
+  const fullPath = buildPath(path37, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path32, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path37, key]);
     return {
       value: merged.data,
       sources: {
@@ -2446,8 +2465,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path32, key) {
-  return [...path32, key].join(".");
+function buildPath(path37, key) {
+  return [...path37, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -3835,16 +3854,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path32) {
-  const ext = getExtension(path32);
+function detectFormat2(path37) {
+  const ext = getExtension(path37);
   return extensionMap[ext];
 }
-function getExtension(path32) {
-  const lastDot = path32.lastIndexOf(".");
+function getExtension(path37) {
+  const lastDot = path37.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path32.slice(lastDot).toLowerCase();
+  return path37.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -3895,9 +3914,9 @@ function resolvePath(rawPath, homeDir, pathMapper) {
 function isNotFound(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
-async function readFileIfExists2(fs3, target) {
+async function readFileIfExists2(fs4, target) {
   try {
-    return await fs3.readFile(target, "utf8");
+    return await fs4.readFile(target, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -3905,9 +3924,9 @@ async function readFileIfExists2(fs3, target) {
     throw error2;
   }
 }
-async function pathExists(fs3, target) {
+async function pathExists(fs4, target) {
   try {
-    await fs3.stat(target);
+    await fs4.stat(target);
     return true;
   } catch (error2) {
     if (isNotFound(error2)) {
@@ -3931,9 +3950,9 @@ function createInvalidDocumentBackupPath(targetPath) {
   const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
   return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs3, targetPath, content) {
+async function backupInvalidDocument(fs4, targetPath, content) {
   const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs3.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs4.writeFile(backupPath, content, { encoding: "utf8" });
 }
 function describeMutation(kind, targetPath) {
   const displayPath = targetPath ?? "target";
@@ -4496,12 +4515,12 @@ function isConfigObject5(value) {
 }
 
 // packages/poe-code-config/src/store.ts
-async function readMergedDocument(fs3, globalPath, projectPath) {
-  const globalDocument = await readStoredDocument(fs3, globalPath);
+async function readMergedDocument(fs4, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs4, globalPath);
   if (!projectPath || projectPath === globalPath) {
     return globalDocument.data;
   }
-  const projectDocument = await readStoredDocument(fs3, projectPath);
+  const projectDocument = await readStoredDocument(fs4, projectPath);
   const resolved = await resolve(
     [
       {
@@ -4515,16 +4534,16 @@ async function readMergedDocument(fs3, globalPath, projectPath) {
       }
     ],
     {
-      fs: createResolvedConfigFs(fs3, globalPath, globalDocument.content),
+      fs: createResolvedConfigFs(fs4, globalPath, globalDocument.content),
       autoExtend: true
     }
   );
   return normalizeDocument(resolved.data);
 }
-async function readStoredDocument(fs3, filePath) {
+async function readStoredDocument(fs4, filePath) {
   try {
-    const raw = await fs3.readFile(filePath, "utf8");
-    return await parseStoredDocument(fs3, filePath, raw);
+    const raw = await fs4.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs4, filePath, raw);
   } catch (error2) {
     if (isNotFound(error2)) {
       return {
@@ -4535,7 +4554,7 @@ async function readStoredDocument(fs3, filePath) {
     throw error2;
   }
 }
-async function parseStoredDocument(fs3, filePath, raw) {
+async function parseStoredDocument(fs4, filePath, raw) {
   try {
     return {
       content: raw,
@@ -4543,7 +4562,7 @@ async function parseStoredDocument(fs3, filePath, raw) {
     };
   } catch (error2) {
     if (error2 instanceof SyntaxError) {
-      await recoverInvalidDocument(fs3, filePath, raw);
+      await recoverInvalidDocument(fs4, filePath, raw);
       return {
         content: EMPTY_DOCUMENT,
         data: {}
@@ -4577,21 +4596,21 @@ function normalizeScopeValues(value) {
   }
   return normalized;
 }
-function createResolvedConfigFs(fs3, globalPath, globalContent) {
+function createResolvedConfigFs(fs4, globalPath, globalContent) {
   return {
     readFile(filePath, _encoding) {
       if (filePath === globalPath) {
         return Promise.resolve(globalContent);
       }
-      return fs3.readFile(filePath, "utf8");
+      return fs4.readFile(filePath, "utf8");
     }
   };
 }
-async function recoverInvalidDocument(fs3, filePath, content) {
-  await fs3.mkdir(path14.dirname(filePath), { recursive: true });
+async function recoverInvalidDocument(fs4, filePath, content) {
+  await fs4.mkdir(path14.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
-  await fs3.writeFile(backupPath, content, { encoding: "utf8" });
-  await fs3.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+  await fs4.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs4.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
   const directory = path14.dirname(filePath);
@@ -4715,7 +4734,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path32 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path37 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key of keys) {
@@ -4727,20 +4746,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path32 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path32, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path37, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord4(baseValue) && isRecord4(overrideValue)) {
-      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path32, key]);
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path37, key]);
       continue;
     }
     merged[key] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path32) {
-  return path32.join(".") === "mounts" || path32.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path37) {
+  return path37.join(".") === "mounts" || path37.join(".") === "runner.workspace.exclude";
 }
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -4928,6 +4947,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",
@@ -4935,6 +4955,12 @@ var poeProvider = {
     prompt: { title: "Poe API key" },
     preferredLogin: "oauth"
   },
+  env: {
+    ANTHROPIC_CUSTOM_HEADERS: {
+      kind: "providerCredential",
+      prefix: "Authorization: Bearer "
+    }
+  },
   apiShapes: [
     {
       id: "openai-chat-completions",
@@ -4963,6 +4989,9 @@ var anthropicProvider = {
     storageKey: "provider:anthropic",
     prompt: { title: "Anthropic API key" }
   },
+  env: {
+    ANTHROPIC_API_KEY: { kind: "providerCredential" }
+  },
   apiShapes: [
     {
       id: "anthropic-messages",
@@ -4985,6 +5014,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",
@@ -5029,7 +5064,7 @@ function isNotFoundError(error2) {
 }
 
 // packages/poe-code-config/src/state/jobs.ts
-function createJobRegistry(homeDir, fs3 = defaultStateFs) {
+function createJobRegistry(homeDir, fs4 = defaultStateFs) {
   const jobsDir = path17.join(homeDir, ".poe-code", "state", "jobs");
   function jobPath(id) {
     assertSafeJobId(id);
@@ -5037,7 +5072,7 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   }
   async function get(id) {
     try {
-      return parseJobEntry(await fs3.readFile(jobPath(id), "utf8"));
+      return parseJobEntry(await fs4.readFile(jobPath(id), "utf8"));
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return null;
@@ -5048,8 +5083,8 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   async function put(entry) {
     assertJobEntry(entry);
     const filePath = jobPath(entry.id);
-    await fs3.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs3 });
+    await fs4.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs4 });
     try {
       await writeJobAtomically(filePath, entry);
     } finally {
@@ -5058,8 +5093,8 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   }
   async function update(id, patch) {
     const filePath = jobPath(id);
-    await fs3.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs3 });
+    await fs4.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs4 });
     try {
       const current = await get(id);
       if (current === null) {
@@ -5080,7 +5115,7 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   async function list(filter = {}) {
     let entries;
     try {
-      entries = await fs3.readdir(jobsDir);
+      entries = await fs4.readdir(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return [];
@@ -5093,11 +5128,11 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
         continue;
       }
       const filePath = path17.join(jobsDir, entry);
-      const stat3 = await fs3.stat(filePath);
+      const stat3 = await fs4.stat(filePath);
       if (!stat3.isFile()) {
         continue;
       }
-      const job = parseJobEntry(await fs3.readFile(filePath, "utf8"));
+      const job = parseJobEntry(await fs4.readFile(filePath, "utf8"));
       if (matchesFilter(job, filter)) {
         jobs.push(job);
       }
@@ -5107,16 +5142,16 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   async function remove2(id) {
     const filePath = jobPath(id);
     try {
-      await fs3.stat(jobsDir);
+      await fs4.stat(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return;
       }
       throw error2;
     }
-    const release = await acquireFileLock(filePath, { fs: fs3 });
+    const release = await acquireFileLock(filePath, { fs: fs4 });
     try {
-      await fs3.unlink(filePath);
+      await fs4.unlink(filePath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -5126,14 +5161,14 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
     }
   }
   async function writeJobAtomically(filePath, entry) {
-    await fs3.mkdir(path17.dirname(filePath), { recursive: true });
+    await fs4.mkdir(path17.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
     try {
-      await fs3.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
+      await fs4.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
 `, {
         encoding: "utf8"
       });
-      await fs3.rename(tempPath, filePath);
+      await fs4.rename(tempPath, filePath);
     } catch (error2) {
       await removeTempFile(tempPath);
       throw error2;
@@ -5141,7 +5176,7 @@ function createJobRegistry(homeDir, fs3 = defaultStateFs) {
   }
   async function removeTempFile(tempPath) {
     try {
-      await fs3.unlink(tempPath);
+      await fs4.unlink(tempPath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -5188,11 +5223,11 @@ function isRecord5(value) {
 
 // packages/poe-code-config/src/state/templates.ts
 import path18 from "node:path";
-function createTemplateRegistry(homeDir, fs3 = defaultStateFs) {
+function createTemplateRegistry(homeDir, fs4 = defaultStateFs) {
   const filePath = path18.join(homeDir, ".poe-code", "state", "templates.json");
   async function readState() {
     try {
-      const raw = await fs3.readFile(filePath, "utf8");
+      const raw = await fs4.readFile(filePath, "utf8");
       return normalizeTemplateState(JSON.parse(raw));
     } catch (error2) {
       if (isNotFoundError(error2)) {
@@ -5202,14 +5237,14 @@ function createTemplateRegistry(homeDir, fs3 = defaultStateFs) {
     }
   }
   async function writeState(state) {
-    await fs3.writeFile(filePath, `${JSON.stringify(state, null, 2)}
+    await fs4.writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, {
       encoding: "utf8"
     });
   }
   async function updateState(mutator) {
-    await fs3.mkdir(path18.dirname(filePath), { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs3 });
+    await fs4.mkdir(path18.dirname(filePath), { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs4 });
     try {
       const state = await readState();
       mutator(state);
@@ -5279,10 +5314,10 @@ function isRecord6(value) {
 }
 
 // packages/poe-code-config/src/state/index.ts
-function createStateManager(homeDir, fs3) {
+function createStateManager(homeDir, fs4) {
   return {
-    templates: createTemplateRegistry(homeDir, fs3),
-    jobs: createJobRegistry(homeDir, fs3)
+    templates: createTemplateRegistry(homeDir, fs4),
+    jobs: createJobRegistry(homeDir, fs4)
   };
 }
 
@@ -5597,7 +5632,7 @@ import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream"
 import path21 from "node:path";
 var JOB_DIR2 = "/tmp/poe-jobs";
 function createE2bJobHandle(input) {
-  const fs3 = createE2bLogStreamFs(input.sandbox);
+  const fs4 = createE2bLogStreamFs(input.sandbox);
   return {
     id: input.jobId,
     envId: input.envId,
@@ -5613,10 +5648,10 @@ function createE2bJobHandle(input) {
       return isRunning ? "running" : "lost";
     },
     stream(opts = {}) {
-      return streamLogFile({ fs: fs3 }, input.jobId, opts);
+      return streamLogFile({ fs: fs4 }, input.jobId, opts);
     },
     async wait() {
-      const result = await waitForExit({ fs: fs3 }, input.jobId);
+      const result = await waitForExit({ fs: fs4 }, input.jobId);
       const preserveMs = input.preserveAfterExitHours * 60 * 60 * 1e3;
       if (preserveMs > 0) {
         await input.sandbox.setTimeout(preserveMs);
@@ -6113,10 +6148,10 @@ var e2bAuthScope = defineScope("e2b", {
 });
 async function resolveE2bApiKey(input) {
   const homeDir = input.homeDir ?? os4.homedir();
-  const fs3 = input.fs ?? nodeFs4;
+  const fs4 = input.fs ?? nodeFs4;
   const env = input.env ?? process.env;
   const document = await readMergedDocument(
-    fs3,
+    fs4,
     resolveConfigPath(homeDir),
     resolveProjectConfigPath(input.cwd)
   );
@@ -6623,6 +6658,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,
@@ -6639,6 +6691,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) {
@@ -6658,8 +6711,8 @@ function listMcpSupportedAgents() {
 }
 
 // packages/agent-spawn/src/spawn.ts
-import { mkdirSync as mkdirSync3, openSync, writeSync, closeSync } from "node:fs";
-import path29 from "node:path";
+import { mkdirSync as mkdirSync5, openSync as openSync2, writeSync, closeSync as closeSync2 } from "node:fs";
+import path34 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -7060,7 +7113,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";
@@ -7074,6 +7127,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"
@@ -7216,7 +7273,7 @@ function resolveSkillReference(ref, cwd, homeDir) {
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import path27 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"], {
@@ -7236,10 +7293,10 @@ function resolveExcludePath(cwd) {
   }
   return path27.join(path27.isAbsolute(gitDir) ? gitDir : path27.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) {
@@ -7255,8 +7312,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) {
@@ -7271,23 +7328,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;
   }
   fs.mkdirSync(path27.dirname(excludePath), { recursive: true });
   const content = readExcludeFile(excludePath);
-  fs.writeFileSync(excludePath, appendBlock(content, runId, entries), "utf8");
+  fs.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;
@@ -7296,7 +7357,11 @@ function removeExcludeBlock(cwd, runId) {
   if (content === void 0) {
     return;
   }
-  fs.writeFileSync(excludePath, removeBlock(content, runId), "utf8");
+  fs.writeFileSync(
+    excludePath,
+    removeBlock(content, runId, opts?.markerPrefix ?? defaultMarkerPrefix),
+    "utf8"
+  );
 }
 
 // packages/agent-skill-config/src/bridge-active-skills.ts
@@ -7502,22 +7567,679 @@ function cleanupBridgedSkills(manifest) {
   removeExcludeBlock(manifest.cwd, manifest.runId);
 }
 
+// packages/agent-hook-config/src/configs.ts
+import os6 from "node:os";
+import path29 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 : path29.join(homeDir, remainder);
+}
+function resolveHookPath(config, scope, cwd, homeDir) {
+  if (scope === "global") {
+    return path29.resolve(expandHome3(config.globalHookPath, homeDir));
+  }
+  return config.localHookPath ? path29.resolve(cwd, config.localHookPath) : void 0;
+}
+
+// packages/agent-hook-config/src/read-hooks.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path30 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 = path30.resolve(cwd, ".claude/settings.json");
+  const userPath = path30.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 path31 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(path31.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 path32 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 isRecord7(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 (!isRecord7(parsed)) {
+    return false;
+  }
+  if (Object.keys(parsed).some((key) => key !== "hooks")) {
+    return false;
+  }
+  const hooks = parsed.hooks;
+  if (!isRecord7(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 (!isRecord7(group) || !Array.isArray(group.hooks)) {
+        return false;
+      }
+      for (const handler of group.hooks) {
+        if (!isRecord7(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(path32.dirname(symlinkPath), { recursive: true });
+  symlinkSync(targetPath, symlinkPath);
+  return { symlinkPath, targetPath, replaced };
+}
+
+// packages/agent-hook-config/src/bridge-hooks.ts
+import * as fs3 from "node:fs";
+import path33 from "node:path";
+var hookExcludeMarkerPrefix = "poe-code-spawn-hooks";
+function isNodeError4(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+function pathExists3(targetPath) {
+  try {
+    fs3.lstatSync(targetPath);
+    return true;
+  } catch (error2) {
+    if (isNodeError4(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function collectMissingParents2(targetPath) {
+  const parents = [];
+  let current = path33.dirname(targetPath);
+  while (!pathExists3(current)) {
+    parents.push(current);
+    const parent = path33.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return parents.reverse();
+}
+function removeDirectoryIfEmpty2(targetPath) {
+  try {
+    fs3.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 = fs3.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) {
+  fs3.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 path33.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 (fs3.lstatSync(manifest.symlinkPath).isSymbolicLink() && fs3.readlinkSync(manifest.symlinkPath) === manifest.symlinkTarget) {
+        fs3.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)) {
+        fs3.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
@@ -7643,21 +8365,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 path32;
+        let path37;
         if (typeof item.content === "string") {
-          path32 = item.content;
+          path37 = item.content;
         } else {
           try {
-            path32 = JSON.stringify(item.content);
+            path37 = JSON.stringify(item.content);
           } catch {
-            path32 = String(item.content);
+            path37 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path32
+          path: path37
         };
       }
     }
@@ -7753,10 +8475,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 path32 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path37 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path32 };
+        yield { event: "tool_complete", id: item.id, kind, path: path37 };
       }
     }
   }
@@ -8284,7 +9006,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())) {
@@ -8335,7 +9057,7 @@ function spawnStreaming(options) {
         ...ctx.logFile && !result.logFile ? { logFile: ctx.logFile } : {}
       };
     } finally {
-      cleanupSkillsForRun(manifest);
+      cleanupResourcesForRun(manifest);
     }
   })();
   return {
@@ -8477,7 +9199,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);
@@ -8545,7 +9267,7 @@ async function runSpawn(agentId, options, context) {
     };
   } finally {
     closeSpawnLog(logFd);
-    cleanupSkillsForRun(manifest);
+    cleanupResourcesForRun(manifest);
   }
 }
 spawn4.retry = createSpawnRetry((service, options) => {
@@ -8567,12 +9289,12 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path29.join(options.logDir, options.logFileName);
+  return path34.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync3(path29.dirname(filePath), { recursive: true });
-    return openSync(filePath, "a");
+    mkdirSync5(path34.dirname(filePath), { recursive: true });
+    return openSync2(filePath, "a");
   } catch {
     return void 0;
   }
@@ -8587,7 +9309,7 @@ function appendSpawnLog(fd, chunk) {
 function closeSpawnLog(fd) {
   if (fd === void 0) return;
   try {
-    closeSync(fd);
+    closeSync2(fd);
   } catch {
   }
 }
@@ -8596,7 +9318,7 @@ function closeSpawnLog(fd) {
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path30 from "node:path";
+import path35 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { open as open2, readdir as readdir2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -8615,7 +9337,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path31 from "node:path";
+import path36 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { mkdir, open as open3 } from "node:fs/promises";
 
@@ -8629,9 +9351,30 @@ stderr:
 ${stderr}`;
 }
 function createSpawnHealthCheck(agentId, options) {
-  const prompt = `Output exactly: ${options.expectedOutput}`;
-  const { binaryName, args, env: modeEnv } = buildSpawnArgs(agentId, {
-    prompt,
+  const {
+    binaryName,
+    args,
+    env: modeEnv
+  } = options.hooks ? {
+    binaryName: "poe-code",
+    args: [
+      "spawn",
+      "--hooks-from",
+      options.hooks.from,
+      ...options.hooks.strategy ? ["--hooks-strategy", options.hooks.strategy] : [],
+      ...options.model ? ["--model", options.model] : [],
+      "--mode",
+      "yolo",
+      agentId,
+      `Output exactly: ${options.expectedOutput}`
+    ],
+    env: void 0
+  } : options.invocation ? {
+    binaryName: options.invocation.command,
+    args: options.invocation.args,
+    env: options.invocation.env
+  } : buildSpawnArgs(agentId, {
+    prompt: `Output exactly: ${options.expectedOutput}`,
     model: options.model,
     mode: "yolo"
   });
@@ -8646,6 +9389,13 @@ function createSpawnHealthCheck(agentId, options) {
         return;
       }
       const result = modeEnv ? await context.runCommand(binaryName, args, { env: modeEnv }) : await context.runCommand(binaryName, args);
+      if (options.hooks) {
+        for (const line of result.stdout.split("\n")) {
+          if (line.includes("Dropped bridged hook event")) {
+            context.logWarning?.(line);
+          }
+        }
+      }
       if (result.exitCode !== 0) {
         throw new Error(
           `spawn ${agentId} failed with exit code ${result.exitCode}.
@@ -8783,6 +9533,7 @@ function createProvider(opts) {
     configurePrompts: opts.configurePrompts,
     postConfigureMessages: opts.postConfigureMessages,
     extendConfigurePayload: opts.extendConfigurePayload,
+    runtimeEnv: opts.runtimeEnv,
     isolatedEnv: opts.isolatedEnv,
     async configure(context, runOptions) {
       await runMutations(opts.manifest.configure, {
@@ -8870,11 +9621,7 @@ function resolveCodexConfigModel(options) {
 var CODEX_INSTALL_DEFINITION = {
   id: "codex",
   summary: "Codex CLI",
-  check: createBinaryExistsCheck(
-    "codex",
-    "codex-cli-binary",
-    "Codex CLI binary must exist"
-  ),
+  check: createBinaryExistsCheck("codex", "codex-cli-binary", "Codex CLI binary must exist"),
   steps: [
     {
       id: "install-codex-cli-npm",
@@ -8976,7 +9723,8 @@ var codexService = createProvider({
     return context.runCheck(
       createSpawnHealthCheck("codex", {
         model: context.model ?? DEFAULT_CODEX_MODEL,
-        expectedOutput: "CODEX_OK"
+        expectedOutput: "CODEX_OK",
+        hooks: context.hooks
       })
     );
   },