poe-code 3.0.224 → 3.0.225

package/dist/providers/poe-agent.js

@@ -609,8 +609,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path49) {
-  if (!isAbsolute(path49)) {
+function assertAbsolutePath(path54) {
+  if (!isAbsolute(path54)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -1867,7 +1867,7 @@ var init_plan_scope = __esm({
 
 // packages/config-extends/src/discover.ts
 import path2 from "node:path";
-async function findBase(name, bases, fs6) {
+async function findBase(name, bases, fs7) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
@@ -1875,7 +1875,7 @@ async function findBase(name, bases, fs6) {
       checkedPaths.push(filePath);
       try {
         return {
-          content: await fs6.readFile(filePath, "utf8"),
+          content: await fs7.readFile(filePath, "utf8"),
           filePath
         };
       } catch (error2) {
@@ -1965,11 +1965,11 @@ var init_parse = __esm({
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path49) {
+function mergeObjectLayers(layers, path54) {
   const data = {};
   const sources = {};
   for (const key2 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key2, path49);
+    const resolved = resolveKey(layers, key2, path54);
     if (resolved === void 0) {
       continue;
     }
@@ -1987,7 +1987,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key2, path49) {
+function resolveKey(layers, key2, path54) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -2017,9 +2017,9 @@ function resolveKey(layers, key2, path49) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path49, key2);
+  const fullPath = buildPath(path54, key2);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path49, key2]);
+    const merged = mergeObjectLayers(objectLayers, [...path54, key2]);
     return {
       value: merged.data,
       sources: {
@@ -2044,8 +2044,8 @@ function isWinningCandidate(key2, value) {
   }
   return true;
 }
-function buildPath(path49, key2) {
-  return [...path49, key2].join(".");
+function buildPath(path54, key2) {
+  return [...path54, key2].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -9888,16 +9888,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path49) {
-  const ext = getExtension(path49);
+function detectFormat2(path54) {
+  const ext = getExtension(path54);
   return extensionMap[ext];
 }
-function getExtension(path49) {
-  const lastDot = path49.lastIndexOf(".");
+function getExtension(path54) {
+  const lastDot = path54.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path49.slice(lastDot).toLowerCase();
+  return path54.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -9976,9 +9976,9 @@ var init_path_utils = __esm({
 function isNotFound(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
-async function readFileIfExists(fs6, target) {
+async function readFileIfExists(fs7, target) {
   try {
-    return await fs6.readFile(target, "utf8");
+    return await fs7.readFile(target, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -9986,9 +9986,9 @@ async function readFileIfExists(fs6, target) {
     throw error2;
   }
 }
-async function pathExists(fs6, target) {
+async function pathExists(fs7, target) {
   try {
-    await fs6.stat(target);
+    await fs7.stat(target);
     return true;
   } catch (error2) {
     if (isNotFound(error2)) {
@@ -10017,9 +10017,9 @@ function createInvalidDocumentBackupPath(targetPath) {
   const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
   return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs6, targetPath, content) {
+async function backupInvalidDocument(fs7, targetPath, content) {
   const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs6.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs7.writeFile(backupPath, content, { encoding: "utf8" });
 }
 function describeMutation(kind, targetPath) {
   const displayPath = targetPath ?? "target";
@@ -10622,26 +10622,26 @@ var init_src4 = __esm({
 
 // packages/poe-code-config/src/store.ts
 import path6 from "node:path";
-async function readDocument(fs6, filePath) {
-  const document = await readStoredDocument(fs6, filePath);
+async function readDocument(fs7, filePath) {
+  const document = await readStoredDocument(fs7, filePath);
   return document.data;
 }
-async function writeScope(fs6, filePath, scope, values) {
-  const document = await readDocument(fs6, filePath);
+async function writeScope(fs7, filePath, scope, values) {
+  const document = await readDocument(fs7, filePath);
   const normalizedValues = normalizeScopeValues(values);
   if (Object.keys(normalizedValues).length === 0) {
     delete document[scope];
   } else {
     document[scope] = normalizedValues;
   }
-  await writeDocument(fs6, filePath, document);
+  await writeDocument(fs7, filePath, document);
 }
-async function readMergedDocument(fs6, globalPath, projectPath) {
-  const globalDocument = await readStoredDocument(fs6, globalPath);
+async function readMergedDocument(fs7, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs7, globalPath);
   if (!projectPath || projectPath === globalPath) {
     return globalDocument.data;
   }
-  const projectDocument = await readStoredDocument(fs6, projectPath);
+  const projectDocument = await readStoredDocument(fs7, projectPath);
   const resolved = await resolve(
     [
       {
@@ -10655,16 +10655,16 @@ async function readMergedDocument(fs6, globalPath, projectPath) {
       }
     ],
     {
-      fs: createResolvedConfigFs(fs6, globalPath, globalDocument.content),
+      fs: createResolvedConfigFs(fs7, globalPath, globalDocument.content),
       autoExtend: true
     }
   );
   return normalizeDocument(resolved.data);
 }
-async function readStoredDocument(fs6, filePath) {
+async function readStoredDocument(fs7, filePath) {
   try {
-    const raw = await fs6.readFile(filePath, "utf8");
-    return await parseStoredDocument(fs6, filePath, raw);
+    const raw = await fs7.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs7, filePath, raw);
   } catch (error2) {
     if (isNotFound(error2)) {
       return {
@@ -10675,7 +10675,7 @@ async function readStoredDocument(fs6, filePath) {
     throw error2;
   }
 }
-async function parseStoredDocument(fs6, filePath, raw) {
+async function parseStoredDocument(fs7, filePath, raw) {
   try {
     return {
       content: raw,
@@ -10683,7 +10683,7 @@ async function parseStoredDocument(fs6, filePath, raw) {
     };
   } catch (error2) {
     if (error2 instanceof SyntaxError) {
-      await recoverInvalidDocument(fs6, filePath, raw);
+      await recoverInvalidDocument(fs7, filePath, raw);
       return {
         content: EMPTY_DOCUMENT,
         data: {}
@@ -10717,28 +10717,28 @@ function normalizeScopeValues(value) {
   }
   return normalized;
 }
-function createResolvedConfigFs(fs6, globalPath, globalContent) {
+function createResolvedConfigFs(fs7, globalPath, globalContent) {
   return {
     readFile(filePath, _encoding) {
       if (filePath === globalPath) {
         return Promise.resolve(globalContent);
       }
-      return fs6.readFile(filePath, "utf8");
+      return fs7.readFile(filePath, "utf8");
     }
   };
 }
-async function writeDocument(fs6, filePath, document) {
-  await fs6.mkdir(path6.dirname(filePath), { recursive: true });
-  await fs6.writeFile(filePath, `${JSON.stringify(document, null, 2)}
+async function writeDocument(fs7, filePath, document) {
+  await fs7.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs7.writeFile(filePath, `${JSON.stringify(document, null, 2)}
 `, {
     encoding: "utf8"
   });
 }
-async function recoverInvalidDocument(fs6, filePath, content) {
-  await fs6.mkdir(path6.dirname(filePath), { recursive: true });
+async function recoverInvalidDocument(fs7, filePath, content) {
+  await fs7.mkdir(path6.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
-  await fs6.writeFile(backupPath, content, { encoding: "utf8" });
-  await fs6.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+  await fs7.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs7.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
   const directory = path6.dirname(filePath);
@@ -10912,7 +10912,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path49 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path54 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key2 of keys) {
@@ -10924,20 +10924,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path49 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path49, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path54, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key2] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord3(baseValue) && isRecord3(overrideValue)) {
-      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path49, key2]);
+      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path54, key2]);
       continue;
     }
     merged[key2] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path49) {
-  return path49.join(".") === "mounts" || path49.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path54) {
+  return path54.join(".") === "mounts" || path54.join(".") === "runner.workspace.exclude";
 }
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -11092,6 +11092,30 @@ var init_codex = __esm({
   }
 });
 
+// packages/agent-defs/src/agents/gemini-cli.ts
+var geminiCliAgent;
+var init_gemini_cli = __esm({
+  "packages/agent-defs/src/agents/gemini-cli.ts"() {
+    "use strict";
+    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;
 var init_opencode = __esm({
@@ -11191,6 +11215,7 @@ var init_agents = __esm({
     init_claude_code();
     init_claude_desktop();
     init_codex();
+    init_gemini_cli();
     init_opencode();
     init_kimi();
     init_goose();
@@ -11214,6 +11239,7 @@ var init_registry = __esm({
       claudeCodeAgent,
       claudeDesktopAgent,
       codexAgent,
+      geminiCliAgent,
       openCodeAgent,
       kimiAgent,
       gooseAgent,
@@ -11459,6 +11485,7 @@ var init_poe = __esm({
       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",
@@ -11466,6 +11493,12 @@ var init_poe = __esm({
         prompt: { title: "Poe API key" },
         preferredLogin: "oauth"
       },
+      env: {
+        ANTHROPIC_CUSTOM_HEADERS: {
+          kind: "providerCredential",
+          prefix: "Authorization: Bearer "
+        }
+      },
       apiShapes: [
         {
           id: "openai-chat-completions",
@@ -11500,6 +11533,9 @@ var init_anthropic = __esm({
         storageKey: "provider:anthropic",
         prompt: { title: "Anthropic API key" }
       },
+      env: {
+        ANTHROPIC_API_KEY: { kind: "providerCredential" }
+      },
       apiShapes: [
         {
           id: "anthropic-messages",
@@ -11528,6 +11564,12 @@ var init_cloudflare = __esm({
         storageKey: "provider:cloudflare",
         prompt: { title: "Cloudflare AI Gateway token" }
       },
+      env: {
+        ANTHROPIC_CUSTOM_HEADERS: {
+          kind: "providerCredential",
+          prefix: "Authorization: Bearer "
+        }
+      },
       apiShapes: [
         {
           id: "openai-chat-completions",
@@ -11637,17 +11679,17 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path49, flags) => fsPromises2.open(path49, flags),
-    readFile: (path49, encoding) => fsPromises2.readFile(path49, encoding),
+    open: (path54, flags) => fsPromises2.open(path54, flags),
+    readFile: (path54, encoding) => fsPromises2.readFile(path54, encoding),
     stat: fsPromises2.stat,
     unlink: fsPromises2.unlink
   };
 }
-async function removeLockFile(fs6, lockPath, signal) {
+async function removeLockFile(fs7, lockPath, signal) {
   for (let attempt = 0; attempt <= 4; attempt += 1) {
     throwIfAborted(signal);
     try {
-      await fs6.unlink(lockPath);
+      await fs7.unlink(lockPath);
       return;
     } catch (error2) {
       if (hasErrorCode(error2, "ENOENT")) {
@@ -11678,12 +11720,12 @@ function parseLockMetadata(content) {
   }
   return void 0;
 }
-async function readLockMetadata(fs6, lockPath) {
-  if (!fs6.readFile) {
+async function readLockMetadata(fs7, lockPath) {
+  if (!fs7.readFile) {
     return void 0;
   }
   try {
-    return parseLockMetadata(await fs6.readFile(lockPath, "utf8"));
+    return parseLockMetadata(await fs7.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode(error2, "ENOENT")) {
       return null;
@@ -11717,7 +11759,7 @@ async function writeLockMetadata(handle) {
   }
 }
 async function acquireFileLock(filePath, options = {}) {
-  const fs6 = options.fs ?? createDefaultFs();
+  const fs7 = options.fs ?? createDefaultFs();
   const retries = options.retries ?? 20;
   const minTimeout = options.minTimeout ?? 25;
   const maxTimeout = options.maxTimeout ?? 250;
@@ -11728,7 +11770,7 @@ async function acquireFileLock(filePath, options = {}) {
   while (attempt <= retries) {
     throwIfAborted(options.signal);
     try {
-      const handle = await fs6.open(lockPath, "wx");
+      const handle = await fs7.open(lockPath, "wx");
       await writeLockMetadata(handle);
       let released = false;
       return async () => {
@@ -11736,7 +11778,7 @@ async function acquireFileLock(filePath, options = {}) {
           return;
         }
         released = true;
-        await removeLockFile(fs6, lockPath, options.signal);
+        await removeLockFile(fs7, lockPath, options.signal);
       };
     } catch (error2) {
       if (!hasErrorCode(error2, "EEXIST")) {
@@ -11745,7 +11787,7 @@ async function acquireFileLock(filePath, options = {}) {
     }
     let stat7;
     try {
-      stat7 = await fs6.stat(lockPath);
+      stat7 = await fs7.stat(lockPath);
     } catch (statError) {
       if (hasErrorCode(statError, "ENOENT")) {
         continue;
@@ -11753,7 +11795,7 @@ async function acquireFileLock(filePath, options = {}) {
       throw statError;
     }
     const reclaimLock = await shouldReclaimLock({
-      fs: fs6,
+      fs: fs7,
       isPidRunning: pidIsRunning,
       lockPath,
       staleMs,
@@ -11763,7 +11805,7 @@ async function acquireFileLock(filePath, options = {}) {
       continue;
     }
     if (reclaimLock) {
-      await removeLockFile(fs6, lockPath, options.signal);
+      await removeLockFile(fs7, lockPath, options.signal);
       continue;
     }
     if (attempt >= retries) {
@@ -11810,7 +11852,7 @@ var init_fs = __esm({
 
 // packages/poe-code-config/src/state/jobs.ts
 import path9 from "node:path";
-function createJobRegistry(homeDir, fs6 = defaultStateFs) {
+function createJobRegistry(homeDir, fs7 = defaultStateFs) {
   const jobsDir = path9.join(homeDir, ".poe-code", "state", "jobs");
   function jobPath(id) {
     assertSafeJobId(id);
@@ -11818,7 +11860,7 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   }
   async function get(id) {
     try {
-      return parseJobEntry(await fs6.readFile(jobPath(id), "utf8"));
+      return parseJobEntry(await fs7.readFile(jobPath(id), "utf8"));
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return null;
@@ -11829,8 +11871,8 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   async function put(entry) {
     assertJobEntry(entry);
     const filePath = jobPath(entry.id);
-    await fs6.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs6 });
+    await fs7.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs7 });
     try {
       await writeJobAtomically(filePath, entry);
     } finally {
@@ -11839,8 +11881,8 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   }
   async function update(id, patch) {
     const filePath = jobPath(id);
-    await fs6.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs6 });
+    await fs7.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs7 });
     try {
       const current = await get(id);
       if (current === null) {
@@ -11861,7 +11903,7 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   async function list(filter = {}) {
     let entries;
     try {
-      entries = await fs6.readdir(jobsDir);
+      entries = await fs7.readdir(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return [];
@@ -11874,11 +11916,11 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
         continue;
       }
       const filePath = path9.join(jobsDir, entry);
-      const stat7 = await fs6.stat(filePath);
+      const stat7 = await fs7.stat(filePath);
       if (!stat7.isFile()) {
         continue;
       }
-      const job = parseJobEntry(await fs6.readFile(filePath, "utf8"));
+      const job = parseJobEntry(await fs7.readFile(filePath, "utf8"));
       if (matchesFilter(job, filter)) {
         jobs.push(job);
       }
@@ -11888,16 +11930,16 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   async function remove2(id) {
     const filePath = jobPath(id);
     try {
-      await fs6.stat(jobsDir);
+      await fs7.stat(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return;
       }
       throw error2;
     }
-    const release = await acquireFileLock(filePath, { fs: fs6 });
+    const release = await acquireFileLock(filePath, { fs: fs7 });
     try {
-      await fs6.unlink(filePath);
+      await fs7.unlink(filePath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -11907,14 +11949,14 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
     }
   }
   async function writeJobAtomically(filePath, entry) {
-    await fs6.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs7.mkdir(path9.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
     try {
-      await fs6.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
+      await fs7.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
 `, {
         encoding: "utf8"
       });
-      await fs6.rename(tempPath, filePath);
+      await fs7.rename(tempPath, filePath);
     } catch (error2) {
       await removeTempFile(tempPath);
       throw error2;
@@ -11922,7 +11964,7 @@ function createJobRegistry(homeDir, fs6 = defaultStateFs) {
   }
   async function removeTempFile(tempPath) {
     try {
-      await fs6.unlink(tempPath);
+      await fs7.unlink(tempPath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -11976,11 +12018,11 @@ var init_jobs2 = __esm({
 
 // packages/poe-code-config/src/state/templates.ts
 import path10 from "node:path";
-function createTemplateRegistry(homeDir, fs6 = defaultStateFs) {
+function createTemplateRegistry(homeDir, fs7 = defaultStateFs) {
   const filePath = path10.join(homeDir, ".poe-code", "state", "templates.json");
   async function readState() {
     try {
-      const raw = await fs6.readFile(filePath, "utf8");
+      const raw = await fs7.readFile(filePath, "utf8");
       return normalizeTemplateState(JSON.parse(raw));
     } catch (error2) {
       if (isNotFoundError(error2)) {
@@ -11990,14 +12032,14 @@ function createTemplateRegistry(homeDir, fs6 = defaultStateFs) {
     }
   }
   async function writeState(state) {
-    await fs6.writeFile(filePath, `${JSON.stringify(state, null, 2)}
+    await fs7.writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, {
       encoding: "utf8"
     });
   }
   async function updateState(mutator) {
-    await fs6.mkdir(path10.dirname(filePath), { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs6 });
+    await fs7.mkdir(path10.dirname(filePath), { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs7 });
     try {
       const state = await readState();
       mutator(state);
@@ -12075,10 +12117,10 @@ var init_templates = __esm({
 
 // packages/poe-code-config/src/state/index.ts
 import os2 from "node:os";
-function createStateManager(homeDir, fs6) {
+function createStateManager(homeDir, fs7) {
   return {
-    templates: createTemplateRegistry(homeDir, fs6),
-    jobs: createJobRegistry(homeDir, fs6)
+    templates: createTemplateRegistry(homeDir, fs7),
+    jobs: createJobRegistry(homeDir, fs7)
   };
 }
 var init_state2 = __esm({
@@ -13760,9 +13802,9 @@ import fsPromises3 from "node:fs/promises";
 import path12 from "node:path";
 import { promisify } from "node:util";
 import fastGlob from "fast-glob";
-async function fileExists(fs6, filePath) {
+async function fileExists(fs7, filePath) {
   try {
-    await fs6.stat(filePath);
+    await fs7.stat(filePath);
     return true;
   } catch {
     return false;
@@ -13800,11 +13842,11 @@ function getOptionalGrepOutputMode(args, key2) {
 function formatDisplayPath(cwd, filePath) {
   return path12.relative(cwd, filePath) || path12.basename(filePath);
 }
-async function sortPathsByModifiedTime(matches, fs6) {
+async function sortPathsByModifiedTime(matches, fs7) {
   const entries = await Promise.all(
     matches.map(async (match) => ({
       path: match,
-      mtimeMs: (await fs6.stat(match)).mtimeMs
+      mtimeMs: (await fs7.stat(match)).mtimeMs
     }))
   );
   entries.sort((left, right) => {
@@ -13815,8 +13857,8 @@ async function sortPathsByModifiedTime(matches, fs6) {
   });
   return entries.map((entry) => entry.path);
 }
-async function defaultSearchContent(options, fs6) {
-  const targetStat = await fs6.stat(options.path);
+async function defaultSearchContent(options, fs7) {
+  const targetStat = await fs7.stat(options.path);
   const searchCwd = targetStat.isDirectory() ? options.path : path12.dirname(options.path);
   const searchTarget = targetStat.isDirectory() ? "." : path12.basename(options.path);
   const args = ["--color", "never"];
@@ -13947,8 +13989,8 @@ var init_poe_agent_plugin_files = __esm({
       const allowedPaths = (options.allowedPaths ?? [cwd]).map(
         (allowedPath) => path12.resolve(cwd, allowedPath)
       );
-      const fs6 = options.fs ?? fsPromises3;
-      const searchContent = options.searchContent ?? ((searchOptions) => defaultSearchContent(searchOptions, fs6));
+      const fs7 = options.fs ?? fsPromises3;
+      const searchContent = options.searchContent ?? ((searchOptions) => defaultSearchContent(searchOptions, fs7));
       const globFiles = options.globFiles ?? defaultGlobFiles;
       const readFileTool = {
         name: "read_file",
@@ -13981,14 +14023,14 @@ var init_poe_agent_plugin_files = __esm({
           const filePath = resolveAllowedPath(cwd, allowedPaths, getRequiredString(args, "path"));
           const imageMimeType = detectImageMimeType(filePath);
           if (imageMimeType !== void 0) {
-            const content2 = await fs6.readFile(filePath);
+            const content2 = await fs7.readFile(filePath);
             return {
               type: "image",
               mimeType: imageMimeType,
               data: Buffer.from(content2).toString("base64")
             };
           }
-          const content = await fs6.readFile(filePath, "utf8");
+          const content = await fs7.readFile(filePath, "utf8");
           return sliceLines(
             content,
             getOptionalNonNegativeInteger(args, "offset") ?? 0,
@@ -14042,7 +14084,7 @@ var init_poe_agent_plugin_files = __esm({
             const oldStr = getRequiredString(args, "old_str", true);
             const newStr = getRequiredString(args, "new_str", true);
             const replaceAll2 = getOptionalBoolean(args, "replace_all") ?? false;
-            const content = await fs6.readFile(filePath, "utf8");
+            const content = await fs7.readFile(filePath, "utf8");
             if (oldStr.length === 0) {
               throw new Error('Tool argument "old_str" must not be empty');
             }
@@ -14053,7 +14095,7 @@ var init_poe_agent_plugin_files = __esm({
             if (!replaceAll2 && count > 1) {
               throw new Error(`old_str appears ${count} times \u2014 must be unique`);
             }
-            await fs6.writeFile(
+            await fs7.writeFile(
               filePath,
               replaceAll2 ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr),
               "utf8"
@@ -14062,17 +14104,17 @@ var init_poe_agent_plugin_files = __esm({
           }
           if (command === "create") {
             const fileText = getRequiredString(args, "file_text", true);
-            if (await fileExists(fs6, filePath)) {
+            if (await fileExists(fs7, filePath)) {
               throw new Error("File already exists \u2014 use str_replace to edit");
             }
-            await fs6.mkdir(path12.dirname(filePath), { recursive: true });
-            await fs6.writeFile(filePath, fileText, "utf8");
+            await fs7.mkdir(path12.dirname(filePath), { recursive: true });
+            await fs7.writeFile(filePath, fileText, "utf8");
             return `Created file: ${displayedPath}`;
           }
           if (command === "overwrite") {
             const fileText = getRequiredString(args, "file_text", true);
-            await fs6.mkdir(path12.dirname(filePath), { recursive: true });
-            await fs6.writeFile(filePath, fileText, "utf8");
+            await fs7.mkdir(path12.dirname(filePath), { recursive: true });
+            await fs7.writeFile(filePath, fileText, "utf8");
             return `Overwrote file: ${displayedPath}`;
           }
           throw new Error(`Unknown edit_file command: ${command}`);
@@ -14097,7 +14139,7 @@ var init_poe_agent_plugin_files = __esm({
         async call(args) {
           const rawPath = getOptionalString(args, "path") ?? ".";
           const directoryPath = resolveAllowedPath(cwd, allowedPaths, rawPath);
-          const entries = await fs6.readdir(directoryPath);
+          const entries = await fs7.readdir(directoryPath);
           const names = entries.sort((left, right) => left.localeCompare(right));
           if (names.length === 0) {
             return "(empty directory)";
@@ -14193,7 +14235,7 @@ var init_poe_agent_plugin_files = __esm({
           });
           const sortedMatches = await sortPathsByModifiedTime(
             matches.map((match) => resolveAllowedPath(cwd, allowedPaths, match)),
-            fs6
+            fs7
           );
           if (sortedMatches.length === 0) {
             return "(no matches)";
@@ -16745,11 +16787,11 @@ async function loadMemory(options) {
   }
   return sections.join("\n\n");
 }
-async function findNearestAgentsFile(cwd, fs6) {
+async function findNearestAgentsFile(cwd, fs7) {
   let currentDirectory = cwd;
   while (true) {
     const filePath = path15.join(currentDirectory, AGENTS_FILE);
-    if (await readOptionalFile(filePath, fs6) !== void 0) {
+    if (await readOptionalFile(filePath, fs7) !== void 0) {
       return filePath;
     }
     const parentDirectory = path15.dirname(currentDirectory);
@@ -16759,15 +16801,15 @@ async function findNearestAgentsFile(cwd, fs6) {
     currentDirectory = parentDirectory;
   }
 }
-async function loadOptionalMemoryFile(filePath, fs6) {
-  const content = await readOptionalFile(filePath, fs6);
+async function loadOptionalMemoryFile(filePath, fs7) {
+  const content = await readOptionalFile(filePath, fs7);
   if (content === void 0) {
     return void 0;
   }
   return await expandImports({
     filePath,
     content,
-    fs: fs6,
+    fs: fs7,
     loading: /* @__PURE__ */ new Set()
   });
 }
@@ -16818,9 +16860,9 @@ ${content}`;
 function normalizeLineEndings(content) {
   return content.split("\r\n").join("\n");
 }
-async function readOptionalFile(filePath, fs6) {
+async function readOptionalFile(filePath, fs7) {
   try {
-    return await fs6.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch (error2) {
     if (isMissingFileError(error2)) {
       return void 0;
@@ -16828,8 +16870,8 @@ async function readOptionalFile(filePath, fs6) {
     throw error2;
   }
 }
-async function readRequiredFile(filePath, fs6) {
-  const content = await readOptionalFile(filePath, fs6);
+async function readRequiredFile(filePath, fs7) {
+  const content = await readOptionalFile(filePath, fs7);
   if (content !== void 0) {
     return content;
   }
@@ -16851,12 +16893,12 @@ var init_poe_agent_plugin_memory = __esm({
     memoryPlugin = (options = {}) => {
       const cwd = path15.resolve(options.cwd ?? process.cwd());
       const homeDir = path15.resolve(options.homeDir ?? os3.homedir());
-      const fs6 = options.fs ?? fsPromises4;
+      const fs7 = options.fs ?? fsPromises4;
       let memoryPromise;
       return {
         name: "poe-agent-plugin-memory",
         async prompt(ctx) {
-          memoryPromise ??= loadMemory({ cwd, homeDir, fs: fs6 });
+          memoryPromise ??= loadMemory({ cwd, homeDir, fs: fs7 });
           const memory = await memoryPromise;
           if (!memory) {
             return ctx;
@@ -20953,9 +20995,9 @@ function validateTaskId(id) {
   }
   return id;
 }
-async function statIfExists(fs6, filePath) {
+async function statIfExists(fs7, filePath) {
   try {
-    return await fs6.stat(filePath);
+    return await fs7.stat(filePath);
   } catch (error2) {
     if (hasErrorCode2(error2, "ENOENT")) {
       return void 0;
@@ -20963,16 +21005,16 @@ async function statIfExists(fs6, filePath) {
     throw error2;
   }
 }
-async function writeAtomically(fs6, filePath, content) {
+async function writeAtomically(fs7, filePath, content) {
   const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
   tmpFileCounter += 1;
-  await fs6.mkdir(path21.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path21.dirname(filePath), { recursive: true });
   try {
-    await fs6.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
-    await fs6.rename(tempPath, filePath);
+    await fs7.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+    await fs7.rename(tempPath, filePath);
   } catch (error2) {
     try {
-      await fs6.unlink(tempPath);
+      await fs7.unlink(tempPath);
     } catch (unlinkError) {
       if (!hasErrorCode2(unlinkError, "ENOENT")) {
         throw unlinkError;
@@ -21909,9 +21951,9 @@ ${stringify(frontmatter)}---
 
 ${description}`;
 }
-async function readDirectoryNames(fs6, directoryPath) {
+async function readDirectoryNames(fs7, directoryPath) {
   try {
-    return sortStrings(await fs6.readdir(directoryPath));
+    return sortStrings(await fs7.readdir(directoryPath));
   } catch (error2) {
     if (hasErrorCode2(error2, "ENOENT")) {
       return [];
@@ -21926,8 +21968,8 @@ async function ensureRootPath(deps) {
   }
   await deps.fs.stat(deps.path);
 }
-async function readTaskFile(fs6, list, id, filePath, validStates, initialState, mode) {
-  const content = await fs6.readFile(filePath, "utf8");
+async function readTaskFile(fs7, list, id, filePath, validStates, initialState, mode) {
+  const content = await fs7.readFile(filePath, "utf8");
   const document = splitTaskDocument(content, filePath, mode);
   const frontmatter = mode === "passthrough" && document.frontmatter.trim().length === 0 ? {} : readFrontmatter(document.frontmatter, filePath);
   if (mode !== "passthrough") {
@@ -21951,8 +21993,8 @@ async function readTaskFile(fs6, list, id, filePath, validStates, initialState,
     task: createTask(list, id, effectiveFrontmatter, document.body, mode, filePath)
   };
 }
-async function findActiveTaskFilename(fs6, listDirectoryPath, id) {
-  const entries = await readDirectoryNames(fs6, listDirectoryPath);
+async function findActiveTaskFilename(fs7, listDirectoryPath, id) {
+  const entries = await readDirectoryNames(fs7, listDirectoryPath);
   for (const entryName of entries) {
     if (isHiddenEntry(entryName) || isLockFile(entryName)) continue;
     const parsed = parseActiveFilename(entryName);
@@ -21962,29 +22004,29 @@ async function findActiveTaskFilename(fs6, listDirectoryPath, id) {
   }
   return void 0;
 }
-async function findTaskLocation(fs6, rootPath, layout, list, id) {
+async function findTaskLocation(fs7, rootPath, layout, list, id) {
   const listDirectoryPath = listPath(rootPath, layout, list);
-  const activeName = await findActiveTaskFilename(fs6, listDirectoryPath, id);
+  const activeName = await findActiveTaskFilename(fs7, listDirectoryPath, id);
   if (activeName) {
     const activePath = path22.join(listDirectoryPath, activeName);
-    const activeStat = await statIfExists(fs6, activePath);
+    const activeStat = await statIfExists(fs7, activePath);
     if (activeStat?.isFile()) {
       return { archived: false, path: activePath };
     }
   }
   const archivedPath = archivedTaskPath(rootPath, layout, list, id);
-  const archivedStat = await statIfExists(fs6, archivedPath);
+  const archivedStat = await statIfExists(fs7, archivedPath);
   if (archivedStat?.isFile()) {
     return { archived: true, path: archivedPath };
   }
   return void 0;
 }
-async function readTaskAtLocation(fs6, rootPath, layout, list, id, validStates, initialState, mode) {
-  const location = await findTaskLocation(fs6, rootPath, layout, list, id);
+async function readTaskAtLocation(fs7, rootPath, layout, list, id, validStates, initialState, mode) {
+  const location = await findTaskLocation(fs7, rootPath, layout, list, id);
   if (!location) {
     throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
   }
-  return readTaskFile(fs6, list, id, location.path, validStates, initialState, mode);
+  return readTaskFile(fs7, list, id, location.path, validStates, initialState, mode);
 }
 function createdFrontmatter(defaults, input, initialState, mode) {
   const frontmatter = mode !== "passthrough" ? {
@@ -22910,8 +22952,8 @@ function serializeDocument(document) {
   return serialized.endsWith("\n") ? serialized : `${serialized}
 `;
 }
-async function readStore(fs6, filePath, validStates) {
-  const content = await fs6.readFile(filePath, "utf8");
+async function readStore(fs7, filePath, validStates) {
+  const content = await fs7.readFile(filePath, "utf8");
   const document = parseStoreDocument(filePath, content);
   const store = document.toJS();
   assertValidStoreRecord(store, filePath);
@@ -23404,9 +23446,9 @@ function defaultFs() {
 function hasErrorCode3(error2, code) {
   return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
 }
-async function directoryExists(fs6, directoryPath) {
+async function directoryExists(fs7, directoryPath) {
   try {
-    return (await fs6.stat(directoryPath)).isDirectory();
+    return (await fs7.stat(directoryPath)).isDirectory();
   } catch (error2) {
     if (hasErrorCode3(error2, "ENOENT") || hasErrorCode3(error2, "ENOTDIR")) {
       return false;
@@ -23434,8 +23476,8 @@ function idFromPlanFileName(fileName) {
   }
   return stem;
 }
-async function readPlanPaths(fs6, directoryPath) {
-  const fileNames = await fs6.readdir(directoryPath);
+async function readPlanPaths(fs7, directoryPath) {
+  const fileNames = await fs7.readdir(directoryPath);
   const pathsById = /* @__PURE__ */ new Map();
   for (const fileName of fileNames) {
     const id = idFromPlanFileName(fileName);
@@ -23443,7 +23485,7 @@ async function readPlanPaths(fs6, directoryPath) {
       continue;
     }
     const absolutePath = path24.join(directoryPath, fileName);
-    const stat7 = await fs6.stat(absolutePath);
+    const stat7 = await fs7.stat(absolutePath);
     if (stat7.isFile()) {
       pathsById.set(id, absolutePath);
     }
@@ -23472,13 +23514,13 @@ function planKind(metadata) {
 }
 async function discoverPlans(options) {
   const resolvedDirectory = resolvePlanDirectory(options);
-  const fs6 = options.fs ?? defaultFs();
-  if (!await directoryExists(fs6, resolvedDirectory)) {
+  const fs7 = options.fs ?? defaultFs();
+  if (!await directoryExists(fs7, resolvedDirectory)) {
     return [];
   }
   const [taskList, pathsById] = await Promise.all([
     openPlanList(options),
-    readPlanPaths(fs6, resolvedDirectory)
+    readPlanPaths(fs7, resolvedDirectory)
   ]);
   const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
   const tasks = await taskList.list(PLAN_LIST_NAME).all();
@@ -23695,29 +23737,29 @@ function wrapForLogTee(argv, jobId) {
   return ["sh", "-c", script];
 }
 async function* streamLogFile(env, jobId, opts) {
-  const fs6 = env.fs ?? nodeFs2;
+  const fs7 = env.fs ?? nodeFs2;
   const file = jobLogPath(jobId);
   let byteOffset = opts.sinceByte ?? 0;
   while (true) {
-    if (opts.since !== void 0 && !await wasModifiedSince(fs6, file, opts.since)) {
-      await waitForLogChange(fs6, file);
+    if (opts.since !== void 0 && !await wasModifiedSince(fs7, file, opts.since)) {
+      await waitForLogChange(fs7, file);
       continue;
     }
-    const result = await readLogChunk(fs6, file, byteOffset);
+    const result = await readLogChunk(fs7, file, byteOffset);
     if (result !== null) {
       byteOffset = result.nextByteOffset;
       yield result.chunk;
       continue;
     }
-    await waitForLogChange(fs6, file);
+    await waitForLogChange(fs7, file);
   }
 }
-async function wasModifiedSince(fs6, file, since) {
-  if (fs6.promises.stat === void 0) {
+async function wasModifiedSince(fs7, file, since) {
+  if (fs7.promises.stat === void 0) {
     return true;
   }
   try {
-    const stat7 = await fs6.promises.stat(file);
+    const stat7 = await fs7.promises.stat(file);
     return stat7.mtimeMs >= since.getTime();
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -23727,11 +23769,11 @@ async function wasModifiedSince(fs6, file, since) {
   }
 }
 async function waitForExit(env, jobId, opts = {}) {
-  const fs6 = env.fs ?? nodeFs2;
+  const fs7 = env.fs ?? nodeFs2;
   const file = jobExitPath(jobId);
   while (true) {
     throwIfAborted2(opts.signal);
-    const contents = await readTextFileIfExists(fs6, file);
+    const contents = await readTextFileIfExists(fs7, file);
     if (contents !== null) {
       const text5 = contents.trim();
       const exitCode = Number(text5);
@@ -23749,8 +23791,8 @@ function jobLogPath(jobId) {
 function jobExitPath(jobId) {
   return `${JOB_DIR}/${jobId}.exit`;
 }
-async function readLogChunk(fs6, file, byteOffset) {
-  const contents = await readFileIfExists2(fs6, file);
+async function readLogChunk(fs7, file, byteOffset) {
+  const contents = await readFileIfExists2(fs7, file);
   if (contents === null || byteOffset >= contents.byteLength) {
     return null;
   }
@@ -23762,13 +23804,13 @@ async function readLogChunk(fs6, file, byteOffset) {
     nextByteOffset: contents.byteLength
   };
 }
-async function readTextFileIfExists(fs6, file) {
-  const contents = await readFileIfExists2(fs6, file);
+async function readTextFileIfExists(fs7, file) {
+  const contents = await readFileIfExists2(fs7, file);
   return contents?.toString("utf8") ?? null;
 }
-async function readFileIfExists2(fs6, file) {
+async function readFileIfExists2(fs7, file) {
   try {
-    const contents = await fs6.promises.readFile(file);
+    const contents = await fs7.promises.readFile(file);
     return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -23777,8 +23819,8 @@ async function readFileIfExists2(fs6, file) {
     throw error2;
   }
 }
-async function waitForLogChange(fs6, file) {
-  const watch = fs6.watch;
+async function waitForLogChange(fs7, file) {
+  const watch = fs7.watch;
   if (typeof watch !== "function") {
     await sleep2(POLL_INTERVAL_MS);
     return;
@@ -24644,7 +24686,7 @@ var init_template_build = __esm({
 // packages/runner-e2b/src/job-handle.ts
 import path28 from "node:path";
 function createE2bJobHandle(input) {
-  const fs6 = createE2bLogStreamFs(input.sandbox);
+  const fs7 = createE2bLogStreamFs(input.sandbox);
   return {
     id: input.jobId,
     envId: input.envId,
@@ -24660,10 +24702,10 @@ function createE2bJobHandle(input) {
       return isRunning ? "running" : "lost";
     },
     stream(opts = {}) {
-      return streamLogFile({ fs: fs6 }, input.jobId, opts);
+      return streamLogFile({ fs: fs7 }, input.jobId, opts);
     },
     async wait() {
-      const result = await waitForExit({ fs: fs6 }, input.jobId);
+      const result = await waitForExit({ fs: fs7 }, input.jobId);
       const preserveMs = input.preserveAfterExitHours * 60 * 60 * 1e3;
       if (preserveMs > 0) {
         await input.sandbox.setTimeout(preserveMs);
@@ -25174,10 +25216,10 @@ import os5 from "node:os";
 import { promises as nodeFs4 } from "node:fs";
 async function resolveE2bApiKey(input) {
   const homeDir = input.homeDir ?? os5.homedir();
-  const fs6 = input.fs ?? nodeFs4;
+  const fs7 = input.fs ?? nodeFs4;
   const env = input.env ?? process.env;
   const document = await readMergedDocument(
-    fs6,
+    fs7,
     resolveConfigPath(homeDir),
     resolveProjectConfigPath(input.cwd)
   );
@@ -25828,6 +25870,29 @@ var init_goose2 = __esm({
   }
 });
 
+// packages/agent-spawn/src/configs/gemini-cli.ts
+var geminiCliAcpSpawnConfig;
+var init_gemini_cli2 = __esm({
+  "packages/agent-spawn/src/configs/gemini-cli.ts"() {
+    "use strict";
+    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
 function getSpawnConfig(input) {
   const resolvedId = resolveAgentId(input);
@@ -25856,6 +25921,7 @@ var init_configs = __esm({
     init_opencode2();
     init_kimi2();
     init_goose2();
+    init_gemini_cli2();
     allSpawnConfigs = [
       claudeCodeSpawnConfig,
       codexSpawnConfig,
@@ -25871,6 +25937,7 @@ var init_configs = __esm({
     acpLookup.set(openCodeAcpSpawnConfig.agentId, openCodeAcpSpawnConfig);
     acpLookup.set(kimiAcpSpawnConfig.agentId, kimiAcpSpawnConfig);
     acpLookup.set(gooseAcpSpawnConfig.agentId, gooseAcpSpawnConfig);
+    acpLookup.set(geminiCliAcpSpawnConfig.agentId, geminiCliAcpSpawnConfig);
   }
 });
 
@@ -26373,6 +26440,10 @@ var init_configs2 = __esm({
         globalSkillDir: "~/.codex/skills",
         localSkillDir: ".codex/skills"
       },
+      "gemini-cli": {
+        globalSkillDir: "~/.gemini/skills",
+        localSkillDir: ".gemini/skills"
+      },
       opencode: {
         globalSkillDir: "~/.config/opencode/skills",
         localSkillDir: ".opencode/skills"
@@ -26567,10 +26638,10 @@ function resolveExcludePath(cwd) {
   }
   return path34.join(path34.isAbsolute(gitDir) ? gitDir : path34.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) {
@@ -26586,8 +26657,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) {
@@ -26602,23 +26673,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;
   }
   fs2.mkdirSync(path34.dirname(excludePath), { recursive: true });
   const content = readExcludeFile(excludePath);
-  fs2.writeFileSync(excludePath, appendBlock(content, runId, entries), "utf8");
+  fs2.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;
@@ -26627,13 +26702,17 @@ function removeExcludeBlock(cwd, runId) {
   if (content === void 0) {
     return;
   }
-  fs2.writeFileSync(excludePath, removeBlock(content, runId), "utf8");
+  fs2.writeFileSync(
+    excludePath,
+    removeBlock(content, runId, opts?.markerPrefix ?? defaultMarkerPrefix),
+    "utf8"
+  );
 }
-var markerPrefix, gitDirRunner;
+var defaultMarkerPrefix, gitDirRunner;
 var init_git_exclude = __esm({
   "packages/agent-skill-config/src/git-exclude.ts"() {
     "use strict";
-    markerPrefix = "# poe-code-spawn-skills:";
+    defaultMarkerPrefix = "poe-code-spawn-skills";
     gitDirRunner = defaultGitDirRunner;
   }
 });
@@ -26861,29 +26940,748 @@ var init_src15 = __esm({
   }
 });
 
+// packages/agent-hook-config/src/configs.ts
+import os7 from "node:os";
+import path36 from "node:path";
+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 = os7.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 : path36.join(homeDir, remainder);
+}
+function resolveHookPath(config, scope, cwd, homeDir) {
+  if (scope === "global") {
+    return path36.resolve(expandHome3(config.globalHookPath, homeDir));
+  }
+  return config.localHookPath ? path36.resolve(cwd, config.localHookPath) : void 0;
+}
+var agentHookConfigs, supportedHookAgents;
+var init_configs3 = __esm({
+  "packages/agent-hook-config/src/configs.ts"() {
+    "use strict";
+    init_src5();
+    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"
+        }
+      }
+    };
+    supportedHookAgents = Object.keys(agentHookConfigs);
+  }
+});
+
+// packages/agent-hook-config/src/read-hooks.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import path37 from "node:path";
+function readSettingsFile(filePath) {
+  let content;
+  try {
+    content = readFileSync4(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 = path37.resolve(cwd, ".claude/settings.json");
+  const userPath = path37.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;
+}
+var init_read_hooks = __esm({
+  "packages/agent-hook-config/src/read-hooks.ts"() {
+    "use strict";
+  }
+});
+
+// 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((key2) => {
+    const from = source.placeholders[key2];
+    const to = target.placeholders[key2];
+    if (!from || !to || from === to) {
+      return [];
+    }
+    return [{ from, to }];
+  });
+}
+var init_event_mapping = __esm({
+  "packages/agent-hook-config/src/event-mapping.ts"() {
+    "use strict";
+    init_configs3();
+  }
+});
+
+// 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;
+}
+var init_transform_hooks = __esm({
+  "packages/agent-hook-config/src/transform-hooks.ts"() {
+    "use strict";
+    init_event_mapping();
+  }
+});
+
+// packages/agent-hook-config/src/write-hooks.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path38 from "node:path";
+function isGeneratedHandler(handler) {
+  return handler.statusMessage?.startsWith("[generated:") ?? false;
+}
+function parseHooksFile(targetPath) {
+  let content;
+  try {
+    content = readFileSync5(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(path38.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
+  };
+}
+var init_write_hooks = __esm({
+  "packages/agent-hook-config/src/write-hooks.ts"() {
+    "use strict";
+  }
+});
+
+// packages/agent-hook-config/src/symlink-hooks.ts
+import {
+  closeSync,
+  lstatSync,
+  mkdirSync as mkdirSync4,
+  openSync,
+  readlinkSync,
+  readSync,
+  symlinkSync,
+  unlinkSync
+} from "node:fs";
+import path39 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 isRecord10(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 (!isRecord10(parsed)) {
+    return false;
+  }
+  if (Object.keys(parsed).some((key2) => key2 !== "hooks")) {
+    return false;
+  }
+  const hooks = parsed.hooks;
+  if (!isRecord10(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 (!isRecord10(group) || !Array.isArray(group.hooks)) {
+        return false;
+      }
+      for (const handler of group.hooks) {
+        if (!isRecord10(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(path39.dirname(symlinkPath), { recursive: true });
+  symlinkSync(targetPath, symlinkPath);
+  return { symlinkPath, targetPath, replaced };
+}
+var init_symlink_hooks = __esm({
+  "packages/agent-hook-config/src/symlink-hooks.ts"() {
+    "use strict";
+    init_configs3();
+  }
+});
+
+// packages/agent-hook-config/src/bridge-hooks.ts
+import * as fs4 from "node:fs";
+import path40 from "node:path";
+function isNodeError4(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+function pathExists3(targetPath) {
+  try {
+    fs4.lstatSync(targetPath);
+    return true;
+  } catch (error2) {
+    if (isNodeError4(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function collectMissingParents2(targetPath) {
+  const parents = [];
+  let current = path40.dirname(targetPath);
+  while (!pathExists3(current)) {
+    parents.push(current);
+    const parent = path40.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return parents.reverse();
+}
+function removeDirectoryIfEmpty2(targetPath) {
+  try {
+    fs4.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 = fs4.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) {
+  fs4.writeFileSync(targetPath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+function hasOnlyEmptyHooks(file) {
+  return Object.keys(file).every((key2) => key2 === "hooks") && Object.values(file.hooks ?? {}).every((groups) => groups.length === 0);
+}
+function relativeToCwd(cwd, targetPath) {
+  return path40.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 (fs4.lstatSync(manifest.symlinkPath).isSymbolicLink() && fs4.readlinkSync(manifest.symlinkPath) === manifest.symlinkTarget) {
+        fs4.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)) {
+        fs4.unlinkSync(manifest.writtenPath);
+      } else {
+        writeCodexFile(manifest.writtenPath, file);
+      }
+    }
+    for (const parent of [...manifest.createdParents ?? []].reverse()) {
+      removeDirectoryIfEmpty2(parent);
+    }
+  }
+  removeExcludeBlock(manifest.cwd, manifest.runId, { markerPrefix: hookExcludeMarkerPrefix });
+}
+var hookExcludeMarkerPrefix;
+var init_bridge_hooks = __esm({
+  "packages/agent-hook-config/src/bridge-hooks.ts"() {
+    "use strict";
+    init_src15();
+    init_configs3();
+    init_read_hooks();
+    init_symlink_hooks();
+    init_transform_hooks();
+    init_write_hooks();
+    hookExcludeMarkerPrefix = "poe-code-spawn-hooks";
+  }
+});
+
+// packages/agent-hook-config/src/index.ts
+var init_src16 = __esm({
+  "packages/agent-hook-config/src/index.ts"() {
+    "use strict";
+    init_configs3();
+    init_read_hooks();
+    init_event_mapping();
+    init_transform_hooks();
+    init_write_hooks();
+    init_symlink_hooks();
+    init_bridge_hooks();
+  }
+});
+
 // packages/agent-spawn/src/skill-bridge.ts
 import crypto4 from "node:crypto";
-import os7 from "node:os";
-function bridgeSkillsForRun(agentId, cwd, skills2) {
-  if (!skills2 || skills2.length === 0) {
+import os8 from "node:os";
+function bridgeResourcesForRun(agentId, cwd, skills2, hooks) {
+  if ((!skills2 || skills2.length === 0) && !hooks) {
     return void 0;
   }
-  const manifest = bridgeActiveSkills(agentId, cwd, skills2, os7.homedir(), crypto4.randomUUID());
-  for (const warning2 of manifest.warnings) {
-    logger.warn(warning2.message);
+  const runId = crypto4.randomUUID();
+  const manifests = {};
+  try {
+    if (skills2 && skills2.length > 0) {
+      manifests.skills = bridgeActiveSkills(agentId, cwd, skills2, os8.homedir(), runId);
+      for (const warning2 of manifests.skills.warnings) {
+        logger.warn(warning2.message);
+      }
+    }
+    if (hooks) {
+      manifests.hooks = bridgeHooks(hooks.from, agentId, cwd, os8.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);
+  }
 }
 var init_skill_bridge = __esm({
   "packages/agent-spawn/src/skill-bridge.ts"() {
     "use strict";
     init_src15();
+    init_src16();
     init_src2();
   }
 });
@@ -26996,21 +27794,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 path49;
+        let path54;
         if (typeof item.content === "string") {
-          path49 = item.content;
+          path54 = item.content;
         } else {
           try {
-            path49 = JSON.stringify(item.content);
+            path54 = JSON.stringify(item.content);
           } catch {
-            path49 = String(item.content);
+            path54 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path49
+          path: path54
         };
       }
     }
@@ -27133,10 +27931,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 path49 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path54 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path49 };
+        yield { event: "tool_complete", id: item.id, kind, path: path54 };
       }
     }
   }
@@ -27714,7 +28512,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())) {
@@ -27765,7 +28563,7 @@ function spawnStreaming(options) {
         ...ctx.logFile && !result.logFile ? { logFile: ctx.logFile } : {}
       };
     } finally {
-      cleanupSkillsForRun(manifest);
+      cleanupResourcesForRun(manifest);
     }
   })();
   return {
@@ -27802,8 +28600,8 @@ var init_spawn = __esm({
 });
 
 // packages/agent-spawn/src/spawn.ts
-import { mkdirSync as mkdirSync3, openSync, writeSync, closeSync } from "node:fs";
-import path36 from "node:path";
+import { mkdirSync as mkdirSync5, openSync as openSync2, writeSync, closeSync as closeSync2 } from "node:fs";
+import path41 from "node:path";
 function createAbortError6() {
   const error2 = new Error("Agent spawn aborted");
   error2.name = "AbortError";
@@ -27927,7 +28725,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);
@@ -27995,7 +28793,7 @@ async function runSpawn(agentId, options, context) {
     };
   } finally {
     closeSpawnLog(logFd);
-    cleanupSkillsForRun(manifest);
+    cleanupResourcesForRun(manifest);
   }
 }
 function resolveSpawnLogPath(options) {
@@ -28005,12 +28803,12 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path36.join(options.logDir, options.logFileName);
+  return path41.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync3(path36.dirname(filePath), { recursive: true });
-    return openSync(filePath, "a");
+    mkdirSync5(path41.dirname(filePath), { recursive: true });
+    return openSync2(filePath, "a");
   } catch {
     return void 0;
   }
@@ -28025,7 +28823,7 @@ function appendSpawnLog(fd, chunk) {
 function closeSpawnLog(fd) {
   if (fd === void 0) return;
   try {
-    closeSync(fd);
+    closeSync2(fd);
   } catch {
   }
 }
@@ -28187,7 +28985,7 @@ var init_autonomous = __esm({
 });
 
 // packages/agent-spawn/src/acp/replay.ts
-import path37 from "node:path";
+import path42 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { open as open2, readdir as readdir2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -28278,7 +29076,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path49 = readString(event.path);
+  const path54 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -28293,8 +29091,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path49) {
-    toolCall.path = path49;
+  if (path54) {
+    toolCall.path = path54;
   }
 }
 var sessionCapture;
@@ -28380,7 +29178,7 @@ var init_usage_capture = __esm({
 });
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path38 from "node:path";
+import path43 from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { mkdir as mkdir2, open as open3 } from "node:fs/promises";
 function pad2(value, width) {
@@ -28417,14 +29215,14 @@ function resolveLogFilePath(ctx) {
   if (ctx.logPath) {
     return ctx.logPath;
   }
-  const baseDir = ctx.logDir ?? path38.join(homedir4(), ".poe-code", "spawn-logs");
+  const baseDir = ctx.logDir ?? path43.join(homedir4(), ".poe-code", "spawn-logs");
   if (ctx.logFileName) {
-    return path38.join(baseDir, ctx.logFileName);
+    return path43.join(baseDir, ctx.logFileName);
   }
   const startedAt = resolveStartedAt(ctx.startedAt);
   const { day, time, milliseconds } = formatTimestamp(startedAt);
   const fileName = `${day}-${time}-${milliseconds}-${normalizeAgent(ctx.agent)}.jsonl`;
-  return path38.join(baseDir, fileName);
+  return path43.join(baseDir, fileName);
 }
 async function writePreloadedEvents(writer, events) {
   for (const event of events) {
@@ -28442,7 +29240,7 @@ var init_spawn_log = __esm({
       logDirPath;
       constructor(ctx) {
         this.filePath = resolveLogFilePath(ctx);
-        this.logDirPath = path38.dirname(this.filePath);
+        this.logDirPath = path43.dirname(this.filePath);
       }
       async writeEvent(event) {
         if (this.isDisabled) {
@@ -28510,7 +29308,7 @@ var init_spawn_log = __esm({
 });
 
 // packages/agent-spawn/src/index.ts
-var init_src16 = __esm({
+var init_src17 = __esm({
   "packages/agent-spawn/src/index.ts"() {
     "use strict";
     init_register_factories();
@@ -28543,7 +29341,7 @@ var gitContext, poe_agent_plugin_git_context_default;
 var init_poe_agent_plugin_git_context = __esm({
   "packages/poe-agent/src/plugins/poe-agent-plugin-git-context.ts"() {
     "use strict";
-    init_src16();
+    init_src17();
     gitContext = (cwd) => ({
       name: "git-context",
       async prompt(ctx) {
@@ -28782,7 +29580,7 @@ __export(src_exports, {
   systemPromptPlugin: () => poe_agent_plugin_system_prompt_default,
   webPlugin: () => poe_agent_plugin_web_default
 });
-var init_src17 = __esm({
+var init_src18 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent();
@@ -28814,7 +29612,7 @@ var init_src17 = __esm({
 
 // src/providers/poe-agent.ts
 import fsPromises10 from "node:fs/promises";
-import os8 from "node:os";
+import os9 from "node:os";
 
 // src/cli/constants.ts
 var DEFAULT_FRONTIER_MODEL = "anthropic/claude-opus-4.7";
@@ -28944,6 +29742,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, {
@@ -28995,16 +29794,16 @@ function createInstallRunner(definition) {
 // src/services/config.ts
 init_src4();
 init_src8();
-init_src17();
-import path48 from "node:path";
+init_src18();
+import path53 from "node:path";
 
 // packages/superintendent/src/document/parse.ts
-import path39 from "node:path";
+import path44 from "node:path";
 import { parseDocument as parseDocument4 } from "yaml";
 var superintendentDocumentSchemaId = "https://poe-platform.github.io/poe-code/schemas/plans/superintendent.schema.json";
 var validStatusStates = /* @__PURE__ */ new Set(["in_progress", "review", "completed"]);
 function parseSuperintendentDoc(filePath, content) {
-  const resolvedFilePath = path39.resolve(filePath);
+  const resolvedFilePath = path44.resolve(filePath);
   const { frontmatterText, body } = splitFrontmatter(resolvedFilePath, content);
   const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
   return {
@@ -29014,7 +29813,7 @@ function parseSuperintendentDoc(filePath, content) {
   };
 }
 function readExplicitBuilderAgent(filePath, content) {
-  const resolvedFilePath = path39.resolve(filePath);
+  const resolvedFilePath = path44.resolve(filePath);
   const { frontmatterText } = splitFrontmatter(resolvedFilePath, content);
   const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
   const frontmatter = expectRecord(parsedFrontmatter, "frontmatter", resolvedFilePath);
@@ -29171,7 +29970,7 @@ function parseStatusBlock(value, filePath) {
   };
 }
 function expectRecord(value, fieldName, filePath) {
-  if (!isRecord10(value)) {
+  if (!isRecord11(value)) {
     throw new Error(`${filePath}: ${fieldName} must be a mapping`);
   }
   return value;
@@ -29200,12 +29999,12 @@ function expectStringArray(value, fieldName, filePath) {
   }
   return value;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // packages/superintendent/src/document/write.ts
-import path40 from "node:path";
+import path45 from "node:path";
 import { isMap as isMap2, parseDocument as parseDocument5 } from "yaml";
 function updateStatus(filePath, content, status) {
   return updateFrontmatter(filePath, content, (frontmatterDocument) => {
@@ -29226,7 +30025,7 @@ function setStatusReason(filePath, content, reason) {
   });
 }
 function updateFrontmatter(filePath, content, mutate) {
-  const resolvedFilePath = path40.resolve(filePath);
+  const resolvedFilePath = path45.resolve(filePath);
   const parts = splitDocument(resolvedFilePath, content);
   const frontmatterDocument = parseDocument5(parts.frontmatterText);
   if (frontmatterDocument.errors.length > 0) {
@@ -29452,7 +30251,7 @@ function extractText(node) {
 
 // packages/superintendent/src/runtime/loop.ts
 init_src13();
-import path43 from "node:path";
+import path48 from "node:path";
 import * as fsPromises8 from "node:fs/promises";
 
 // packages/superintendent/src/state/machine.ts
@@ -29471,9 +30270,9 @@ function createLoopState(doc) {
 // packages/superintendent/src/runtime/agent-runner.ts
 init_register_factories();
 init_src13();
-init_src16();
-import { mkdirSync as mkdirSync4, openSync as openSync2, writeSync as writeSync2, closeSync as closeSync2 } from "node:fs";
-import path41 from "node:path";
+init_src17();
+import { mkdirSync as mkdirSync6, openSync as openSync3, writeSync as writeSync2, closeSync as closeSync3 } from "node:fs";
+import path46 from "node:path";
 var injectedRunner;
 async function withAutonomousAgentRunner(runner, operation) {
   const previous = injectedRunner;
@@ -29561,8 +30360,8 @@ async function runAutonomousAgent(input) {
 }
 function openSpawnLog2(filePath) {
   try {
-    mkdirSync4(path41.dirname(filePath), { recursive: true });
-    return openSync2(filePath, "a");
+    mkdirSync6(path46.dirname(filePath), { recursive: true });
+    return openSync3(filePath, "a");
   } catch {
     return void 0;
   }
@@ -29577,7 +30376,7 @@ function appendSpawnLog2(fd, chunk) {
 function closeSpawnLog2(fd) {
   if (fd === void 0) return;
   try {
-    closeSync2(fd);
+    closeSync3(fd);
   } catch {
   }
 }
@@ -29586,15 +30385,15 @@ function closeSpawnLog2(fd) {
 init_register_factories();
 
 // packages/superintendent/src/runtime/resolve-cwd.ts
-import path42 from "node:path";
+import path47 from "node:path";
 function resolveRoleCwd(role, docPath, defaultCwd) {
   if (role.cwd === void 0) {
     return defaultCwd;
   }
-  if (path42.isAbsolute(role.cwd)) {
+  if (path47.isAbsolute(role.cwd)) {
     return role.cwd;
   }
-  return path42.resolve(path42.dirname(docPath), role.cwd);
+  return path47.resolve(path47.dirname(docPath), role.cwd);
 }
 
 // packages/superintendent/src/runtime/templates.ts
@@ -29614,9 +30413,9 @@ function collectReferencedInspectors(template) {
   return names;
 }
 function readTemplateValue(context, variablePath) {
-  return variablePath.split(".").reduce((value, segment) => isRecord11(value) ? value[segment] : void 0, context);
+  return variablePath.split(".").reduce((value, segment) => isRecord12(value) ? value[segment] : void 0, context);
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -29875,7 +30674,7 @@ function createWorkflowTool(role, state) {
   };
 }
 function parseWorkflowCall(input) {
-  if (!isRecord12(input)) {
+  if (!isRecord13(input)) {
     throw invalidActionError();
   }
   const { action } = input;
@@ -29947,7 +30746,7 @@ function invalidActionError() {
     'workflow_transition action must be one of "request_review", "approve_completion", or "request_changes"'
   );
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -30037,7 +30836,7 @@ function collectToolNames(result) {
   }
   const names = [];
   collectToolNamesFrom(result.toolCalls, names);
-  if (isRecord13(result.sessionResult)) {
+  if (isRecord14(result.sessionResult)) {
     collectToolNamesFrom(result.sessionResult.toolCalls, names);
   }
   return names;
@@ -30082,13 +30881,13 @@ function readTransitionFromToolCalls(value) {
   return void 0;
 }
 function readTransitionFromSessionResult(value) {
-  if (!isRecord13(value)) {
+  if (!isRecord14(value)) {
     return void 0;
   }
   return readTransitionFromToolCalls(value.toolCalls);
 }
 function readToolCall(value) {
-  return isRecord13(value) ? value : void 0;
+  return isRecord14(value) ? value : void 0;
 }
 function readToolCallName(toolCall) {
   return readString4(toolCall.name) ?? readString4(toolCall.tool) ?? readString4(toolCall.title) ?? readString4(toolCall.path);
@@ -30125,7 +30924,7 @@ function encodeJson(value) {
 function readString4(value) {
   return typeof value === "string" ? value : void 0;
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -30234,7 +31033,7 @@ function readTransitionFromToolCalls2(value) {
   return void 0;
 }
 function readTransitionFromSessionResult2(value) {
-  if (!isRecord14(value)) {
+  if (!isRecord15(value)) {
     return void 0;
   }
   return readTransitionFromToolCalls2(value.toolCalls);
@@ -30259,7 +31058,7 @@ function extractOutputText(result) {
   return readString5(result.output) ?? readString5(result.stdout) ?? readString5(result.text) ?? "";
 }
 function readToolCall2(value) {
-  return isRecord14(value) ? value : void 0;
+  return isRecord15(value) ? value : void 0;
 }
 function readToolCallName2(toolCall) {
   return readString5(toolCall.name) ?? readString5(toolCall.tool) ?? readString5(toolCall.title) ?? readString5(toolCall.path);
@@ -30299,7 +31098,7 @@ function splitLines(value) {
 function readString5(value) {
   return typeof value === "string" ? value : void 0;
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -30330,8 +31129,15 @@ async function runLoop2(input, callbacks) {
           options.callbacks.onBuilderStart?.();
           let builderResult;
           try {
+            const builderDoc = await readDocument2(options.fs, options.docPath);
             builderResult = await options.runners.builder(
-              await readDocument2(options.fs, options.docPath),
+              options.builderAgent ? {
+                ...builderDoc,
+                frontmatter: {
+                  ...builderDoc.frontmatter,
+                  builder: { ...builderDoc.frontmatter.builder, agent: options.builderAgent }
+                }
+              } : builderDoc,
               createTemplateContext(context),
               buildRoleOptions(options, "builder")
             );
@@ -30433,7 +31239,9 @@ async function runLoop2(input, callbacks) {
         if (context.ownerFeedback && shouldContinueReview(await readDocument2(options.fs, options.docPath))) {
           const superintendentResult = await executeSuperintendent(options, context);
           if (superintendentResult.transition?.action !== "request_review") {
-            throw new Error("Superintendent must call request_review to continue a review exchange");
+            throw new Error(
+              "Superintendent must call request_review to continue a review exchange"
+            );
           }
           context = {
             ...context,
@@ -30511,6 +31319,7 @@ function normalizeOptions(input, callbacks) {
       callbacks: input.callbacks ?? {},
       runners: resolveRunners(input.runners),
       ...input.runAgent ? { runAgent: input.runAgent } : {},
+      ...input.builderAgent ? { builderAgent: input.builderAgent } : {},
       ...input.signal ? { signal: input.signal } : {},
       ...input.logDir ? { logDir: input.logDir } : {}
     };
@@ -30535,7 +31344,7 @@ function resolveRunners(overrides) {
   };
 }
 function createDefaultFs3() {
-  const fs6 = {
+  const fs7 = {
     readFile: fsPromises8.readFile,
     writeFile: fsPromises8.writeFile,
     readdir: fsPromises8.readdir,
@@ -30561,26 +31370,26 @@ function createDefaultFs3() {
       await fsPromises8.rename(oldPath, newPath);
     }
   };
-  return fs6;
+  return fs7;
 }
-async function readDocument2(fs6, docPath) {
-  const content = await readDocumentContent(fs6, docPath);
+async function readDocument2(fs7, docPath) {
+  const content = await readDocumentContent(fs7, docPath);
   return parseSuperintendentDoc(docPath, content);
 }
-async function readDocumentContent(fs6, docPath) {
-  return fs6.readFile(docPath, "utf8");
+async function readDocumentContent(fs7, docPath) {
+  return fs7.readFile(docPath, "utf8");
 }
-async function writeLoopState(fs6, docPath, state) {
-  const content = await fs6.readFile(docPath, "utf8");
+async function writeLoopState(fs7, docPath, state) {
+  const content = await fs7.readFile(docPath, "utf8");
   const updatedContent = updateStatus(docPath, content, {
     state: state.state,
     round: state.round,
     review_turn: state.reviewTurn
   });
-  await fs6.writeFile(docPath, updatedContent, { encoding: "utf8" });
+  await fs7.writeFile(docPath, updatedContent, { encoding: "utf8" });
 }
-async function restoreDocument(fs6, docPath, content) {
-  await fs6.writeFile(docPath, content, { encoding: "utf8" });
+async function restoreDocument(fs7, docPath, content) {
+  await fs7.writeFile(docPath, content, { encoding: "utf8" });
 }
 async function rollbackRoundStatus(options, state) {
   await writeLoopState(options.fs, options.docPath, state);
@@ -30649,7 +31458,7 @@ async function executeSuperintendent(options, context) {
 function buildRoleOptions(options, role) {
   return {
     defaultCwd: options.cwd,
-    ...options.logDir ? { logPath: path43.join(options.logDir, makeRunLogFileName(role)) } : {}
+    ...options.logDir ? { logPath: path48.join(options.logDir, makeRunLogFileName(role)) } : {}
   };
 }
 function shouldContinueReview(doc) {
@@ -30912,8 +31721,8 @@ var S = {
 };
 
 // packages/toolcraft/src/package-metadata.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import path44 from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
+import path49 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/toolcraft/src/index.ts
@@ -31280,8 +32089,8 @@ function createBuilderRunCommand(runners) {
     positional: ["path"],
     params: builderRunParams,
     scope: ["cli", "mcp", "sdk"],
-    handler: async ({ params, fs: fs6 }) => {
-      const content = await readDocument3(params.path, fs6);
+    handler: async ({ params, fs: fs7 }) => {
+      const content = await readDocument3(params.path, fs7);
       const document = parseSuperintendentDoc(params.path, content);
       return runBuilderImpl(document, {}, { defaultCwd: process.cwd() });
     },
@@ -31308,9 +32117,9 @@ function createBuilderGroup(runners) {
   });
 }
 var builderGroup = createBuilderGroup();
-async function readDocument3(filePath, fs6) {
+async function readDocument3(filePath, fs7) {
   try {
-    return await fs6.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch (error2) {
     if (hasCode2(error2, "ENOENT")) {
       throw new UserError(`Superintendent document not found: ${filePath}`);
@@ -31339,13 +32148,13 @@ function hasCode2(error2, code) {
 }
 
 // packages/superintendent/src/commands/install.ts
-import path45 from "node:path";
+import path50 from "node:path";
 import { readFile as readFile8, stat as stat4, mkdir as mkdir4, writeFile as writeFile3, unlink as unlink3, readdir as readdir4, chmod as chmod2 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 init_src8();
 init_src15();
 init_src13();
-var fs4 = {
+var fs5 = {
   readFile: (p, encoding) => readFile8(p, encoding),
   writeFile: (p, content) => writeFile3(p, content),
   mkdir: (p, options) => mkdir4(p, options).then(() => void 0),
@@ -31386,7 +32195,7 @@ var installCommand = defineCommand({
         content: skillContent + "\n\n" + skillPlanConfigSection("superintendent")
       },
       {
-        fs: fs4,
+        fs: fs5,
         cwd,
         homeDir,
         scope
@@ -31395,7 +32204,7 @@ var installCommand = defineCommand({
     const planDirectory = await resolvePlanDirectory2(cwd, homeDir, process.env);
     const absolutePlanDirectory = resolveAbsoluteDirectory(planDirectory, cwd, homeDir);
     let planDirectoryCreated = false;
-    if (!await pathExists3(absolutePlanDirectory)) {
+    if (!await pathExists4(absolutePlanDirectory)) {
       await mkdir4(absolutePlanDirectory, { recursive: true });
       planDirectoryCreated = true;
     }
@@ -31436,16 +32245,16 @@ var installCommand = defineCommand({
 async function resolvePlanDirectory2(cwd, homeDir, env) {
   const configPath = resolveConfigPath(homeDir);
   const projectConfigPath = resolveProjectConfigPath(cwd);
-  const document = await readMergedDocument(fs4, configPath, projectConfigPath);
+  const document = await readMergedDocument(fs5, configPath, projectConfigPath);
   return resolveScope(planConfigScope.schema, document.plan, env).plan_directory;
 }
 function resolveAbsoluteDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path45.join(homeDir, dir.slice(2));
+    return path50.join(homeDir, dir.slice(2));
   }
-  return path45.isAbsolute(dir) ? dir : path45.resolve(cwd, dir);
+  return path50.isAbsolute(dir) ? dir : path50.resolve(cwd, dir);
 }
-async function pathExists3(targetPath) {
+async function pathExists4(targetPath) {
   try {
     await stat4(targetPath);
     return true;
@@ -31463,15 +32272,15 @@ async function loadSkillTemplate() {
   }
   const packageRoot = await findPackageRoot(fileURLToPath5(import.meta.url));
   const templateRoots = [
-    path45.join(packageRoot, "src", "templates"),
-    path45.join(packageRoot, "dist", "templates")
+    path50.join(packageRoot, "src", "templates"),
+    path50.join(packageRoot, "dist", "templates")
   ];
   for (const templateRoot of templateRoots) {
-    if (!await pathExists3(templateRoot)) {
+    if (!await pathExists4(templateRoot)) {
       continue;
     }
     skillTemplateCache = await readFile8(
-      path45.join(templateRoot, "SKILL_superintendent.md"),
+      path50.join(templateRoot, "SKILL_superintendent.md"),
       "utf8"
     );
     return skillTemplateCache;
@@ -31479,12 +32288,12 @@ async function loadSkillTemplate() {
   throw new Error("Unable to locate Superintendent skill template.");
 }
 async function findPackageRoot(entryFilePath) {
-  let currentPath = path45.dirname(entryFilePath);
+  let currentPath = path50.dirname(entryFilePath);
   while (true) {
-    if (await pathExists3(path45.join(currentPath, "package.json"))) {
+    if (await pathExists4(path50.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path45.dirname(currentPath);
+    const parentPath = path50.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Superintendent templates.");
     }
@@ -31506,8 +32315,8 @@ var inspectorListCommand = defineCommand({
   positional: ["path"],
   params: inspectorListParams,
   scope: ["cli", "mcp", "sdk"],
-  handler: async ({ params, fs: fs6 }) => {
-    const content = await readDocument4(params.path, fs6);
+  handler: async ({ params, fs: fs7 }) => {
+    const content = await readDocument4(params.path, fs7);
     const document = parseSuperintendentDoc(params.path, content);
     return Object.entries(document.frontmatter.inspectors ?? {}).map(([name, config]) => ({
       name,
@@ -31550,8 +32359,8 @@ function createInspectorRunCommand(runners) {
     positional: ["path", "name"],
     params: inspectorRunParams,
     scope: ["cli", "mcp", "sdk"],
-    handler: async ({ params, fs: fs6 }) => {
-      const content = await readDocument4(params.path, fs6);
+    handler: async ({ params, fs: fs7 }) => {
+      const content = await readDocument4(params.path, fs7);
       const document = parseSuperintendentDoc(params.path, content);
       const defaultCwd = process.cwd();
       if (params.name === void 0) {
@@ -31589,9 +32398,9 @@ function createInspectorGroup(runners) {
   });
 }
 var inspectorGroup = createInspectorGroup();
-async function readDocument4(filePath, fs6) {
+async function readDocument4(filePath, fs7) {
   try {
-    return await fs6.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch (error2) {
     if (hasCode3(error2, "ENOENT")) {
       throw new UserError(`Superintendent document not found: ${filePath}`);
@@ -31639,11 +32448,11 @@ var completeCommand = defineCommand({
   positional: ["path"],
   params: completeParams,
   scope: ["cli", "mcp", "sdk"],
-  handler: async ({ params, fs: fs6 }) => {
-    const content = await readDocument5(params.path, fs6);
+  handler: async ({ params, fs: fs7 }) => {
+    const content = await readDocument5(params.path, fs7);
     const completedContent = transitionState(params.path, content, "completed");
     const updatedContent = setStatusReason(params.path, completedContent, params.reason);
-    await fs6.writeFile(params.path, updatedContent);
+    await fs7.writeFile(params.path, updatedContent);
     return {
       path: params.path,
       state: "completed",
@@ -31667,9 +32476,9 @@ var completeCommand = defineCommand({
     json: (result) => result
   }
 });
-async function readDocument5(filePath, fs6) {
+async function readDocument5(filePath, fs7) {
   try {
-    return await fs6.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch (error2) {
     if (hasCode4(error2, "ENOENT")) {
       throw new UserError(`Superintendent document not found: ${filePath}`);
@@ -31682,10 +32491,10 @@ function hasCode4(error2, code) {
 }
 
 // packages/superintendent/src/commands/plan-path.ts
-import path46 from "node:path";
+import path51 from "node:path";
 import { readFile as readFile9, writeFile as writeFile4, mkdir as mkdir5, unlink as unlink4, stat as stat5, readdir as readdir5 } from "node:fs/promises";
 init_src8();
-var fs5 = {
+var fs6 = {
   readFile: (p, encoding) => readFile9(p, encoding),
   writeFile: (p, content) => writeFile4(p, content),
   mkdir: (p, options) => mkdir5(p, options).then(() => void 0),
@@ -31703,7 +32512,7 @@ var planPathCommand = defineCommand({
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? cwd;
     const configPath = resolveConfigPath(homeDir);
     const projectConfigPath = resolveProjectConfigPath(cwd);
-    const document = await readMergedDocument(fs5, configPath, projectConfigPath);
+    const document = await readMergedDocument(fs6, configPath, projectConfigPath);
     const planDirectory = resolveScope(planConfigScope.schema, document.plan, process.env).plan_directory;
     return { planDirectory: resolveAbsoluteDirectory2(planDirectory, cwd, homeDir) };
   },
@@ -31718,22 +32527,22 @@ var planPathCommand = defineCommand({
 });
 function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path46.join(homeDir, dir.slice(2));
+    return path51.join(homeDir, dir.slice(2));
   }
-  return path46.isAbsolute(dir) ? dir : path46.resolve(cwd, dir);
+  return path51.isAbsolute(dir) ? dir : path51.resolve(cwd, dir);
 }
 
 // packages/superintendent/src/commands/run.ts
 init_src13();
-init_src16();
+init_src17();
 init_src5();
-import path47 from "node:path";
+import path52 from "node:path";
 import * as fsPromises9 from "node:fs/promises";
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 
 // packages/superintendent/src/commands/poe-agent-runner.ts
 init_src5();
-init_src17();
+init_src18();
 async function executePoeAgent(agentSpec, input, createAgent = agent) {
   const { model } = parseAgentSpecifier(agentSpec);
   if (!model) {
@@ -32817,12 +33626,12 @@ function createRunMcpCommand(runners) {
   });
 }
 var runMcpCommand = createRunMcpCommand();
-async function resolveSuperintendentCommandConfig(cwd, homeDir, env, fs6) {
+async function resolveSuperintendentCommandConfig(cwd, homeDir, env, fs7) {
   const configPath = resolveConfigPath(homeDir);
   const projectConfigPath = resolveProjectConfigPath(cwd);
   try {
     const document = await readMergedDocument(
-      createConfigResolutionFs(fs6),
+      createConfigResolutionFs(fs7),
       configPath,
       projectConfigPath
     );
@@ -32843,11 +33652,11 @@ async function resolveSuperintendentCommandConfig(cwd, homeDir, env, fs6) {
     return { configDoc: {}, configuredDefaultAgent: null, tui: false };
   }
 }
-async function resolveSuperintendentPlanDirectory(cwd, homeDir, env, fs6) {
+async function resolveSuperintendentPlanDirectory(cwd, homeDir, env, fs7) {
   const configPath = resolveConfigPath(homeDir);
   const projectConfigPath = resolveProjectConfigPath(cwd);
   const document = await readMergedDocument(
-    createConfigResolutionFs(fs6),
+    createConfigResolutionFs(fs7),
     configPath,
     projectConfigPath
   );
@@ -32868,23 +33677,23 @@ var configFs = {
   },
   readdir: (filePath) => fsPromises9.readdir(filePath)
 };
-function createConfigResolutionFs(fs6) {
-  if (!fs6) {
+function createConfigResolutionFs(fs7) {
+  if (!fs7) {
     return configFs;
   }
   return {
     ...configFs,
-    readFile: (filePath, encoding) => fs6.readFile(filePath, encoding),
+    readFile: (filePath, encoding) => fs7.readFile(filePath, encoding),
     writeFile: async (filePath, content, options) => {
-      await fs6.writeFile(filePath, content, options);
+      await fs7.writeFile(filePath, content, options);
     },
     mkdir: async (filePath, options) => {
-      await fs6.mkdir(filePath, options);
+      await fs7.mkdir(filePath, options);
     }
   };
 }
 async function runSuperintendentCommand(options) {
-  const fs6 = options.fs ?? createDefaultFs4();
+  const fs7 = options.fs ?? createDefaultFs4();
   const now = options.now ?? Date.now;
   const selectPrompt = options.selectPrompt ?? select2;
   const dashboardFactory = options.createDashboard ?? createDashboard;
@@ -32915,7 +33724,7 @@ async function runSuperintendentCommand(options) {
     assumeYes,
     interactive,
     env,
-    fs: fs6,
+    fs: fs7,
     selectPrompt
   });
   const runLogDir = resolveRunLogDir({
@@ -32923,7 +33732,7 @@ async function runSuperintendentCommand(options) {
     runner: "superintendent",
     homeDir: options.homeDir
   });
-  const documentContent = await fs6.readFile(selectedDocPath, "utf8");
+  const documentContent = await fs7.readFile(selectedDocPath, "utf8");
   const document = parseSuperintendentDoc(selectedDocPath, documentContent);
   const selectedBuilder = await resolveLoopAgent({
     providedAgent: normalizeAgentSelection(options.builderAgent),
@@ -32955,7 +33764,7 @@ async function runSuperintendentCommand(options) {
         docPath: selectedDocPath,
         cwd: options.cwd,
         homeDir: options.homeDir,
-        ...options.fs ? { fs: fs6 } : {},
+        ...options.fs ? { fs: fs7 } : {},
         signal: headlessAbort.signal,
         logDir: runLogDir,
         callbacks: mergeLoopCallbacks({
@@ -33214,7 +34023,7 @@ async function runSuperintendentCommand(options) {
         session.pauseRequested = true;
       }
       editPlan(session.dashboard, session.latestLogFile, env, options.openInEditor);
-      appendEvent("info", `Log opened: ${path47.basename(session.latestLogFile)}`);
+      appendEvent("info", `Log opened: ${path52.basename(session.latestLogFile)}`);
       syncStats();
     }
   };
@@ -33234,7 +34043,7 @@ async function runSuperintendentCommand(options) {
         docPath: selectedDocPath,
         cwd: options.cwd,
         homeDir: options.homeDir,
-        ...options.fs ? { fs: fs6 } : {},
+        ...options.fs ? { fs: fs7 } : {},
         callbacks: mergeLoopCallbacks(callbacks, integrations?.superintendentCallbacks),
         signal: abortController.signal,
         logDir: runLogDir,
@@ -33595,7 +34404,7 @@ function resolveEditor(env) {
   const parts = raw.split(/\s+/);
   const command = parts[0] ?? "vi";
   const args = parts.slice(1);
-  const binary = path47.basename(command);
+  const binary = path52.basename(command);
   const mode = GUI_EDITOR_BINARIES.has(binary) ? "gui" : "tty";
   return { command, args, mode };
 }
@@ -33622,7 +34431,7 @@ function stripStopReason(result) {
   };
 }
 function createDefaultFs4() {
-  const fs6 = {
+  const fs7 = {
     readFile: fsPromises9.readFile,
     writeFile: fsPromises9.writeFile,
     readdir: fsPromises9.readdir,
@@ -33648,7 +34457,7 @@ function createDefaultFs4() {
       await fsPromises9.rename(oldPath, newPath);
     }
   };
-  return fs6;
+  return fs7;
 }
 function toError6(error2) {
   return error2 instanceof Error ? error2 : new Error(String(error2));
@@ -33664,8 +34473,8 @@ var validateCommand = defineCommand({
   positional: ["path"],
   params: validateParams,
   scope: ["cli", "mcp", "sdk"],
-  handler: async ({ params, fs: fs6 }) => {
-    const content = await readDocument6(params.path, fs6);
+  handler: async ({ params, fs: fs7 }) => {
+    const content = await readDocument6(params.path, fs7);
     return validateSuperintendentDocument(params.path, content);
   },
   render: {
@@ -33751,9 +34560,9 @@ function validateSuperintendentDocument(filePath, content) {
   problems.push(...validatePromptVariables(document));
   return toValidationResult(problems);
 }
-async function readDocument6(filePath, fs6) {
+async function readDocument6(filePath, fs7) {
   try {
-    return await fs6.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch (error2) {
     if (hasCode5(error2, "ENOENT")) {
       throw new UserError(`Superintendent document not found: ${filePath}`);
@@ -34239,19 +35048,19 @@ function emitEvent(callback, event) {
   callback(event);
 }
 async function loadConfiguredPlugins(options) {
-  const fs6 = createConfigFileSystem(options.fs);
-  const homeDir = options.homeDir ?? os8.homedir();
+  const fs7 = createConfigFileSystem(options.fs);
+  const homeDir = options.homeDir ?? os9.homedir();
   const store = createConfigStore({
-    fs: fs6,
+    fs: fs7,
     filePath: options.configPath ?? resolveConfigPath(homeDir),
     projectFilePath: options.projectConfigPath ?? resolveProjectConfigPath(options.cwd)
   });
   const plugins = await store.scope(agentConfigScope).get("plugins");
   return plugins ?? void 0;
 }
-function createConfigFileSystem(fs6) {
-  if (fs6) {
-    return fs6;
+function createConfigFileSystem(fs7) {
+  if (fs7) {
+    return fs7;
   }
   return {
     readFile(filePath, encoding) {
@@ -34311,7 +35120,7 @@ function createInMemoryAcpTransport2(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src17(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src18(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
           cwd: request.cwd || options.cwd,