poe-code 3.0.222 → 3.0.224

package/packages/memory/dist/index.js

@@ -35,7 +35,7 @@ function assertSafeRelPath(input) {
 }
 
 // packages/memory/src/resolve-root.ts
-import path11 from "node:path";
+import path12 from "node:path";
 
 // packages/poe-code-config/src/runtime.ts
 import { existsSync } from "node:fs";
@@ -523,7 +523,7 @@ import path7 from "node:path";
 
 // packages/config-extends/src/discover.ts
 import path3 from "node:path";
-async function findBase(name, bases, fs14) {
+async function findBase(name, bases, fs16) {
   const checkedPaths = [];
   for (const basePath of bases) {
     for (const extension of [".md", ".yaml", ".yml", ".json"]) {
@@ -531,7 +531,7 @@ async function findBase(name, bases, fs14) {
       checkedPaths.push(filePath);
       try {
         return {
-          content: await fs14.readFile(filePath, "utf8"),
+          content: await fs16.readFile(filePath, "utf8"),
           filePath
         };
       } catch (error2) {
@@ -611,11 +611,11 @@ function stripBom(content) {
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path45) {
+function mergeObjectLayers(layers, path50) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path45);
+    const resolved = resolveKey(layers, key, path50);
     if (resolved === void 0) {
       continue;
     }
@@ -633,7 +633,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path45) {
+function resolveKey(layers, key, path50) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -663,9 +663,9 @@ function resolveKey(layers, key, path45) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path45, key);
+  const fullPath = buildPath(path50, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path45, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path50, key]);
     return {
       value: merged.data,
       sources: {
@@ -690,8 +690,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path45, key) {
-  return [...path45, key].join(".");
+function buildPath(path50, key) {
+  return [...path50, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1445,6 +1445,10 @@ function hasProperty(value, key) {
   return key in value;
 }
 
+// packages/design-system/src/components/browser.ts
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+
 // packages/design-system/src/acp/writer.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
@@ -2075,16 +2079,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path45) {
-  const ext = getExtension(path45);
+function detectFormat2(path50) {
+  const ext = getExtension(path50);
   return extensionMap[ext];
 }
-function getExtension(path45) {
-  const lastDot = path45.lastIndexOf(".");
+function getExtension(path50) {
+  const lastDot = path50.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path45.slice(lastDot).toLowerCase();
+  return path50.slice(lastDot).toLowerCase();
 }
 
 // packages/config-mutations/src/execution/path-utils.ts
@@ -2135,9 +2139,9 @@ function resolvePath(rawPath, homeDir, pathMapper) {
 function isNotFound(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
-async function readFileIfExists(fs14, target) {
+async function readFileIfExists(fs16, target) {
   try {
-    return await fs14.readFile(target, "utf8");
+    return await fs16.readFile(target, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -2145,9 +2149,9 @@ async function readFileIfExists(fs14, target) {
     throw error2;
   }
 }
-async function pathExists(fs14, target) {
+async function pathExists(fs16, target) {
   try {
-    await fs14.stat(target);
+    await fs16.stat(target);
     return true;
   } catch (error2) {
     if (isNotFound(error2)) {
@@ -2171,9 +2175,9 @@ function createInvalidDocumentBackupPath(targetPath) {
   const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
   return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs14, targetPath, content) {
+async function backupInvalidDocument(fs16, targetPath, content) {
   const backupPath = createInvalidDocumentBackupPath(targetPath);
-  await fs14.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs16.writeFile(backupPath, content, { encoding: "utf8" });
 }
 function describeMutation(kind, targetPath) {
   const displayPath = targetPath ?? "target";
@@ -2731,12 +2735,12 @@ async function executeMutation(mutation, context, options) {
 }
 
 // packages/poe-code-config/src/store.ts
-async function readMergedDocument(fs14, globalPath, projectPath) {
-  const globalDocument = await readStoredDocument(fs14, globalPath);
+async function readMergedDocument(fs16, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs16, globalPath);
   if (!projectPath || projectPath === globalPath) {
     return globalDocument.data;
   }
-  const projectDocument = await readStoredDocument(fs14, projectPath);
+  const projectDocument = await readStoredDocument(fs16, projectPath);
   const resolved = await resolve(
     [
       {
@@ -2750,16 +2754,16 @@ async function readMergedDocument(fs14, globalPath, projectPath) {
       }
     ],
     {
-      fs: createResolvedConfigFs(fs14, globalPath, globalDocument.content),
+      fs: createResolvedConfigFs(fs16, globalPath, globalDocument.content),
       autoExtend: true
     }
   );
   return normalizeDocument(resolved.data);
 }
-async function readStoredDocument(fs14, filePath) {
+async function readStoredDocument(fs16, filePath) {
   try {
-    const raw = await fs14.readFile(filePath, "utf8");
-    return await parseStoredDocument(fs14, filePath, raw);
+    const raw = await fs16.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs16, filePath, raw);
   } catch (error2) {
     if (isNotFound(error2)) {
       return {
@@ -2770,7 +2774,7 @@ async function readStoredDocument(fs14, filePath) {
     throw error2;
   }
 }
-async function parseStoredDocument(fs14, filePath, raw) {
+async function parseStoredDocument(fs16, filePath, raw) {
   try {
     return {
       content: raw,
@@ -2778,7 +2782,7 @@ async function parseStoredDocument(fs14, filePath, raw) {
     };
   } catch (error2) {
     if (error2 instanceof SyntaxError) {
-      await recoverInvalidDocument(fs14, filePath, raw);
+      await recoverInvalidDocument(fs16, filePath, raw);
       return {
         content: EMPTY_DOCUMENT,
         data: {}
@@ -2812,21 +2816,21 @@ function normalizeScopeValues(value) {
   }
   return normalized;
 }
-function createResolvedConfigFs(fs14, globalPath, globalContent) {
+function createResolvedConfigFs(fs16, globalPath, globalContent) {
   return {
     readFile(filePath, _encoding) {
       if (filePath === globalPath) {
         return Promise.resolve(globalContent);
       }
-      return fs14.readFile(filePath, "utf8");
+      return fs16.readFile(filePath, "utf8");
     }
   };
 }
-async function recoverInvalidDocument(fs14, filePath, content) {
-  await fs14.mkdir(path7.dirname(filePath), { recursive: true });
+async function recoverInvalidDocument(fs16, filePath, content) {
+  await fs16.mkdir(path7.dirname(filePath), { recursive: true });
   const backupPath = createInvalidBackupPath(filePath);
-  await fs14.writeFile(backupPath, content, { encoding: "utf8" });
-  await fs14.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+  await fs16.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs16.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
 }
 function createInvalidBackupPath(filePath) {
   const directory = path7.dirname(filePath);
@@ -2950,7 +2954,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path45 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path50 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key of keys) {
@@ -2962,20 +2966,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path45 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path45, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path50, key]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord3(baseValue) && isRecord3(overrideValue)) {
-      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path45, key]);
+      merged[key] = mergeRuntimeScope(baseValue, overrideValue, [...path50, key]);
       continue;
     }
     merged[key] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path45) {
-  return path45.join(".") === "mounts" || path45.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path50) {
+  return path50.join(".") === "mounts" || path50.join(".") === "runner.workspace.exclude";
 }
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -3031,11 +3035,420 @@ import path8 from "node:path";
 var EMPTY_DOCUMENT2 = `${JSON.stringify({}, null, 2)}
 `;
 
+// packages/poe-code-config/src/configured-services.ts
+import path9 from "node:path";
+
+// packages/agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  apiShapes: ["anthropic-messages"],
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  apiShapes: ["openai-responses"],
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  apiShapes: ["openai-chat-completions"],
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  apiShapes: ["openai-chat-completions"],
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/goose.ts
+var gooseAgent = {
+  id: "goose",
+  name: "goose",
+  label: "Goose",
+  summary: "Block's open-source AI agent with ACP support.",
+  binaryName: "goose",
+  apiShapes: ["openai-chat-completions"],
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/poe-agent.ts
+var poeAgentAgent = {
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  apiShapes: ["openai-responses", "openai-chat-completions"],
+  configPath: "~/.poe-code/config.json",
+  branding: {
+    colors: {
+      dark: "#A465F7",
+      light: "#7A3FD3"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent,
+  gooseAgent,
+  poeAgentAgent
+];
+var lookup2 = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup2.has(normalized)) {
+      lookup2.set(normalized, agent.id);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup2.get(input.toLowerCase());
+}
+
+// packages/providers/src/auth/api-key.ts
+function requireApiKeyAuth(provider) {
+  if (provider.auth.kind !== "api-key") {
+    throw new Error(
+      `Provider ${provider.id} does not use api-key auth (got ${provider.auth.kind}).`
+    );
+  }
+  return provider.auth;
+}
+async function acquireApiKey(provider, options, context) {
+  const auth = requireApiKeyAuth(provider);
+  const candidate = options.apiKey ?? await context.promptForSecret?.(auth.prompt);
+  const trimmed = candidate?.trim();
+  if (!trimmed) {
+    throw new Error(
+      `No API key available for provider "${provider.id}". Pass --api-key or run interactively.`
+    );
+  }
+  return trimmed;
+}
+var apiKeyAuthStrategy = {
+  async login(provider, options, context) {
+    const apiKey = await acquireApiKey(provider, options, context);
+    await context.secretStore.set(apiKey);
+    return apiKey;
+  },
+  async logout(_provider, context) {
+    await context.secretStore.delete();
+  },
+  async isLoggedIn(_provider, context) {
+    const value = await context.secretStore.get();
+    return typeof value === "string" && value.trim().length > 0;
+  },
+  async resolveCredential(provider, context) {
+    requireApiKeyAuth(provider);
+    const value = await context.secretStore.get();
+    if (!value || value.trim().length === 0) {
+      throw new Error(
+        `No stored credential for provider "${provider.id}". Run \`poe-code provider login ${provider.id}\`.`
+      );
+    }
+    return value;
+  }
+};
+
+// packages/providers/src/compatibility.ts
+function resolveApiShape(provider, agent) {
+  if (!provider.apiShapes || !agent.apiShapes) {
+    return void 0;
+  }
+  for (const shapeId of agent.apiShapes) {
+    if (provider.apiShapes.some((shape) => shape.id === shapeId)) {
+      return shapeId;
+    }
+  }
+  return void 0;
+}
+
+// packages/providers/src/registry.ts
+var ProviderRegistry = class {
+  providers;
+  byId;
+  storeFactory;
+  envVars;
+  constructor(providers, storeFactory, options) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const provider of providers) {
+      if (byId.has(provider.id)) {
+        throw new Error(`Duplicate provider id: ${provider.id}`);
+      }
+      byId.set(provider.id, provider);
+    }
+    this.providers = providers;
+    this.byId = byId;
+    this.storeFactory = storeFactory;
+    this.envVars = options?.envVars ?? {};
+  }
+  list() {
+    return this.providers;
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  forAgent(agent) {
+    return this.providers.filter((provider) => {
+      return resolveApiShape(provider, agent) !== void 0;
+    });
+  }
+  async isLoggedIn(id) {
+    const provider = this.requireProvider(id);
+    if (provider.auth.kind === "api-key") {
+      const envValue = this.envVars[provider.auth.envVar];
+      if (typeof envValue === "string" && envValue.trim().length > 0) {
+        return true;
+      }
+    }
+    const store = this.requireStore(id);
+    const credential = await store.get();
+    return credential !== null;
+  }
+  async login(id, options, context) {
+    const provider = this.requireProvider(id);
+    const store = this.requireStore(id);
+    if (provider.auth.kind !== "api-key") {
+      throw new Error(`Provider "${id}" does not use api-key auth.`);
+    }
+    const auth = provider.auth;
+    const envApiKey = context?.envVars?.[auth.envVar];
+    const resolvedApiKey = options.apiKey ?? (typeof envApiKey === "string" && envApiKey.trim() ? envApiKey : void 0);
+    if (auth.preferredLogin && context?.resolvePreferredLogin) {
+      const apiKey = await context.resolvePreferredLogin({
+        provider,
+        apiKey: options.apiKey,
+        envValue: typeof envApiKey === "string" ? envApiKey : void 0
+      });
+      await store.set(apiKey);
+      return;
+    }
+    await apiKeyAuthStrategy.login(
+      provider,
+      { apiKey: resolvedApiKey },
+      { secretStore: store, promptForSecret: context?.promptForSecret }
+    );
+  }
+  async resolveCredential(id, options = {}, context) {
+    const provider = this.requireProvider(id);
+    if (provider.auth.kind !== "api-key") {
+      throw new Error(`Provider "${id}" does not use api-key auth.`);
+    }
+    if (options.apiKey !== void 0) {
+      return normalizeRequiredCredential(provider.id, options.apiKey);
+    }
+    const envVars = context?.envVars ?? this.envVars;
+    const envApiKey = envVars[provider.auth.envVar];
+    if (typeof envApiKey === "string" && envApiKey.trim().length > 0) {
+      return envApiKey.trim();
+    }
+    const store = this.requireStore(id);
+    return apiKeyAuthStrategy.resolveCredential(provider, { secretStore: store });
+  }
+  async logout(id) {
+    this.requireProvider(id);
+    const store = this.requireStore(id);
+    await store.delete();
+  }
+  requireProvider(id) {
+    const provider = this.byId.get(id);
+    if (!provider) {
+      throw new Error(`Unknown provider: "${id}".`);
+    }
+    return provider;
+  }
+  requireStore(id) {
+    if (!this.storeFactory) {
+      throw new Error(`No store factory configured for ProviderRegistry.`);
+    }
+    return this.storeFactory(id);
+  }
+};
+function normalizeRequiredCredential(providerId, value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`No API key available for provider "${providerId}".`);
+  }
+  return trimmed;
+}
+
+// packages/providers/src/providers/poe.ts
+var POE_PROVIDER_ID = "poe";
+var poeProvider = {
+  id: POE_PROVIDER_ID,
+  label: "Poe",
+  summary: "Route AI coding agents through Poe's API.",
+  baseUrl: "https://api.poe.com",
+  auth: {
+    kind: "api-key",
+    envVar: "POE_API_KEY",
+    storageKey: "provider:poe",
+    prompt: { title: "Poe API key" },
+    preferredLogin: "oauth"
+  },
+  apiShapes: [
+    {
+      id: "openai-chat-completions",
+      defaultBaseUrl: "https://api.poe.com/v1"
+    },
+    {
+      id: "openai-responses",
+      defaultBaseUrl: "https://api.poe.com/v1"
+    },
+    {
+      id: "anthropic-messages",
+      defaultBaseUrl: "https://api.poe.com/anthropic"
+    }
+  ]
+};
+
+// packages/providers/src/providers/anthropic.ts
+var anthropicProvider = {
+  id: "anthropic",
+  label: "Anthropic",
+  summary: "Route AI coding agents through Anthropic's API.",
+  baseUrl: "https://api.anthropic.com",
+  auth: {
+    kind: "api-key",
+    envVar: "ANTHROPIC_API_KEY",
+    storageKey: "provider:anthropic",
+    prompt: { title: "Anthropic API key" }
+  },
+  apiShapes: [
+    {
+      id: "anthropic-messages",
+      defaultBaseUrl: "https://api.anthropic.com"
+    }
+  ]
+};
+
+// packages/providers/src/providers/cloudflare.ts
+var cloudflareProvider = {
+  id: "cloudflare",
+  label: "Cloudflare AI Gateway",
+  summary: "Route coding agents through Cloudflare AI Gateway.",
+  baseUrlEnvVar: "CF_AIG_BASE_URL",
+  requiresBaseUrl: true,
+  modelInput: { kind: "freeform" },
+  auth: {
+    kind: "api-key",
+    envVar: "CF_AIG_TOKEN",
+    storageKey: "provider:cloudflare",
+    prompt: { title: "Cloudflare AI Gateway token" }
+  },
+  apiShapes: [
+    {
+      id: "openai-chat-completions",
+      baseUrlPath: "compat"
+    },
+    {
+      id: "openai-responses",
+      baseUrlPath: "openai"
+    },
+    {
+      id: "anthropic-messages",
+      baseUrlPath: "anthropic"
+    },
+    {
+      id: "google-generations",
+      baseUrlPath: "google-ai-studio"
+    }
+  ]
+};
+
+// packages/poe-code-config/src/configured-services.ts
+var agentsById = new Map(allAgents.map((agent) => [agent.id, agent]));
+var defaultProviderRegistry = new ProviderRegistry([
+  poeProvider,
+  anthropicProvider,
+  cloudflareProvider
+]);
+var EMPTY_DOCUMENT3 = `${JSON.stringify({}, null, 2)}
+`;
+
 // packages/poe-code-config/src/state/index.ts
 import os2 from "node:os";
 
 // packages/poe-code-config/src/state/jobs.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // packages/file-lock/src/lock.ts
 import * as fsPromises from "node:fs/promises";
@@ -3096,17 +3509,17 @@ function isPidRunning(pid) {
 }
 function createDefaultFs() {
   return {
-    open: (path45, flags) => fsPromises.open(path45, flags),
-    readFile: (path45, encoding) => fsPromises.readFile(path45, encoding),
+    open: (path50, flags) => fsPromises.open(path50, flags),
+    readFile: (path50, encoding) => fsPromises.readFile(path50, encoding),
     stat: fsPromises.stat,
     unlink: fsPromises.unlink
   };
 }
-async function removeLockFile(fs14, lockPath, signal) {
+async function removeLockFile(fs16, lockPath, signal) {
   for (let attempt = 0; attempt <= 4; attempt += 1) {
     throwIfAborted(signal);
     try {
-      await fs14.unlink(lockPath);
+      await fs16.unlink(lockPath);
       return;
     } catch (error2) {
       if (hasErrorCode(error2, "ENOENT")) {
@@ -3137,12 +3550,12 @@ function parseLockMetadata(content) {
   }
   return void 0;
 }
-async function readLockMetadata(fs14, lockPath) {
-  if (!fs14.readFile) {
+async function readLockMetadata(fs16, lockPath) {
+  if (!fs16.readFile) {
     return void 0;
   }
   try {
-    return parseLockMetadata(await fs14.readFile(lockPath, "utf8"));
+    return parseLockMetadata(await fs16.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode(error2, "ENOENT")) {
       return null;
@@ -3176,7 +3589,7 @@ async function writeLockMetadata(handle) {
   }
 }
 async function acquireFileLock(filePath, options = {}) {
-  const fs14 = options.fs ?? createDefaultFs();
+  const fs16 = options.fs ?? createDefaultFs();
   const retries = options.retries ?? 20;
   const minTimeout = options.minTimeout ?? 25;
   const maxTimeout = options.maxTimeout ?? 250;
@@ -3187,7 +3600,7 @@ async function acquireFileLock(filePath, options = {}) {
   while (attempt <= retries) {
     throwIfAborted(options.signal);
     try {
-      const handle = await fs14.open(lockPath, "wx");
+      const handle = await fs16.open(lockPath, "wx");
       await writeLockMetadata(handle);
       let released = false;
       return async () => {
@@ -3195,7 +3608,7 @@ async function acquireFileLock(filePath, options = {}) {
           return;
         }
         released = true;
-        await removeLockFile(fs14, lockPath, options.signal);
+        await removeLockFile(fs16, lockPath, options.signal);
       };
     } catch (error2) {
       if (!hasErrorCode(error2, "EEXIST")) {
@@ -3204,7 +3617,7 @@ async function acquireFileLock(filePath, options = {}) {
     }
     let stat7;
     try {
-      stat7 = await fs14.stat(lockPath);
+      stat7 = await fs16.stat(lockPath);
     } catch (statError) {
       if (hasErrorCode(statError, "ENOENT")) {
         continue;
@@ -3212,7 +3625,7 @@ async function acquireFileLock(filePath, options = {}) {
       throw statError;
     }
     const reclaimLock = await shouldReclaimLock({
-      fs: fs14,
+      fs: fs16,
       isPidRunning: pidIsRunning,
       lockPath,
       staleMs,
@@ -3222,7 +3635,7 @@ async function acquireFileLock(filePath, options = {}) {
       continue;
     }
     if (reclaimLock) {
-      await removeLockFile(fs14, lockPath, options.signal);
+      await removeLockFile(fs16, lockPath, options.signal);
       continue;
     }
     if (attempt >= retries) {
@@ -3242,15 +3655,15 @@ function isNotFoundError(error2) {
 }
 
 // packages/poe-code-config/src/state/jobs.ts
-function createJobRegistry(homeDir, fs14 = defaultStateFs) {
-  const jobsDir = path9.join(homeDir, ".poe-code", "state", "jobs");
+function createJobRegistry(homeDir, fs16 = defaultStateFs) {
+  const jobsDir = path10.join(homeDir, ".poe-code", "state", "jobs");
   function jobPath(id) {
     assertSafeJobId(id);
-    return path9.join(jobsDir, `${id}.json`);
+    return path10.join(jobsDir, `${id}.json`);
   }
   async function get(id) {
     try {
-      return parseJobEntry(await fs14.readFile(jobPath(id), "utf8"));
+      return parseJobEntry(await fs16.readFile(jobPath(id), "utf8"));
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return null;
@@ -3261,8 +3674,8 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   async function put(entry) {
     assertJobEntry(entry);
     const filePath = jobPath(entry.id);
-    await fs14.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs14 });
+    await fs16.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs16 });
     try {
       await writeJobAtomically(filePath, entry);
     } finally {
@@ -3271,8 +3684,8 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   }
   async function update(id, patch) {
     const filePath = jobPath(id);
-    await fs14.mkdir(jobsDir, { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs14 });
+    await fs16.mkdir(jobsDir, { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs16 });
     try {
       const current = await get(id);
       if (current === null) {
@@ -3293,7 +3706,7 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   async function list(filter = {}) {
     let entries;
     try {
-      entries = await fs14.readdir(jobsDir);
+      entries = await fs16.readdir(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return [];
@@ -3305,12 +3718,12 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
       if (!entry.endsWith(".json")) {
         continue;
       }
-      const filePath = path9.join(jobsDir, entry);
-      const stat7 = await fs14.stat(filePath);
+      const filePath = path10.join(jobsDir, entry);
+      const stat7 = await fs16.stat(filePath);
       if (!stat7.isFile()) {
         continue;
       }
-      const job = parseJobEntry(await fs14.readFile(filePath, "utf8"));
+      const job = parseJobEntry(await fs16.readFile(filePath, "utf8"));
       if (matchesFilter(job, filter)) {
         jobs.push(job);
       }
@@ -3320,16 +3733,16 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   async function remove2(id) {
     const filePath = jobPath(id);
     try {
-      await fs14.stat(jobsDir);
+      await fs16.stat(jobsDir);
     } catch (error2) {
       if (isNotFoundError(error2)) {
         return;
       }
       throw error2;
     }
-    const release = await acquireFileLock(filePath, { fs: fs14 });
+    const release = await acquireFileLock(filePath, { fs: fs16 });
     try {
-      await fs14.unlink(filePath);
+      await fs16.unlink(filePath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -3339,14 +3752,14 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
     }
   }
   async function writeJobAtomically(filePath, entry) {
-    await fs14.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs16.mkdir(path10.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
     try {
-      await fs14.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
+      await fs16.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}
 `, {
         encoding: "utf8"
       });
-      await fs14.rename(tempPath, filePath);
+      await fs16.rename(tempPath, filePath);
     } catch (error2) {
       await removeTempFile(tempPath);
       throw error2;
@@ -3354,7 +3767,7 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   }
   async function removeTempFile(tempPath) {
     try {
-      await fs14.unlink(tempPath);
+      await fs16.unlink(tempPath);
     } catch (error2) {
       if (!isNotFoundError(error2)) {
         throw error2;
@@ -3370,7 +3783,7 @@ function createJobRegistry(homeDir, fs14 = defaultStateFs) {
   };
 }
 function assertSafeJobId(id) {
-  if (id.length === 0 || id === "." || id === ".." || path9.isAbsolute(id) || id.includes("/") || id.includes("\\") || id.includes("\0")) {
+  if (id.length === 0 || id === "." || id === ".." || path10.isAbsolute(id) || id.includes("/") || id.includes("\\") || id.includes("\0")) {
     throw new Error("Invalid job id.");
   }
 }
@@ -3400,12 +3813,12 @@ function isRecord4(value) {
 }
 
 // packages/poe-code-config/src/state/templates.ts
-import path10 from "node:path";
-function createTemplateRegistry(homeDir, fs14 = defaultStateFs) {
-  const filePath = path10.join(homeDir, ".poe-code", "state", "templates.json");
+import path11 from "node:path";
+function createTemplateRegistry(homeDir, fs16 = defaultStateFs) {
+  const filePath = path11.join(homeDir, ".poe-code", "state", "templates.json");
   async function readState() {
     try {
-      const raw = await fs14.readFile(filePath, "utf8");
+      const raw = await fs16.readFile(filePath, "utf8");
       return normalizeTemplateState(JSON.parse(raw));
     } catch (error2) {
       if (isNotFoundError(error2)) {
@@ -3415,14 +3828,14 @@ function createTemplateRegistry(homeDir, fs14 = defaultStateFs) {
     }
   }
   async function writeState(state) {
-    await fs14.writeFile(filePath, `${JSON.stringify(state, null, 2)}
+    await fs16.writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, {
       encoding: "utf8"
     });
   }
   async function updateState(mutator) {
-    await fs14.mkdir(path10.dirname(filePath), { recursive: true });
-    const release = await acquireFileLock(filePath, { fs: fs14 });
+    await fs16.mkdir(path11.dirname(filePath), { recursive: true });
+    const release = await acquireFileLock(filePath, { fs: fs16 });
     try {
       const state = await readState();
       mutator(state);
@@ -3492,10 +3905,10 @@ function isRecord5(value) {
 }
 
 // packages/poe-code-config/src/state/index.ts
-function createStateManager(homeDir, fs14) {
+function createStateManager(homeDir, fs16) {
   return {
-    templates: createTemplateRegistry(homeDir, fs14),
-    jobs: createJobRegistry(homeDir, fs14)
+    templates: createTemplateRegistry(homeDir, fs16),
+    jobs: createJobRegistry(homeDir, fs16)
   };
 }
 
@@ -3517,16 +3930,16 @@ async function resolveConfiguredMemoryRoot(options) {
   return resolveMemoryRoot(options.cwd);
 }
 function resolveAgainstCwd(cwd, value) {
-  return path11.isAbsolute(value) ? value : path11.resolve(cwd, value);
+  return path12.isAbsolute(value) ? value : path12.resolve(cwd, value);
 }
 
 // packages/memory/src/init.ts
 import * as fs from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 async function initMemory(root) {
-  await fs.mkdir(path12.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
-  await writeFileIfMissing(path12.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
-  await writeFileIfMissing(path12.join(root, MEMORY_LOG_RELPATH), "");
+  await fs.mkdir(path13.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
+  await writeFileIfMissing(path13.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
+  await writeFileIfMissing(path13.join(root, MEMORY_LOG_RELPATH), "");
 }
 async function writeFileIfMissing(filePath, content) {
   try {
@@ -3543,7 +3956,7 @@ function hasErrorCode2(error2, code) {
 
 // packages/memory/src/pages.ts
 import * as fs2 from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // packages/memory/src/frontmatter.ts
 import { parse as parse6, stringify } from "yaml";
@@ -3723,10 +4136,10 @@ function parseSources(value) {
     if (!isRecord6(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path45 = readRequiredString(item.path, "sources[].path");
+    const path50 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path45, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path50, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString(value, field) {
@@ -3771,7 +4184,7 @@ async function listPages(root) {
 }
 async function readPage(root, relPath) {
   const normalizedRelPath = assertMarkdownRelPath(relPath);
-  const absPath = path13.join(root, normalizedRelPath);
+  const absPath = path14.join(root, normalizedRelPath);
   const [content, stat7] = await Promise.all([fs2.readFile(absPath, "utf8"), fs2.stat(absPath)]);
   try {
     const parsed = parseFrontmatter(content);
@@ -3800,7 +4213,7 @@ async function collectMarkdownRelPaths(root, startRelPath = "") {
   return relPaths.sort((left, right) => left.localeCompare(right));
 }
 async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
-  const absPath = path13.join(root, currentRelPath);
+  const absPath = path14.join(root, currentRelPath);
   let entryNames;
   try {
     entryNames = await fs2.readdir(absPath);
@@ -3811,8 +4224,8 @@ async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
     throw error2;
   }
   for (const entryName of entryNames.sort((left, right) => left.localeCompare(right))) {
-    const entryRelPath = currentRelPath.length === 0 ? entryName : path13.posix.join(currentRelPath, entryName);
-    const entryAbsPath = path13.join(root, entryRelPath);
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path14.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path14.join(root, entryRelPath);
     const entryStat = await fs2.stat(entryAbsPath);
     if (entryStat.isDirectory()) {
       if (entryName === MEMORY_CACHE_DIR_RELPATH) {
@@ -3842,7 +4255,7 @@ function assertMarkdownRelPath(relPath) {
   return normalizedRelPath;
 }
 function isMarkdownPath(relPath) {
-  return path13.posix.extname(relPath).toLowerCase() === ".md";
+  return path14.posix.extname(relPath).toLowerCase() === ".md";
 }
 function isMissing(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
@@ -3850,7 +4263,7 @@ function isMissing(error2) {
 
 // packages/memory/src/search.ts
 import * as fs3 from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 async function searchMemory(root, query) {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) {
@@ -3859,7 +4272,7 @@ async function searchMemory(root, query) {
   const relPaths = await collectMarkdownRelPaths(root);
   const hits = [];
   for (const relPath of relPaths) {
-    const content = await fs3.readFile(path14.join(root, relPath), "utf8");
+    const content = await fs3.readFile(path15.join(root, relPath), "utf8");
     if (content.length === 0) {
       continue;
     }
@@ -3880,7 +4293,7 @@ async function searchMemory(root, query) {
 
 // packages/memory/src/status.ts
 import * as fs4 from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 async function statusOf(root) {
   if (!await pathExists2(root)) {
     return {
@@ -3897,7 +4310,7 @@ async function statusOf(root) {
   let totalBytes = 0;
   let lastWriteAtMs = Number.NEGATIVE_INFINITY;
   for (const relPath of markdownRelPaths) {
-    const stat7 = await fs4.stat(path15.join(root, relPath));
+    const stat7 = await fs4.stat(path16.join(root, relPath));
     totalBytes += stat7.size;
     lastWriteAtMs = Math.max(lastWriteAtMs, stat7.mtimeMs);
   }
@@ -3922,15 +4335,15 @@ async function pathExists2(targetPath) {
 
 // packages/memory/src/edit.ts
 import * as fs7 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 
 // packages/memory/src/write.ts
 import * as fs6 from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // packages/memory/src/lock.ts
 import * as fsPromises2 from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 function createDefaultFs2() {
   return {
     readFile: (filePath, encoding) => fsPromises2.readFile(filePath, encoding),
@@ -3968,18 +4381,18 @@ function isPidRunning2(pid) {
     return !hasErrorCode3(error2, "ESRCH");
   }
 }
-async function removeLockFile2(fs14, lockPath) {
+async function removeLockFile2(fs16, lockPath) {
   try {
-    await fs14.unlink(lockPath);
+    await fs16.unlink(lockPath);
   } catch (error2) {
     if (!hasErrorCode3(error2, "ENOENT")) {
       throw error2;
     }
   }
 }
-async function readLockPid(fs14, lockPath) {
+async function readLockPid(fs16, lockPath) {
   try {
-    return parsePid(await fs14.readFile(lockPath, "utf8"));
+    return parsePid(await fs16.readFile(lockPath, "utf8"));
   } catch (error2) {
     if (hasErrorCode3(error2, "ENOENT")) {
       return null;
@@ -3988,8 +4401,8 @@ async function readLockPid(fs14, lockPath) {
   }
 }
 async function withLock(root, run, options = {}) {
-  const fs14 = options.fs ?? createDefaultFs2();
-  const lockPath = path16.join(root, MEMORY_LOCK_RELPATH);
+  const fs16 = options.fs ?? createDefaultFs2();
+  const lockPath = path17.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
   const minTimeoutMs = options.minTimeoutMs ?? 25;
@@ -3997,24 +4410,24 @@ async function withLock(root, run, options = {}) {
   const pidIsRunning = options.isPidRunning ?? isPidRunning2;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
     try {
-      await fs14.writeFile(lockPath, `${pid}
+      await fs16.writeFile(lockPath, `${pid}
 `, { encoding: "utf8", flag: "wx" });
       try {
         return await run();
       } finally {
-        await removeLockFile2(fs14, lockPath);
+        await removeLockFile2(fs16, lockPath);
       }
     } catch (error2) {
       if (!hasErrorCode3(error2, "EEXIST")) {
         throw error2;
       }
     }
-    const existingPid = await readLockPid(fs14, lockPath);
+    const existingPid = await readLockPid(fs16, lockPath);
     if (existingPid === null) {
       continue;
     }
     if (existingPid === void 0 || !pidIsRunning(existingPid)) {
-      await removeLockFile2(fs14, lockPath);
+      await removeLockFile2(fs16, lockPath);
       continue;
     }
     if (attempt < retries) {
@@ -4027,7 +4440,7 @@ async function withLock(root, run, options = {}) {
 // packages/memory/src/reconcile.ts
 import { createHash } from "node:crypto";
 import * as fs5 from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // packages/memory/src/confidence.ts
 var TAG_RE = /^<!--\s*memory:(?<verb>extracted|inferred|ambiguous)(?<rest>[^>]*?)-->\s*$/;
@@ -4239,7 +4652,7 @@ async function snapshot(root) {
     await Promise.all(
       (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => [
         relPath,
-        hashContent(await fs5.readFile(path17.join(root, relPath), "utf8"))
+        hashContent(await fs5.readFile(path18.join(root, relPath), "utf8"))
       ])
     )
   );
@@ -4250,7 +4663,7 @@ async function reconcile(root, before, _verb, detail) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const currentPages = await Promise.all(
     (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => {
-      const absPath = path17.join(root, relPath);
+      const absPath = path18.join(root, relPath);
       const markdown = await fs5.readFile(absPath, "utf8");
       const parsed = parsePageMarkdown(relPath, markdown);
       const normalizedFrontmatter = withDenormalizedSources(parsed.frontmatter, parsed.body);
@@ -4272,7 +4685,7 @@ async function reconcile(root, before, _verb, detail) {
     })
   );
   await Promise.all(
-    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs5.writeFile(path17.join(root, page.relPath), page.nextMarkdown, "utf8"))
+    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs5.writeFile(path18.join(root, page.relPath), page.nextMarkdown, "utf8"))
   );
   const diff2 = diffSnapshots(before, await snapshot(root));
   await writeIndex(root);
@@ -4302,7 +4715,7 @@ async function appendLogEntries(root, diff2, detail, timestamp = (/* @__PURE__ *
   if (entries.length === 0) {
     return;
   }
-  const logPath = path17.join(root, MEMORY_LOG_RELPATH);
+  const logPath = path18.join(root, MEMORY_LOG_RELPATH);
   const existing = await fs5.readFile(logPath, "utf8");
   const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   await fs5.writeFile(logPath, `${existing}${separator}${entries.join("\n")}
@@ -4326,7 +4739,7 @@ async function writeIndex(root) {
       description: page.frontmatter.description ?? ""
     }))
   );
-  await fs5.writeFile(path17.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
+  await fs5.writeFile(path18.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
 }
 function parsePageMarkdown(relPath, markdown) {
   try {
@@ -4371,9 +4784,9 @@ async function writePage(root, relPath, body, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    await fs6.mkdir(path18.dirname(path18.join(root, pageRelPath)), { recursive: true });
+    await fs6.mkdir(path19.dirname(path19.join(root, pageRelPath)), { recursive: true });
     await fs6.writeFile(
-      path18.join(root, pageRelPath),
+      path19.join(root, pageRelPath),
       serializeFrontmatter(opts.frontmatter ?? {}, body),
       "utf8"
     );
@@ -4384,8 +4797,8 @@ async function appendToPage(root, relPath, content, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    const pagePath = path18.join(root, pageRelPath);
-    await fs6.mkdir(path18.dirname(pagePath), { recursive: true });
+    const pagePath = path19.join(root, pageRelPath);
+    await fs6.mkdir(path19.dirname(pagePath), { recursive: true });
     const existing = await readMarkdownIfPresent(pagePath);
     const parsed = existing === void 0 ? { frontmatter: {}, body: "" } : parseFrontmatter(existing);
     await fs6.writeFile(
@@ -4407,7 +4820,7 @@ async function removeChildren(directoryPath) {
     if (entryName === MEMORY_LOCK_RELPATH) {
       continue;
     }
-    const entryPath = path18.join(directoryPath, entryName);
+    const entryPath = path19.join(directoryPath, entryName);
     const stat7 = await fs6.stat(entryPath);
     if (stat7.isDirectory()) {
       await removeDirectory2(entryPath);
@@ -4424,7 +4837,7 @@ async function removeDirectory2(directoryPath) {
 }
 function assertPageRelPath(relPath) {
   const normalizedRelPath = assertSafeRelPath(relPath);
-  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path18.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
+  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path19.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
     throw new Error(`Expected a markdown page path under "${MEMORY_PAGES_DIR_RELPATH}/".`);
   }
   return normalizedRelPath;
@@ -4442,12 +4855,12 @@ async function readMarkdownIfPresent(filePath) {
 
 // packages/memory/src/edit.ts
 async function editPage(root, relPath, opts) {
-  const pagePath = path19.join(root, relPath);
+  const pagePath = path20.join(root, relPath);
   const original = await readIfPresent(pagePath);
-  const tempRoot = path19.join(root, ".tmp");
+  const tempRoot = path20.join(root, ".tmp");
   await fs7.mkdir(tempRoot, { recursive: true });
-  const tempDir = await fs7.mkdtemp(path19.join(tempRoot, "poe-code-memory-edit-"));
-  const tempPath = path19.join(tempDir, path19.basename(relPath));
+  const tempDir = await fs7.mkdtemp(path20.join(tempRoot, "poe-code-memory-edit-"));
+  const tempPath = path20.join(tempDir, path20.basename(relPath));
   try {
     await fs7.writeFile(tempPath, original ?? "", "utf8");
     await opts.launchEditor(tempPath);
@@ -4481,7 +4894,7 @@ async function readIfPresent(filePath) {
 
 // packages/memory/src/audit.ts
 import * as fs8 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 var DEFAULT_MIN_INFERRED_CONFIDENCE = 0.3;
 var DEFAULT_REJECT_UNTAGGED = false;
 var DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS = 200;
@@ -4536,10 +4949,10 @@ async function auditSourceRef(source, claimLineNumber, repoRoot, sourceCache) {
   if (isUrlLike(source.path)) {
     return void 0;
   }
-  if (path20.isAbsolute(source.path)) {
+  if (path21.isAbsolute(source.path)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but source paths must be repo-relative or URLs.`;
   }
-  const absPath = path20.resolve(repoRoot, source.path);
+  const absPath = path21.resolve(repoRoot, source.path);
   if (!isWithinRoot(repoRoot, absPath)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", which resolves outside the repo root.`;
   }
@@ -4605,14 +5018,14 @@ function isUrlLike(value) {
   return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
 }
 function isWithinRoot(root, absPath) {
-  const relative = path20.relative(root, absPath);
-  return relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative);
+  const relative = path21.relative(root, absPath);
+  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
 }
 
 // packages/memory/src/cache.ts
 import { createHash as createHash2 } from "node:crypto";
 import * as fs9 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 function computeIngestKey(input) {
   const hash = createHash2("sha256");
   hash.update(input.sourceBytes);
@@ -4625,7 +5038,7 @@ function computeIngestKey(input) {
   return hash.digest("hex");
 }
 async function readCacheEntry(root, key) {
-  const cachePath = path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
+  const cachePath = path22.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
   let raw;
   try {
     raw = await fs9.readFile(cachePath, "utf8");
@@ -4644,17 +5057,17 @@ async function readCacheEntry(root, key) {
   }
 }
 async function writeCacheEntry(root, entry) {
-  await fs9.mkdir(path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+  await fs9.mkdir(path22.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
   await fs9.writeFile(
-    path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
+    path22.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
     `${JSON.stringify(entry)}
 `,
     "utf8"
   );
 }
 async function clearCache(root, opts = {}) {
-  const ingestDir = path21.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
-  const cacheDir = path21.join(root, MEMORY_CACHE_DIR_RELPATH);
+  const ingestDir = path22.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+  const cacheDir = path22.join(root, MEMORY_CACHE_DIR_RELPATH);
   const fileNames = await readCacheFileNames(ingestDir);
   if (fileNames.length === 0) {
     if (opts.olderThanMs === void 0) {
@@ -4674,7 +5087,7 @@ async function clearCache(root, opts = {}) {
     if (entry === null || Date.parse(entry.ingestedAt) > cutoff) {
       continue;
     }
-    await fs9.rm(path21.join(ingestDir, fileName), { force: true });
+    await fs9.rm(path22.join(ingestDir, fileName), { force: true });
     removed += 1;
   }
   await removeEmptyDirectory(ingestDir);
@@ -4730,7 +5143,7 @@ function expectStringArray(value, field) {
 }
 async function readCacheFileNames(ingestDir) {
   try {
-    return (await fs9.readdir(ingestDir)).filter((fileName) => path21.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
+    return (await fs9.readdir(ingestDir)).filter((fileName) => path22.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
   } catch (error2) {
     if (isMissing3(error2)) {
       return [];
@@ -4781,18 +5194,18 @@ function parseOlderThan(value) {
 }
 
 // packages/memory/src/ingest.ts
-import * as fs11 from "node:fs/promises";
-import path38 from "node:path";
+import * as fs13 from "node:fs/promises";
+import path45 from "node:path";
 
 // packages/agent-spawn/src/register-factories.ts
 import { spawn as spawnChildProcess2 } from "node:child_process";
 
 // packages/agent-harness-tools/src/paths.ts
-import path22 from "node:path";
+import path23 from "node:path";
 
 // packages/agent-harness-tools/src/plans.ts
 import * as fsPromises4 from "node:fs/promises";
-import path27 from "node:path";
+import path29 from "node:path";
 
 // packages/task-list/src/open.ts
 import * as fsPromises3 from "node:fs/promises";
@@ -4875,7 +5288,7 @@ import * as childProcess from "node:child_process";
 import { randomBytes } from "node:crypto";
 
 // packages/process-runner/src/docker/args.ts
-import path23 from "node:path";
+import path24 from "node:path";
 function buildDockerRunArgs(input) {
   const args = [input.engine];
   if (input.engine === "docker" && input.context) {
@@ -4902,7 +5315,7 @@ function buildDockerRunArgs(input) {
     args.push("-e", `${key}=${value}`);
   }
   for (const mount of input.mounts) {
-    const volume = `${path23.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    const volume = `${path24.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
     args.push("-v", volume);
   }
   for (const port of input.ports) {
@@ -4921,7 +5334,7 @@ import { createHash as createHash3, randomBytes as randomBytes2 } from "node:cry
 import { mkdtempSync, rmSync } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // packages/process-runner/src/host/host-runner.ts
 import { spawn as spawnChildProcess } from "node:child_process";
@@ -5061,8 +5474,8 @@ function createDockerEnv(input) {
     id: containerRef,
     job: input.attachedJobId === void 0 ? null : createContainerJob(containerRef, input.runner, input.engine, input.context, input.attachedJobId),
     async uploadWorkspace() {
-      const tempDir = mkdtempSync(path24.join(tmpdir(), "poe-docker-upload-"));
-      const archivePath = path24.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync(path25.join(tmpdir(), "poe-docker-upload-"));
+      const archivePath = path25.join(tempDir, "workspace.tar");
       try {
         const excludeArgs = input.spec.uploadIgnoreFiles.flatMap((ignored) => [
           "--exclude",
@@ -5105,8 +5518,8 @@ function createDockerEnv(input) {
       }
     },
     async downloadWorkspace(opts) {
-      const tempDir = mkdtempSync(path24.join(tmpdir(), "poe-docker-download-"));
-      const archivePath = path24.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync(path25.join(tmpdir(), "poe-docker-download-"));
+      const archivePath = path25.join(tempDir, "workspace.tar");
       try {
         await runOrThrow(input.runner, {
           command: input.engine,
@@ -5206,11 +5619,11 @@ async function buildDockerRuntimeTemplate(input) {
   const runner = input.runner ?? createHostRunner();
   const engine = input.runtime.engine ?? detectEngine();
   const context = detectContext();
-  const dockerfilePath = path24.resolve(
+  const dockerfilePath = path25.resolve(
     input.cwd,
-    input.runtime.dockerfile ?? path24.join(".poe-code", "Dockerfile")
+    input.runtime.dockerfile ?? path25.join(".poe-code", "Dockerfile")
   );
-  const buildContext = path24.resolve(input.cwd, input.runtime.build_context ?? ".");
+  const buildContext = path25.resolve(input.cwd, input.runtime.build_context ?? ".");
   const dockerfileBytes = await readFile10(dockerfilePath);
   const hash = hashDockerTemplate(dockerfileBytes, input.runtime.build_args ?? {});
   const cached2 = input.force ? null : await input.state?.templates.get("docker", hash);
@@ -5472,10 +5885,10 @@ var hostExecutionEnvFactory = {
 import { Readable, Writable } from "node:stream";
 
 // packages/task-list/src/backends/utils.ts
-import path25 from "node:path";
+import path26 from "node:path";
 
 // packages/task-list/src/backends/markdown-dir.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import { parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 
 // packages/task-list/src/schema/task.schema.json
@@ -5549,6 +5962,7 @@ var defaultTransitions = deriveLegacyTransitions(defaultStateMachine);
 var TASK_SCHEMA_ID = task_schema_default.$id;
 
 // packages/task-list/src/backends/yaml-file.ts
+import path28 from "node:path";
 import { isMap, parseDocument as parseDocument3 } from "yaml";
 
 // packages/task-list/src/schema/store.schema.json
@@ -5589,145 +6003,6 @@ var store_schema_default = {
 var STORE_SCHEMA_ID = store_schema_default.$id;
 var TASK_SCHEMA_ID2 = task_schema_default.$id;
 
-// packages/agent-defs/src/agents/claude-code.ts
-var claudeCodeAgent = {
-  id: "claude-code",
-  name: "claude-code",
-  label: "Claude Code",
-  summary: "Configure Claude Code to route through Poe.",
-  aliases: ["claude"],
-  binaryName: "claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#C15F3C",
-      light: "#C15F3C"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/claude-desktop.ts
-var claudeDesktopAgent = {
-  id: "claude-desktop",
-  name: "claude-desktop",
-  label: "Claude Desktop",
-  summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.claude/settings.json",
-  branding: {
-    colors: {
-      dark: "#D97757",
-      light: "#D97757"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/codex.ts
-var codexAgent = {
-  id: "codex",
-  name: "codex",
-  label: "Codex",
-  summary: "Configure Codex to use Poe as the model provider.",
-  binaryName: "codex",
-  configPath: "~/.codex/config.toml",
-  branding: {
-    colors: {
-      dark: "#D5D9DF",
-      light: "#7A7F86"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/opencode.ts
-var openCodeAgent = {
-  id: "opencode",
-  name: "opencode",
-  label: "OpenCode CLI",
-  summary: "Configure OpenCode CLI to use the Poe API.",
-  binaryName: "opencode",
-  configPath: "~/.config/opencode/config.json",
-  branding: {
-    colors: {
-      dark: "#4A4F55",
-      light: "#2F3338"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/kimi.ts
-var kimiAgent = {
-  id: "kimi",
-  name: "kimi",
-  label: "Kimi",
-  summary: "Configure Kimi CLI to use Poe API",
-  aliases: ["kimi-cli"],
-  binaryName: "kimi",
-  configPath: "~/.kimi/config.toml",
-  branding: {
-    colors: {
-      dark: "#7B68EE",
-      light: "#6A5ACD"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/goose.ts
-var gooseAgent = {
-  id: "goose",
-  name: "goose",
-  label: "Goose",
-  summary: "Block's open-source AI agent with ACP support.",
-  binaryName: "goose",
-  configPath: "~/.config/goose/config.yaml",
-  branding: {
-    colors: {
-      dark: "#FF6B35",
-      light: "#E85D26"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/poe-agent.ts
-var poeAgentAgent = {
-  id: "poe-agent",
-  name: "poe-agent",
-  label: "Poe Agent",
-  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
-  configPath: "~/.poe-code/config.json",
-  branding: {
-    colors: {
-      dark: "#A465F7",
-      light: "#7A3FD3"
-    }
-  }
-};
-
-// packages/agent-defs/src/registry.ts
-var allAgents = [
-  claudeCodeAgent,
-  claudeDesktopAgent,
-  codexAgent,
-  openCodeAgent,
-  kimiAgent,
-  gooseAgent,
-  poeAgentAgent
-];
-var lookup2 = /* @__PURE__ */ new Map();
-for (const agent of allAgents) {
-  const values = [agent.id, agent.name, ...agent.aliases ?? []];
-  for (const value of values) {
-    const normalized = value.toLowerCase();
-    if (!lookup2.has(normalized)) {
-      lookup2.set(normalized, agent.id);
-    }
-  }
-}
-function resolveAgentId(input) {
-  if (!input) {
-    return void 0;
-  }
-  return lookup2.get(input.toLowerCase());
-}
-
 // packages/agent-harness-tools/src/select-agent.ts
 var loopAgents = allAgents.filter(
   (agent) => agent.binaryName !== void 0 || agent.id === "poe-agent"
@@ -5735,7 +6010,7 @@ var loopAgents = allAgents.filter(
 var supportedAgents = loopAgents.map((agent) => agent.id).join(", ");
 
 // packages/agent-harness-tools/src/run-logs.ts
-import path28 from "node:path";
+import path30 from "node:path";
 
 // packages/agent-harness-tools/src/log-stream.ts
 import nodeFs2 from "node:fs";
@@ -5756,29 +6031,29 @@ function wrapForLogTee(argv, jobId) {
   return ["sh", "-c", script];
 }
 async function* streamLogFile(env, jobId, opts) {
-  const fs14 = env.fs ?? nodeFs2;
+  const fs16 = env.fs ?? nodeFs2;
   const file = jobLogPath(jobId);
   let byteOffset = opts.sinceByte ?? 0;
   while (true) {
-    if (opts.since !== void 0 && !await wasModifiedSince(fs14, file, opts.since)) {
-      await waitForLogChange(fs14, file);
+    if (opts.since !== void 0 && !await wasModifiedSince(fs16, file, opts.since)) {
+      await waitForLogChange(fs16, file);
       continue;
     }
-    const result = await readLogChunk(fs14, file, byteOffset);
+    const result = await readLogChunk(fs16, file, byteOffset);
     if (result !== null) {
       byteOffset = result.nextByteOffset;
       yield result.chunk;
       continue;
     }
-    await waitForLogChange(fs14, file);
+    await waitForLogChange(fs16, file);
   }
 }
-async function wasModifiedSince(fs14, file, since) {
-  if (fs14.promises.stat === void 0) {
+async function wasModifiedSince(fs16, file, since) {
+  if (fs16.promises.stat === void 0) {
     return true;
   }
   try {
-    const stat7 = await fs14.promises.stat(file);
+    const stat7 = await fs16.promises.stat(file);
     return stat7.mtimeMs >= since.getTime();
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -5788,11 +6063,11 @@ async function wasModifiedSince(fs14, file, since) {
   }
 }
 async function waitForExit(env, jobId, opts = {}) {
-  const fs14 = env.fs ?? nodeFs2;
+  const fs16 = env.fs ?? nodeFs2;
   const file = jobExitPath(jobId);
   while (true) {
     throwIfAborted2(opts.signal);
-    const contents = await readTextFileIfExists(fs14, file);
+    const contents = await readTextFileIfExists(fs16, file);
     if (contents !== null) {
       const text5 = contents.trim();
       const exitCode = Number(text5);
@@ -5810,8 +6085,8 @@ function jobLogPath(jobId) {
 function jobExitPath(jobId) {
   return `${JOB_DIR}/${jobId}.exit`;
 }
-async function readLogChunk(fs14, file, byteOffset) {
-  const contents = await readFileIfExists2(fs14, file);
+async function readLogChunk(fs16, file, byteOffset) {
+  const contents = await readFileIfExists2(fs16, file);
   if (contents === null || byteOffset >= contents.byteLength) {
     return null;
   }
@@ -5823,13 +6098,13 @@ async function readLogChunk(fs14, file, byteOffset) {
     nextByteOffset: contents.byteLength
   };
 }
-async function readTextFileIfExists(fs14, file) {
-  const contents = await readFileIfExists2(fs14, file);
+async function readTextFileIfExists(fs16, file) {
+  const contents = await readFileIfExists2(fs16, file);
   return contents?.toString("utf8") ?? null;
 }
-async function readFileIfExists2(fs14, file) {
+async function readFileIfExists2(fs16, file) {
   try {
-    const contents = await fs14.promises.readFile(file);
+    const contents = await fs16.promises.readFile(file);
     return Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   } catch (error2) {
     if (isNodeError(error2) && error2.code === "ENOENT") {
@@ -5838,8 +6113,8 @@ async function readFileIfExists2(fs14, file) {
     throw error2;
   }
 }
-async function waitForLogChange(fs14, file) {
-  const watch = fs14.watch;
+async function waitForLogChange(fs16, file) {
+  const watch = fs16.watch;
   if (typeof watch !== "function") {
     await sleep3(POLL_INTERVAL_MS);
     return;
@@ -5960,8 +6235,7 @@ async function runPoeCommand(opts) {
       signal: opts.signal
     });
     if (execution?.input !== void 0) {
-      handle.stdin?.setDefaultEncoding("utf8");
-      handle.stdin?.end(execution.input);
+      writeExecutionInput(handle, execution.input);
     }
     const runningJob = opts.state.jobs.update(jobId, {
       status: "running",
@@ -6271,6 +6545,19 @@ function setDetachedJobContext(env, context) {
   const candidate = env;
   candidate.setDetachedJobContext?.(context);
 }
+function writeExecutionInput(handle, input) {
+  const stdin = handle.stdin;
+  if (stdin === null) {
+    return;
+  }
+  stdin.on("error", (error2) => {
+    if (error2.code !== "EPIPE") {
+      throw error2;
+    }
+  });
+  stdin.setDefaultEncoding("utf8");
+  stdin.end(input);
+}
 function isPromiseLike(value) {
   return typeof value.then === "function";
 }
@@ -6456,10 +6743,10 @@ function createMemoryStateManager() {
 // packages/agent-harness-tools/src/workspace-transfer.ts
 import { createHash as createHash4 } from "node:crypto";
 import { promises as nodeFs3 } from "node:fs";
-import path29 from "node:path";
+import path31 from "node:path";
 
 // packages/runner-e2b/src/factory.ts
-import path33 from "node:path";
+import path35 from "node:path";
 
 // packages/runner-e2b/src/sdk.ts
 import { Template, Sandbox } from "e2b";
@@ -6508,7 +6795,7 @@ async function readableToString(stream) {
 // packages/runner-e2b/src/template-build.ts
 import { createHash as createHash5 } from "node:crypto";
 import { readdir as readdir4, readFile as readFile11 } from "node:fs/promises";
-import path30 from "node:path";
+import path32 from "node:path";
 var BUILD_LOG_TAIL_SIZE = 30;
 async function buildE2bRuntimeTemplate(input) {
   const dockerfileBytes = await readFile11(input.dockerfilePath);
@@ -6589,10 +6876,10 @@ async function readBuildContextFiles(buildContext) {
   return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 async function collectBuildContextFiles(buildContext, relativeDir, files) {
-  const absoluteDir = path30.join(buildContext, relativeDir);
+  const absoluteDir = path32.join(buildContext, relativeDir);
   const entries = await readdir4(absoluteDir, { withFileTypes: true });
   for (const entry of entries) {
-    const relativePath = path30.join(relativeDir, entry.name);
+    const relativePath = path32.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       await collectBuildContextFiles(buildContext, relativePath, files);
       continue;
@@ -6601,8 +6888,8 @@ async function collectBuildContextFiles(buildContext, relativeDir, files) {
       continue;
     }
     files.push({
-      relativePath: relativePath.split(path30.sep).join("/"),
-      bytes: await readFile11(path30.join(buildContext, relativePath))
+      relativePath: relativePath.split(path32.sep).join("/"),
+      bytes: await readFile11(path32.join(buildContext, relativePath))
     });
   }
 }
@@ -6611,14 +6898,14 @@ async function collectBuildContextFiles(buildContext, relativeDir, files) {
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
 import { readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import path32 from "node:path";
+import path34 from "node:path";
 import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream";
 
 // packages/runner-e2b/src/job-handle.ts
-import path31 from "node:path";
+import path33 from "node:path";
 var JOB_DIR2 = "/tmp/poe-jobs";
 function createE2bJobHandle(input) {
-  const fs14 = createE2bLogStreamFs(input.sandbox);
+  const fs16 = createE2bLogStreamFs(input.sandbox);
   return {
     id: input.jobId,
     envId: input.envId,
@@ -6630,14 +6917,14 @@ function createE2bJobHandle(input) {
         return "exited";
       }
       const processes = await input.sandbox.commands.list();
-      const isRunning = input.pid === void 0 ? processes.some((process2) => processMentionsJob(process2, input.jobId)) : processes.some((process2) => process2.pid === input.pid);
+      const isRunning = input.pid === void 0 ? processes.some((process3) => processMentionsJob(process3, input.jobId)) : processes.some((process3) => process3.pid === input.pid);
       return isRunning ? "running" : "lost";
     },
     stream(opts = {}) {
-      return streamLogFile({ fs: fs14 }, input.jobId, opts);
+      return streamLogFile({ fs: fs16 }, input.jobId, opts);
     },
     async wait() {
-      const result = await waitForExit({ fs: fs14 }, input.jobId);
+      const result = await waitForExit({ fs: fs16 }, input.jobId);
       const preserveMs = input.preserveAfterExitHours * 60 * 60 * 1e3;
       if (preserveMs > 0) {
         await input.sandbox.setTimeout(preserveMs);
@@ -6645,7 +6932,7 @@ function createE2bJobHandle(input) {
       return result;
     },
     async kill() {
-      const pids = input.pid === void 0 ? (await input.sandbox.commands.list()).filter((process2) => processMentionsJob(process2, input.jobId)).map((process2) => process2.pid) : [input.pid];
+      const pids = input.pid === void 0 ? (await input.sandbox.commands.list()).filter((process3) => processMentionsJob(process3, input.jobId)).map((process3) => process3.pid) : [input.pid];
       await Promise.all(pids.map((pid) => input.sandbox.commands.kill(pid)));
     }
   };
@@ -6673,7 +6960,7 @@ function createE2bLogStreamFs(sandbox) {
     watch(filePath, listener) {
       let closed = false;
       let stop = null;
-      void sandbox.files.watchDir(path31.dirname(filePath), listener, { recursive: false }).then((handle) => {
+      void sandbox.files.watchDir(path33.dirname(filePath), listener, { recursive: false }).then((handle) => {
         if (closed) {
           void handle.stop();
           return;
@@ -6691,9 +6978,9 @@ function createE2bLogStreamFs(sandbox) {
     }
   };
 }
-function processMentionsJob(process2, jobId) {
+function processMentionsJob(process3, jobId) {
   const needle = `/tmp/poe-jobs/${jobId}`;
-  return process2.cmd.includes(needle) || process2.args.some((arg) => arg.includes(needle));
+  return process3.cmd.includes(needle) || process3.args.some((arg) => arg.includes(needle));
 }
 function shellQuote3(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
@@ -6712,7 +6999,7 @@ async function readExitCode(sandbox, jobId) {
 var REMOTE_COMMAND_STDERR_TAIL_SIZE = 30;
 function createOpenedE2bEnv(input) {
   const hostRunner = input.spec.hostRunner ?? createHostRunner();
-  const hostWorkspaceDir = path32.resolve(input.spec.cwd);
+  const hostWorkspaceDir = path34.resolve(input.spec.cwd);
   const sandboxWorkspaceDir = normalizeSandboxWorkspaceDir(input.runtime.workspace_dir);
   let lastProcess = null;
   let detachedJobContext = null;
@@ -6720,7 +7007,7 @@ function createOpenedE2bEnv(input) {
     if (cwd === void 0) {
       return void 0;
     }
-    if (path32.isAbsolute(cwd) && path32.resolve(cwd) === hostWorkspaceDir) {
+    if (path34.isAbsolute(cwd) && path34.resolve(cwd) === hostWorkspaceDir) {
       return sandboxWorkspaceDir;
     }
     return cwd;
@@ -6744,8 +7031,8 @@ function createOpenedE2bEnv(input) {
       if (input.spec.runner?.sync === "none") {
         return { files: 0, bytes: 0, skipped: [] };
       }
-      const tempDir = mkdtempSync2(path32.join(tmpdir2(), "poe-e2b-upload-"));
-      const archivePath = path32.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync2(path34.join(tmpdir2(), "poe-e2b-upload-"));
+      const archivePath = path34.join(tempDir, "workspace.tar");
       try {
         await runOrThrow2(hostRunner, {
           command: "tar",
@@ -6777,8 +7064,8 @@ function createOpenedE2bEnv(input) {
       if (input.spec.runner?.sync === "upload" || input.spec.runner?.sync === "none") {
         return { files: 0, bytes: 0, conflicts: [] };
       }
-      const tempDir = mkdtempSync2(path32.join(tmpdir2(), "poe-e2b-download-"));
-      const archivePath = path32.join(tempDir, "workspace.tar");
+      const tempDir = mkdtempSync2(path34.join(tmpdir2(), "poe-e2b-download-"));
+      const archivePath = path34.join(tempDir, "workspace.tar");
       try {
         await runRemoteOrThrow(
           input.sandbox,
@@ -7101,10 +7388,10 @@ function resolveSandboxCommandEnv(env) {
 }
 function normalizeSandboxWorkspaceDir(workspaceDir) {
   const resolvedWorkspaceDir = workspaceDir ?? "/workspace";
-  if (!path32.posix.isAbsolute(resolvedWorkspaceDir)) {
+  if (!path34.posix.isAbsolute(resolvedWorkspaceDir)) {
     throw new Error("E2B runtime workspace_dir must be an absolute sandbox path.");
   }
-  let normalized = path32.posix.normalize(resolvedWorkspaceDir);
+  let normalized = path34.posix.normalize(resolvedWorkspaceDir);
   while (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
@@ -7134,10 +7421,10 @@ var e2bAuthScope = defineScope("e2b", {
 });
 async function resolveE2bApiKey(input) {
   const homeDir = input.homeDir ?? os4.homedir();
-  const fs14 = input.fs ?? nodeFs4;
+  const fs16 = input.fs ?? nodeFs4;
   const env = input.env ?? process.env;
   const document = await readMergedDocument(
-    fs14,
+    fs16,
     resolveConfigPath(homeDir),
     resolveProjectConfigPath(input.cwd)
   );
@@ -7160,11 +7447,11 @@ var e2bExecutionEnvFactory = {
     const apiKey = await resolveE2bApiKey({ cwd: runtimeCwd });
     const templateId = runtime.template_id ?? (await buildE2bRuntimeTemplate({
       runtime,
-      dockerfilePath: path33.resolve(
+      dockerfilePath: path35.resolve(
         runtimeCwd,
-        runtime.dockerfile ?? path33.join(".poe-code", "Dockerfile")
+        runtime.dockerfile ?? path35.join(".poe-code", "Dockerfile")
       ),
-      buildContext: path33.resolve(runtimeCwd, runtime.build_context ?? "."),
+      buildContext: path35.resolve(runtimeCwd, runtime.build_context ?? "."),
       state: spec.state,
       apiKey
     })).templateId;
@@ -7309,8 +7596,83 @@ function runHost(spawnProcess, spec) {
   };
 }
 
+// packages/agent-spawn/src/observability/otel.ts
+var noopOtelSpan = {
+  setAttribute: () => void 0,
+  addEvent: () => void 0,
+  end: () => void 0
+};
+function observeAgentSpawn(input, operation) {
+  const span = safeStartSpan(input.otelSink, "agent.spawn", {
+    agent: input.agent,
+    mode: input.mode ?? "yolo",
+    cwd: input.cwd ?? process.cwd()
+  });
+  safeAddEvent(span, "prompt", { prompt: input.prompt });
+  return (async () => {
+    try {
+      const result = await operation();
+      safeAddEvent(span, "summary", { summary: readSummary(result) });
+      safeAddEvent(span, "exit", { exitCode: result.exitCode });
+      return result;
+    } catch (error2) {
+      safeRecordException(input.otelSink, span, error2);
+      throw error2;
+    } finally {
+      safeEndSpan(span);
+    }
+  })();
+}
+function safeStartSpan(sink, name, attrs) {
+  if (sink === void 0) {
+    return noopOtelSpan;
+  }
+  try {
+    return sink.startSpan(name, attrs);
+  } catch (error2) {
+    warnOtelSinkFailure("startSpan", error2);
+    return noopOtelSpan;
+  }
+}
+function safeAddEvent(span, name, attrs) {
+  if (span === void 0) {
+    return;
+  }
+  try {
+    span.addEvent(name, attrs);
+  } catch (error2) {
+    warnOtelSinkFailure("addEvent", error2);
+  }
+}
+function safeRecordException(sink, span, error2) {
+  if (sink === void 0) {
+    return;
+  }
+  try {
+    sink.recordException(span, error2);
+  } catch (recordError) {
+    warnOtelSinkFailure("recordException", recordError);
+  }
+}
+function safeEndSpan(span) {
+  try {
+    span.end();
+  } catch (error2) {
+    warnOtelSinkFailure("end", error2);
+  }
+}
+function readSummary(result) {
+  return result.stdout.trim() || result.stderr.trim();
+}
+function warnOtelSinkFailure(method, error2) {
+  console.warn(`OpenTelemetry sink ${method} failed: ${readErrorMessage(error2)}`);
+}
+function readErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+
 // packages/agent-spawn/src/run-command.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 
 // packages/agent-spawn/src/types.ts
 function resolveModeConfig(modeConfig) {
@@ -7604,8 +7966,8 @@ function listMcpSupportedAgents() {
 }
 
 // packages/agent-spawn/src/spawn.ts
-import { mkdirSync, openSync, writeSync, closeSync } from "node:fs";
-import path34 from "node:path";
+import { mkdirSync as mkdirSync3, openSync, writeSync, closeSync } from "node:fs";
+import path41 from "node:path";
 
 // packages/agent-spawn/src/configs/resolve-config.ts
 function resolveConfig(agentId) {
@@ -7641,6 +8003,12 @@ function getMcpArgs(config, servers) {
   }
   return config.mcpArgs(servers);
 }
+function getMcpEnv(config, servers) {
+  if (!hasMcpServers(servers) || !config.mcpEnv) {
+    return {};
+  }
+  return config.mcpEnv(servers);
+}
 function formatUnsupportedMcpSpawnMessage(agentId) {
   const supported = listMcpSupportedAgents();
   const supportedText = supported.length > 0 ? supported.join(", ") : "(none)";
@@ -7654,50 +8022,1743 @@ function stripModelNamespace(model) {
   return slashIndex === -1 ? model : model.slice(slashIndex + 1);
 }
 
-// packages/agent-spawn/src/spawn.ts
-function createAbortError3() {
-  const error2 = new Error("Agent spawn aborted");
-  error2.name = "AbortError";
-  return error2;
+// packages/agent-spawn/src/parallel.ts
+var SpawnParallelError = class extends Error {
+  index;
+  result;
+  results;
+  constructor(index, result, results) {
+    super(`spawn.parallel call ${index} failed with exit code ${result.exitCode}.`);
+    this.name = "SpawnParallelError";
+    this.index = index;
+    this.result = result;
+    this.results = results;
+  }
+};
+function createSpawnParallel(spawnOnce) {
+  return async function parallel(calls, options = {}) {
+    if (calls.length === 0) {
+      return [];
+    }
+    const maxConcurrent = normalizeMaxConcurrent(options.maxConcurrent);
+    const failFast = options.failFast ?? true;
+    const group = new AbortController();
+    const results = new Array(calls.length);
+    const errors = [];
+    let nextIndex = 0;
+    let primaryFailure;
+    const removeParentAbort = linkParentAbort(options.signal, group, (error2) => {
+      primaryFailure ??= error2;
+    });
+    const worker = async () => {
+      while (!primaryFailure) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= calls.length) {
+          return;
+        }
+        try {
+          const result = await runParallelCall(calls[index], spawnOnce, group.signal);
+          results[index] = result;
+          if (failFast && result.exitCode !== 0) {
+            const error2 = new SpawnParallelError(index, result, results);
+            primaryFailure ??= error2;
+            group.abort(error2);
+            return;
+          }
+        } catch (error2) {
+          if (failFast || group.signal.aborted) {
+            primaryFailure ??= error2;
+            group.abort(error2);
+            return;
+          }
+          errors.push(error2);
+        }
+      }
+    };
+    try {
+      await Promise.allSettled(
+        Array.from({ length: Math.min(maxConcurrent, calls.length) }, () => worker())
+      );
+    } finally {
+      removeParentAbort();
+    }
+    if (primaryFailure) {
+      throw primaryFailure;
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "spawn.parallel failed before every call returned a result.");
+    }
+    return results;
+  };
 }
-function resolveCliConfig(agentId) {
-  const resolved = resolveConfig(agentId);
-  if (!resolved.spawnConfig) {
-    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
+async function runParallelCall(call, spawnOnce, signal) {
+  throwIfAborted3(signal);
+  if (typeof call === "function") {
+    const handle = call(signal);
+    const [result] = await Promise.all([handle.result, drainEvents(handle.events)]);
+    return result;
   }
-  if (resolved.spawnConfig.kind !== "cli") {
-    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  if (!isSpawnTuple(call)) {
+    throw new Error("spawn.parallel calls must be [service, options] tuples or spawn thunks.");
   }
-  if (!resolved.binaryName) {
-    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
+  const { options, cleanup } = withAbortSignal(call[1], signal);
+  try {
+    const handle = spawnOnce(call[0], options);
+    const [result] = await Promise.all([handle.result, drainEvents(handle.events)]);
+    return result;
+  } finally {
+    cleanup();
   }
-  return {
-    agentId: resolved.agentId,
-    binaryName: resolved.binaryName,
-    spawnConfig: resolved.spawnConfig
-  };
-}
-function getDefaultArgsPosition(config) {
-  return config.defaultArgsPosition ?? "afterPrompt";
 }
-function getMcpArgsPosition(config) {
-  if (config.mcpArgsPosition) {
-    return config.mcpArgsPosition;
+async function drainEvents(events) {
+  for await (const ignoredEvent of events) {
+    void ignoredEvent;
   }
-  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
 }
-function buildCliArgs(config, options, stdinMode) {
-  const mcpArgs = getMcpArgs(config, options.mcpServers);
-  const resumeArgs = getResumeArgs(config, options);
-  const defaultArgsPosition = getDefaultArgsPosition(config);
-  const mcpArgsPosition = getMcpArgsPosition(config);
-  const resumeArgsPosition = config.resume?.position ?? "afterPrompt";
-  const args = [];
-  if (mcpArgsPosition === "beforeCommand") {
-    args.push(...mcpArgs);
+function normalizeMaxConcurrent(maxConcurrent) {
+  const value = maxConcurrent ?? 4;
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("spawn.parallel maxConcurrent must be an integer greater than or equal to 1.");
   }
-  if (defaultArgsPosition === "beforePrompt") {
-    args.push(...config.defaultArgs);
+  return value;
+}
+function isSpawnTuple(call) {
+  return Array.isArray(call) && call.length === 2;
+}
+function withAbortSignal(options, signal) {
+  if (!options.signal) {
+    return {
+      options: { ...options, signal },
+      cleanup() {
+      }
+    };
+  }
+  const controller = new AbortController();
+  const abort = () => {
+    controller.abort();
+  };
+  if (signal.aborted || options.signal.aborted) {
+    controller.abort();
+  } else {
+    signal.addEventListener("abort", abort, { once: true });
+    options.signal.addEventListener("abort", abort, { once: true });
+  }
+  return {
+    options: { ...options, signal: controller.signal },
+    cleanup() {
+      signal.removeEventListener("abort", abort);
+      options.signal?.removeEventListener("abort", abort);
+    }
+  };
+}
+function linkParentAbort(parentSignal, group, setFailure) {
+  if (!parentSignal) {
+    return () => {
+    };
+  }
+  const abort = () => {
+    const error2 = createAbortError3();
+    setFailure(error2);
+    group.abort(error2);
+  };
+  if (parentSignal.aborted) {
+    abort();
+    return () => {
+    };
+  }
+  parentSignal.addEventListener("abort", abort, { once: true });
+  return () => parentSignal.removeEventListener("abort", abort);
+}
+function throwIfAborted3(signal) {
+  if (signal.aborted) {
+    throw createAbortError3();
+  }
+}
+function createAbortError3() {
+  const error2 = new Error("Agent spawn parallel aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+
+// packages/agent-spawn/src/prompt-transport.ts
+function shouldSendPromptViaStdin(config, options) {
+  return !!config.stdinMode && (options.useStdin === true || options.prompt.includes("\0"));
+}
+
+// packages/agent-spawn/src/retry.ts
+var retryableExitCodes = /* @__PURE__ */ new Set([1, 124, 125, 137]);
+var maxBackoffMs = 3e4;
+function createSpawnRetry(spawnOnce) {
+  return (service, options, retryOptions) => {
+    const normalizedRetryOptions = normalizeRetryOptions(retryOptions);
+    const queue = createEventQueue();
+    const result = runRetryingSpawn({
+      service,
+      options,
+      retryOptions: normalizedRetryOptions,
+      spawnOnce,
+      emit: queue.push
+    }).then((value) => {
+      queue.close();
+      return value;
+    }).catch((error2) => {
+      queue.fail(error2);
+      throw error2;
+    });
+    return {
+      events: queue,
+      result
+    };
+  };
+}
+function defaultIsRetryable(result) {
+  return retryableExitCodes.has(result.exitCode);
+}
+function calculateBackoffMs(baseBackoffMs, completedAttempt) {
+  return Math.min(baseBackoffMs * 2 ** (completedAttempt - 1), maxBackoffMs);
+}
+function normalizeRetryOptions(retryOptions) {
+  if (!Number.isInteger(retryOptions.maxAttempts) || retryOptions.maxAttempts < 1) {
+    throw new Error("spawn.retry maxAttempts must be an integer greater than or equal to 1.");
+  }
+  if (!Number.isFinite(retryOptions.backoffMs) || retryOptions.backoffMs < 0) {
+    throw new Error("spawn.retry backoffMs must be a non-negative finite number.");
+  }
+  return {
+    maxAttempts: retryOptions.maxAttempts,
+    backoffMs: retryOptions.backoffMs,
+    isRetryable: retryOptions.isRetryable ?? defaultIsRetryable
+  };
+}
+async function runRetryingSpawn(input) {
+  for (let attempt = 1; attempt <= input.retryOptions.maxAttempts; attempt += 1) {
+    throwIfAborted4(input.options.signal);
+    const handle = input.spawnOnce(input.service, input.options);
+    const events = forwardAttemptEvents(handle.events, attempt, input.emit);
+    const result = await handle.result;
+    await events;
+    const isLastAttempt = attempt >= input.retryOptions.maxAttempts;
+    if (result.exitCode === 0 || isLastAttempt || !input.retryOptions.isRetryable(result)) {
+      return result;
+    }
+    const delayMs = calculateBackoffMs(input.retryOptions.backoffMs, attempt);
+    input.emit(createWaitEvent(attempt, delayMs));
+    await sleep4(delayMs, input.options.signal);
+  }
+  throw new Error("spawn.retry reached an unreachable retry state.");
+}
+async function forwardAttemptEvents(events, attempt, emit) {
+  for await (const event of events) {
+    emit(prefixEvent(event, attempt));
+  }
+}
+function prefixEvent(event, attempt) {
+  const prefix = `attempt: ${attempt}`;
+  if (event.event === "agent_message" || event.event === "reasoning") {
+    return { ...event, text: `${prefix} ${event.text}` };
+  }
+  if (event.event === "error") {
+    return { ...event, message: `${prefix} ${event.message}` };
+  }
+  if (event.event === "tool_start") {
+    return { ...event, title: `${prefix} ${event.title}` };
+  }
+  if (event.event === "tool_complete") {
+    return { ...event, path: `${prefix} ${event.path}` };
+  }
+  return {
+    ...event,
+    _meta: {
+      ...typeof event._meta === "object" && event._meta !== null ? event._meta : {},
+      attempt
+    }
+  };
+}
+function createWaitEvent(attempt, delayMs) {
+  return {
+    event: "agent_message",
+    text: `attempt: ${attempt} wait ${delayMs}ms before retry`
+  };
+}
+function sleep4(delayMs, signal) {
+  throwIfAborted4(signal);
+  return new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(createAbortError4());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function throwIfAborted4(signal) {
+  if (signal?.aborted) {
+    throw createAbortError4();
+  }
+}
+function createAbortError4() {
+  const error2 = new Error("Agent spawn retry aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+function createEventQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let failure;
+  const next = () => {
+    if (values.length > 0) {
+      return Promise.resolve({ value: values.shift(), done: false });
+    }
+    if (failure !== void 0) {
+      return Promise.reject(failure);
+    }
+    if (closed) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve2, reject) => {
+      waiters.push({ resolve: resolve2, reject });
+    });
+  };
+  return {
+    push(value) {
+      if (closed || failure !== void 0) {
+        return;
+      }
+      const waiter = waiters.shift();
+      if (waiter) {
+        waiter.resolve({ value, done: false });
+        return;
+      }
+      values.push(value);
+    },
+    close() {
+      if (closed || failure !== void 0) {
+        return;
+      }
+      closed = true;
+      for (const waiter of waiters.splice(0)) {
+        waiter.resolve({ value: void 0, done: true });
+      }
+    },
+    fail(error2) {
+      if (closed || failure !== void 0) {
+        return;
+      }
+      failure = error2;
+      for (const waiter of waiters.splice(0)) {
+        waiter.reject(error2);
+      }
+    },
+    async *[Symbol.asyncIterator]() {
+      while (true) {
+        const item = await next();
+        if (item.done) {
+          return;
+        }
+        yield item.value;
+      }
+    }
+  };
+}
+
+// packages/agent-spawn/src/skill-bridge.ts
+import crypto from "node:crypto";
+import os6 from "node:os";
+
+// packages/agent-skill-config/src/configs.ts
+import os5 from "node:os";
+import path36 from "node:path";
+var agentSkillConfigs = {
+  "claude-code": {
+    globalSkillDir: "~/.claude/skills",
+    localSkillDir: ".claude/skills"
+  },
+  codex: {
+    globalSkillDir: "~/.codex/skills",
+    localSkillDir: ".codex/skills"
+  },
+  opencode: {
+    globalSkillDir: "~/.config/opencode/skills",
+    localSkillDir: ".opencode/skills"
+  },
+  goose: {
+    globalSkillDir: "~/.agents/skills",
+    localSkillDir: ".agents/skills"
+  }
+};
+var supportedAgents2 = Object.keys(agentSkillConfigs);
+function resolveAgentSupport(input, registry = agentSkillConfigs) {
+  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 getAgentConfig(agentId) {
+  const support = resolveAgentSupport(agentId);
+  return support.status === "supported" ? support.config : void 0;
+}
+function expandHome2(targetPath, homeDir = os5.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 resolveSkillDir(config, scope, cwd, homeDir) {
+  if (scope === "global") {
+    return path36.resolve(expandHome2(config.globalSkillDir, homeDir));
+  }
+  return path36.resolve(cwd, config.localSkillDir);
+}
+
+// packages/agent-skill-config/src/templates.ts
+import { readFile as readFile13, stat as stat5 } from "node:fs/promises";
+import path37 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/agent-skill-config/src/apply.ts
+var UnsupportedAgentError = class extends Error {
+  constructor(agentId) {
+    super(`Unsupported agent: ${agentId}`);
+    this.name = "UnsupportedAgentError";
+  }
+};
+function toHomeRelative(localSkillDir) {
+  if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+    return localSkillDir;
+  }
+  const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
+  return `~/${normalized}`;
+}
+var SKILL_TEMPLATE_ID = "__skill_content__";
+async function installSkill(agentId, skill, options) {
+  const support = resolveAgentSupport(agentId);
+  if (support.status !== "supported") {
+    throw new UnsupportedAgentError(agentId);
+  }
+  const scope = options.scope ?? "local";
+  const config = support.config;
+  const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+  const skillFolderPath = `${skillDir}/${skill.name}`;
+  const skillFilePath = `${skillFolderPath}/SKILL.md`;
+  const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+  await runMutations(
+    [
+      fileMutation.ensureDirectory({
+        path: skillFolderPath,
+        label: `Ensure skill directory ${skill.name}`
+      }),
+      templateMutation.write({
+        target: skillFilePath,
+        templateId: SKILL_TEMPLATE_ID,
+        label: `Write skill ${skill.name}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: scope === "global" ? options.homeDir : options.cwd,
+      dryRun: options.dryRun,
+      observers: options.observers,
+      templates: async (templateId) => {
+        if (templateId === SKILL_TEMPLATE_ID) {
+          return skill.content;
+        }
+        throw new Error(`Unknown template: ${templateId}`);
+      }
+    }
+  );
+  return { skillPath: skillFilePath, displayPath };
+}
+
+// packages/agent-skill-config/src/resolve-skill-reference.ts
+import { statSync } from "node:fs";
+import path38 from "node:path";
+function isMalformedSegment(segment) {
+  return segment.length === 0 || segment !== segment.trim();
+}
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function findSkill(ref, name, tiers, sourceAgentId) {
+  for (const tier of tiers) {
+    if (isDirectory(tier.sourcePath)) {
+      return {
+        kind: "resolved",
+        ref,
+        name,
+        ...sourceAgentId ? { sourceAgentId } : {},
+        sourcePath: tier.sourcePath,
+        scope: tier.scope
+      };
+    }
+  }
+  return {
+    kind: "not-found",
+    ref,
+    searchedPaths: tiers.map((tier) => tier.sourcePath)
+  };
+}
+function resolveSkillReference(ref, cwd, homeDir) {
+  const slashIndex = ref.indexOf("/");
+  const hasPrefix = slashIndex !== -1;
+  if (ref.length === 0 || ref !== ref.trim() || hasPrefix && ref.indexOf("/", slashIndex + 1) !== -1) {
+    return { kind: "malformed", ref };
+  }
+  if (!hasPrefix) {
+    if (isMalformedSegment(ref)) {
+      return { kind: "malformed", ref };
+    }
+    const tiers2 = [
+      {
+        scope: "project",
+        sourcePath: path38.resolve(cwd, ".poe-code/skills", ref)
+      },
+      {
+        scope: "user",
+        sourcePath: path38.resolve(homeDir, ".poe-code/skills", ref)
+      }
+    ];
+    return findSkill(ref, ref, tiers2);
+  }
+  const agentInput = ref.slice(0, slashIndex);
+  const name = ref.slice(slashIndex + 1);
+  if (isMalformedSegment(agentInput) || isMalformedSegment(name)) {
+    return { kind: "malformed", ref };
+  }
+  const support = resolveAgentSupport(agentInput);
+  if (support.status !== "supported" || !support.id) {
+    return { kind: "unknown-agent", ref, agentInput };
+  }
+  const config = getAgentConfig(support.id);
+  if (!config) {
+    return { kind: "unknown-agent", ref, agentInput };
+  }
+  const tiers = [
+    {
+      scope: "project",
+      sourcePath: path38.resolve(resolveSkillDir(config, "local", cwd), name)
+    },
+    {
+      scope: "user",
+      sourcePath: path38.resolve(resolveSkillDir(config, "global", cwd, homeDir), name)
+    }
+  ];
+  return findSkill(ref, name, tiers, support.id);
+}
+
+// packages/agent-skill-config/src/git-exclude.ts
+import { execFileSync } from "node:child_process";
+import * as fs10 from "node:fs";
+import path39 from "node:path";
+var markerPrefix = "# poe-code-spawn-skills:";
+function defaultGitDirRunner(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--git-dir"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+var gitDirRunner = defaultGitDirRunner;
+function resolveExcludePath(cwd) {
+  const gitDir = gitDirRunner(cwd);
+  if (gitDir === void 0 || gitDir.length === 0) {
+    return void 0;
+  }
+  return path39.join(path39.isAbsolute(gitDir) ? gitDir : path39.resolve(cwd, gitDir), "info/exclude");
+}
+function markers(runId) {
+  return {
+    begin: `${markerPrefix}${runId} begin`,
+    end: `${markerPrefix}${runId} end`
+  };
+}
+function readExcludeFile(excludePath) {
+  try {
+    return fs10.readFileSync(excludePath, "utf8");
+  } catch (error2) {
+    if (isNodeError2(error2) && error2.code === "ENOENT") {
+      return void 0;
+    }
+    throw error2;
+  }
+}
+function isNodeError2(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+function removeBlock(content, runId) {
+  const { begin, end } = markers(runId);
+  const lines = content.split("\n");
+  const result = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index] === begin) {
+      const endIndex = lines.indexOf(end, index + 1);
+      if (endIndex !== -1) {
+        index = endIndex;
+        continue;
+      }
+    }
+    result.push(lines[index]);
+  }
+  return result.join("\n");
+}
+function appendBlock(content, runId, entries) {
+  const { begin, end } = markers(runId);
+  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) {
+  const excludePath = resolveExcludePath(cwd);
+  if (excludePath === void 0) {
+    return;
+  }
+  fs10.mkdirSync(path39.dirname(excludePath), { recursive: true });
+  const content = readExcludeFile(excludePath);
+  fs10.writeFileSync(excludePath, appendBlock(content, runId, entries), "utf8");
+}
+function removeExcludeBlock(cwd, runId) {
+  const excludePath = resolveExcludePath(cwd);
+  if (excludePath === void 0) {
+    return;
+  }
+  const content = readExcludeFile(excludePath);
+  if (content === void 0) {
+    return;
+  }
+  fs10.writeFileSync(excludePath, removeBlock(content, runId), "utf8");
+}
+
+// packages/agent-skill-config/src/bridge-active-skills.ts
+import * as fs11 from "node:fs";
+import path40 from "node:path";
+function isNodeError3(error2) {
+  return error2 instanceof Error && "code" in error2;
+}
+function pathExists3(targetPath) {
+  try {
+    fs11.statSync(targetPath);
+    return true;
+  } catch (error2) {
+    if (isNodeError3(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function isDirectory2(targetPath) {
+  try {
+    return fs11.statSync(targetPath).isDirectory();
+  } catch (error2) {
+    if (isNodeError3(error2) && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function formatResolutionFailureError(failures) {
+  const malformed = failures.filter((failure) => failure.kind === "malformed");
+  const unknownAgent = failures.filter((failure) => failure.kind === "unknown-agent");
+  const notFound = failures.filter((failure) => failure.kind === "not-found");
+  const lines = [
+    `Failed to bridge active skills: ${failures.length} skill reference(s) could not be resolved.`
+  ];
+  if (malformed.length > 0) {
+    lines.push("", "Malformed skill references:");
+    for (const failure of malformed) {
+      lines.push(`- ${failure.ref}`);
+    }
+    lines.push('Expected syntax: "<name>" or "<agentId>/<name>".');
+  }
+  if (unknownAgent.length > 0) {
+    lines.push("", "Unknown agent references:");
+    for (const failure of unknownAgent) {
+      lines.push(`- ${failure.ref} (agent token: ${failure.agentInput})`);
+    }
+    lines.push(`Supported agents: ${supportedAgents2.join(", ")}.`);
+  }
+  if (notFound.length > 0) {
+    lines.push("", "Not found skill references.");
+    for (const failure of notFound) {
+      lines.push(`- ${failure.ref}`);
+      lines.push("  searched paths:");
+      for (const searchedPath of failure.searchedPaths) {
+        lines.push(`  - ${searchedPath}`);
+      }
+    }
+  }
+  return new Error(lines.join("\n"));
+}
+function copyDirectory(sourcePath, targetPath) {
+  fs11.mkdirSync(targetPath, { recursive: true });
+  for (const dirent of fs11.readdirSync(sourcePath, { withFileTypes: true })) {
+    const childSource = path40.join(sourcePath, dirent.name);
+    const childTarget = path40.join(targetPath, dirent.name);
+    if (dirent.isDirectory()) {
+      copyDirectory(childSource, childTarget);
+      continue;
+    }
+    if (dirent.isFile()) {
+      fs11.copyFileSync(childSource, childTarget);
+    }
+  }
+}
+function collectMissingParents(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 removeDirectoryIfEmpty(targetPath) {
+  try {
+    fs11.rmdirSync(targetPath);
+  } catch (error2) {
+    if (isNodeError3(error2) && (error2.code === "ENOENT" || error2.code === "ENOTEMPTY" || error2.code === "EEXIST")) {
+      return;
+    }
+    throw error2;
+  }
+}
+function removeTarget(targetPath) {
+  fs11.rmSync(targetPath, { recursive: true, force: true });
+}
+function toCwdRelative(cwd, targetPath) {
+  return path40.relative(cwd, targetPath);
+}
+function warning(kind, ref, sourcePath, conflictingPath) {
+  const messages = {
+    "intra-batch-collision": `Skipping ${ref}: an earlier bridged skill already targets ${conflictingPath}.`,
+    "local-collision": `Skipping ${ref}: local skill already exists at ${conflictingPath}.`,
+    "global-collision": `Skipping ${ref}: global skill already exists at ${conflictingPath}.`,
+    "self-reference": `Skipping ${ref}: spawning agent already sees this native skill at ${conflictingPath}.`
+  };
+  return {
+    kind,
+    ref,
+    sourcePath,
+    conflictingPath,
+    message: messages[kind]
+  };
+}
+function bridgeActiveSkills(spawnAgentId, cwd, refs, homeDir, runId) {
+  const spawnConfig = getAgentConfig(spawnAgentId);
+  const spawnSupport = resolveAgentSupport(spawnAgentId);
+  if (!spawnConfig || spawnSupport.status !== "supported" || !spawnSupport.id) {
+    throw new Error(
+      `Unsupported spawn agent "${spawnAgentId}". Supported agents: ${supportedAgents2.join(", ")}.`
+    );
+  }
+  const targetDir = resolveSkillDir(spawnConfig, "local", cwd);
+  const globalTargetDir = resolveSkillDir(spawnConfig, "global", cwd, homeDir);
+  const resolutions = refs.map((ref) => resolveSkillReference(ref, cwd, homeDir));
+  const failures = resolutions.filter(
+    (resolution) => resolution.kind !== "resolved"
+  );
+  if (failures.length > 0) {
+    throw formatResolutionFailureError(failures);
+  }
+  const sources = resolutions.map((source, index) => ({
+    ref: refs[index],
+    source,
+    targetPath: path40.resolve(targetDir, source.name),
+    globalTargetPath: path40.resolve(globalTargetDir, source.name)
+  }));
+  const entries = [];
+  const warnings = [];
+  const claimedTargets = /* @__PURE__ */ new Set();
+  for (const item of sources) {
+    if (claimedTargets.has(item.targetPath)) {
+      warnings.push(
+        warning("intra-batch-collision", item.ref, item.source.sourcePath, item.targetPath)
+      );
+      continue;
+    }
+    if (item.source.sourceAgentId === spawnSupport.id) {
+      warnings.push(
+        warning("self-reference", item.ref, item.source.sourcePath, item.source.sourcePath)
+      );
+      continue;
+    }
+    if (pathExists3(item.targetPath)) {
+      warnings.push(warning("local-collision", item.ref, item.source.sourcePath, item.targetPath));
+      continue;
+    }
+    if (isDirectory2(item.globalTargetPath)) {
+      warnings.push(
+        warning("global-collision", item.ref, item.source.sourcePath, item.globalTargetPath)
+      );
+      continue;
+    }
+    const createdParents = collectMissingParents(item.targetPath);
+    fs11.mkdirSync(path40.dirname(item.targetPath), { recursive: true });
+    copyDirectory(item.source.sourcePath, item.targetPath);
+    claimedTargets.add(item.targetPath);
+    entries.push({
+      ref: item.ref,
+      sourcePath: item.source.sourcePath,
+      targetPath: item.targetPath,
+      createdParents
+    });
+  }
+  if (entries.length > 0) {
+    appendExcludeBlock(
+      cwd,
+      runId,
+      entries.map((entry) => toCwdRelative(cwd, entry.targetPath))
+    );
+  }
+  return {
+    spawnAgentId,
+    cwd,
+    runId,
+    entries,
+    warnings
+  };
+}
+function cleanupBridgedSkills(manifest) {
+  for (const entry of manifest.entries) {
+    removeTarget(entry.targetPath);
+    for (const parent of [...entry.createdParents].reverse()) {
+      removeDirectoryIfEmpty(parent);
+    }
+  }
+  removeExcludeBlock(manifest.cwd, manifest.runId);
+}
+
+// packages/agent-spawn/src/skill-bridge.ts
+function bridgeSkillsForRun(agentId, cwd, skills) {
+  if (!skills || skills.length === 0) {
+    return void 0;
+  }
+  const manifest = bridgeActiveSkills(agentId, cwd, skills, os6.homedir(), crypto.randomUUID());
+  for (const warning2 of manifest.warnings) {
+    logger.warn(warning2.message);
+  }
+  return manifest;
+}
+function cleanupSkillsForRun(manifest) {
+  if (!manifest) {
+    return;
+  }
+  cleanupBridgedSkills(manifest);
+}
+
+// packages/agent-spawn/src/adapters/utils.ts
+function truncate(text5, maxLength) {
+  if (text5.length <= maxLength) return text5;
+  if (maxLength <= 3) return text5.slice(0, maxLength);
+  return `${text5.slice(0, maxLength - 3)}...`;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function extractThreadId(value) {
+  if (!value || typeof value !== "object") return;
+  const obj = value;
+  const maybeThreadId = isNonEmptyString(obj.thread_id) && obj.thread_id || isNonEmptyString(obj.threadId) && obj.threadId || isNonEmptyString(obj.threadID) && obj.threadID || isNonEmptyString(obj.session_id) && obj.session_id || isNonEmptyString(obj.sessionId) && obj.sessionId || isNonEmptyString(obj.sessionID) && obj.sessionID;
+  return maybeThreadId || void 0;
+}
+
+// packages/agent-spawn/src/adapters/claude.ts
+var TOOL_KIND_MAP = {
+  Read: "read",
+  Write: "edit",
+  Edit: "edit",
+  NotebookEdit: "edit",
+  Bash: "exec",
+  Glob: "search",
+  Grep: "search",
+  Task: "think"
+};
+var TITLE_KEYS = {
+  Bash: ["command"],
+  Read: ["file_path"],
+  Write: ["file_path"],
+  Edit: ["file_path"],
+  NotebookEdit: ["notebook_path"],
+  Glob: ["pattern"],
+  Grep: ["pattern"],
+  Task: ["description", "prompt"]
+};
+function extractTitle(name, input) {
+  const keys = TITLE_KEYS[name];
+  if (keys && input && typeof input === "object") {
+    const obj = input;
+    for (const key of keys) {
+      const value = obj[key];
+      if (typeof value === "string" && value.length > 0) {
+        return truncate(value, 80);
+      }
+    }
+  }
+  return name;
+}
+async function* adaptClaude(lines) {
+  const toolKindsById = /* @__PURE__ */ new Map();
+  let emittedSessionStart = false;
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const firstChar = line[0];
+    if (firstChar !== "{" && firstChar !== "[") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptClaude] Malformed JSON line: ${truncate(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (!emittedSessionStart) {
+      const threadId = extractThreadId(event);
+      emittedSessionStart = true;
+      yield { event: "session_start", threadId };
+    }
+    if (eventType === "result") {
+      const usage = event.usage ?? {};
+      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : typeof event.input_tokens === "number" ? event.input_tokens : typeof event.num_input_tokens === "number" ? event.num_input_tokens : 0;
+      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : typeof event.output_tokens === "number" ? event.output_tokens : typeof event.num_output_tokens === "number" ? event.num_output_tokens : 0;
+      const costUsd = typeof usage.cost_usd === "number" ? usage.cost_usd : typeof event.cost_usd === "number" ? event.cost_usd : void 0;
+      yield { event: "usage", inputTokens, outputTokens, costUsd };
+      continue;
+    }
+    if (eventType !== "assistant" && eventType !== "user") continue;
+    const message2 = event.message ?? null;
+    if (!message2 || typeof message2 !== "object") continue;
+    const content = message2.content ?? null;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      const item = block;
+      if (!item || typeof item !== "object") continue;
+      const blockType = item.type;
+      if (!isNonEmptyString(blockType)) continue;
+      if (eventType === "assistant") {
+        if (blockType === "text" && isNonEmptyString(item.text)) {
+          yield {
+            event: "agent_message",
+            text: item.text
+          };
+          continue;
+        }
+        if (blockType === "tool_use" && isNonEmptyString(item.id) && isNonEmptyString(item.name)) {
+          const kind = TOOL_KIND_MAP[item.name] ?? "other";
+          toolKindsById.set(item.id, kind);
+          yield {
+            event: "tool_start",
+            id: item.id,
+            kind,
+            title: extractTitle(item.name, item.input),
+            input: item.input
+          };
+        }
+        continue;
+      }
+      if (eventType === "user") {
+        if (!isNonEmptyString(item.tool_use_id)) continue;
+        if (blockType !== "tool_result") continue;
+        const kind = toolKindsById.get(item.tool_use_id);
+        toolKindsById.delete(item.tool_use_id);
+        let path50;
+        if (typeof item.content === "string") {
+          path50 = item.content;
+        } else {
+          try {
+            path50 = JSON.stringify(item.content);
+          } catch {
+            path50 = String(item.content);
+          }
+        }
+        yield {
+          event: "tool_complete",
+          id: item.tool_use_id,
+          kind,
+          path: path50
+        };
+      }
+    }
+  }
+}
+
+// packages/agent-spawn/src/adapters/codex.ts
+async function* adaptCodex(lines) {
+  const toolTitleById = /* @__PURE__ */ new Map();
+  const toolKindById = /* @__PURE__ */ new Map();
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptCodex] Malformed JSON line: ${truncate(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (eventType === "thread.started") {
+      const maybeThreadId = extractThreadId(event);
+      yield { event: "session_start", threadId: maybeThreadId };
+      continue;
+    }
+    if (eventType === "turn.started") {
+      continue;
+    }
+    if (eventType === "turn.completed") {
+      const usage = event.usage ?? {};
+      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+      const cachedTokens = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : 0;
+      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
+      continue;
+    }
+    if (eventType === "turn.failed") {
+      const message2 = extractErrorMessage(event) ?? "Turn failed";
+      yield { event: "error", message: message2 };
+      continue;
+    }
+    const item = event.item ?? null;
+    if (!item || typeof item !== "object") continue;
+    const itemType = item.type;
+    if (!isNonEmptyString(itemType)) continue;
+    if (eventType === "item.started") {
+      if (!isNonEmptyString(item.id)) continue;
+      let kind;
+      let title;
+      if (itemType === "command_execution") {
+        kind = "exec";
+        title = truncate(isNonEmptyString(item.command) ? item.command : "", 80);
+      } else if (itemType === "file_edit") {
+        kind = "edit";
+        title = isNonEmptyString(item.path) ? item.path : "";
+      } else if (itemType === "thinking") {
+        kind = "think";
+        title = "thinking...";
+      } else if (itemType === "mcp_tool_call") {
+        const server = isNonEmptyString(item.server) ? item.server : "unknown";
+        const tool = isNonEmptyString(item.tool) ? item.tool : "unknown";
+        kind = "other";
+        title = `${server}.${tool}`;
+      }
+      if (kind && title !== void 0) {
+        toolTitleById.set(item.id, title);
+        toolKindById.set(item.id, kind);
+        yield { event: "tool_start", id: item.id, kind, title };
+      }
+      continue;
+    }
+    if (eventType === "item.completed") {
+      if (itemType === "agent_message") {
+        if (!isNonEmptyString(item.text)) continue;
+        yield { event: "agent_message", text: item.text };
+        continue;
+      }
+      if (itemType === "reasoning") {
+        const text5 = isNonEmptyString(item.text) ? item.text : isNonEmptyString(item.content) ? item.content : isNonEmptyString(item.summary) ? item.summary : void 0;
+        if (!text5) continue;
+        yield { event: "reasoning", text: text5 };
+        continue;
+      }
+      if (!isNonEmptyString(item.id)) continue;
+      if (itemType === "command_execution" || itemType === "file_edit" || itemType === "mcp_tool_call") {
+        const kindFromStart = toolKindById.get(item.id);
+        const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
+        const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
+        const path50 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        toolTitleById.delete(item.id);
+        toolKindById.delete(item.id);
+        yield { event: "tool_complete", id: item.id, kind, path: path50 };
+      }
+    }
+  }
+}
+function extractErrorMessage(event) {
+  if (isNonEmptyString(event.message)) return event.message;
+  const error2 = event.error;
+  if (isNonEmptyString(error2)) return error2;
+  if (typeof error2 === "object" && error2 !== null) {
+    const errorObj = error2;
+    if (isNonEmptyString(errorObj.message)) return errorObj.message;
+  }
+  if (isNonEmptyString(event.reason)) return event.reason;
+  return void 0;
+}
+
+// packages/agent-spawn/src/adapters/kimi.ts
+async function* adaptKimi(lines) {
+  let emittedSessionStart = false;
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptKimi] Malformed JSON line: ${truncate(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    if (!event || typeof event !== "object") continue;
+    if (!emittedSessionStart) {
+      const threadId = extractThreadId(event);
+      if (threadId) {
+        emittedSessionStart = true;
+        yield { event: "session_start", threadId };
+      }
+    }
+    const role = event.role;
+    if (!isNonEmptyString(role) || role !== "assistant") continue;
+    const content = event.content;
+    if (!isNonEmptyString(content)) continue;
+    yield { event: "agent_message", text: content };
+  }
+}
+
+// packages/agent-spawn/src/adapters/native.ts
+async function* adaptNative(lines) {
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptNative] Malformed JSON line: ${truncate(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const maybeEventType = event?.event;
+    if (!isNonEmptyString(maybeEventType)) {
+      yield {
+        event: "error",
+        message: `[adaptNative] Line missing string "event" field: ${truncate(line, 200)}`
+      };
+      continue;
+    }
+    yield event;
+  }
+}
+
+// packages/agent-spawn/src/adapters/opencode.ts
+function guessToolKind(toolName) {
+  const normalized = toolName.toLowerCase();
+  if (normalized === "bash" || normalized === "shell" || normalized === "sh") return "exec";
+  if (normalized.includes("read")) return "read";
+  if (normalized.includes("write") || normalized.includes("edit") || normalized.includes("patch")) {
+    return "edit";
+  }
+  if (normalized.includes("search") || normalized.includes("grep") || normalized.includes("glob") || normalized.includes("find")) {
+    return "search";
+  }
+  if (normalized.includes("think") || normalized.includes("task")) return "think";
+  return "other";
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+async function* adaptOpenCode(lines) {
+  let emittedSessionStart = false;
+  const toolKindById = /* @__PURE__ */ new Map();
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptOpenCode] Malformed JSON line: ${truncate(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    if (!event || typeof event !== "object") continue;
+    const sessionID = extractThreadId(event);
+    if (!emittedSessionStart && isNonEmptyString(sessionID)) {
+      emittedSessionStart = true;
+      yield { event: "session_start", threadId: sessionID };
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (eventType === "text") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      if (!isNonEmptyString(part.text)) continue;
+      yield { event: "agent_message", text: part.text };
+      continue;
+    }
+    if (eventType === "tool_use") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      if (!isNonEmptyString(part.callID) || !isNonEmptyString(part.tool)) continue;
+      const state = part.state ?? null;
+      if (!state || typeof state !== "object") continue;
+      const kind = guessToolKind(part.tool);
+      const status = state.status;
+      const terminal = status === "completed" || status === "failed";
+      if (!toolKindById.has(part.callID)) {
+        toolKindById.set(part.callID, kind);
+        let title = part.tool;
+        const maybeInput = state.input;
+        if (kind === "exec" && maybeInput && typeof maybeInput === "object") {
+          const command = maybeInput.command;
+          if (isNonEmptyString(command)) {
+            title = truncate(command, 80);
+          }
+        }
+        yield {
+          event: "tool_start",
+          id: part.callID,
+          kind,
+          title,
+          input: state.input
+        };
+      }
+      if (terminal) {
+        const kindFromStart = toolKindById.get(part.callID) ?? kind;
+        toolKindById.delete(part.callID);
+        yield {
+          event: "tool_complete",
+          id: part.callID,
+          kind: kindFromStart,
+          path: safeStringify(state.output)
+        };
+      }
+      continue;
+    }
+    if (eventType === "step_finish") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      const tokens = part.tokens ?? null;
+      if (!tokens || typeof tokens !== "object") continue;
+      const inputTokens = typeof tokens.input === "number" ? tokens.input : 0;
+      const outputTokens = typeof tokens.output === "number" ? tokens.output : 0;
+      const cache = tokens.cache ?? null;
+      const cachedTokens = cache && typeof cache === "object" && typeof cache.read === "number" ? cache.read : void 0;
+      if (inputTokens === 0 && outputTokens === 0 && cachedTokens === void 0) continue;
+      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
+      continue;
+    }
+  }
+}
+
+// packages/agent-spawn/src/adapters/index.ts
+var adapters = {
+  codex: adaptCodex,
+  claude: adaptClaude,
+  kimi: adaptKimi,
+  native: adaptNative,
+  opencode: adaptOpenCode
+};
+function getAdapter(type) {
+  const adapter = adapters[type];
+  if (!adapter) {
+    throw new Error(`Unknown adapter "${String(type)}".`);
+  }
+  return adapter;
+}
+
+// packages/agent-spawn/src/acp/meta.ts
+function stampReceiveTime(event, ts) {
+  if (event === null || typeof event !== "object") {
+    return event;
+  }
+  const target = event;
+  const existing = target._meta;
+  if (existing && typeof existing.ts === "number") {
+    return event;
+  }
+  target._meta = existing ? { ...existing, ts } : { ts };
+  return event;
+}
+
+// packages/agent-spawn/src/acp/middleware.ts
+async function applyMiddlewares(middlewares, ctx) {
+  let index = -1;
+  async function dispatch(position) {
+    if (position <= index) {
+      throw new Error("next() called multiple times");
+    }
+    index = position;
+    if (position === middlewares.length) {
+      return;
+    }
+    const middleware = middlewares[position];
+    if (typeof middleware !== "function") {
+      throw new Error(`Invalid ACP middleware at index ${position}`);
+    }
+    await middleware(ctx, () => dispatch(position + 1));
+  }
+  await dispatch(0);
+}
+
+// packages/agent-spawn/src/acp/spawn.ts
+function createAbortError5() {
+  const error2 = new Error("Agent spawn aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+function isAcpEvent(value) {
+  return !!value && typeof value === "object" && "event" in value;
+}
+function accumulateUsage(ctx, event) {
+  if (event.event !== "usage") {
+    return;
+  }
+  const usage = event;
+  if (typeof usage.inputTokens === "number" && Number.isFinite(usage.inputTokens)) {
+    ctx.usage.inputTokens += usage.inputTokens;
+  }
+  if (typeof usage.outputTokens === "number" && Number.isFinite(usage.outputTokens)) {
+    ctx.usage.outputTokens += usage.outputTokens;
+  }
+  if (typeof usage.cachedTokens === "number" && Number.isFinite(usage.cachedTokens)) {
+    ctx.usage.cachedTokens = (ctx.usage.cachedTokens ?? 0) + usage.cachedTokens;
+  }
+  if (typeof usage.costUsd === "number" && Number.isFinite(usage.costUsd)) {
+    ctx.usage.costUsd = (ctx.usage.costUsd ?? 0) + usage.costUsd;
+  }
+}
+function createLineQueue() {
+  const lines = [];
+  const waiters = [];
+  let pending = "";
+  let closed = false;
+  const emit = (line) => {
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value: line });
+      return;
+    }
+    lines.push(line);
+  };
+  const finishWaiters = () => {
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      waiter.resolve({ done: true, value: void 0 });
+    }
+  };
+  return {
+    push(chunk) {
+      if (closed) return;
+      pending += chunk;
+      let newlineIndex = pending.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const raw = pending.slice(0, newlineIndex);
+        emit(raw.endsWith("\r") ? raw.slice(0, -1) : raw);
+        pending = pending.slice(newlineIndex + 1);
+        newlineIndex = pending.indexOf("\n");
+      }
+    },
+    close() {
+      if (closed) return;
+      if (pending.length > 0) {
+        emit(pending.endsWith("\r") ? pending.slice(0, -1) : pending);
+        pending = "";
+      }
+      closed = true;
+      finishWaiters();
+    },
+    lines() {
+      return {
+        [Symbol.asyncIterator]() {
+          return {
+            next() {
+              if (lines.length > 0) {
+                return Promise.resolve({ done: false, value: lines.shift() });
+              }
+              if (closed) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              return new Promise((resolve2) => {
+                waiters.push({ resolve: resolve2 });
+              });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function getDefaultArgsPosition(config) {
+  return config.defaultArgsPosition ?? "afterPrompt";
+}
+function getMcpArgsPosition(config) {
+  if (config.mcpArgsPosition) {
+    return config.mcpArgsPosition;
+  }
+  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+}
+function getResumeArgs(config, options) {
+  if (!options.resumeThreadId) {
+    return [];
+  }
+  if (!config.resume) {
+    throw new Error(`Agent "${config.agentId}" does not support resumeThreadId.`);
+  }
+  return config.resume.args(options.resumeThreadId, options.cwd ?? process.cwd());
+}
+function spawnStreaming(options) {
+  if (options.signal?.aborted) {
+    throw createAbortError5();
+  }
+  const { agentId, binaryName, spawnConfig } = resolveConfig(options.agentId);
+  if (spawnConfig === void 0) {
+    throw new Error(`Agent "${agentId}" has no spawn config.`);
+  }
+  if (spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${agentId}" does not support CLI spawn.`);
+  }
+  if (!binaryName) {
+    throw new Error(`Agent "${agentId}" has no binaryName.`);
+  }
+  const mcpArgs = getMcpArgs(spawnConfig, options.mcpServers);
+  const mcpEnvVars = getMcpEnv(spawnConfig, options.mcpServers);
+  const resumeArgs = getResumeArgs(spawnConfig, options);
+  const defaultArgsPosition = getDefaultArgsPosition(spawnConfig);
+  const mcpArgsPosition = getMcpArgsPosition(spawnConfig);
+  const resumeArgsPosition = spawnConfig.resume?.position ?? "afterPrompt";
+  const args = [];
+  if (mcpArgsPosition === "beforeCommand") {
+    args.push(...mcpArgs);
+  }
+  if (defaultArgsPosition === "beforePrompt") {
+    args.push(...spawnConfig.defaultArgs);
+  }
+  if (mcpArgsPosition === "beforePrompt") {
+    args.push(...mcpArgs);
+  }
+  args.push(spawnConfig.promptFlag);
+  if (resumeArgsPosition === "beforePrompt") {
+    args.push(...resumeArgs);
+  }
+  const useStdin = shouldSendPromptViaStdin(spawnConfig, options);
+  if (!useStdin || !spawnConfig.stdinMode?.omitPrompt) {
+    args.push(options.prompt);
+  }
+  if (options.model && spawnConfig.modelFlag) {
+    let model = spawnConfig.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
+    if (spawnConfig.modelTransform) model = spawnConfig.modelTransform(model);
+    args.push(spawnConfig.modelFlag, model);
+  }
+  if (defaultArgsPosition === "afterPrompt") {
+    args.push(...spawnConfig.defaultArgs);
+  }
+  if (mcpArgsPosition === "afterCommand") {
+    args.push(...mcpArgs);
+  }
+  const modeResolved = resolveModeConfig(spawnConfig.modes[options.mode ?? "yolo"]);
+  args.push(...modeResolved.args);
+  if (useStdin) {
+    args.push(...spawnConfig.stdinMode.extraArgs);
+  }
+  if (options.args && options.args.length > 0) {
+    if (resumeArgsPosition === "afterPrompt") {
+      args.push(...resumeArgs);
+    }
+    args.push(...options.args);
+  } else if (resumeArgsPosition === "afterPrompt") {
+    args.push(...resumeArgs);
+  }
+  const envOverrides = { ...mcpEnvVars, ...modeResolved.env };
+  const processEnv = Object.keys(envOverrides).length > 0 ? { ...process.env, ...envOverrides } : void 0;
+  const cwd = options.cwd ?? process.cwd();
+  const queue = createLineQueue();
+  const argv = [binaryName, ...args];
+  const execution = resolvePoeCommandExecution({
+    cwd,
+    runtimeConfigCwd: options.runtimeConfigCwd,
+    env: processEnv ?? process.env,
+    argv,
+    tool: agentId,
+    runtime: {
+      runtime: options.runtime,
+      runtimeImage: options.runtimeImage,
+      runtimeTemplate: options.runtimeTemplate,
+      detach: options.detach,
+      mountPoeCode: options.mountPoeCode,
+      runnerSync: options.runnerSync
+    },
+    openSpec: {
+      execution: {
+        wrapForLogTee: false,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: processEnv,
+        input: useStdin ? options.prompt : "",
+        captureOutput: true,
+        activityTimeoutMs: options.activityTimeoutMs,
+        onStdout(chunk) {
+          queue.push(chunk);
+        },
+        onStderr(chunk) {
+          if (options.tee?.stderr) options.tee.stderr.write(chunk);
+        }
+      }
+    }
+  });
+  const result = { stdout: "", stderr: "", exitCode: 1 };
+  const adapter = getAdapter(spawnConfig.adapter);
+  let resolveEventStreamDone;
+  let rejectEventStreamDone;
+  const eventStreamDone = new Promise((resolve2, reject) => {
+    resolveEventStreamDone = resolve2;
+    rejectEventStreamDone = reject;
+  });
+  const eventQueue = [];
+  const waiters = [];
+  let eventsDone = false;
+  let eventStreamError;
+  const ctx = {
+    sessionId: "unknown",
+    agent: agentId,
+    ...options.logPath !== void 0 ? { logPath: options.logPath } : {},
+    ...options.logDir !== void 0 ? { logDir: options.logDir } : {},
+    ...options.logFileName !== void 0 ? { logFileName: options.logFileName } : {},
+    events: [],
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0
+    },
+    prompt: options.prompt,
+    model: options.model,
+    mode: options.mode,
+    cwd: options.cwd ?? process.cwd(),
+    startedAt: /* @__PURE__ */ new Date()
+  };
+  const pushEvent = (event) => {
+    if (eventsDone) return;
+    if (event.event === "session_start") {
+      const threadId = event.threadId;
+      if (typeof threadId === "string" && threadId.length > 0) {
+        ctx.threadId = threadId;
+        ctx.sessionId = threadId;
+      }
+    }
+    ctx.events.push(event);
+    accumulateUsage(ctx, event);
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value: event });
+      return;
+    }
+    eventQueue.push(event);
+  };
+  const completeEventStream = () => {
+    if (eventsDone) return;
+    eventsDone = true;
+    while (waiters.length > 0) {
+      waiters.shift()?.resolve({ done: true, value: void 0 });
+    }
+  };
+  const failEventStream = (error2) => {
+    if (eventsDone) return;
+    eventStreamError = error2;
+    eventsDone = true;
+    while (waiters.length > 0) {
+      waiters.shift()?.reject(error2);
+    }
+  };
+  ctx.eventStream = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (eventQueue.length > 0) {
+            return Promise.resolve({ done: false, value: eventQueue.shift() });
+          }
+          if (eventStreamError) {
+            return Promise.reject(eventStreamError);
+          }
+          if (eventsDone) {
+            return Promise.resolve({ done: true, value: void 0 });
+          }
+          return new Promise((resolve2, reject) => {
+            waiters.push({ resolve: resolve2, reject });
+          });
+        }
+      };
+    }
+  };
+  const manifest = bridgeSkillsForRun(options.agentId, cwd, options.skills);
+  void (async () => {
+    try {
+      for await (const output of adapter(queue.lines())) {
+        if (!isAcpEvent(output)) continue;
+        pushEvent(stampReceiveTime(output, Date.now()));
+      }
+      completeEventStream();
+      resolveEventStreamDone?.();
+    } catch (error2) {
+      failEventStream(error2);
+      rejectEventStreamDone?.(error2);
+    }
+  })();
+  const done = (async () => {
+    try {
+      await applyMiddlewares(
+        [
+          ...options.middlewares ?? [],
+          async (_ctx, next) => {
+            try {
+              const runResult = await runPoeCommand({
+                factory: execution.factory,
+                openSpec: execution.openSpec,
+                detach: execution.detach,
+                state: execution.state,
+                signal: options.signal
+              });
+              if (runResult.kind === "detached") {
+                result.stdout = "";
+                result.stderr = "";
+                result.exitCode = 0;
+                result.detached = { jobId: runResult.jobId, envId: runResult.envId };
+              } else {
+                result.stderr = runResult.stderr ?? "";
+                result.exitCode = runResult.exitCode;
+              }
+            } finally {
+              queue.close();
+            }
+            await eventStreamDone;
+            await next();
+          }
+        ],
+        ctx
+      );
+      return {
+        ...result,
+        ...ctx.logFile && !result.logFile ? { logFile: ctx.logFile } : {}
+      };
+    } finally {
+      cleanupSkillsForRun(manifest);
+    }
+  })();
+  return {
+    events: ctx.eventStream,
+    done: observeAgentSpawn(
+      {
+        agent: agentId,
+        cwd: options.cwd,
+        mode: options.mode,
+        otelSink: options.otelSink,
+        prompt: options.prompt
+      },
+      () => done
+    )
+  };
+}
+
+// packages/agent-spawn/src/spawn.ts
+function createAbortError6() {
+  const error2 = new Error("Agent spawn aborted");
+  error2.name = "AbortError";
+  return error2;
+}
+function resolveCliConfig(agentId) {
+  const resolved = resolveConfig(agentId);
+  if (!resolved.spawnConfig) {
+    throw new Error(`Agent "${resolved.agentId}" has no spawn config.`);
+  }
+  if (resolved.spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${resolved.agentId}" does not support CLI spawn.`);
+  }
+  if (!resolved.binaryName) {
+    throw new Error(`Agent "${resolved.agentId}" has no binaryName.`);
+  }
+  return {
+    agentId: resolved.agentId,
+    binaryName: resolved.binaryName,
+    spawnConfig: resolved.spawnConfig
+  };
+}
+function getDefaultArgsPosition2(config) {
+  return config.defaultArgsPosition ?? "afterPrompt";
+}
+function getMcpArgsPosition2(config) {
+  if (config.mcpArgsPosition) {
+    return config.mcpArgsPosition;
+  }
+  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+}
+function buildCliArgs(config, options, stdinMode) {
+  const mcpArgs = getMcpArgs(config, options.mcpServers);
+  const resumeArgs = getResumeArgs2(config, options);
+  const defaultArgsPosition = getDefaultArgsPosition2(config);
+  const mcpArgsPosition = getMcpArgsPosition2(config);
+  const resumeArgsPosition = config.resume?.position ?? "afterPrompt";
+  const args = [];
+  if (mcpArgsPosition === "beforeCommand") {
+    args.push(...mcpArgs);
+  }
+  if (defaultArgsPosition === "beforePrompt") {
+    args.push(...config.defaultArgs);
   }
   if (mcpArgsPosition === "beforePrompt") {
     args.push(...mcpArgs);
@@ -7738,7 +9799,7 @@ function buildCliArgs(config, options, stdinMode) {
   }
   return { args, env: mode.env };
 }
-function getResumeArgs(config, options) {
+function getResumeArgs2(config, options) {
   if (!options.resumeThreadId) {
     return [];
   }
@@ -7747,59 +9808,74 @@ function getResumeArgs(config, options) {
   }
   return config.resume.args(options.resumeThreadId, options.cwd ?? process.cwd());
 }
-async function spawn3(agentId, options, context) {
+async function spawn4(agentId, options, context) {
+  return observeAgentSpawn(
+    {
+      agent: agentId,
+      cwd: options.cwd,
+      mode: options.mode,
+      otelSink: options.otelSink,
+      prompt: options.prompt
+    },
+    () => runSpawn(agentId, options, context)
+  );
+}
+async function runSpawn(agentId, options, context) {
   if (options.signal?.aborted) {
-    throw createAbortError3();
+    throw createAbortError6();
   }
   const { agentId: resolvedId, binaryName, spawnConfig } = resolveCliConfig(agentId);
-  const stdinMode = options.useStdin && spawnConfig.stdinMode ? spawnConfig.stdinMode : void 0;
+  const stdinMode = shouldSendPromptViaStdin(spawnConfig, options) ? spawnConfig.stdinMode : void 0;
   const { args: spawnArgs, env: modeEnv } = buildCliArgs(spawnConfig, options, stdinMode);
   if (context?.dryRun) {
     const rendered = [binaryName, ...spawnArgs].join(" ");
     context.logger?.dryRun(rendered);
     return { stdout: "", stderr: "", exitCode: 0 };
   }
-  const logFilePath = resolveSpawnLogPath(options);
-  const logFd = logFilePath ? openSpawnLog(logFilePath) : void 0;
-  const processEnv = modeEnv ? { ...process.env, ...modeEnv } : void 0;
-  const argv = [binaryName, ...spawnArgs];
-  const execution = resolvePoeCommandExecution({
-    cwd: options.cwd ?? process.cwd(),
-    runtimeConfigCwd: options.runtimeConfigCwd,
-    env: processEnv ?? process.env,
-    argv,
-    tool: resolvedId,
-    runtime: {
-      runtime: options.runtime,
-      runtimeImage: options.runtimeImage,
-      runtimeTemplate: options.runtimeTemplate,
-      detach: options.detach,
-      mountPoeCode: options.mountPoeCode,
-      runnerSync: options.runnerSync
-    },
-    context,
-    openSpec: {
-      execution: {
-        wrapForLogTee: false,
-        stdin: stdinMode ? "pipe" : "inherit",
-        stdout: "pipe",
-        stderr: "pipe",
-        env: processEnv,
-        input: stdinMode ? options.prompt : void 0,
-        captureOutput: true,
-        activityTimeoutMs: options.activityTimeoutMs,
-        onStdout(chunk) {
-          options.tee?.stdout?.write(chunk);
-          appendSpawnLog(logFd, chunk);
-        },
-        onStderr(chunk) {
-          options.tee?.stderr?.write(chunk);
-          appendSpawnLog(logFd, chunk);
+  const cwd = options.cwd ?? process.cwd();
+  const manifest = bridgeSkillsForRun(agentId, cwd, options.skills);
+  let logFd;
+  try {
+    const logFilePath = resolveSpawnLogPath(options);
+    logFd = logFilePath ? openSpawnLog(logFilePath) : void 0;
+    const processEnv = modeEnv ? { ...process.env, ...modeEnv } : void 0;
+    const argv = [binaryName, ...spawnArgs];
+    const execution = resolvePoeCommandExecution({
+      cwd,
+      runtimeConfigCwd: options.runtimeConfigCwd,
+      env: processEnv ?? process.env,
+      argv,
+      tool: resolvedId,
+      runtime: {
+        runtime: options.runtime,
+        runtimeImage: options.runtimeImage,
+        runtimeTemplate: options.runtimeTemplate,
+        detach: options.detach,
+        mountPoeCode: options.mountPoeCode,
+        runnerSync: options.runnerSync
+      },
+      context,
+      openSpec: {
+        execution: {
+          wrapForLogTee: false,
+          stdin: stdinMode ? "pipe" : "inherit",
+          stdout: "pipe",
+          stderr: "pipe",
+          env: processEnv,
+          input: stdinMode ? options.prompt : void 0,
+          captureOutput: true,
+          activityTimeoutMs: options.activityTimeoutMs,
+          onStdout(chunk) {
+            options.tee?.stdout?.write(chunk);
+            appendSpawnLog(logFd, chunk);
+          },
+          onStderr(chunk) {
+            options.tee?.stderr?.write(chunk);
+            appendSpawnLog(logFd, chunk);
+          }
         }
       }
-    }
-  });
-  try {
+    });
     const result = await runPoeCommand({
       factory: execution.factory,
       openSpec: execution.openSpec,
@@ -7825,8 +9901,21 @@ async function spawn3(agentId, options, context) {
     };
   } finally {
     closeSpawnLog(logFd);
+    cleanupSkillsForRun(manifest);
   }
 }
+spawn4.retry = createSpawnRetry((service, options) => {
+  const handle = spawnStreaming({ ...options, agentId: service });
+  return {
+    events: handle.events,
+    result: handle.done
+  };
+});
+spawn4.parallel = createSpawnParallel((service, options) => ({
+  events: (async function* () {
+  })(),
+  result: spawn4(service, options)
+}));
 function resolveSpawnLogPath(options) {
   if (options.logPath) {
     return options.logPath;
@@ -7834,11 +9923,11 @@ function resolveSpawnLogPath(options) {
   if (!options.logDir || !options.logFileName) {
     return void 0;
   }
-  return path34.join(options.logDir, options.logFileName);
+  return path41.join(options.logDir, options.logFileName);
 }
 function openSpawnLog(filePath) {
   try {
-    mkdirSync(path34.dirname(filePath), { recursive: true });
+    mkdirSync3(path41.dirname(filePath), { recursive: true });
     return openSync(filePath, "a");
   } catch {
     return void 0;
@@ -7863,7 +9952,7 @@ function closeSpawnLog(fd) {
 var DEFAULT_ACTIVITY_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // packages/agent-spawn/src/acp/replay.ts
-import path35 from "node:path";
+import path42 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { open as open2, readdir as readdir5 } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -7882,13 +9971,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 // packages/agent-spawn/src/acp/middlewares/spawn-log.ts
-import path36 from "node:path";
+import path43 from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { mkdir as mkdir5, open as open3 } from "node:fs/promises";
 
 // packages/memory/src/tokens.ts
-import * as fs10 from "node:fs/promises";
-import path37 from "node:path";
+import * as fs12 from "node:fs/promises";
+import path44 from "node:path";
 
 // packages/tokenfill/dist/tokenizer.js
 import { get_encoding } from "tiktoken";
@@ -7929,20 +10018,20 @@ function countTokens(text5) {
 }
 
 // packages/tokenfill/dist/corpus.js
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CORPUS_ARTICLE_SEPARATOR = "\n\n";
-var corpusDirectoryPath = join2(dirname(fileURLToPath(import.meta.url)), "corpus");
+var corpusDirectoryPath = join2(dirname(fileURLToPath2(import.meta.url)), "corpus");
 function getCorpusFileNames() {
-  return readdirSync(corpusDirectoryPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+  return readdirSync2(corpusDirectoryPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
 }
 function loadBuiltInCorpusArticles() {
   const corpusFileNames = getCorpusFileNames();
   if (corpusFileNames.length === 0) {
     throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
   }
-  return corpusFileNames.map((fileName) => readFileSync2(join2(corpusDirectoryPath, fileName), "utf8").trim());
+  return corpusFileNames.map((fileName) => readFileSync3(join2(corpusDirectoryPath, fileName), "utf8").trim());
 }
 var BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
 
@@ -7952,7 +10041,7 @@ var builtInCorpusByteLength = Buffer.byteLength(builtInCorpusText, "utf8");
 
 // packages/memory/src/tokens.ts
 async function computeTokenStats(root) {
-  if (!await pathExists3(root)) {
+  if (!await pathExists4(root)) {
     return {
       memoryTokens: 0,
       sourceTokens: 0,
@@ -7972,13 +10061,13 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path37.resolve(root, "..", "..");
+  const repoRoot = path44.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path37.isAbsolute(sourcePath) ? sourcePath : path37.resolve(repoRoot, sourcePath);
+    const absPath = path44.isAbsolute(sourcePath) ? sourcePath : path44.resolve(repoRoot, sourcePath);
     try {
-      const content = await fs10.readFile(absPath, "utf8");
+      const content = await fs12.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
     } catch (error2) {
       if (isMissing4(error2)) {
@@ -7997,9 +10086,9 @@ async function computeTokenStats(root) {
     missingSources
   };
 }
-async function pathExists3(targetPath) {
+async function pathExists4(targetPath) {
   try {
-    await fs10.stat(targetPath);
+    await fs12.stat(targetPath);
     return true;
   } catch (error2) {
     if (isMissing4(error2)) {
@@ -8027,10 +10116,10 @@ function resolveRunners(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs11.readFile(path38.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs13.readFile(path45.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
-    fs: fs11,
-    filePath: path38.join(inferRepoRoot(root), "poe-code.json")
+    fs: fs13,
+    filePath: path45.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key = resolved.computeIngestKey({
@@ -8068,7 +10157,7 @@ async function ingest(root, opts, runners) {
   let timeoutError;
   try {
     const result = await runWithTimeout(
-      spawn3(agentId, { prompt }),
+      spawn4(agentId, { prompt }),
       opts.timeoutMs ?? await configuredTimeout(configOptions)
     );
     exitCode = result.exitCode;
@@ -8110,7 +10199,7 @@ function buildIngestPrompt(root, sourceLabel, sourceText) {
 }
 async function materializeSource(source) {
   if (source.kind === "file") {
-    const bytes = await fs11.readFile(source.absPath);
+    const bytes = await fs13.readFile(source.absPath);
     return {
       label: source.absPath,
       bytes,
@@ -8120,7 +10209,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path38.resolve(root, "..", "..");
+  return path45.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -8877,99 +10966,6 @@ function printMcpConfig() {
   );
 }
 
-// packages/agent-skill-config/src/configs.ts
-import os5 from "node:os";
-import path39 from "node:path";
-var agentSkillConfigs = {
-  "claude-code": {
-    globalSkillDir: "~/.claude/skills",
-    localSkillDir: ".claude/skills"
-  },
-  codex: {
-    globalSkillDir: "~/.codex/skills",
-    localSkillDir: ".codex/skills"
-  },
-  opencode: {
-    globalSkillDir: "~/.config/opencode/skills",
-    localSkillDir: ".opencode/skills"
-  },
-  goose: {
-    globalSkillDir: "~/.agents/skills",
-    localSkillDir: ".agents/skills"
-  }
-};
-var supportedAgents2 = Object.keys(agentSkillConfigs);
-function resolveAgentSupport(input, registry = agentSkillConfigs) {
-  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 };
-}
-
-// packages/agent-skill-config/src/templates.ts
-import { readFile as readFile15, stat as stat6 } from "node:fs/promises";
-import path40 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// packages/agent-skill-config/src/apply.ts
-var UnsupportedAgentError = class extends Error {
-  constructor(agentId) {
-    super(`Unsupported agent: ${agentId}`);
-    this.name = "UnsupportedAgentError";
-  }
-};
-function toHomeRelative(localSkillDir) {
-  if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
-    return localSkillDir;
-  }
-  const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
-  return `~/${normalized}`;
-}
-var SKILL_TEMPLATE_ID = "__skill_content__";
-async function installSkill(agentId, skill, options) {
-  const support = resolveAgentSupport(agentId);
-  if (support.status !== "supported") {
-    throw new UnsupportedAgentError(agentId);
-  }
-  const scope = options.scope ?? "local";
-  const config = support.config;
-  const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
-  const skillFolderPath = `${skillDir}/${skill.name}`;
-  const skillFilePath = `${skillFolderPath}/SKILL.md`;
-  const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
-  await runMutations(
-    [
-      fileMutation.ensureDirectory({
-        path: skillFolderPath,
-        label: `Ensure skill directory ${skill.name}`
-      }),
-      templateMutation.write({
-        target: skillFilePath,
-        templateId: SKILL_TEMPLATE_ID,
-        label: `Write skill ${skill.name}`
-      })
-    ],
-    {
-      fs: options.fs,
-      homeDir: scope === "global" ? options.homeDir : options.cwd,
-      dryRun: options.dryRun,
-      observers: options.observers,
-      templates: async (templateId) => {
-        if (templateId === SKILL_TEMPLATE_ID) {
-          return skill.content;
-        }
-        throw new Error(`Unknown template: ${templateId}`);
-      }
-    }
-  );
-  return { skillPath: skillFilePath, displayPath };
-}
-
 // packages/agent-mcp-config/src/configs.ts
 var agentMcpConfigs = {
   "claude-code": {
@@ -9046,7 +11042,7 @@ function resolveConfigPath2(config, platform) {
 }
 
 // packages/agent-mcp-config/src/apply.ts
-import path41 from "node:path";
+import path46 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // packages/agent-mcp-config/src/shapes.ts
@@ -9138,7 +11134,7 @@ function getShapeTransformer(shape) {
 
 // packages/agent-mcp-config/src/apply.ts
 function getConfigDirectory(configPath) {
-  return path41.dirname(configPath);
+  return path46.dirname(configPath);
 }
 var UnsupportedAgentError2 = class extends Error {
   constructor(agentId) {
@@ -9164,9 +11160,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path41.join(homeDir, configPath.slice(2));
+    return path46.join(homeDir, configPath.slice(2));
   }
-  return path41.join(homeDir, configPath.slice(1));
+  return path46.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument(content) {
   if (content.trim() === "") {
@@ -9199,7 +11195,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path41.dirname(absolutePath);
+  const configDir = path46.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -9376,8 +11372,8 @@ async function installMemory(options) {
 }
 
 // packages/memory/src/query.ts
-import * as fs12 from "node:fs/promises";
-import path42 from "node:path";
+import * as fs14 from "node:fs/promises";
+import path47 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -9390,12 +11386,12 @@ async function queryMemory(root, options) {
     };
   }
   const configOptions = {
-    fs: fs12,
-    filePath: path42.join(inferRepoRoot2(root), "poe-code.json")
+    fs: fs14,
+    filePath: path47.join(inferRepoRoot2(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const context = await selectQueryContext(root, options.question, options.budget);
-  const result = await spawn3(agentId, { prompt: context.prompt });
+  const result = await spawn4(agentId, { prompt: context.prompt });
   return {
     answer: result.answer,
     citations: result.citations,
@@ -9406,7 +11402,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs12.readFile(path42.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs14.readFile(path47.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -9485,12 +11481,12 @@ function tokenize(text5) {
   return text5.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path42.resolve(root, "..", "..");
+  return path47.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.ts
-import * as fs13 from "node:fs/promises";
-import path43 from "node:path";
+import * as fs15 from "node:fs/promises";
+import path48 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -9512,11 +11508,11 @@ async function explainPage(root, options) {
     throw new Error(`budget too small; needs at least ${tokensUsed} tokens`);
   }
   const configOptions = {
-    fs: fs13,
-    filePath: path43.join(inferRepoRoot3(root), "poe-code.json")
+    fs: fs15,
+    filePath: path48.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
-  const response = await spawn3(agentId, { prompt });
+  const response = await spawn4(agentId, { prompt });
   return {
     answer: response.answer,
     citations: response.citations,
@@ -9562,7 +11558,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path43.resolve(root, "..", "..");
+  return path48.resolve(root, "..", "..");
 }
 
 // packages/memory/src/explain.cli.ts
@@ -9575,9 +11571,9 @@ async function runMemoryExplain(input) {
 }
 
 // packages/memory/src/handle.ts
-import path44 from "node:path";
+import path49 from "node:path";
 function openMemory(opts) {
-  if (!path44.isAbsolute(opts.root)) {
+  if (!path49.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;